declapract-typescript-ehmpathy 0.49.13 → 0.49.14

package/dist/practices/environments/best-practice/src/access/sdks/sdkAwsLambdaEnvAccessAncient.ts

@@ -11,6 +11,13 @@ import { envStatic } from '@src/utils/environment';
  */
 export type LambdaEnvSlug = EnvironmentAccessTier | 'dev';
 
+/**
+ * .what = the exact slugs an ancient peer publishes under: `prod`, or the legacy `dev`.
+ * .why  = the ancient helper never emits `test` or `prep`, so its return type says so — a caller
+ *         that narrows on it handles only the two values that can arrive.
+ */
+export type LambdaEnvSlugAncient = Extract<LambdaEnvSlug, 'prod' | 'dev'>;
+
 /**
  * .what = address an **ancient** peer — one that publishes `-dev-` only.
  * .why  = `askLambdaEndpoint` builds its target as `${service}-${access}-${function}`.
@@ -21,12 +28,13 @@ export type LambdaEnvSlug = EnvironmentAccessTier | 'dev';
  * .note = the helper choice IS the migration ledger: `grep AccessAncient` lists every
  *         peer still published under `-dev-` only. once zero remain, this ancient branch
  *         — and the divergent `dev` slug — retire together, alongside its contemp
- *         counterpart `sdkAwsLambdaEnvAccessContemp`. the return type is `LambdaEnvSlug`,
- *         so the `dev` slug flows with a compiler-tracked type — no cast, no lie.
+ *         counterpart `sdkAwsLambdaEnvAccessContemp`. the return type is the exact set
+ *         `LambdaEnvSlugAncient`, so the `dev` slug flows with a compiler-tracked type — no
+ *         cast, no lie.
  */
-export const sdkAwsLambdaEnvAccessAncient = (
-  input?: { access: EnvironmentAccessTier | null },
-): LambdaEnvSlug => {
+export const sdkAwsLambdaEnvAccessAncient = (input?: {
+  access: EnvironmentAccessTier | null;
+}): LambdaEnvSlugAncient => {
   const access = input?.access ?? envStatic.access;
   return access === 'prod' ? 'prod' : 'dev';
 };

package/dist/practices/environments/best-practice/src/access/sdks/sdkAwsLambdaEnvAccessContemp.ts

@@ -9,6 +9,6 @@ import { envStatic } from '@src/utils/environment';
  *         `sdkAwsLambdaEnvAccessAncient`: as peers migrate, a caller flips
  *         `Ancient → Contemp` per peer, and `grep AccessAncient` at zero is the exit.
  */
-export const sdkAwsLambdaEnvAccessContemp = (
-  input?: { access: EnvironmentAccessTier | null },
-): EnvironmentAccessTier => input?.access ?? envStatic.access;
+export const sdkAwsLambdaEnvAccessContemp = (input?: {
+  access: EnvironmentAccessTier | null;
+}): EnvironmentAccessTier => input?.access ?? envStatic.access;

package/dist/practices/environments-aws/best-practice/.declapract.readme.md

@@ -1 +1,5 @@
 the aws environments provisioned here follow the `environments` best practices
+
+this practice declares no file of its own: `terraform-aws` owns `provision/aws/environments/{test,prep,prod}/`.
+an EXISTS-only claim here could never be fixed (an EXISTS check carries no fix), so on a fresh repo it
+marked the file manual and blocked the owner's fix too (#630, #607).

package/dist/practices/format/.declapract.integration.test.ts

@@ -8,37 +8,28 @@ import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
 jest.setTimeout(180_000); // 3 minutes
 
 /**
- * .what = pipeline test for the usecase-aware format package.json `contents` fn (r001.b3)
- * .why  = a unit test proves the `contents` fn in isolation against a mocked context; only the
- *         real executeApply pipeline proves that declapract:
- *         - matches the package.json declaration to the consumer's package.json
- *         - feeds context.projectPractices with the terraform signal derived through a REAL usecase
- *           (terraform-common present vs absent), NOT a hand-built context object
- *         - emits the chained fix:format / test:format the branch builds, into the file on disk
- *         per rule.require.declapract-integration-tests, a usecase-aware `contents` fn that silently
- *         changes what a consumer receives owes an executeApply pipeline test, not a unit test alone.
+ * .what = pipeline test for the format practice's package.json: biome is the one formatter (#645).
+ * .why  = `terraform fmt` needs a host binary that no practice declares, so `npm run test:format`
+ *         failed on any box without terraform. two declarations must cooperate on one file:
+ *         - the best-practice CONTAINS json fix rewrites the `fix:format` / `test:format` chains
+ *         - the `terraform-formatter` bad-practice deletes the two terraform sub-command keys
+ *         only the real executeApply proves declapract runs both on one package.json and that the
+ *         result converges (a second apply changes zero bytes).
  * .note = INTEGRATION by rule.forbid.unit.remote-boundaries: it reads the filesystem + runs
- *         executeApply against a temp clone. no credential, no network. the fixtures live under a
- *         `.test` dot-dir (excluded from tsconfig/jest globs); a lean declarations mirror symlinks
- *         only format + terraform-common so the whole-usecase compile does not blow the hook timeout.
- * .note = the confound: terraform-common's OWN package.json also declares a standalone
- *         `fix:format:terraform` command, so a bare "contains fix:format:terraform" assertion could
- *         not isolate the format branch. the DISTINGUISHING signal for format's branch is the
- *         CHAINED `fix:format` value (`... && npm run fix:format:terraform`), which only format emits.
- *         so every assertion reads the `fix:format` chain value, never the standalone key.
- * .teeth = with-terraform: the emitted `fix:format` chain MUST include the terraform sub-command —
- *          a revert of the branch to biome-only reddens it. without-terraform: the chain MUST be
- *          biome-only — a branch that fired on the wrong (absent) signal reddens it.
+ *         executeApply against a temp clone. the fixtures live under a `.test` dot-dir; a lean
+ *         declarations mirror symlinks only format + terraform-common so the whole-usecase compile
+ *         does not blow the hook timeout.
+ * .note = filter by file only, never by practice, so every usecase practice stays in
+ *         projectPractices — terraform-common sits in the case1 usecase, and the chain must still
+ *         come out biome only.
+ * .teeth = restore the terraform branch in format's contents, or drop the bad-practice, and case1
+ *          goes red: a terraform sub-command or key survives the apply.
  */
-describe('format practice — the usecase-aware package.json contents fn (r001.b3)', () => {
-  const readCommands = async (
-    tempDir: string,
-  ): Promise<Record<string, string>> => {
-    const raw = await fs.readFile(path.join(tempDir, 'package.json'), 'utf-8');
-    return JSON.parse(raw).scripts as Record<string, string>;
-  };
+describe('format practice — package.json is biome only (#645)', () => {
+  const readPackageJSON = async (tempDir: string): Promise<string> =>
+    fs.readFile(path.join(tempDir, 'package.json'), 'utf-8');
 
-  given('[case1] a consumer on a terraform usecase', () => {
+  given('[case1] an adopter one release behind, on a terraform usecase', () => {
     const tempDir = genTempDir({
       slug: 'format-pkgjson-with-terraform',
       clone: './src/.test/assets/format/repo-with-terraform',
@@ -51,41 +42,55 @@ describe('format practice — the usecase-aware package.json contents fn (r001.b
       ],
     });
 
-    // useBeforeAll RETURNS the captured reads (no in-place mutation of a shared const).
-    // .note = filter by file ONLY, never by practice. the practice filter narrows
-    //         projectPractices too (getDesiredPractices), which would strip terraform-common
-    //         and silence the branch. file-only keeps every usecase practice in projectPractices
-    //         while it applies just the package.json plan.
-    const commands = useBeforeAll(async () => {
+    const result = useBeforeAll(async () => {
+      const before = await readPackageJSON(tempDir);
       await executeApply({
         config: path.join(tempDir, 'declapract.use.yml'),
         file: 'package.json',
       });
-      return readCommands(tempDir);
+      const afterFirst = await readPackageJSON(tempDir);
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        file: 'package.json',
+      });
+      const afterSecond = await readPackageJSON(tempDir);
+      return { before, afterFirst, afterSecond };
     }, 170_000);
 
-    when('[t0] the format package.json is applied', () => {
-      then('the fix:format chain includes the terraform sub-command', () => {
-        expect(commands['fix:format']).toContain('npm run fix:format:terraform');
+    when('[t0] declapract apply', () => {
+      then('fix:format and test:format chain biome only', () => {
+        const { scripts } = JSON.parse(result.afterFirst);
+        expect(scripts['fix:format']).toEqual('npm run fix:format:biome');
+        expect(scripts['test:format']).toEqual('npm run test:format:biome');
       });
 
-      then('the fix:format chain still leads with biome', () => {
-        expect(commands['fix:format']).toContain('npm run fix:format:biome');
+      then('the two terraform formatter keys are gone', () => {
+        const { scripts } = JSON.parse(result.afterFirst);
+        expect(scripts['fix:format:terraform']).toBeUndefined();
+        expect(scripts['test:format:terraform']).toBeUndefined();
+        expect(result.afterFirst).not.toContain('terraform');
       });
 
-      then('the test:format chain includes the terraform sub-command', () => {
-        expect(commands['test:format']).toContain(
-          'npm run test:format:terraform',
-        );
+      then('the biome sub-commands the adopter owns survive', () => {
+        const { scripts } = JSON.parse(result.afterFirst);
+        expect(scripts['fix:format:biome']).toEqual('biome check --write');
+        expect(scripts['test:format:biome']).toEqual('biome format');
       });
 
-      then('the emitted commands block matches snapshot', () => {
-        expect(commands).toMatchSnapshot('with-terraform — commands');
+      then('before + after of package.json match snapshot', () => {
+        expect(result.before).toMatchSnapshot('package.json — before');
+        expect(result.afterFirst).toMatchSnapshot('package.json — after');
+      });
+    });
+
+    when('[t1] declapract apply a second time', () => {
+      then('zero bytes change', () => {
+        expect(result.afterSecond).toEqual(result.afterFirst);
       });
     });
   });
 
-  given('[case2] a consumer on a non-terraform usecase', () => {
+  given('[case2] a fresh consumer on a non-terraform usecase', () => {
     const tempDir = genTempDir({
       slug: 'format-pkgjson-without-terraform',
       clone: './src/.test/assets/format/repo-without-terraform',
@@ -98,33 +103,24 @@ describe('format practice — the usecase-aware package.json contents fn (r001.b
       ],
     });
 
-    const commands = useBeforeAll(async () => {
+    // useBeforeAll returns a proxy, so the string rides inside an object
+    const result = useBeforeAll(async () => {
       await executeApply({
         config: path.join(tempDir, 'declapract.use.yml'),
         file: 'package.json',
       });
-      return readCommands(tempDir);
+      return { after: await readPackageJSON(tempDir) };
     }, 170_000);
 
-    when('[t0] the format package.json is applied', () => {
-      then('the fix:format chain is biome-only', () => {
-        expect(commands['fix:format']).toEqual('npm run fix:format:biome');
-      });
-
-      then('the fix:format chain omits the terraform sub-command (the teeth)', () => {
-        expect(commands['fix:format']).not.toContain(
-          'npm run fix:format:terraform',
-        );
-      });
-
-      then('the test:format chain omits the terraform sub-command', () => {
-        expect(commands['test:format']).not.toContain(
-          'npm run test:format:terraform',
-        );
+    when('[t0] declapract apply', () => {
+      then('fix:format and test:format chain biome only', () => {
+        const { scripts } = JSON.parse(result.after);
+        expect(scripts['fix:format']).toEqual('npm run fix:format:biome');
+        expect(scripts['test:format']).toEqual('npm run test:format:biome');
       });
 
-      then('the emitted commands block matches snapshot', () => {
-        expect(commands).toMatchSnapshot('without-terraform — commands');
+      then('package.json matches snapshot', () => {
+        expect(result.after).toMatchSnapshot('package.json — after');
       });
     });
   });

package/dist/practices/format/__snapshots__/.declapract.integration.test.ts.snap

@@ -1,17 +1,43 @@
 // Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
-exports[`format practice — the usecase-aware package.json contents fn (r001.b3) given: [case1] a consumer on a terraform usecase when: [t0] the format package.json is applied then: the emitted commands block matches snapshot: with-terraform — commands 1`] = `
-{
-  "fix:format": "npm run fix:format:biome && npm run fix:format:terraform",
-  "fix:format:terraform": "terraform fmt -recursive provision",
-  "test:format": "npm run test:format:biome && npm run test:format:terraform",
-  "test:format:terraform": "terraform fmt -recursive -check provision",
+exports[`format practice — package.json is biome only (#645) given: [case1] an adopter one release behind, on a terraform usecase when: [t0] declapract apply then: before + after of package.json match snapshot: package.json — after 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "scripts": {
+    "fix:format:biome": "biome check --write",
+    "fix:format": "npm run fix:format:biome",
+    "test:format:biome": "biome format",
+    "test:format": "npm run test:format:biome"
+  }
 }
+"
 `;
 
-exports[`format practice — the usecase-aware package.json contents fn (r001.b3) given: [case2] a consumer on a non-terraform usecase when: [t0] the format package.json is applied then: the emitted commands block matches snapshot: without-terraform — commands 1`] = `
-{
-  "fix:format": "npm run fix:format:biome",
-  "test:format": "npm run test:format:biome",
+exports[`format practice — package.json is biome only (#645) given: [case1] an adopter one release behind, on a terraform usecase when: [t0] declapract apply then: before + after of package.json match snapshot: package.json — before 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "scripts": {
+    "fix:format:biome": "biome check --write",
+    "fix:format:terraform": "terraform fmt -recursive provision",
+    "fix:format": "npm run fix:format:biome && npm run fix:format:terraform",
+    "test:format:terraform": "terraform fmt -recursive -check provision",
+    "test:format:biome": "biome format",
+    "test:format": "npm run test:format:biome && npm run test:format:terraform"
+  }
 }
+"
+`;
+
+exports[`format practice — package.json is biome only (#645) given: [case2] a fresh consumer on a non-terraform usecase when: [t0] declapract apply then: package.json matches snapshot: package.json — after 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "scripts": {
+    "fix:format": "npm run fix:format:biome",
+    "test:format": "npm run test:format:biome"
+  }
+}
+"
 `;

package/dist/practices/format/bad-practices/terraform-formatter/package.json.declapract.ts

@@ -0,0 +1,57 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { asPackageJSON } from '../../../../utils/asPackageJSON';
+
+/**
+ * .what = the two terraform formatter commands `terraform-common` once shipped into package.json
+ * .why  = format is biome only (#645). `terraform fmt` needs a host binary that no practice
+ *         declares, so `npm run test:format` failed on every box without terraform. the format
+ *         best-practice is a CONTAINS json check: its fix rewrites the `fix:format` / `test:format`
+ *         chains to biome only, but never deletes a key. this bad-practice deletes the two keys.
+ * .note = lives in `format`, not `terraform-common`: format is core and stays, so it still cleans
+ *         an adopter that upgrades after terraform-common is gone.
+ */
+const TERRAFORM_FORMAT_KEYS = ['fix:format:terraform', 'test:format:terraform'];
+const PRACTICE = 'format/terraform-formatter';
+
+export const check: FileCheckFunction = (contents) => {
+  if (!contents)
+    throw new Error(
+      `does not match bad practice: [${PRACTICE}] package.json has no contents`,
+    );
+
+  const packageJSON = asPackageJSON({ contents }, { practice: PRACTICE });
+  const scripts: Record<string, unknown> = packageJSON.scripts ?? {};
+  if (TERRAFORM_FORMAT_KEYS.some((key) => key in scripts)) return; // detected
+
+  throw new Error(
+    `does not match bad practice: [${PRACTICE}] no terraform formatter command in scripts`,
+  );
+};
+
+/**
+ * .what = the package.json without the two terraform formatter commands; all other keys keep
+ *         their order and value
+ */
+const withoutTerraformFormatKeys = (input: {
+  packageJSON: Record<string, any>;
+}): Record<string, any> => {
+  const scripts = { ...input.packageJSON.scripts };
+  TERRAFORM_FORMAT_KEYS.forEach((key) => {
+    delete scripts[key];
+  });
+  return { ...input.packageJSON, scripts };
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+
+  const packageJSON = asPackageJSON({ contents }, { practice: PRACTICE });
+  return {
+    contents: JSON.stringify(
+      withoutTerraformFormatKeys({ packageJSON }),
+      null,
+      2,
+    ),
+  };
+};

package/dist/practices/format/best-practice/package.json

@@ -0,0 +1,6 @@
+{
+  "scripts": {
+    "fix:format": "npm run fix:format:biome",
+    "test:format": "npm run test:format:biome"
+  }
+}

package/dist/practices/format/best-practice/package.json.declapract.ts

@@ -1,50 +1,10 @@
-import { FileCheckType, type FileContentsFunction } from 'declapract';
-import { isPresent } from 'type-fns';
+import { FileCheckType } from 'declapract';
 
 /**
- * .what = the active formatter set for a repo — `biome` always, `terraform` only when a terraform
- *         practice is in use.
- * .why  = names the set derivation as one intent, so `contents` reads what-not-how rather than an
- *         inline conditional-null-in-array + filter pipeline a reader must mentally simulate
- *         (`rule.forbid.inline-decode-friction`).
+ * .what = the `fix:format` / `test:format` commands must be present, biome only.
+ * .why  = biome is the one formatter (#645). a chain that also ran `terraform fmt` needed a host
+ *         binary no practice declares, so it failed on every box without terraform. the json
+ *         CONTAINS fix rewrites a stale chain in place; `bad-practices/terraform-formatter`
+ *         deletes the old terraform sub-command keys.
  */
-const asActiveFormatters = (input: { usesTerraform: boolean }): string[] =>
-  ['biome', input.usesTerraform ? 'terraform' : null].filter(isPresent);
-
-/**
- * .what = build the `fix:format` / `test:format` npm commands from the active formatter list — each
- *         a ` && `-joined chain of per-formatter sub-commands.
- * .why  = names the derivation as one intent, so `contents` reads what-not-how rather than an
- *         inline filter/map/join pipeline a reader must mentally simulate (`rule.require.named-transformers`).
- */
-const asFormatScripts = (input: {
-  formatters: string[];
-}): Record<string, string> => ({
-  'fix:format': input.formatters
-    .map((formatter) => `npm run fix:format:${formatter}`)
-    .join(' && '),
-  'test:format': input.formatters
-    .map((formatter) => `npm run test:format:${formatter}`)
-    .join(' && '),
-});
-
-/**
- * declare the expected contents
- */
-export const contents: FileContentsFunction = (context) => {
-  // only include the terraform formatter if a terraform practice is in use.
-  // the practices are named `terraform-common` / `terraform-aws` (see useCases.yml) —
-  // a check for the bare `terraform` matches NO practice, so the formatter would never run.
-  const usesTerraform =
-    context.projectPractices.includes('terraform-common') ||
-    context.projectPractices.includes('terraform-aws');
-
-  const formatters = asActiveFormatters({ usesTerraform });
-
-  return JSON.stringify({ scripts: asFormatScripts({ formatters }) }, null, 2);
-};
-
-/**
- * check that they're contained in the file
- */
-export const check: FileCheckType = FileCheckType.CONTAINS;
+export const check = FileCheckType.CONTAINS;

package/dist/practices/git/.gitattributes.declapract.integration.test.ts

@@ -0,0 +1,105 @@
+import fs from 'node:fs/promises';
+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
+jest.setTimeout(5 * 60 * 1000);
+
+const MANAGED_ENTRIES = [
+  'pnpm-lock.yaml -diff',
+  'package-lock.json -diff',
+  'pnpm-lock.yaml merge=theirs',
+  'package-lock.json merge=theirs',
+];
+
+/**
+ * .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
+ *         (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
+ */
+describe('git .gitattributes', () => {
+  given('[case1] a repo whose .gitattributes holds a legacy header, a legacy entry, and an out-of-section entry', () => {
+    const tempDir = genTempDir({
+      slug: 'git-gitattributes-legacy',
+      clone: './src/practices/git/.test/assets/repo-with-legacy-gitattributes',
+      symlink: [
+        { at: 'declarations', to: './.test/assets/git/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+    const read = () =>
+      fs.readFile(path.join(tempDir, '.gitattributes'), 'utf-8');
+    const apply = () =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'git',
+        file: '.gitattributes',
+      });
+
+    when('[t0] before any apply', () => {
+      then('the input file matches snapshot', async () => {
+        expect(await read()).toMatchSnapshot('.gitattributes — before');
+      });
+    });
+
+    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 };
+      });
+
+      then('the file contains the template verbatim — the CONTAINS check passes', () => {
+        expect(scene.after).toContain(scene.template.trim());
+      });
+
+      then('the legacy header and the legacy entry are gone', () => {
+        expect(scene.after).not.toContain('# exclude package-lock from git diff');
+        expect(scene.after).not.toContain('pnpm-lock.json -diff');
+      });
+
+      then('each managed entry appears exactly once', () => {
+        MANAGED_ENTRIES.forEach((entry) =>
+          expect(
+            scene.after.split('\n').filter((line) => line.trim() === entry),
+          ).toHaveLength(1),
+        );
+      });
+
+      then('the repo-own line survives', () => {
+        expect(scene.after).toContain('*.png binary');
+      });
+
+      then('no declapract template syntax leaked', () => {
+        expect(scene.after).not.toContain('@declapract{');
+      });
+
+      then('the output matches snapshot', () => {
+        expect(scene.after).toMatchSnapshot('.gitattributes — after');
+      });
+    });
+
+    when('[t2] apply runs a second time', () => {
+      const before = useBeforeAll(async () => ({ contents: await read() }));
+      const scene = useThen('apply again', async () => {
+        await apply();
+        return { after: await read() };
+      });
+
+      then('the file is byte-identical — the apply is a fixed point', () => {
+        expect(scene.after).toEqual(before.contents);
+      });
+    });
+  });
+});

package/dist/practices/git/.test/assets/repo-with-legacy-gitattributes/.gitattributes

@@ -0,0 +1,6 @@
+*.png binary
+
+# exclude package-lock from git diff; https://stackoverflow.com/a/72834452/3068233
+package-lock.json -diff
+pnpm-lock.json -diff
+pnpm-lock.yaml merge=theirs

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

@@ -0,0 +1,7 @@
+# .note = declarations dir is symlinked by the test to .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
+# .note = NO `variables:` block — `git` and `rhachet` reference zero `@declapract{variable.*}`
+declarations: 'declarations/declapract.declare.yml'
+useCase: typescript-project

package/dist/practices/git/.test/assets/repo-with-legacy-gitattributes/package.json

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

package/dist/practices/git/__snapshots__/.declapract.integration.test.ts.snap

@@ -9,14 +9,15 @@ node_modules
 `;
 
 exports[`gitignore practices given: [case1] a repo whose .gitignore lacks both cache dirs when: [t3] both practices are applied a second time then: the settled file matches snapshot: .gitignore -- settled 1`] = `
-"*.bak.*
+"**/.claude/scheduled_tasks*
+*.bak.*
 *.local.json
 *.log
 *.tsbuildinfo
 .agent/.cache/
+.agent/.notes/
 .artifact
 .cache/
-.claude/scheduled_tasks*
 .env
 .idea
 .log/slowtest/
@@ -42,8 +43,9 @@ node_modules
 `;
 
 exports[`gitignore practices given: [case2] a repo whose use case has rhachet but NOT git when: [t1] the rhachet practice is applied then: the settled file matches snapshot: .gitignore -- rhachet only 1`] = `
-".agent/.cache/
-.claude/scheduled_tasks*
+"**/.claude/scheduled_tasks*
+.agent/.cache/
+.agent/.notes/
 .idea
 dist
 node_modules

package/dist/practices/git/__snapshots__/.gitattributes.declapract.integration.test.ts.snap

@@ -0,0 +1,24 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`git .gitattributes given: [case1] a repo whose .gitattributes holds a legacy header, a legacy entry, and an out-of-section entry when: [t0] before any apply then: the input file matches snapshot: .gitattributes — before 1`] = `
+"*.png binary
+
+# exclude package-lock from git diff; https://stackoverflow.com/a/72834452/3068233
+package-lock.json -diff
+pnpm-lock.json -diff
+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
+pnpm-lock.yaml -diff
+package-lock.json -diff
+
+# auto-resolve lock file conflicts by taking theirs; run install after merge
+pnpm-lock.yaml merge=theirs
+package-lock.json merge=theirs
+"
+`;