declapract-typescript-ehmpathy 0.49.10 → 0.49.12

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

@@ -0,0 +1,6 @@
+# .note = declarations dir is symlinked by the test
+# .why  = `rhachet-only` deliberately omits the `git` practice, to prove rhachet
+#         declares the ignore for the dir rhachet writes without help from a
+#         neighbor practice
+declarations: 'declarations/declapract.declare.yml'
+useCase: rhachet-only

package/dist/.test/assets/expo-migration/declarations/practices/git/.test/assets/repo-with-rhachet-only/package.json

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

package/dist/.test/assets/expo-migration/declarations/practices/git/.test/assets/repo-without-cache-ignores/declapract.use.yml

@@ -0,0 +1,9 @@
+# .note = declarations dir is symlinked by the test
+# .note = NO `variables:` block. the rule's top gotcha is that apply evaluates the
+#         whole practice, so every `@declapract{variable.*}` it references must be
+#         defined here. both `git` and `rhachet` reference ZERO -- verified by grep,
+#         and by this fixture, which applies clean without any. a variables block
+#         copied from another fixture "to be safe" would be a claim the practices
+#         make demands they do not.
+declarations: 'declarations/declapract.declare.yml'
+useCase: typescript-project

package/dist/.test/assets/expo-migration/declarations/practices/git/.test/assets/repo-without-cache-ignores/package.json

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

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

@@ -0,0 +1,53 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`gitignore practices given: [case1] a repo whose .gitignore lacks both cache dirs when: [t0] before any apply then: the input file matches snapshot: .gitignore -- before 1`] = `
+"dist
+coverage
+.idea
+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.*
+*.local.json
+*.log
+*.tsbuildinfo
+.agent/.cache/
+.artifact
+.cache/
+.claude/scheduled_tasks*
+.env
+.idea
+.log/slowtest/
+.serverless
+.temp
+.terraform
+.terraform.lock
+.vscode
+.yalc
+coverage
+dist
+node_modules
+!.test*/**/node_modules
+!.test*/**/node_modules/**
+"
+`;
+
+exports[`gitignore practices given: [case2] a repo whose use case has rhachet but NOT git when: [t0] before any apply then: the input file matches snapshot: .gitignore -- rhachet only -- before 1`] = `
+"dist
+node_modules
+.idea
+"
+`;
+
+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*
+.idea
+dist
+node_modules
+!.test*/**/node_modules
+!.test*/**/node_modules/**
+"
+`;

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

@@ -0,0 +1,23 @@
+the repo-root `.gitignore` and `.gitattributes`
+
+📖 several practices declare the `.gitignore`. the contract they share — one shared algorithm, the
+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.
+
+## `.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 —
+which is a different claim from which practices declare the ignore for it.
+
+this line stays because `app-react-native-expo` (`src/useCases.yml`) takes `git` **without**
+`rhachet`, so for those repos it is the only explicit source of the ignore. `.cache/` happens to
+cover `.agent/.cache/` at any depth, but that coverage is implicit — narrow `.cache/` and it is
+gone. the same caution sits in `.gitignore.declapract.ts`, at the point of edit.
+
+## this repo consumes this practice
+
+`declapract.use.yml` sets `useCase: npm-package`, which extends `typescript-project`, which
+carries `git`. so `[case3]` in `src/practices/git/.declapract.integration.test.ts` checks this
+repo's own `.gitignore` against the declaration — add a line to `ignoresSortable` and it goes red
+until the practice is applied here too.

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

@@ -0,0 +1,7 @@
+# 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/.test/assets/expo-migration/declarations/practices/git/best-practice/.gitattributes.declapract.ts

@@ -0,0 +1,172 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+/**
+ * check that they're contained in the file
+ */
+export const check: FileCheckType = FileCheckType.CONTAINS;
+
+/**
+ * sections of gitattributes entries to ensure exist
+ */
+const SECTIONS: {
+  header: { latest: string; priors: string[] };
+  entries: { latest: string[]; priors: string[] };
+}[] = [
+  {
+    header: {
+      latest:
+        '# 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'],
+    },
+  },
+  {
+    header: {
+      latest:
+        '# 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'],
+    },
+  },
+];
+
+/**
+ * all latest entries managed by this practice (for deduplication)
+ */
+const ALL_LATEST_ENTRIES = SECTIONS.flatMap((s) => s.entries.latest);
+
+/**
+ * all prior entries that should be removed
+ */
+const ALL_PRIOR_ENTRIES = SECTIONS.flatMap((s) => s.entries.priors);
+
+/**
+ * all prior headers that should be removed
+ */
+const ALL_PRIOR_HEADERS = SECTIONS.flatMap((s) => s.header.priors);
+
+/**
+ * .what = drops prior headers + prior entries, and dedupes latest entries (keep first)
+ * .why = the fix must not re-emit a legacy line, nor a second copy of a managed entry;
+ *        a named transform keeps cleanContent a narrative of what happens, not how
+ */
+const asLinesWithLegacyDroppedAndDeduped = (input: {
+  lines: string[];
+}): string[] => {
+  const { lines } = input.lines.reduce<{
+    lines: string[];
+    seen: Set<string>;
+  }>(
+    (acc, line) => {
+      const trimmed = line.trim();
+
+      // skip prior headers + prior entries
+      if (ALL_PRIOR_HEADERS.includes(trimmed)) return acc;
+      if (ALL_PRIOR_ENTRIES.includes(trimmed)) return acc;
+
+      // skip duplicate latest entries (keep first occurrence)
+      if (ALL_LATEST_ENTRIES.includes(trimmed)) {
+        if (acc.seen.has(trimmed)) return acc;
+        return {
+          lines: [...acc.lines, line],
+          seen: new Set([...acc.seen, trimmed]),
+        };
+      }
+
+      return { lines: [...acc.lines, line], seen: acc.seen };
+    },
+    { lines: [], seen: new Set<string>() },
+  );
+  return lines;
+};
+
+/**
+ * removes legacy headers, duplicate entries, and cleans up empty lines
+ */
+const cleanContent = (content: string): string => {
+  // drop legacy headers, legacy entries, and duplicate latest entries (keep first)
+  const cleanedLines = asLinesWithLegacyDroppedAndDeduped({
+    lines: content.split('\n'),
+  });
+
+  // collapse multiple consecutive empty lines into one (drop an empty that follows an empty)
+  const collapsedLines = cleanedLines.filter((line, index) => {
+    const isEmpty = line.trim() === '';
+    const prevWasEmpty = index > 0 && cleanedLines[index - 1]!.trim() === '';
+    return !(isEmpty && prevWasEmpty);
+  });
+
+  return collapsedLines.join('\n').trim();
+};
+
+/**
+ * ensures a section with header and entries exists in the content
+ */
+const ensureSection = (
+  content: string,
+  section: (typeof SECTIONS)[number],
+): string => {
+  const lines = content.split('\n');
+
+  // find which entries are absent from the content
+  const entriesAbsent = section.entries.latest.filter(
+    (entry) => !content.includes(entry),
+  );
+
+  // find the header line index
+  const headerIndex = lines.findIndex(
+    (line) => line.trim() === section.header.latest,
+  );
+
+  // if header not found, append header and only absent entries
+  if (headerIndex === -1) {
+    return (
+      content.trimEnd() +
+      '\n\n' +
+      [section.header.latest, ...entriesAbsent].join('\n') +
+      '\n'
+    );
+  }
+
+  // if all entries present, no fix required
+  if (entriesAbsent.length === 0) return content;
+
+  // insert absent entries right after the header
+  const newLines = [
+    ...lines.slice(0, headerIndex + 1),
+    ...entriesAbsent,
+    ...lines.slice(headerIndex + 1),
+  ];
+
+  return newLines.join('\n');
+};
+
+/**
+ * fix by cleanup of legacy content and ensure all sections are present
+ */
+export const fix: FileFixFunction = (contents) => {
+  // if no contents, create the file with all sections
+  if (!contents) {
+    const allSections = SECTIONS.map((s) =>
+      [s.header.latest, ...s.entries.latest].join('\n'),
+    ).join('\n\n');
+    return { contents: allSections + '\n' };
+  }
+
+  // clean up legacy headers and duplicates, then ensure each section exists
+  const result = SECTIONS.reduce(
+    (acc, section) => ensureSection(acc, section),
+    cleanContent(contents),
+  );
+
+  // trim to exactly one final newline
+  return { contents: result.trimEnd() + '\n' };
+};

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

@@ -0,0 +1,100 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import expect from 'expect';
+
+import { defineExpectedGitignoreContents } from '../../../utils/defineExpectedGitignoreContents';
+
+/**
+ * ignores that can be sorted alphabetically (no order dependencies)
+ *
+ * .note = `.agent/.cache/` is declared HERE and by
+ *         `src/practices/rhachet/best-practice/.gitignore.declapract.ts`. that is not drift, and
+ *         the line must not be "cleaned up" as a duplicate of rhachet's -- rhachet OWNS that dir
+ *         in the causal sense (it creates it), which is a different claim from which practices
+ *         declare the ignore for it.
+ *
+ *         two facts carry the load here:
+ *         - `app-react-native-expo` (`src/useCases.yml`) takes `git` WITHOUT `rhachet`, so for
+ *           every repo on that use case THIS line is the only explicit source of the ignore
+ *         - `.cache/` below happens to cover `.agent/.cache/` at any depth (a gitignore pattern
+ *           with no interior separator is unanchored -- measured with `git check-ignore -v`), so
+ *           a reader sees the overlap and reads it as redundant. that coverage is IMPLICIT --
+ *           narrow `.cache/` and it is gone
+ *
+ *         so removal here would un-ignore the agent cache for every git-without-rhachet repo, on
+ *         the day `.cache/` is next edited, with no line left to say why. if this ever moves, it
+ *         must land in a practice that still reaches every `git` consumer.
+ *
+ * .note = this list is NOT sorted here, and that is deliberate. `defineExpectedGitignoreContents`
+ *         sorts the union of these lines with the repo's own, so a `.sort()` at this site would
+ *         be a second sort that changes no output -- while it mutates a module-cached array in
+ *         place. `readonly` forbids that mutation outright rather than merely discourages it
+ *         (`rule.prefer.prevent-over-correct`), so the source may group lines by what they are
+ *         for, with their comments beside them, and the one sort that matters stays in one place.
+ *
+ * .note = every line here governs an UNTRACKED path only. git consults `.gitignore` for a path
+ *         not yet in the index; a path a consumer ALREADY tracks stays tracked, and this
+ *         declaration cannot reach the index to reconcile it (the `fix` is a pure contents
+ *         transform, so it has no seam to the index). so a consumer that committed a match
+ *         BEFORE this practice declared the pattern keeps it committed, silently, behind a line
+ *         that reads as enforcement. to reconcile an extant match, run `git rm --cached <path>`
+ *         by hand. a loud in-consumer report of that case is a proposed follow-on (#582).
+ */
+const ignoresSortable: readonly string[] = [
+  '*.log',
+  '*.tsbuildinfo',
+  '.agent/.cache/', // agent cache -- kept even though rhachet declares it too; see .note above
+  '.artifact', // deployment artifacts from `simple-artifact-builder` are produced here
+  '.cache/', // cache directories from various tools
+  '.env',
+  '.serverless',
+  '.log/slowtest/',
+  '.terraform',
+  '.terraform.lock',
+  '.yalc',
+  '.temp',
+  '.vscode',
+  '*.local.json', // e.g., .claude/permission.attempts.local.json
+  '*.bak.*', // backup files
+  'coverage',
+  'dist',
+];
+
+/**
+ * .what = emits the `.gitignore` this practice declares, given the repo's extant one
+ * .why  = one algorithm serves both `check` and `fix`, so the gate and the repair can
+ *         never disagree about what the file should hold.
+ * .why  = the algorithm AND the ordered tail are imported, not declared here, because this
+ *         practice is not the only declarer of the repo-root `.gitignore`. declarers converge
+ *         only while every one of them emits an identical tail by an identical algorithm --
+ *         so they share one, and the drift that would break convergence cannot be written.
+ *         which practices those are is a `grep`; a count here would go stale the first time
+ *         one is added, as it already has once.
+ */
+const defineExpectedContents = (contents: string | null): string =>
+  defineExpectedGitignoreContents({ contents, ignoresSortable });
+
+/**
+ * .what = throws when the repo's `.gitignore` does not carry what this practice declares
+ * .why  = `check` is the GATE: declapract runs `fix` for a file only when `check`
+ *         rejects it. so a line added to `ignoresSortable` above reaches a consumer
+ *         repo only because this throws on the file that lacks it.
+ * .note = best-practice semantics are inverted from what a reader expects -- a THROW
+ *         means the practice is violated, a return means it is followed. see
+ *         `.agent/repo=.this/role=any/briefs/declapract-check-semantics.md`.
+ */
+export const check: FileCheckFunction = (contents) => {
+  expect(contents).toEqual(defineExpectedContents(contents));
+};
+
+/**
+ * .what = unions this practice's declared ignores into the repo's `.gitignore`
+ * .why  = a findsert by construction -- a line already present stays present once,
+ *         and a repo's own custom ignores survive, because the file's extant lines
+ *         are unioned in before the sort.
+ * .note = a fixed point: `fix(fix(x)) === fix(x)`, and `check` passes on its own
+ *         output -- without both, `declapract fix` would rewrite this file forever.
+ *         clamped by `.gitignore.declapract.test.ts` -> `idempotency`.
+ */
+export const fix: FileFixFunction = (contents) => {
+  return { contents: defineExpectedContents(contents) };
+};

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

@@ -0,0 +1,165 @@
+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), so widen the jest budget
+jest.setTimeout(180_000); // 3 minutes
+
+/**
+ * .what = pipeline test for the usecase-aware .npmrc findsert (check/fix union)
+ * .why  = a unit test proves the check/fix in isolation; only the real
+ *         executeApply pipeline proves that declapract:
+ *         - matches the .npmrc declaration to the target file
+ *         - feeds context.projectPractices with the expo signal
+ *           (cicd-app-react-native-expo present in the usecase)
+ *         - findserts the declared lines into the consumer's .npmrc: the base
+ *           node lines PLUS the hoisted-linker block, unioned in so a repo's own
+ *           lines survive (a consumer merge, NOT an EQUALS overwrite)
+ *         - reaches a fixed point on a second apply (idempotent)
+ */
+describe('node practice .npmrc — expo hoisted linker', () => {
+  given('[case1] an expo consumer repo with a base node .npmrc', () => {
+    const tempDir = genTempDir({
+      slug: 'node-npmrc-expo',
+      clone: './src/practices/node/.test/assets/repo-expo-npmrc',
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/expo/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const npmrcPath = () => path.join(tempDir, '.npmrc');
+
+    // useBeforeAll RETURNS the captured reads (no in-place mutation of a shared const)
+    const readState = useBeforeAll(async () => {
+      // capture the consumer's own .npmrc before any apply
+      const before = await fs.readFile(npmrcPath(), 'utf-8');
+
+      // first apply
+      // .note = filter by file ONLY, never by practice. the practice filter
+      //         narrows projectPractices too (getDesiredPractices), which would
+      //         strip cicd-app-react-native-expo and silence the expo branch.
+      //         file-only keeps every usecase practice in projectPractices while
+      //         it applies just the .npmrc plan.
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        file: '.npmrc',
+      });
+      const after1 = await fs.readFile(npmrcPath(), 'utf-8');
+
+      // second apply — to prove a fixed point
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        file: '.npmrc',
+      });
+      const after2 = await fs.readFile(npmrcPath(), 'utf-8');
+
+      return { before, after1, after2 };
+    }, 170_000);
+
+    when('[t0] the node practice is applied', () => {
+      then('the base node lines are preserved', () => {
+        expect(readState.after1).toContain('engine-strict=true');
+        expect(readState.after1).toContain('save-exact=true');
+        expect(readState.after1).toContain('message=%s 🎉');
+      });
+
+      then('the hoisted-linker block is appended', () => {
+        expect(readState.after1).toContain('node-linker=hoisted');
+        expect(readState.after1).toContain('public-hoist-pattern[]=*expo*');
+        expect(readState.after1).toContain(
+          'public-hoist-pattern[]=*react-native*',
+        );
+        expect(readState.after1).toContain(
+          'public-hoist-pattern[]=@react-native/*',
+        );
+        expect(readState.after1).toContain('public-hoist-pattern[]=metro*');
+        expect(readState.after1).toContain('public-hoist-pattern[]=*metro-*');
+      });
+
+      then('the before + after contents match snapshot', () => {
+        expect(readState.before).toMatchSnapshot('.npmrc — before');
+        expect(readState.after1).toMatchSnapshot('.npmrc — after apply');
+      });
+    });
+
+    when('[t1] the node practice is applied a second time', () => {
+      then('the fixed point holds — after2 equals after1', () => {
+        expect(readState.after2).toEqual(readState.after1);
+      });
+
+      then('a single hoist block exists, never a duplicate', () => {
+        const occurrences =
+          readState.after2.split('node-linker=hoisted').length - 1;
+        expect(occurrences).toEqual(1);
+      });
+    });
+  });
+
+  /**
+   * .what = a narrow-scope apply of the node practice on an expo repo leaves the hoist intact
+   * .why  = a narrow `declapract fix --practice node` on an expo repo makes
+   *         projectPractices === ['node'], so the expo branch does not fire. the `.npmrc`
+   *         declaration is a findsert (check/fix union) that appends only absent lines, so a
+   *         narrow-scope apply is a no-op on an already-hoisted `.npmrc`. this test reproduces
+   *         that narrow-scope invocation and asserts the hoist is preserved — it fails if the
+   *         declaration is ever changed to an EQUALS overwrite (which would append no union
+   *         and rewrite the file to base).
+   */
+  given('[case2] a narrow --practice node apply on an expo repo keeps the hoist', () => {
+    const tempDir = genTempDir({
+      slug: 'node-npmrc-expo-narrow',
+      clone: './src/practices/node/.test/assets/repo-expo-npmrc',
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/expo/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const npmrcPath = () => path.join(tempDir, '.npmrc');
+
+    const readState = useBeforeAll(async () => {
+      const config = path.join(tempDir, 'declapract.use.yml');
+
+      // first, reach the CORRECT expo state via the SUPPORTED path (file filter keeps
+      // every usecase practice in projectPractices, so the expo branch fires)
+      await executeApply({ config, file: '.npmrc' });
+      const withHoist = await fs.readFile(npmrcPath(), 'utf-8');
+
+      // now apply the narrow scope: `--practice node` makes projectPractices === ['node'],
+      // so the expo branch does not fire. the findsert appends only absent lines, so the
+      // hoist is preserved.
+      await executeApply({ config, practice: 'node' });
+      const afterNarrow = await fs.readFile(npmrcPath(), 'utf-8');
+
+      return { withHoist, afterNarrow };
+    }, 170_000);
+
+    when('[t0] the supported path first produced the hoist', () => {
+      then('the hoisted-linker block is present', () => {
+        expect(readState.withHoist).toContain('node-linker=hoisted');
+        expect(readState.withHoist).toContain('public-hoist-pattern[]=*expo*');
+      });
+    });
+
+    when('[t1] a narrow `--practice node` fix then runs on that repo', () => {
+      then('the hoist is preserved', () => {
+        expect(readState.afterNarrow).toContain('node-linker=hoisted');
+        expect(readState.afterNarrow).toContain(
+          'public-hoist-pattern[]=*expo*',
+        );
+      });
+
+      then('the base node lines survive too', () => {
+        expect(readState.afterNarrow).toContain('engine-strict=true');
+        expect(readState.afterNarrow).toContain('save-exact=true');
+      });
+
+      then('the narrow-scope apply is a no-op — afterNarrow equals withHoist', () => {
+        expect(readState.afterNarrow).toEqual(readState.withHoist);
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/node/.test/assets/repo-expo-npmrc/declapract.use.yml

@@ -0,0 +1,23 @@
+# .note = declarations dir is symlinked by the test to test/assets/expo/declarations
+# .why  = an expo consumer repo, used to prove the node practice's .npmrc contents fn
+#         appends the hoisted-linker block when the expo usecase is in play.
+declarations: 'declarations/declapract.declare.yml'
+useCase: app-react-native-expo
+# .note = the apply evaluates the WHOLE usecase (node + cicd-app-react-native-expo)
+#         before the file-filter narrows to .npmrc, so EVERY variable any file in
+#         those practices references must be defined here, or evaluation throws.
+variables:
+  projectName: app-example-native
+  organizationName: ahbode
+  infrastructureNamespaceId: aaa000
+  awsAccountId:
+    prep: '111111111111'
+    prod: '222222222222'
+  app:
+    web:
+      domain:
+        prep: example.prep.ahbode.dev
+        prod: example.ahbode.dev
+      port:
+        hot: 3447
+        cold: 3449

package/dist/.test/assets/expo-migration/declarations/practices/node/.test/assets/repo-expo-npmrc/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "app-example-native",
+  "version": "1.0.0"
+}

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

@@ -0,0 +1,24 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`node practice .npmrc — expo hoisted linker given: [case1] an expo consumer repo with a base node .npmrc when: [t0] the node practice is applied then: the before + after contents match snapshot: .npmrc — after apply 1`] = `
+"engine-strict=true
+save-exact=true
+message=%s 🎉
+
+# hoisted linker flattens node_modules — create-expo-app default for pnpm,
+# the documented fallback when isolated installs break metro native lookup
+node-linker=hoisted
+public-hoist-pattern[]=*expo*
+public-hoist-pattern[]=*react-native*
+public-hoist-pattern[]=@react-native/*
+public-hoist-pattern[]=metro*
+public-hoist-pattern[]=*metro-*
+"
+`;
+
+exports[`node practice .npmrc — expo hoisted linker given: [case1] an expo consumer repo with a base node .npmrc when: [t0] the node practice is applied then: the before + after contents match snapshot: .npmrc — before 1`] = `
+"engine-strict=true
+save-exact=true
+message=%s 🎉
+"
+`;