declapract-typescript-ehmpathy 0.49.12 → 0.49.14

package/dist/.test/assets/lint/declarations/practices/tests-expo/best-practice/jest.integration.env.ts

@@ -0,0 +1,26 @@
+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';
+
+jest.setTimeout(90000); // since downstream apis are reached
+
+// set console.log to not truncate nested objects
+util.inspect.defaultOptions.depth = 5;
+
+// react-test-renderer 19 requires this flag to run act() cleanly
+(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT =
+  true;
+
+/**
+ * sanity check that integration tests only run in the 'test' environment
+ * .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 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/.test/assets/lint/declarations/practices/tests-expo/best-practice/jest.integration.prepare.ts

@@ -0,0 +1,29 @@
+/// <reference path="./src/.test/assets/test-fns.autoprune.d.ts" />
+import autopruneSetup from 'test-fns/autoprune.setup.jest';
+
+import { useWakeOfLivedb } from './src/.test/useWakeOfLivedb';
+
+/**
+ * .what = jest globalSetup for the expo integration suite — runs once, in the main process, before
+ *         jest forks its workers.
+ * .why =
+ *   - an expo app owns no database, but it reaches one THROUGH its gateway, whose peers query the
+ *     shared aurora-serverless cluster. at min-capacity 0 that cluster auto-pauses, so the first
+ *     query after a pause cold-starts past the timeout and flakes the suite.
+ *   - the wake is `via-gateway`: an expo app has no `config/` dir with a db tunnel to gate on, so
+ *     the test kind itself is the signal — an integration run reaches a deployment by construction.
+ *   - COMPOSES the wake with test-fns autoprune in jest's ONE globalSetup: wake FIRST (best-effort),
+ *     THEN autoprune mints the run id. `globalConfig` is FORWARDED to autoprune unchanged, so its
+ *     half-wired-state check reads the real `globalTeardown` slot.
+ * .note = `useWakeOfLivedb` is imported by RELATIVE path, never the `@src` alias — a globalSetup is
+ *         loaded BEFORE jest's moduleNameMapper exists, so `@src` here fails at startup.
+ */
+// biome-ignore lint/style/noDefaultExport: jest globalSetup api requires default export
+export default async (globalConfig: { globalTeardown?: string | null }): Promise<void> => {
+  // the wake refuses prod (prod never scales to 0); every other access wakes the prep cluster
+  await useWakeOfLivedb({
+    env: process.env.ACCESS === 'prod' ? 'prod' : null,
+    reaches: 'via-gateway',
+  });
+  await autopruneSetup(globalConfig);
+};

package/dist/.test/assets/lint/declarations/practices/tests-expo/best-practice/jest.unit.config.ts

@@ -0,0 +1,67 @@
+/**
+ * @jest-config-loader esbuild-register
+ */
+import type { Config } from 'jest';
+
+// ensure tests run in utc, like they will on cicd and on server; https://stackoverflow.com/a/56277249/15593329
+process.env.TZ = 'UTC';
+
+// ensure tests run like on local machines, so snapshots are equal on local && cicd
+process.env.FORCE_COLOR = 'true';
+
+// https://jestjs.io/docs/configuration
+const config: Config = {
+  // jest-expo wires up babel-preset-expo (metro's transform) + react-native module
+  // resolution (platform suffixes, haste). this is what lets tests that reach the
+  // expo/react-native boundary load, where a plain node preset cannot.
+  preset: 'jest-expo',
+
+  verbose: true,
+  reporters: [
+    ['default', { summaryThreshold: 0 }], // ensure we always get a failure summary at the bottom, to avoid the hunt
+    ['test-fns/slowtest.reporter.jest', { slow: '10s', output: '.log/slowtest/unit.report.json' }],
+  ],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/$1',
+    '^@src/(.*)$': '<rootDir>/src/$1',
+    '^@assets/(.*)$': '<rootDir>/assets/$1',
+  },
+  // the jest-expo preset's transformIgnorePatterns assume a hoisted (flat) node_modules.
+  // pnpm's `.pnpm/`-nested store ships react-native/expo as untranspiled ESM one layer
+  // deeper, so add a `.pnpm/` branch that still transforms those families. a repo that
+  // pulls other untranspiled-ESM packages (e.g. a native storage lib) appends its own
+  // package names to BOTH branches.
+  transformIgnorePatterns: [
+    'node_modules/.pnpm/(?!.*(react-native|@react-native|expo|@expo|@unimodules|unimodules|@react-navigation|react-navigation|sentry-expo|native-base|@sentry))',
+    'node_modules/(?!.pnpm)(?!(jest-)?react-native|@react-native(-community)?|expo(nent)?|@expo(nent)?|react-navigation|@react-navigation|@unimodules|unimodules|sentry-expo|native-base|@sentry)',
+  ],
+  testMatch: [
+    // note: order matters
+    '**/*.test.{ts,tsx}', // also matches the `._.unit.test` kind seam
+    '!**/*.acceptance.test.{ts,tsx}',
+    '!**/*.integration.test.{ts,tsx}',
+    '!**/*.evaluation.test.{ts,tsx}',
+    '!**/*._.acpt.test.{ts,tsx}',
+    '!**/*._.intg.test.{ts,tsx}',
+    '!**/*._.eval.test.{ts,tsx}',
+    '!**/.agent/.actors/**', // rhachet host-local state; holds a scratch clone of this repo, whose suites are not ours
+    '!**/.agent/.cache/**',
+    '!**/.yalc/**',
+  ],
+  // skip all of `.agent/`: rhachet roles, host-local clones, and the rmsafe trash live there. a test
+  // there would run as ours, and a snapshot there would read as obsolete (the haste map scans it)
+  testPathIgnorePatterns: ['/node_modules/', '/.agent/'],
+  modulePathIgnorePatterns: ['<rootDir>/.agent/'],
+  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
+};
+
+// eslint-disable-next-line import/no-default-export
+export default config;

package/dist/.test/assets/lint/declarations/practices/tests-expo/best-practice/jest.unit.env.ts

@@ -0,0 +1,23 @@
+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';
+
+// set console.log to not truncate nested objects
+util.inspect.defaultOptions.depth = 5;
+
+// react-test-renderer 19 requires this flag to run act() cleanly
+(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT =
+  true;
+
+/**
+ * sanity check that unit tests only run in the 'test' environment
+ * .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 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 },
+  );

package/dist/.test/assets/lint/declarations/practices/tests-expo/best-practice/package.json.declapract.ts

@@ -0,0 +1,208 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import { ConstraintError } from 'helpful-errors';
+
+import { asPackageJSON } from '../../../utils/asPackageJSON';
+
+/**
+ * .what = the expo half of the tests triad: the jest-expo transform stack that replaces
+ *         node's `@swc/jest`. this check GATES the SDK-coupled majors on the repo's OWN
+ *         expo + react majors, rather than floor them at a fixed baseline.
+ * .why  = jest-expo's preset pokes react internals of the SDK it targets. a fixed
+ *         `minVersion('54.0.0')` floor forces jest-expo 54 (a react-19-era preset) onto an
+ *         expo-51 / react-18 repo, and every unit suite throws
+ *         `TypeError: Object.defineProperty called on non-object` at jest-expo's preset setup
+ *         (#584 / defect D1). the two crashing deps each track a major 1:1:
+ *           - jest-expo major  == expo major  (jest-expo 54 pairs with expo 54)
+ *           - react-test-renderer major == react major (rtr ships lockstep with react)
+ *         so the gate reads the repo's OWN expo + react majors and requires a match — which
+ *         holds jest-expo at 51 on an expo-51 repo and at 54 on an expo-54 repo, with no
+ *         version table to rot as new SDKs ship.
+ * .note = @babel/core + babel-preset-expo + isomorphic-fetch stay MINIMA (not the crash; each a
+ *         plain floor the pre-gate template already declared). babel-preset-expo also tracks the
+ *         SDK, but backward-compatibly; its floor is left as a residual — see .deliver/584.md.
+ * .note = a repo with no `expo` dep is not an expo repo in a gate-able state; the check passes
+ *         (returns) rather than flags, so a non-expo package.json is never falsely reddened.
+ */
+
+const BABEL_CORE_MIN = { major: 7, minor: 24, patch: 0 };
+const BABEL_PRESET_EXPO_MIN = { major: 12, minor: 0, patch: 0 };
+const ISOMORPHIC_FETCH_MIN = { major: 3, minor: 0, patch: 0 };
+
+interface SemverTriple {
+  major: number;
+  minor: number;
+  patch: number;
+}
+
+/** parse the leading `major.minor.patch` out of a semver range (`^54.0.0`, `~19.1.2`, `>=3.0.0`). */
+const parseVersionTriple = (range: string | undefined): SemverTriple | null => {
+  if (!range) return null;
+  const match = range.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+  };
+};
+
+const majorOf = (range: string | undefined): number | null =>
+  parseVersionTriple(range)?.major ?? null;
+
+const meetsMinimum = (
+  range: string | undefined,
+  min: SemverTriple,
+): boolean => {
+  const found = parseVersionTriple(range);
+  if (!found) return false;
+  if (found.major !== min.major) return found.major > min.major;
+  if (found.minor !== min.minor) return found.minor > min.minor;
+  return found.patch >= min.patch;
+};
+
+/** the subset of a package.json this declaration reads + rewrites (dep maps), typed rather than `any`. */
+interface PackageJSON {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+/**
+ * .what = a dep map with its keys in alphabetical order, as npm and pnpm write them
+ * .why  = the fix adds deps; appended in place, they land after the sorted keys, so
+ *         package-json-order re-sorts them on the next apply and this fix re-appends them, and
+ *         the two practices never converge
+ */
+const asSortedDeps = (deps: Record<string, string>): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(deps).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
+  );
+
+const getAllDeps = (packageJSON: PackageJSON): Record<string, string> => ({
+  ...(packageJSON.dependencies ?? {}),
+  ...(packageJSON.devDependencies ?? {}),
+});
+
+export const check: FileCheckFunction = (contents) => {
+  // no file → no gate to enforce; a best-practice check passes (returns) when clean
+  if (!contents) return;
+
+  const packageJSON: PackageJSON = asPackageJSON(
+    { contents },
+    {
+      practice: 'tests-expo',
+    },
+  );
+  const deps = getAllDeps(packageJSON);
+
+  // a repo with no `expo` dep is not an expo repo in a gate-able state — do not flag it
+  const expoMajor = majorOf(deps.expo);
+  if (expoMajor === null) return;
+
+  // jest-expo major must MATCH the repo's expo major (jest-expo tracks the SDK 1:1)
+  const jestExpoMajor = majorOf(deps['jest-expo']);
+  if (jestExpoMajor !== expoMajor)
+    throw new ConstraintError(
+      `jest-expo major (${jestExpoMajor}) must match the repo's expo major (${expoMajor}) — run \`declapract apply\` to pin jest-expo to ^${expoMajor}.0.0`,
+      { found: jestExpoMajor, required: expoMajor, dep: 'jest-expo' },
+    );
+
+  // react-test-renderer major must MATCH the repo's react major (rtr ships lockstep with react)
+  const reactMajor = majorOf(deps.react);
+  if (reactMajor !== null) {
+    const rtrMajor = majorOf(deps['react-test-renderer']);
+    if (rtrMajor !== reactMajor)
+      throw new ConstraintError(
+        `react-test-renderer major (${rtrMajor}) must match the repo's react major (${reactMajor}) — run \`declapract apply\` to pin react-test-renderer to ^${reactMajor}.0.0`,
+        { found: rtrMajor, required: reactMajor, dep: 'react-test-renderer' },
+      );
+  }
+
+  // @babel/core + babel-preset-expo + isomorphic-fetch stay MINIMA (not the crash; a plain
+  // floor, exactly as the pre-gate template declared each of the three)
+  if (!meetsMinimum(deps['@babel/core'], BABEL_CORE_MIN))
+    throw new ConstraintError(
+      '@babel/core must be >= 7.24.0 — run `declapract apply` to raise it',
+      {
+        found: deps['@babel/core'] ?? null,
+        required: '7.24.0',
+        dep: '@babel/core',
+      },
+    );
+  if (!meetsMinimum(deps['babel-preset-expo'], BABEL_PRESET_EXPO_MIN))
+    throw new ConstraintError(
+      'babel-preset-expo must be >= 12.0.0 — run `declapract apply` to raise it',
+      {
+        found: deps['babel-preset-expo'] ?? null,
+        required: '12.0.0',
+        dep: 'babel-preset-expo',
+      },
+    );
+  if (!meetsMinimum(deps['isomorphic-fetch'], ISOMORPHIC_FETCH_MIN))
+    throw new ConstraintError(
+      'isomorphic-fetch must be >= 3.0.0 — run `declapract apply` to raise it',
+      {
+        found: deps['isomorphic-fetch'] ?? null,
+        required: '3.0.0',
+        dep: 'isomorphic-fetch',
+      },
+    );
+
+  // all gates satisfied
+  return;
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+
+  const packageJSON: PackageJSON = asPackageJSON(
+    { contents },
+    {
+      practice: 'tests-expo',
+    },
+  );
+  const deps = getAllDeps(packageJSON);
+  const expoMajor = majorOf(deps.expo);
+
+  // no expo dep → not a gate-able expo repo; leave untouched
+  if (expoMajor === null) return { contents };
+
+  const devDependencies = { ...(packageJSON.devDependencies ?? {}) };
+  const dependencies = { ...(packageJSON.dependencies ?? {}) };
+
+  // jest-expo + react-test-renderer are test-time deps that belong in devDependencies ALONE. pin
+  // them there AND delete any copy under `dependencies` — else the merged getAllDeps check (dev
+  // wins) reads green while npm installs ONE version and a stale `dependencies` copy at a conflicting
+  // major can win at install time (the two-section version conflict r006.b1 forbids). the sibling
+  // dep declarations (logs/leveled-term, rhachet/prod-deps) strip from both sections for the same reason.
+  devDependencies['jest-expo'] = `^${expoMajor}.0.0`;
+  delete dependencies['jest-expo'];
+
+  // pin react-test-renderer to the repo's react major, when a react dep is present
+  const reactMajor = majorOf(deps.react);
+  if (reactMajor !== null) {
+    devDependencies['react-test-renderer'] = `^${reactMajor}.0.0`;
+    delete dependencies['react-test-renderer'];
+  }
+
+  // raise @babel/core + babel-preset-expo + isomorphic-fetch to their minima when below
+  if (!meetsMinimum(deps['@babel/core'], BABEL_CORE_MIN))
+    devDependencies['@babel/core'] = '^7.24.0';
+  if (!meetsMinimum(deps['babel-preset-expo'], BABEL_PRESET_EXPO_MIN))
+    devDependencies['babel-preset-expo'] = '^12.0.0';
+  if (!meetsMinimum(deps['isomorphic-fetch'], ISOMORPHIC_FETCH_MIN))
+    devDependencies['isomorphic-fetch'] = '^3.0.0';
+
+  // preserve each section's presence: rewrite `dependencies` ONLY when the manifest already declared
+  // one (so a repo with no prod deps never gains an empty `dependencies: {}` it did not have).
+  const result: PackageJSON = {
+    ...packageJSON,
+    devDependencies: asSortedDeps(devDependencies),
+  };
+  if (packageJSON.dependencies)
+    result.dependencies = asSortedDeps(dependencies);
+
+  return {
+    contents: JSON.stringify(result, null, 2),
+  };
+};

package/dist/.test/assets/lint/declarations/practices/tests-expo/best-practice/src/.test/assets/test-fns.autoprune.d.ts

@@ -0,0 +1,14 @@
+/**
+ * .what = types for the `test-fns/autoprune.setup.jest` subpath, which the `jest.*.prepare.ts` files
+ *         import and reach via a triple-slash reference
+ * .why = expo sdk < 54 resolves with `moduleResolution: node`, which ignores `exports`; test-fns ships
+ *        the subpath only via `exports`, so the import is TS2307 there (jest loads it fine at runtime)
+ * .note = a stand-in. it retires once test-fns ships `typesVersions` for its subpaths
+ */
+declare module 'test-fns/autoprune.setup.jest' {
+  const autopruneSetup: (globalConfig: {
+    globalTeardown?: string | null;
+  }) => Promise<void>;
+  // biome-ignore lint/style/noDefaultExport: mirrors the jest globalSetup default export
+  export default autopruneSetup;
+}

package/dist/.test/assets/lint/declarations/practices/tests-expo/package.json.declapract.integration.test.ts

@@ -0,0 +1,94 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
+
+// executeApply is slow (full practice evaluation)
+jest.setTimeout(180_000);
+
+/**
+ * .what = pipeline test for the tests-expo jest-expo/rtr SDK-major gate (#584 / defect D1).
+ * .why  = the unit test proves the check/fix in isolation; only the real executeApply pipeline
+ *         proves declapract WIRES the declaration to `package.json` and reaches a fixed point on
+ *         a re-run. the crash this gate prevents is a react-19-era jest-expo (54) held onto an
+ *         expo-51 / react-18 repo — every unit suite throws at jest-expo's preset setup — so the
+ *         gate must hold jest-expo at the repo's OWN expo major (51), never bump it to 54.
+ * .note = scoped `practice: 'tests-expo'` — the declaration reads only `contents`, never
+ *         `context.projectPractices`, so a practice scope is safe (no usecase-aware branch goes
+ *         dark) and isolates the apply to tests-expo's package.json declaration alone.
+ */
+describe('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)', () => {
+    const tempDir = genTempDir({
+      slug: 'tests-expo-major-gate',
+      clone: './src/.test/assets/expo-migration/repo-app-protools-shaped',
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/expo-migration/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const pkgPath = () => path.join(tempDir, 'package.json');
+    const readPkg = () => fs.readFile(pkgPath(), 'utf-8');
+
+    const state = useBeforeAll(async () => {
+      // seed the crash shape: a react-19-era jest-expo/rtr on an expo-51 / react-18 repo
+      const seeded = {
+        ...JSON.parse(await readPkg()),
+        devDependencies: {
+          ...JSON.parse(await readPkg()).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',
+        },
+      };
+      await fs.writeFile(pkgPath(), `${JSON.stringify(seeded, null, 2)}\n`);
+      const pkgBefore = await readPkg();
+
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'tests-expo',
+        file: 'package.json',
+      });
+      const pkgAfter1 = await readPkg();
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'tests-expo',
+        file: 'package.json',
+      });
+      const pkgAfter2 = await readPkg();
+
+      return { pkgBefore, pkgAfter1, pkgAfter2 };
+    }, 170_000);
+
+    when('[t0] the tests-expo gate is applied to the seeded package.json', () => {
+      then('jest-expo is held at the repo expo major (51), not bumped to 54', () => {
+        expect(JSON.parse(state.pkgBefore).devDependencies['jest-expo']).toEqual(
+          '^54.0.0',
+        );
+        expect(JSON.parse(state.pkgAfter1).devDependencies['jest-expo']).toEqual(
+          '^51.0.0',
+        );
+      });
+
+      then('react-test-renderer is held at the repo react major (18), not 19', () => {
+        expect(
+          JSON.parse(state.pkgAfter1).devDependencies['react-test-renderer'],
+        ).toEqual('^18.0.0');
+      });
+
+      then('before + after match snapshot', () => {
+        expect(state.pkgBefore).toMatchSnapshot('package.json — before');
+        expect(state.pkgAfter1).toMatchSnapshot('package.json — after gate');
+      });
+
+      then('a second apply is a fixed point (the gate holds)', () => {
+        expect(state.pkgAfter2).toEqual(state.pkgAfter1);
+      });
+    });
+  });
+});

package/dist/.test/assets/lint/declarations/useCases.yml

@@ -0,0 +1,11 @@
+# minimal lint use cases for integration tests
+# .why = the .depcheckrc.yml contents fn adds the expo ignores on
+#        context.projectPractices.includes('tests-expo'), so the expo usecase lists it
+use-cases:
+  lint-node:
+    practices:
+      - lint
+  lint-expo:
+    practices:
+      - lint
+      - tests-expo

package/dist/.test/assets/logs/declarations/declapract.declare.yml

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

package/dist/.test/assets/logs/declarations/practices/logs/.declapract.integration.test.ts

@@ -0,0 +1,103 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+// each executeApply evaluates the whole usecase; under full-suite load one apply runs past 100s
+jest.setTimeout(240_000);
+
+/**
+ * .what = end-to-end proof of the logs/leveled-term fix, run through the REAL declapract apply
+ *   pipeline against a genTempDir clone of a consumer repo whose package.json lists the deprecated
+ *   `simple-leveled-log-methods` in BOTH `dependencies` and `devDependencies` (D50 / #571).
+ * .why  = the old declaration was a `CONTAINS` template pinned to `devDependencies`, so it was blind
+ *   to a `dependencies` placement — the bad practice silently never fired for a repo that had the
+ *   dep at runtime. the fix is now a `FileCheckFunction` + `withoutDeprecatedDep` transformer that
+ *   removes it from BOTH sections. a unit test of the transformer is necessary but not sufficient
+ *   (`rule.require.declapract-integration-tests`): only the pipeline proves the declaration's target
+ *   glob matches package.json and the fix lands on a real consumer file.
+ * .note = the package.json is snapshotted in full (before AND after) so a reviewer can eyeball the
+ *   exact end-state. the target file holds the dep in both sections, so the after-state proves the
+ *   both-section removal AND the section-presence preservation.
+ */
+describe('logs/leveled-term removal', () => {
+  given('[case1] a repo with simple-leveled-log-methods in both dep sections', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-logs-leveled-term',
+      clone: './src/practices/logs/bad-practices/leveled-term/.test/assets/demo-repo-with-leveled-term',
+      symlink: [{ at: 'declarations', to: 'src' }],
+    });
+
+    const pkgPath = 'package.json';
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const applyFix = () =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'logs',
+        file: pkgPath,
+      });
+
+    when('[t0] the input (before any fix)', () => {
+      then('the package.json input matches snapshot', async () => {
+        expect(await read(pkgPath)).toMatchSnapshot('package.json — before');
+      });
+    });
+
+    when('[t1] the leveled-term fix is applied', () => {
+      useThen('remove the deprecated dep from both sections', async () =>
+        applyFix(),
+      );
+
+      then(
+        'the dep is gone from dependencies AND devDependencies, both sections preserved, and matches snapshot',
+        async () => {
+          const pkg = JSON.parse(await read(pkgPath));
+          // the deprecated dep is gone from both sections
+          expect(pkg.dependencies?.['simple-leveled-log-methods']).toBeUndefined();
+          expect(
+            pkg.devDependencies?.['simple-leveled-log-methods'],
+          ).toBeUndefined();
+          // each section's PRESENCE is preserved (the repo declared both, so both stay)
+          expect(pkg.dependencies).toBeDefined();
+          expect(pkg.devDependencies).toBeDefined();
+          // the peer deps in each section survive untouched
+          expect(pkg.dependencies.uuid).toEqual('9.0.0');
+          expect(pkg.devDependencies.jest).toEqual('29.3.1');
+          // full content, for the reviewer's eye
+          expect(await read(pkgPath)).toMatchSnapshot('package.json — after');
+        },
+      );
+    });
+
+    when('[t2] the fix is applied a second time (idempotency)', () => {
+      // .note = the D50 invariant under re-apply is that the leveled-term fix is a
+      //   FIXED POINT for the deprecated dep: once removed, a second pass neither
+      //   re-introduces it nor drops a peer section. we do NOT assert full-file byte
+      //   equality here, because the logs best-practice package.json declaration (a
+      //   separate declarer, out of scope for D50) writes a raw
+      //   `@declapract{check.minVersion(...)}` marker on the first pass and resolves it
+      //   to a bare version on the second — a marker-resolution quirk of that declaration,
+      //   not of the leveled-term transformer under test.
+      const pkg = useThen('a second apply over its own output', async () => {
+        await applyFix(); // second apply, over the post-first-fix output
+        return JSON.parse(await read(pkgPath));
+      });
+
+      then('the deprecated dep stays gone from both sections', () => {
+        expect(pkg.dependencies?.['simple-leveled-log-methods']).toBeUndefined();
+        expect(
+          pkg.devDependencies?.['simple-leveled-log-methods'],
+        ).toBeUndefined();
+      });
+
+      then('both sections and their peer deps survive the re-apply', () => {
+        expect(pkg.dependencies).toBeDefined();
+        expect(pkg.devDependencies).toBeDefined();
+        expect(pkg.dependencies.uuid).toEqual('9.0.0');
+        expect(pkg.devDependencies.jest).toEqual('29.3.1');
+      });
+    });
+  });
+});

package/dist/.test/assets/logs/declarations/practices/logs/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,33 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`logs/leveled-term removal given: [case1] a repo with simple-leveled-log-methods in both dep sections when: [t0] the input (before any fix) then: the package.json input matches snapshot: package.json — before 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "simple-leveled-log-methods": "0.1.7",
+    "uuid": "9.0.0"
+  },
+  "devDependencies": {
+    "simple-leveled-log-methods": "0.1.7",
+    "jest": "29.3.1"
+  }
+}
+"
+`;
+
+exports[`logs/leveled-term removal given: [case1] a repo with simple-leveled-log-methods in both dep sections when: [t1] the leveled-term fix is applied then: the dep is gone from dependencies AND devDependencies, both sections preserved, and matches snapshot: package.json — after 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "uuid": "9.0.0",
+    "sdk-environment": "@declapract{check.minVersion('0.1.5')}",
+    "sdk-logs": "@declapract{check.minVersion('0.9.2')}"
+  },
+  "devDependencies": {
+    "jest": "29.3.1"
+  }
+}
+"
+`;