declapract-typescript-ehmpathy 0.49.14 → 0.50.0

package/dist/.test/assets/expo-fullusecase/declarations/practices/rhachet/best-practice/.gitattributes.declapract.ts

@@ -0,0 +1,65 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import expect from 'expect';
+
+import {
+  defineExpectedGitattributesContents,
+  type GitattributesSection,
+} from '../../../utils/defineExpectedGitattributesContents';
+
+/**
+ * .what = the `.gitattributes` section this practice owns: route robocode folds in pr diffs
+ * .why  = rhachet installs the roles that drive routes (bhrain: `.route/`; bhuild:
+ *         `.behavior/`). a route carries stones, guards, reviews, caches: the trail. the
+ *         yields hold what the route concluded, and `.radio/` holds what it handed off. so a
+ *         pr folds the trail and opens on the yields and the radio
+ * .note = order carries load: git takes the last line that matches, so each
+ *         `-linguist-generated` exception follows the collapse line it carves out of.
+ *         attributes never recurse from a dir, so each pattern ends in `/**`
+ */
+const sections: readonly GitattributesSection[] = [
+  {
+    header: {
+      latest:
+        '# [rhachet] collapse route robocode in pr diffs; yields and radio stay open',
+      retired: [],
+    },
+    entries: {
+      latest: [
+        '.route/** linguist-generated',
+        '.route/**/*.yield.* -linguist-generated',
+        '.route/**/.radio/** -linguist-generated',
+        '.behavior/** linguist-generated',
+        '.behavior/**/*.yield.* -linguist-generated',
+        '.behavior/**/.radio/** -linguist-generated',
+      ],
+      retired: [],
+    },
+  },
+];
+
+/**
+ * .what = emits the `.gitattributes` this practice declares, given the repo's extant one
+ * .why  = several practices declare this file; they converge only through the shared util
+ */
+const defineExpectedContents = (input: { contents: string | null }): string =>
+  defineExpectedGitattributesContents({
+    contents: input.contents,
+    declarer: 'rhachet',
+    sections,
+  });
+
+/**
+ * .what = throws when the repo's `.gitattributes` differs from what the shared layout emits
+ * .why  = `check` gates `fix` (a throw means violated); exact equality, so `check(x) ⟺ x === fix(x)`
+ */
+export const check: FileCheckFunction = (contents) => {
+  expect(contents).toEqual(defineExpectedContents({ contents }));
+};
+
+/**
+ * .what = sets this practice's section into the repo's `.gitattributes`
+ * .why  = a fixed point: a second fix changes zero, and `check` passes on the output
+ */
+export const fix: FileFixFunction = (contents) => ({
+  contents: defineExpectedContents({ contents }),
+});

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/best-practice/.declapract.readme.md

@@ -43,3 +43,10 @@
   - `jest.unit.env`
   - `jest.integration.env`
   - `jest.acceptance.env`
+
+## test source folds in a pr; snapshots stay open
+
+this practice declares a `# [tests-any]` section of the repo-root `.gitattributes`: `*.test.ts` and
+`*.test.tsx` are `linguist-generated`, so github renders them collapsed. `*.snap` files stay open, so
+a reviewer still reads each output change. to un-fold a path, see "what folds in a pr" in
+`src/practices/git/best-practice/.declapract.readme.md`.

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/best-practice/.gitattributes.declapract.ts

@@ -0,0 +1,60 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import expect from 'expect';
+
+import {
+  defineExpectedGitattributesContents,
+  type GitattributesSection,
+} from '../../../utils/defineExpectedGitattributesContents';
+
+/**
+ * .what = the `.gitattributes` section this practice owns: test source folds in pr diffs
+ * .why  = a test file is the how; its snapshot is the proof. github folds a file marked
+ *         `linguist-generated`, one click away, so a pr opens on the snapshot diff and the
+ *         source, and the test source waits for the reviewer who asks for it
+ * .note = `*.snap` takes no line: linguist never marks a snapshot as generated, so it renders
+ *         open. `*.test.tsx` covers the expo cut, whose jest matches
+ *         `<star><star>/<star>.test.{ts,tsx}`
+ * .note = `<star>` stands in for the literal `*` wildcard, and must stay a stand-in. a literal
+ *         `*` immediately before a `/` closes this comment mid-prose
+ * .note = `linguist-generated` names a render hint here, not provenance; the header says so
+ */
+const sections: readonly GitattributesSection[] = [
+  {
+    header: {
+      latest:
+        '# [tests-any] collapse test source in pr diffs; snapshots stay open',
+      retired: [],
+    },
+    entries: {
+      latest: ['*.test.ts linguist-generated', '*.test.tsx linguist-generated'],
+      retired: [],
+    },
+  },
+];
+
+/**
+ * .what = emits the `.gitattributes` this practice declares, given the repo's extant one
+ * .why  = several practices declare this file; they converge only through the shared util
+ */
+const defineExpectedContents = (input: { contents: string | null }): string =>
+  defineExpectedGitattributesContents({
+    contents: input.contents,
+    declarer: 'tests-any',
+    sections,
+  });
+
+/**
+ * .what = throws when the repo's `.gitattributes` differs from what the shared layout emits
+ * .why  = `check` gates `fix` (a throw means violated); exact equality, so `check(x) ⟺ x === fix(x)`
+ */
+export const check: FileCheckFunction = (contents) => {
+  expect(contents).toEqual(defineExpectedContents({ contents }));
+};
+
+/**
+ * .what = sets this practice's section into the repo's `.gitattributes`
+ * .why  = a fixed point: a second fix changes zero, and `check` passes on the output
+ */
+export const fix: FileFixFunction = (contents) => ({
+  contents: defineExpectedContents({ contents }),
+});

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

@@ -152,7 +152,7 @@ describe('gitignore practices', () => {
       slug: 'git-cache-dirs',
       clone: './src/practices/git/.test/assets/repo-without-cache-ignores',
       symlink: [
-        { at: 'declarations', to: './.test/assets/git/declarations' },
+        { at: 'declarations', to: './src/.test/assets/git/declarations' },
         { at: 'node_modules', to: 'node_modules' },
       ],
     });
@@ -602,7 +602,7 @@ describe('gitignore practices', () => {
       slug: 'git-rhachet-only',
       clone: './src/practices/git/.test/assets/repo-with-rhachet-only',
       symlink: [
-        { at: 'declarations', to: './.test/assets/git/declarations' },
+        { at: 'declarations', to: './src/.test/assets/git/declarations' },
         { at: 'node_modules', to: 'node_modules' },
       ],
     });

package/dist/.test/assets/expo-migration/declarations/practices/git/.gitattributes.declapract.integration.test.ts

@@ -4,9 +4,24 @@ import path from 'node:path';
 import { executeApply } from 'declapract';
 import { genTempDir, given, then, useBeforeAll, useThen, when } from 'test-fns';
 
-// executeApply evaluates the whole git practice before the `file` filter narrows it
+import { check as checkGit } from './best-practice/.gitattributes.declapract';
+
+// executeApply evaluates the whole practice before the `file` filter narrows it
 jest.setTimeout(5 * 60 * 1000);
 
+const context = {} as Parameters<typeof checkGit>[1]; // .note = the check reads no context
+
+// .note = a literal, independent of the declaration: the check is `x === fix(x)`, so it passes on
+//         any fixed point and cannot by itself prove the bytes are the ones the practice promises
+const MANAGED_SECTIONS = `# [git] exclude package locks from git diff; https://stackoverflow.com/a/72834452/3068233
+pnpm-lock.yaml -diff
+package-lock.json -diff
+
+# [git] auto-resolve lock file conflicts by taking theirs; run install after merge
+pnpm-lock.yaml merge=theirs
+package-lock.json merge=theirs
+`;
+
 const MANAGED_ENTRIES = [
   'pnpm-lock.yaml -diff',
   'package-lock.json -diff',
@@ -15,15 +30,13 @@ const MANAGED_ENTRIES = [
 ];
 
 /**
- * .what = proves the .gitattributes fix through the real declapract pipeline
- * .why  = the unit suite proves the fix in isolation; only executeApply proves the declared path
- *         reaches the repo-root file, the CONTAINS check gates the fix, and the settled file
- *         satisfies that check — so a rerun is a no-op and the plan stops to flag it
+ * .what = proves the git `.gitattributes` declaration through the real declapract pipeline
+ * .why  = the unit suite proves the fix in isolation; only executeApply proves the declared
+ *         path reaches the repo-root file, the check gates the fix, and the settled file
+ *         satisfies the check — so a rerun is a no-op and the plan stops to flag it
  *         (rule.require.declapract-integration-tests, rule.require.idempotent-fixes)
- * .teeth = emit any section's entries out of declared order, and [t1] `contains the template`
- *          reddens while [t2] stays a byte-identical fixed point — the reflag loop a fixed-point
- *          test alone cannot see. the prior fix (sections re-assembled in place, a stray entry
- *          left outside its section) was in exactly that state
+ * .note = all five declarers together, and this repo's own file, are proven in
+ *         `src/gitattributesDeclarers.declapract.integration.test.ts`
  */
 describe('git .gitattributes', () => {
   given('[case1] a repo whose .gitattributes holds a legacy header, a legacy entry, and an out-of-section entry', () => {
@@ -31,7 +44,7 @@ describe('git .gitattributes', () => {
       slug: 'git-gitattributes-legacy',
       clone: './src/practices/git/.test/assets/repo-with-legacy-gitattributes',
       symlink: [
-        { at: 'declarations', to: './.test/assets/git/declarations' },
+        { at: 'declarations', to: './src/.test/assets/git/declarations' },
         { at: 'node_modules', to: 'node_modules' },
       ],
     });
@@ -53,15 +66,15 @@ describe('git .gitattributes', () => {
     when('[t1] apply runs', () => {
       const scene = useThen('apply settles', async () => {
         await apply();
-        const template = await fs.readFile(
-          path.join(__dirname, 'best-practice/.gitattributes'),
-          'utf-8',
-        );
-        return { after: await read(), template };
+        return { after: await read() };
+      });
+
+      then('the git check passes on the file', () => {
+        expect(() => checkGit(scene.after, context)).not.toThrow();
       });
 
-      then('the file contains the template verbatim — the CONTAINS check passes', () => {
-        expect(scene.after).toContain(scene.template.trim());
+      then('the file holds the managed sections verbatim, then the repo-own line', () => {
+        expect(scene.after).toEqual(`${MANAGED_SECTIONS}\n*.png binary\n`);
       });
 
       then('the legacy header and the legacy entry are gone', () => {
@@ -77,8 +90,10 @@ describe('git .gitattributes', () => {
         );
       });
 
-      then('the repo-own line survives', () => {
-        expect(scene.after).toContain('*.png binary');
+      then('the repo-own line survives, after the managed sections', () => {
+        expect(scene.after.trim().split('\n').slice(-1)[0]).toEqual(
+          '*.png binary',
+        );
       });
 
       then('no declapract template syntax leaked', () => {

package/dist/.test/assets/expo-migration/declarations/practices/git/.test/assets/repo-with-legacy-gitattributes/declapract.use.yml

@@ -1,7 +1,7 @@
-# .note = declarations dir is symlinked by the test to .test/assets/git/declarations
+# .note = declarations dir is symlinked by the test to src/.test/assets/git/declarations
 # .why  = a repo whose .gitattributes predates the current template: a legacy header, a legacy
-#         entry, and a managed entry outside any section — so the CONTAINS check fails and the
-#         git practice's fix runs
+#         entry, and a managed entry outside any section — so the check fails and the git
+#         practice's fix runs
 # .note = NO `variables:` block — `git` and `rhachet` reference zero `@declapract{variable.*}`
 declarations: 'declarations/declapract.declare.yml'
 useCase: typescript-project

package/dist/.test/assets/expo-migration/declarations/practices/git/__snapshots__/.gitattributes.declapract.integration.test.ts.snap

@@ -11,14 +11,14 @@ pnpm-lock.yaml merge=theirs
 `;
 
 exports[`git .gitattributes given: [case1] a repo whose .gitattributes holds a legacy header, a legacy entry, and an out-of-section entry when: [t1] apply runs then: the output matches snapshot: .gitattributes — after 1`] = `
-"*.png binary
-
-# exclude package locks from git diff; https://stackoverflow.com/a/72834452/3068233
+"# [git] exclude package locks from git diff; https://stackoverflow.com/a/72834452/3068233
 pnpm-lock.yaml -diff
 package-lock.json -diff
 
-# auto-resolve lock file conflicts by taking theirs; run install after merge
+# [git] auto-resolve lock file conflicts by taking theirs; run install after merge
 pnpm-lock.yaml merge=theirs
 package-lock.json merge=theirs
+
+*.png binary
 "
 `;

package/dist/.test/assets/expo-migration/declarations/practices/git/best-practice/.declapract.readme.md

@@ -5,6 +5,43 @@ ordered tail, what a new declarer owes — is stated once at
 `.agent/repo=.this/role=any/briefs/howto.declare-the-repo-gitignore.md`. read that before you add
 a line here.
 
+📖 several practices declare the `.gitattributes` too, and there order carries load. their shared
+contract — the canonical layout, the declarer tag, what a new declarer owes — is stated once at
+`.agent/repo=.this/role=any/briefs/howto.declare-the-repo-gitattributes.md`.
+
+## what folds in a pr, and how to un-fold a path
+
+a repo that adopts these practices gets `linguist-generated` lines, so github renders robocode
+collapsed in a pr. each stays one click away.
+
+| folds | declared by |
+|-------|-------------|
+| `*.test.ts`, `*.test.tsx` | `tests-any` |
+| `src/access/daos/**/.generated/**`, `provision/schema/**/.generated/**` | `persist-with-rds` |
+| `src/access/daos/**/.generated/**` | `persist-with-dynamodb` |
+| `.route/**`, `.behavior/**`, except `*.yield.*` and `.radio/**` | `rhachet` |
+
+snapshots (`*.snap`) stay open: no line names them. the daos and the schemas stay open too: they
+are the internal contracts. only the `.generated/` dirs within them fold.
+
+to un-fold a path, add a line at the bottom of `.gitattributes`, below every `# [<declarer>]`
+section and apart from them by a blank line:
+
+```
+src/access/daos/.generated/** -linguist-generated
+```
+
+the repo's own lines always sit last, and git takes the last line that matches, so this line wins.
+
+- a dir-level line un-folds every file under it, test files included, since it outranks the
+  `tests-any` line too
+- one file un-folds with a line of its own:
+  `src/access/daos/.generated/queryFunctions.ts -linguist-generated`
+- leave your own lines untagged. a `# [<word>]` header marks a managed block: it floats above the
+  repo-own lines, and one that names a declarer is rewritten by that declarer's fix
+
+a folded file may also drop out of github code search, which skips generated files.
+
 ## `.agent/.cache/` is declared here and by the rhachet practice
 
 deliberate, and neither is redundant. rhachet owns the dir in the causal sense — it creates it —

package/dist/.test/assets/expo-migration/declarations/practices/git/best-practice/.gitattributes.declapract.ts

@@ -1,98 +1,77 @@
-import { FileCheckType, type FileFixFunction } from 'declapract';
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import expect from 'expect';
 
-/**
- * check that they're contained in the file
- */
-export const check: FileCheckType = FileCheckType.CONTAINS;
+import {
+  defineExpectedGitattributesContents,
+  type GitattributesSection,
+} from '../../../utils/defineExpectedGitattributesContents';
 
 /**
- * sections of gitattributes entries to ensure exist
+ * .what = the `.gitattributes` sections this practice owns: lock-file diff and merge rules
+ * .why  = lock files churn on every install. `-diff` folds them out of `git diff`, and
+ *         `merge=theirs` takes the incoming lock on a conflict, so an install after the merge
+ *         rebuilds it
+ * .note = `retired` hold every form these sections once took — the untagged headers, the
+ *         `pnpm-lock.json` typo — so a fix lifts them out of an extant file
  */
-const SECTIONS: {
-  header: { latest: string; priors: string[] };
-  entries: { latest: string[]; priors: string[] };
-}[] = [
+const sections: readonly GitattributesSection[] = [
   {
     header: {
       latest:
+        '# [git] exclude package locks from git diff; https://stackoverflow.com/a/72834452/3068233',
+      retired: [
         '# exclude package locks from git diff; https://stackoverflow.com/a/72834452/3068233',
-      priors: [
         '# exclude package-lock from git diff; https://stackoverflow.com/a/72834452/3068233',
       ],
     },
     entries: {
       latest: ['pnpm-lock.yaml -diff', 'package-lock.json -diff'],
-      priors: ['pnpm-lock.json -diff'],
+      retired: ['pnpm-lock.json -diff'],
     },
   },
   {
     header: {
       latest:
+        '# [git] auto-resolve lock file conflicts by taking theirs; run install after merge',
+      retired: [
         '# auto-resolve lock file conflicts by taking theirs; run install after merge',
-      priors: [],
+      ],
     },
     entries: {
       latest: ['pnpm-lock.yaml merge=theirs', 'package-lock.json merge=theirs'],
-      priors: ['pnpm-lock.json merge=theirs'],
+      retired: ['pnpm-lock.json merge=theirs'],
     },
   },
 ];
 
 /**
- * .what = every line this practice manages: each section's header and entries, latest and prior
- * .why  = the fix lifts each of these out of wherever it sits, so none can linger out of place,
- *         out of order, or twice
+ * .what = emits the `.gitattributes` this practice declares, given the repo's extant one
+ * .why  = tests-any, rhachet, and the persist practices declare this same file. they converge
+ *         only through one shared algorithm, so this file declares its sections and imports
+ *         the rest
  */
-const ALL_MANAGED_LINES = SECTIONS.flatMap((s) => [
-  s.header.latest,
-  ...s.header.priors,
-  ...s.entries.latest,
-  ...s.entries.priors,
-]);
+const defineExpectedContents = (input: { contents: string | null }): string =>
+  defineExpectedGitattributesContents({
+    contents: input.contents,
+    declarer: 'git',
+    sections,
+  });
 
 /**
- * .what = the canonical block: each section's latest header + latest entries, in declared order
- * .why  = the check is CONTAINS — the file must hold the whole template as one contiguous run of
- *         text — so the fix must emit this block verbatim. a section re-assembled in place (an
- *         entry inserted after its header, or a stray entry left outside its section) is a fixed
- *         point that never CONTAINS the template, so the plan would flag the file on every run
+ * .what = throws when the repo's `.gitattributes` differs from what the shared layout emits
+ * .why  = `check` gates `fix`: a throw means violated (best-practice semantics). an exact
+ *         equality, not CONTAINS, since order carries load and `check(x) ⟺ x === fix(x)`
+ *         keeps `declapract apply` from a loop
  */
-const CANONICAL_BLOCK = SECTIONS.map((s) =>
-  [s.header.latest, ...s.entries.latest].join('\n'),
-).join('\n\n');
-
-/**
- * .what = the repo-own lines of a .gitattributes: every managed line dropped, runs of blank
- *         lines collapsed to one, and the edges trimmed
- * .why  = the repo keeps every line this practice does not manage, in its own order
- */
-const asRepoOwnBlock = (input: { contents: string }): string => {
-  // drop every managed line, wherever it sits
-  const linesRepoOwn = input.contents
-    .split('\n')
-    .filter((line) => !ALL_MANAGED_LINES.includes(line.trim()));
-
-  // collapse runs of blank lines into one (drop a blank that follows a blank)
-  const linesCollapsed = linesRepoOwn.filter(
-    (line, index) =>
-      !(
-        line.trim() === '' &&
-        index > 0 &&
-        linesRepoOwn[index - 1]!.trim() === ''
-      ),
-  );
-
-  return linesCollapsed.join('\n').trim();
+export const check: FileCheckFunction = (contents) => {
+  expect(contents).toEqual(defineExpectedContents({ contents }));
 };
 
 /**
- * .what = the repo-own lines first, then the canonical block, with exactly one final newline
- * .why  = legacy headers and entries drop, duplicates collapse to one, and the output CONTAINS the
- *         template — so the check passes on the fixed output and a second fix changes zero
+ * .what = sets this practice's sections into the repo's `.gitattributes`
+ * .why  = legacy headers and entries drop, duplicates collapse to one, repo-own lines move
+ *         last; a fixed point, so a second fix changes zero
  */
-export const fix: FileFixFunction = (contents) => {
-  const repoOwnBlock = asRepoOwnBlock({ contents: contents ?? '' });
-  return {
-    contents: `${[repoOwnBlock, CANONICAL_BLOCK].filter((block) => block).join('\n\n')}\n`,
-  };
-};
+export const fix: FileFixFunction = (contents) => ({
+  contents: defineExpectedContents({ contents }),
+});

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/.test/assets/repo-stale-patch-beside-bare/declapract.use.yml

@@ -0,0 +1,4 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/pnpm/declarations
+# .why  = a repo with one patch the lockfile moved past and one it still resolves (#680)
+declarations: 'declarations/declapract.declare.yml'
+useCase: pnpm-repo

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/.test/assets/repo-stale-patch-beside-bare/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "repo-stale-patch-beside-bare",
+  "version": "1.0.0",
+  "packageManager": "pnpm@10.34.5",
+  "pnpm": {
+    "overrides": {
+      "react-refresh": "0.14.2"
+    },
+    "patchedDependencies": {
+      "rhachet-roles-ehmpathy": "patches/rhachet-roles-ehmpathy.patch",
+      "rhachet-roles-ehmpathy@1.39.1": "patches/rhachet-roles-ehmpathy@1.39.1.patch",
+      "type-fns@1.21.3": "patches/type-fns@1.21.3.patch"
+    }
+  }
+}

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/.test/assets/repo-stale-patch-beside-bare/patches/rhachet-roles-ehmpathy.patch

@@ -0,0 +1,6 @@
+diff --git a/dist/index.js b/dist/index.js
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -1 +1 @@
+-module.exports = {};
++module.exports = { patched: true };

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/.test/assets/repo-stale-patch-beside-bare/patches/rhachet-roles-ehmpathy@1.39.1.patch

@@ -0,0 +1,6 @@
+diff --git a/dist/index.js b/dist/index.js
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -1 +1 @@
+-module.exports = {};
++module.exports = { patched: true };

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/.test/assets/repo-stale-patch-beside-bare/patches/type-fns@1.21.3.patch

@@ -0,0 +1,6 @@
+diff --git a/dist/index.js b/dist/index.js
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -1 +1 @@
+-module.exports = {};
++module.exports = { patched: true };

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/.test/assets/repo-stale-patch-beside-bare/pnpm-lock.yaml

@@ -0,0 +1,19 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+packages:
+
+  rhachet-roles-ehmpathy@1.40.0:
+    resolution: {integrity: sha512-a}
+
+  type-fns@1.21.3:
+    resolution: {integrity: sha512-b}
+
+snapshots:
+
+  rhachet-roles-ehmpathy@1.40.0: {}
+
+  type-fns@1.21.3: {}

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/__snapshots__/stale-patched-dependency.declapract.integration.test.ts.snap

@@ -36,3 +36,42 @@ exports[`pnpm — a stale patch never blocks an install given: [case1] a repo wi
 }
 "
 `;
+
+exports[`pnpm — a stale patch never blocks an install given: [case2] a repo with a bare-name patch key beside a stale exact key of the same package when: [t0] the pnpm practice is applied then: the before + after contents match snapshot: package.json — after 1`] = `
+"{
+  "name": "repo-stale-patch-beside-bare",
+  "version": "1.0.0",
+  "packageManager": "pnpm@10.34.5",
+  "pnpm": {
+    "overrides": {
+      "react-refresh": "0.14.2"
+    },
+    "patchedDependencies": {
+      "rhachet-roles-ehmpathy": "patches/rhachet-roles-ehmpathy.patch",
+      "type-fns@1.21.3": "patches/type-fns@1.21.3.patch"
+    },
+    "allowUnusedPatches": true,
+    "ignorePatchFailures": true
+  }
+}
+"
+`;
+
+exports[`pnpm — a stale patch never blocks an install given: [case2] a repo with a bare-name patch key beside a stale exact key of the same package when: [t0] the pnpm practice is applied then: the before + after contents match snapshot: package.json — before 1`] = `
+"{
+  "name": "repo-stale-patch-beside-bare",
+  "version": "1.0.0",
+  "packageManager": "pnpm@10.34.5",
+  "pnpm": {
+    "overrides": {
+      "react-refresh": "0.14.2"
+    },
+    "patchedDependencies": {
+      "rhachet-roles-ehmpathy": "patches/rhachet-roles-ehmpathy.patch",
+      "rhachet-roles-ehmpathy@1.39.1": "patches/rhachet-roles-ehmpathy@1.39.1.patch",
+      "type-fns@1.21.3": "patches/type-fns@1.21.3.patch"
+    }
+  }
+}
+"
+`;

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/stale-patched-dependency.declapract.integration.test.ts

@@ -79,4 +79,57 @@ describe('pnpm — a stale patch never blocks an install', () => {
       });
     });
   });
+
+  given('[case2] a repo with a bare-name patch key beside a stale exact key of the same package', () => {
+    // the shape persist-with-rds ships for pg-pool: a bare key, which no lockfile can move past
+    const tempDir = genTempRepoWithDeclarationsOutside({
+      slug: 'pnpm-stale-patch-beside-bare',
+      clone: './src/practices/pnpm/.test/assets/repo-stale-patch-beside-bare',
+      declarations: './src/.test/assets/pnpm/declarations',
+      symlink: [{ at: 'node_modules', to: 'node_modules' }],
+    });
+    const stalePatch = 'patches/rhachet-roles-ehmpathy@1.39.1.patch';
+    const barePatch = 'patches/rhachet-roles-ehmpathy.patch';
+
+    const state = useBeforeAll(async () => {
+      const config = path.join(tempDir, 'declapract.use.yml');
+      const read = () =>
+        fs.readFile(path.join(tempDir, 'package.json'), 'utf-8');
+      const before = await read();
+      await executeApply({ config });
+      const after1 = await read();
+      const exists1 = {
+        stale: existsSync(path.join(tempDir, stalePatch)),
+        bare: existsSync(path.join(tempDir, barePatch)),
+      };
+      await executeApply({ config });
+      const after2 = await read();
+      return { before, after1, after2, exists1 };
+    }, 170_000);
+
+    when('[t0] the pnpm practice is applied', () => {
+      then('the stale exact key is retired; the bare-name key is kept', () => {
+        const patched = JSON.parse(state.after1).pnpm.patchedDependencies;
+        expect(patched).toEqual({
+          'rhachet-roles-ehmpathy': barePatch,
+          'type-fns@1.21.3': 'patches/type-fns@1.21.3.patch',
+        });
+      });
+
+      then('the stale patch file is deleted; the bare-name file is kept', () => {
+        expect(state.exists1).toEqual({ stale: false, bare: true });
+      });
+
+      then('the before + after contents match snapshot', () => {
+        expect(state.before).toMatchSnapshot('package.json — before');
+        expect(state.after1).toMatchSnapshot('package.json — after');
+      });
+    });
+
+    when('[t1] the practice is applied a second time', () => {
+      then('the second apply is a no-op', () => {
+        expect(state.after2).toEqual(state.after1);
+      });
+    });
+  });
 });

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/best-practice/.declapract.readme.md

@@ -30,3 +30,11 @@ that a re-apply changes zero bytes.
 
 it sits there because one temp repo must hold both declarations to prove they agree. this pointer
 exists so a reader in `src/practices/rhachet/` can find it.
+
+## route robocode folds in a pr
+
+this practice declares a `# [rhachet]` section of the repo-root `.gitattributes`: each file under
+`.route/` and `.behavior/` is `linguist-generated`, so github renders it collapsed, except
+`*.yield.*` files and `.radio/` records, which stay open. its section sits last among the declarers,
+so those exceptions win over any earlier collapse line. to un-fold a path, see "what folds in a pr"
+in `src/practices/git/best-practice/.declapract.readme.md`.