declapract-typescript-ehmpathy 0.49.14 → 0.50.0

package/dist/typecheckBestPracticeTemplates.declapract.integration.test.ts

@@ -4,6 +4,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 import { executeApply, executePlan } from 'declapract';
+import { ConstraintError, MalfunctionError } from 'helpful-errors';
 import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
 
 import { asPackageJSON } from './utils/asPackageJSON';
@@ -12,6 +13,10 @@ import { asPackageJSON } from './utils/asPackageJSON';
  * .what = the pnpm this repo pins in its own `packageManager`, run via npx
  * .why  = a ci test job restores node_modules from cache and puts no pnpm on its PATH, so a bare
  *         `pnpm` spawn fails ENOENT. npx fetches the pinned version, so the run needs no host pnpm
+ * .note = `--loglevel=error` sits before the package spec, so it quiets npx's own npm and reaches
+ *         neither pnpm nor tsc: npx reads the emitted `.npmrc`, and a newer host npm warns on each
+ *         pnpm-only key in it (`node-linker`, `public-hoist-pattern`), which says naught of the
+ *         templates and would vary each snapshot with the host's npm
  */
 const PNPM_VIA_NPX = (() => {
   const packageManager: string = asPackageJSON(
@@ -23,7 +28,10 @@ const PNPM_VIA_NPX = (() => {
     },
     { practice: 'typecheck-best-practice-templates' },
   ).packageManager;
-  return { command: 'npx', argsBefore: ['--yes', packageManager] };
+  return {
+    command: 'npx',
+    argsBefore: ['--yes', '--loglevel=error', packageManager],
+  };
 })();
 
 /**
@@ -55,6 +63,12 @@ const PNPM_VIA_NPX = (() => {
  * .teeth = restore `/\bs3\s*:/` as the s3 key pattern in `cache/bad-practices/cache-directory-options`
  *          — the config template `src/utils/config/getOneCacheDirectory.ts` is flagged in each
  *          usecase that ships it.
+ * .what = also runs each usecase's emitted cycle check (`test:lint:cycles`) on the installed tree,
+ *         and clamps that no cycle runs through pg-pool. dpdm walks node_modules (`exclude: []`),
+ *         so a cycle in a shipped prod dep reddens every adopter's lint gate at once. every other
+ *         cycle it finds is held in a snapshot, so a new one shows in review.
+ * .teeth = drop the `pg-pool` key from `persist-with-rds/best-practice/package.json`
+ *          `pnpm.patchedDependencies` — `lambda-service-with-rds` reports `pg -> pg-pool`.
  * .note = the test lives at `src/` (not under `src/.test/`): jest skips dot dirs, so a test there
  *         would never run.
  */
@@ -70,6 +84,10 @@ const USECASES = [
 ] as const;
 type Usecase = (typeof USECASES)[number];
 
+// the usecases whose install holds pg-pool; `[t3]` checks this set against each real install, so
+// a usecase that gains pg reddens until it joins, and its pg-pool verdict is never vacuous
+const USECASES_WITH_PG_POOL: readonly Usecase[] = ['lambda-service-with-rds'];
+
 // every `@declapract{variable.*}` any practice in any usecase references
 const VARIABLES_YML = `
 variables:
@@ -114,6 +132,8 @@ const runInRepo = (input: {
     const child = spawn(input.command, input.args, {
       cwd: input.cwd,
       env: { ...process.env, CI: 'true', FORCE_COLOR: '0' },
+      // a stalled registry kills the child (status null) instead of a silent park of the run
+      timeout: 900_000,
     });
     const chunks: string[] = [];
     child.stdout.on('data', (chunk) => chunks.push(String(chunk)));
@@ -144,6 +164,39 @@ const asMaskedOutput = (input: { output: string; dirs: string[] }): string =>
     input.output,
   );
 
+/**
+ * .what = the package each segment of one dpdm cycle line sits in, joined in cycle order
+ * .why  = a raw cycle line names pnpm store dirs whose suffix hashes shift with every peer set;
+ *         the packages alone are the stable fact a snapshot can hold
+ */
+const asCyclePackages = (input: { line: string }): string =>
+  input.line
+    .split(' -> ')
+    .map((segment) => {
+      const afterStore = segment.trim().split('node_modules/').pop() ?? '';
+      const match = afterStore.match(/^((?:@[^/]+\/)?[^/]+)/);
+      return match?.[1] ?? segment.trim();
+    })
+    .join(' -> ');
+
+/**
+ * .what = the verdict of one `test:lint:cycles` run: whether dpdm analyzed a tree, and each
+ *         cycle it found, as package chains
+ * .why  = a bare repo of a usecase that emits no `src/**\/*.ts` gives dpdm no entry file, which it
+ *         reports as a failure; that is not a cycle, so the summary keeps the two apart
+ */
+const asCycleSummary = (input: {
+  output: string;
+}): { analyzed: boolean; cycles: string[] } => ({
+  analyzed: input.output.includes('Analyze done!'),
+  cycles: input.output
+    .split('\n')
+    .map((line) => line.match(/^\s*\d+\)\s+(.+)$/)?.[1])
+    .filter((line): line is string => line !== undefined)
+    .map((line) => asCyclePackages({ line }))
+    .sort(), // dpdm reports cycles in traversal order, which shifts between runs
+});
+
 /**
  * .what = applies one usecase into its temp repo, installs the emitted deps, and compiles
  * .why  = the three steps an adopter takes before their first `tsc`
@@ -155,8 +208,11 @@ const genTypecheckResult = async (input: {
 }): Promise<{
   config: string;
   tsconfigFound: boolean;
+  holdsPgPool: boolean;
+  srcImportsPg: boolean;
   install: { status: number | null; output: string };
   compile: { status: number | null; output: string };
+  cycles: { status: number | null; output: string };
 }> => {
   // declare the usecase this repo adopts, from declarations that live outside the repo
   // .note = declapract joins `declarations` onto the config's dir, so the path is relative, and both
@@ -225,17 +281,48 @@ const genTypecheckResult = async (input: {
     ],
   });
 
+  const compiledAt = Date.now();
+
+  // run the emitted cycle check, as the adopter's `npm run test:lint` does
+  const cycles = await runInRepo({
+    cwd,
+    command: PNPM_VIA_NPX.command,
+    args: [...PNPM_VIA_NPX.argsBefore, 'run', 'test:lint:cycles'],
+  });
+
   // report the per-phase cost, so a slow usecase is visible in the run log
   console.log(`typecheck-templates ${input.usecase} phase cost`, {
     applyMs: appliedAt - startedAt,
     installMs: installedAt - appliedAt,
-    compileMs: Date.now() - installedAt,
+    compileMs: compiledAt - installedAt,
+    cyclesMs: Date.now() - compiledAt,
   });
 
+  // whether the install holds pg-pool at all; pnpm keeps a transitive dep only in its store
+  const pnpmStore = path.join(cwd, 'node_modules', '.pnpm');
+  const holdsPgPool =
+    existsSync(pnpmStore) &&
+    (await fs.readdir(pnpmStore)).some((name) => name.startsWith('pg-pool@'));
+
+  // whether any emitted src file imports pg; without one, dpdm never reaches pg-pool
+  const srcDir = path.join(cwd, 'src');
+  const srcFiles = existsSync(srcDir)
+    ? (await fs.readdir(srcDir, { recursive: true }))
+        .map(String)
+        .filter((file) => file.endsWith('.ts'))
+    : [];
+  const srcImportsPg = (
+    await Promise.all(
+      srcFiles.map((file) => fs.readFile(path.join(srcDir, file), 'utf-8')),
+    )
+  ).some((contents) => /from 'pg'/.test(contents));
+
   const dirs = [cwd, input.tempDir];
   return {
     config,
     tsconfigFound,
+    holdsPgPool,
+    srcImportsPg,
     install: {
       status: install.status,
       output: asMaskedOutput({ output: install.output, dirs }),
@@ -244,6 +331,10 @@ const genTypecheckResult = async (input: {
       status: compile.status,
       output: asMaskedOutput({ output: compile.output, dirs }),
     },
+    cycles: {
+      status: cycles.status,
+      output: asMaskedOutput({ output: cycles.output, dirs }),
+    },
   };
 };
 
@@ -326,8 +417,8 @@ describe('typecheck best-practice templates', () => {
   });
 
   // read one usecase's result; a usecase whose preparation threw fails each of its thens loud
-  const getScene = (usecase: Usecase) => {
-    const result = settled[usecase];
+  const getScene = (input: { usecase: Usecase }) => {
+    const result = settled[input.usecase];
     if (result.status === 'rejected') throw result.reason;
     return result.value;
   };
@@ -358,8 +449,8 @@ describe('typecheck best-practice templates', () => {
   });
 
   // read one usecase's plan flags; a plan that threw fails each of its thens loud
-  const getPlan = (usecase: Usecase) => {
-    const result = plans[usecase];
+  const getPlan = (input: { usecase: Usecase }) => {
+    const result = plans[input.usecase];
     if (result.status === 'rejected') throw result.reason;
     return result.value;
   };
@@ -368,55 +459,126 @@ describe('typecheck best-practice templates', () => {
     given(`[usecase] ${usecase} applied to a bare repo`, () => {
       when('[t0] the emitted deps are installed', () => {
         then('the install exits 0', () => {
-          const scene = getScene(usecase);
+          const scene = getScene({ usecase });
           if (scene.install.status !== 0)
-            throw new Error(
-              `pnpm install failed for ${usecase} (exit ${scene.install.status}):\n${scene.install.output}`,
-            );
+            throw new MalfunctionError(`pnpm install failed for ${usecase}`, {
+              status: scene.install.status,
+              output: scene.install.output,
+              hint: 'read the install output above; a registry or cache fault is the usual cause',
+            });
           expect(scene.install.status).toEqual(0);
         });
       });
 
       when('[t1] the emitted tree is compiled with the emitted tsconfig', () => {
         then('the usecase emits a tsconfig.json', () => {
-          expect(getScene(usecase).tsconfigFound).toEqual(true);
+          expect(getScene({ usecase }).tsconfigFound).toEqual(true);
         });
 
         then('the tsc diagnostics match snapshot', () => {
-          expect(getScene(usecase).compile.output).toMatchSnapshot(
+          expect(getScene({ usecase }).compile.output).toMatchSnapshot(
             `${usecase} — tsc --noEmit diagnostics`,
           );
         });
 
         then('tsc --noEmit exits 0', () => {
-          const scene = getScene(usecase);
+          const scene = getScene({ usecase });
           if (scene.compile.status !== 0)
-            throw new Error(
-              `tsc --noEmit failed for ${usecase} (exit ${scene.compile.status}):\n${scene.compile.output}`,
-            );
+            throw new ConstraintError(`tsc --noEmit failed for ${usecase}`, {
+              status: scene.compile.status,
+              output: scene.compile.output,
+              hint: 'a template the usecase ships does not compile; the diagnostics name it',
+            });
           expect(scene.compile.status).toEqual(0);
         });
       });
 
       when('[t2] the twice-applied repo is planned again', () => {
         then('no file is flagged for an automatic fix (the apply converges)', () => {
-          expect(getPlan(usecase).automatic).toEqual([]);
+          expect(getPlan({ usecase }).automatic).toEqual([]);
         });
 
         then('no file the apply wrote is flagged by its own usecase', () => {
           const cwd = realpathSync(tempDirs[usecase].repo);
-          const flaggedWritten = getPlan(usecase).manual.filter((file) =>
+          const flaggedWritten = getPlan({ usecase }).manual.filter((file) =>
             existsSync(path.join(cwd, file)),
           );
           expect(flaggedWritten).toEqual([]);
         });
 
         then('the files left for a human to author match snapshot', () => {
-          expect(getPlan(usecase).manual).toMatchSnapshot(
+          expect(getPlan({ usecase }).manual).toMatchSnapshot(
             `${usecase} — files flagged for a human`,
           );
         });
       });
+
+      when('[t3] the emitted cycle check runs, as `npm run test:lint` does', () => {
+        then('the install holds pg-pool exactly where the usecase is declared to', () => {
+          const scene = getScene({ usecase });
+          const declared = USECASES_WITH_PG_POOL.includes(usecase);
+          if (scene.holdsPgPool !== declared)
+            throw new ConstraintError(`pg-pool presence drifted for ${usecase}`, {
+              holdsPgPool: scene.holdsPgPool,
+              declared,
+              hint: 'update USECASES_WITH_PG_POOL to match the install, so the pg-pool verdict below stays real',
+            });
+          expect(scene.holdsPgPool).toEqual(declared);
+        });
+
+        then('it reports no cycle through pg-pool', () => {
+          const { cycles } = asCycleSummary({
+            output: getScene({ usecase }).cycles.output,
+          });
+          const cyclesThroughPgPool = cycles.filter((cycle) =>
+            cycle.includes('pg-pool'),
+          );
+          if (cyclesThroughPgPool.length > 0)
+            throw new ConstraintError(`pg-pool cycle found for ${usecase}`, {
+              cyclesThroughPgPool,
+              hint: 'the shipped patches/pg-pool.patch did not apply; check its key in persist-with-rds package.json, and whether pg-pool moved the line (pnpm warns by name)',
+            });
+          expect(cyclesThroughPgPool).toEqual([]);
+        });
+
+        if (USECASES_WITH_PG_POOL.includes(usecase))
+          then('it analyzes the tree, so the pg-pool verdict is real', () => {
+            expect(
+              asCycleSummary({ output: getScene({ usecase }).cycles.output })
+                .analyzed,
+            ).toEqual(true);
+          });
+
+        if (USECASES_WITH_PG_POOL.includes(usecase))
+          then('its emitted src imports pg, so dpdm can reach pg-pool', () => {
+            expect(getScene({ usecase }).srcImportsPg).toEqual(true);
+          });
+
+        // a drift in dpdm's cycle line format would parse to zero cycles and pass the pg-pool verdict blind
+        then('the parsed cycles agree with the verdict dpdm prints', () => {
+          const { output } = getScene({ usecase }).cycles;
+          const summary = asCycleSummary({ output });
+          if (!summary.analyzed) return expect(summary.cycles).toEqual([]);
+          const noneFound = output.includes('no circular dependency was found');
+          if (noneFound !== (summary.cycles.length === 0))
+            throw new MalfunctionError(`cycle parse drifted for ${usecase}`, {
+              noneFound,
+              cyclesParsed: summary.cycles.length,
+              hint: 'dpdm changed its cycle line format; update the line pattern in asCycleSummary',
+            });
+          expect(noneFound).toEqual(summary.cycles.length === 0);
+        });
+
+        // .note = the exit status rides in the snapshot, so a pass/fail flip shows in review. it is not
+        //         asserted 0: a bare repo with no src entry, and cycles at floor versions outside pg-pool,
+        //         each exit the check 1 for causes this clamp does not own
+        then('the exit status and the cycles it finds match snapshot', () => {
+          expect({
+            status: getScene({ usecase }).cycles.status,
+            ...asCycleSummary({ output: getScene({ usecase }).cycles.output }),
+          }).toMatchSnapshot(`${usecase} — test:lint:cycles summary`);
+        });
+      });
     });
   });
 });

package/dist/utils/defineExpectedGitattributesContents.ts

@@ -0,0 +1,247 @@
+import { UnexpectedCodePathError } from 'helpful-errors';
+
+/**
+ * .what = one section of a `.gitattributes`: a header comment, then its entries
+ * .why  = a section is the unit a practice owns. `retired` names the forms a section once
+ *         took, so a fix lifts them out of an extant file rather than leave them to linger. the
+ *         gitignore declarers name the same concept `ignoresRetired`
+ * .note = `header.latest` must open with the declarer tag, `# [<declarer>] `. the tag is how every
+ *         other declarer recognizes this section and keeps it in place
+ */
+export type GitattributesSection = {
+  header: { latest: string; retired: readonly string[] };
+  entries: { latest: readonly string[]; retired: readonly string[] };
+};
+
+/**
+ * .what = every practice that declares the repo-root `.gitattributes`, in emit order
+ * .why  = git takes the last line that matches a path, so the order of sections decides which
+ *         declarer wins where two match one path. `rhachet` sits last: its exceptions
+ *         (`*.yield.*`, `.radio/**` → `-linguist-generated`) must be the last managed match for
+ *         a route path, or a later collapse line (`*.test.ts`) would fold a yield or a radio
+ *         record named like a test
+ * .note = a new declarer adds itself here, at the place its lines must hold. the util throws on
+ *         a declarer absent from this list, so that place is decided, never defaulted
+ */
+export const declarersOrderedForGitattributes: readonly string[] = [
+  'git',
+  'tests-any',
+  'persist-with-rds',
+  'persist-with-dynamodb',
+  'rhachet',
+];
+
+/**
+ * .what = emits the `.gitattributes` a practice declares, given the repo's extant one
+ * .why  = shared across every practice that declares this file. git takes the last line
+ *         that matches a path, so order carries load, and a sorted union (the `.gitignore`
+ *         method) cannot serve. every declarer must emit one identical layout, or each
+ *         rewrites the file the other produced, on every `declapract apply`:
+ *         - managed sections first, grouped by declarer in `declarersOrderedForGitattributes`
+ *           order, each declarer's sections in the order it declares them
+ *         - a tagged block whose declarer is not in that list (a hand-written tag) after the
+ *           known declarers, in code-unit order
+ *         - the repo's own lines last, in their own order, so a repo-own
+ *           `<path> -linguist-generated` line wins over a managed collapse line
+ * .why  = each declarer knows only its own sections. it recognizes another declarer's section
+ *         by the tag in its header and keeps that block verbatim, in canonical place. so
+ *         `fix_A(fix_B(x)) === fix_B(fix_A(x))`, and each is a fixed point
+ * .note = no fix edits another declarer's section, not even to drop a line it also holds. two
+ *         sections may then both carry one entry (the dao `.generated/` fold, rds and dynamodb);
+ *         both are collapse lines above every exception, so a repeat is inert under last-match-wins
+ *
+ * .note = a new declarer of the repo-root `.gitattributes` imports this rather than re-derive
+ *         it: a hand-rolled copy can pass its own check and still oscillate against the rest.
+ *         the cross-declarer clamps sit in `src/gitattributesDeclarers.declapract.test.ts` and
+ *         `src/gitattributesDeclarers.declapract.integration.test.ts`.
+ */
+export const defineExpectedGitattributesContents = (input: {
+  contents: string | null;
+  declarer: string;
+  sections: readonly GitattributesSection[];
+}): string => {
+  // reject a declarer with no decided place in the emit order
+  if (!declarersOrderedForGitattributes.includes(input.declarer))
+    throw new UnexpectedCodePathError(
+      'gitattributes declarer has no place in declarersOrderedForGitattributes',
+      { declarer: input.declarer, declarers: declarersOrderedForGitattributes },
+    );
+
+  // reject a section whose header does not carry this declarer's tag; the layout rests on it
+  input.sections.forEach((section) => {
+    if (asDeclarerOfHeader({ line: section.header.latest }) !== input.declarer)
+      throw new UnexpectedCodePathError(
+        'gitattributes section header lacks its declarer tag',
+        { declarer: input.declarer, header: section.header.latest },
+      );
+  });
+
+  // split the extant file into blocks; a blank run ends a block (crlf in, lf out)
+  const blocks = asGitattributesBlocks({ contents: input.contents ?? '' });
+
+  // keep each block another declarer tagged, verbatim
+  const sectionsForeign = asSectionsForeign({
+    blocks,
+    declarer: input.declarer,
+  });
+
+  // the rest is repo-own, minus every line this declarer manages, wherever it sits
+  const blocksRepoOwn = asBlocksRepoOwn({
+    blocks,
+    declarer: input.declarer,
+    sections: input.sections,
+  });
+
+  // order every managed section: by declarer rank, then as declared or as found
+  const sectionsOrdered = asSectionsOrdered({
+    sections: [
+      ...sectionsForeign,
+      ...asSectionsOwn({ declarer: input.declarer, sections: input.sections }),
+    ],
+  });
+
+  // emit managed sections, then the repo-own blocks, one blank line apart
+  return asGitattributesContents({
+    blocks: [...sectionsOrdered.map((section) => section.lines), ...blocksRepoOwn],
+  });
+};
+
+/**
+ * .what = the declarer a header line names via its `# [<declarer>] ` tag, or null
+ * .why  = the tag is how a declarer tells another declarer's section from a repo-own comment
+ */
+const asDeclarerOfHeader = (input: { line: string }): string | null =>
+  input.line.match(/^# \[([a-z0-9-]+)\] /)?.[1] ?? null;
+
+/**
+ * .what = a managed section as it sits in a file: its declarer, then its lines (header first)
+ */
+type GitattributesSectionFound = { declarer: string; lines: readonly string[] };
+
+/**
+ * .what = the blocks another declarer tagged, each kept verbatim
+ * .why  = a declarer knows only its own sections; the tag is how it keeps every other one
+ */
+const asSectionsForeign = (input: {
+  blocks: readonly (readonly string[])[];
+  declarer: string;
+}): GitattributesSectionFound[] =>
+  input.blocks
+    .map((lines) => ({
+      declarer: asDeclarerOfHeader({ line: lines[0]! }),
+      lines,
+    }))
+    .filter(
+      (block): block is GitattributesSectionFound =>
+        block.declarer !== null && block.declarer !== input.declarer,
+    );
+
+/**
+ * .what = the repo's own blocks: untagged or this declarer's, minus each line it manages
+ * .why  = a managed line found anywhere (a hand copy, a prior form) lifts into its section
+ */
+const asBlocksRepoOwn = (input: {
+  blocks: readonly (readonly string[])[];
+  declarer: string;
+  sections: readonly GitattributesSection[];
+}): string[][] => {
+  const linesManaged = asLinesManaged({ sections: input.sections });
+  return input.blocks
+    .filter((lines) => {
+      const declarer = asDeclarerOfHeader({ line: lines[0]! });
+      return declarer === null || declarer === input.declarer;
+    })
+    .map((lines) =>
+      lines.filter(
+        (line) =>
+          !linesManaged.has(line.trim()) &&
+          asDeclarerOfHeader({ line }) !== input.declarer,
+      ),
+    )
+    .filter((lines) => lines.length > 0);
+};
+
+/**
+ * .what = every line a declarer manages: each header and entry, latest and prior
+ */
+const asLinesManaged = (input: {
+  sections: readonly GitattributesSection[];
+}): ReadonlySet<string> =>
+  new Set(
+    input.sections.flatMap((section) => [
+      section.header.latest,
+      ...section.header.retired,
+      ...section.entries.latest,
+      ...section.entries.retired,
+    ]),
+  );
+
+/**
+ * .what = this declarer's sections, in their latest form
+ */
+const asSectionsOwn = (input: {
+  declarer: string;
+  sections: readonly GitattributesSection[];
+}): GitattributesSectionFound[] =>
+  input.sections.map((section) => ({
+    declarer: input.declarer,
+    lines: [section.header.latest, ...section.entries.latest],
+  }));
+
+/**
+ * .what = sections sorted by declarer rank, then by declarer code unit
+ * .why  = a stable sort keeps each declarer's own sections in the order found
+ */
+const asSectionsOrdered = (input: {
+  sections: readonly GitattributesSectionFound[];
+}): GitattributesSectionFound[] =>
+  [...input.sections].sort(
+    (a, b) =>
+      asDeclarerRank({ declarer: a.declarer }) -
+        asDeclarerRank({ declarer: b.declarer }) ||
+      asCodeUnitOrder({ a: a.declarer, b: b.declarer }),
+  );
+
+/**
+ * .what = the file text: blocks one blank line apart, one newline at the end
+ */
+const asGitattributesContents = (input: {
+  blocks: readonly (readonly string[])[];
+}): string =>
+  `${input.blocks.map((lines) => lines.join('\n')).join('\n\n')}\n`;
+
+/**
+ * .what = a declarer's place in the emit order; a declarer absent from the list ranks after all
+ * .why  = a hand-written tag must still sort the same way in every declarer's output
+ */
+const asDeclarerRank = (input: { declarer: string }): number => {
+  const rank = declarersOrderedForGitattributes.indexOf(input.declarer);
+  return rank === -1 ? declarersOrderedForGitattributes.length : rank;
+};
+
+/**
+ * .what = a sort comparator by code unit: negative, zero, or positive
+ * .why  = `localeCompare` varies by host locale; every declarer must sort one way on every host
+ */
+const asCodeUnitOrder = (input: { a: string; b: string }): number => {
+  if (input.a < input.b) return -1;
+  if (input.a > input.b) return 1;
+  return 0;
+};
+
+/**
+ * .what = parses a `.gitattributes` into blocks: runs of lines apart by blank lines
+ * .why  = a section is one block (header + entries), so a blank line bounds it
+ */
+const asGitattributesBlocks = (input: { contents: string }): string[][] =>
+  input.contents
+    .split('\n')
+    .map((line) => line.replace(/\r$/, ''))
+    .reduce<string[][]>(
+      (blocks, line) =>
+        line.trim() === ''
+          ? [...blocks, []]
+          : [...blocks.slice(0, -1), [...(blocks.slice(-1)[0] ?? []), line]],
+      [[]],
+    )
+    .filter((block) => block.length > 0);

package/package.json

@@ -3,7 +3,7 @@
   "author": "ehmpathy",
   "description": "declapract best practices declarations for typescript",
   "private": false,
-  "version": "0.49.14",
+  "version": "0.50.0",
   "license": "MIT",
   "main": "src/index.js",
   "repository": "ehmpathy/declapract-typescript-ehmpathy",
@@ -77,15 +77,15 @@
     "esbuild-register": "3.6.0",
     "husky": "8.0.3",
     "jest": "30.2.0",
-    "rhachet": "1.49.2",
+    "rhachet": "1.50.1",
     "rhachet-brains-anthropic": "0.4.3",
     "rhachet-brains-fireworksai": "0.2.3",
-    "rhachet-brains-openrouter": "0.1.3",
+    "rhachet-brains-openrouter": "0.1.4",
     "rhachet-brains-xai": "0.3.3",
-    "rhachet-roles-bhrain": "0.39.3",
+    "rhachet-roles-bhrain": "0.42.4",
     "rhachet-roles-bhrowser": "0.1.0",
-    "rhachet-roles-bhuild": "0.23.2",
-    "rhachet-roles-ehmpathy": "1.39.5",
+    "rhachet-roles-bhuild": "0.24.0",
+    "rhachet-roles-ehmpathy": "1.41.0",
     "rhachet-roles-ghlitch": "0.3.0",
     "rhachet-roles-rhachet": "0.1.7",
     "sdk-aws-lambda": "0.7.2",

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

@@ -1,7 +0,0 @@
-# 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

package/dist/practices/git/best-practice/.gitattributes

@@ -1,7 +0,0 @@
-# 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