declapract-typescript-ehmpathy 0.49.12 → 0.49.14

package/dist/.test/assets/expo-migration/declarations/practices/cicd-app-react-native-expo/package.json.declapract.integration.test.ts

@@ -0,0 +1,149 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { given, then, when } from 'test-fns';
+import { parse } from 'yaml';
+
+/**
+ * .what = clamps on the expo start/proxy commands and the web deploy compile step: each names
+ *         the access it builds with, and each proxy waits on its target
+ * .why  = `start:cold:prep` and `start:cold:prod` were byte-identical and both reached prod
+ *         (#620, #653); the deploy compile step held `inputs.access` and dropped it (#619); and a
+ *         proxy that starts before its target listens hangs every request (#676). none of that
+ *         is visible to a green typecheck or build, so these clamps read the shipped templates.
+ * .note = a filesystem read of the templates → integration grain, per
+ *         rule.forbid.unit.remote-boundaries; no credential, no network
+ */
+
+/**
+ * .what = the npm run commands and devDependencies the template declares
+ * .why  = one read of the shipped template, named by what the clamps consume
+ */
+const getTemplateCommands = (): {
+  commands: Record<string, string>;
+  devDependencies: Record<string, string>;
+} => {
+  const template = JSON.parse(
+    readFileSync(path.join(__dirname, 'best-practice/package.json'), 'utf-8'),
+  );
+  return {
+    commands: template.scripts ?? {},
+    devDependencies: template.devDependencies ?? {},
+  };
+};
+
+/**
+ * .what = the access a command sets inline (`ACCESS=<access> …`), or null where it sets none
+ * .why  = names the read so each clamp states which access a command builds with
+ */
+const asAccessOfCommand = (input: { command: string }): string | null =>
+  /(?:^|\s)ACCESS=([a-z]+)\b/.exec(input.command)?.[1] ?? null;
+
+/**
+ * .what = the `--target` port a local-ssl-proxy command forwards to
+ * .why  = names the read so the wait-on clamp can pair each proxy with its own target
+ */
+const asProxyTargetPort = (input: { command: string }): string | null =>
+  /local-ssl-proxy .*--target (\d+)/.exec(input.command)?.[1] ?? null;
+
+describe('cicd-app-react-native-expo package.json — access + proxy clamps', () => {
+  given('[case1] the shipped start commands', () => {
+    const { commands, devDependencies } = getTemplateCommands();
+
+    when('[t0] each cold build is paired with its hot twin (#653)', () => {
+      const envsCold = Object.keys(commands)
+        .map((name) => /^start:cold:([a-z]+)$/.exec(name)?.[1] ?? null)
+        .filter((env): env is string => env !== null && env !== 'proxy');
+
+      then('both access envs have a cold build', () => {
+        expect([...envsCold].sort()).toEqual(['prep', 'prod']);
+      });
+
+      then('each start:cold:<env> sets the same ACCESS as its start:hot:<env>, and that ACCESS is <env>', () => {
+        for (const env of envsCold) {
+          const accessCold = asAccessOfCommand({
+            command: commands[`start:cold:${env}`] ?? '',
+          });
+          const accessHot = asAccessOfCommand({
+            command: commands[`start:hot:${env}`] ?? '',
+          });
+          expect({ env, accessCold }).toEqual({ env, accessCold: env });
+          expect({ env, accessHot }).toEqual({ env, accessHot: env });
+        }
+      });
+
+      then('start:cold:prep and start:cold:prod differ (#620)', () => {
+        expect(commands['start:cold:prep']).not.toEqual(
+          commands['start:cold:prod'],
+        );
+      });
+    });
+
+    when('[t1] each proxy gates on its target port (#676)', () => {
+      const proxies = Object.entries(commands).filter(([, command]) =>
+        command.includes('local-ssl-proxy'),
+      );
+
+      then('there is a hot and a cold proxy', () => {
+        expect(proxies.map(([name]) => name).sort()).toEqual([
+          'start:cold:proxy',
+          'start:hot:proxy',
+        ]);
+      });
+
+      then('each proxy waits on tcp:<its own target> before it listens', () => {
+        for (const [name, command] of proxies) {
+          const port = asProxyTargetPort({ command });
+          expect({ name, port }).toEqual({ name, port: expect.any(String) });
+          expect({
+            name,
+            gated: command.startsWith(`wait-on tcp:${port} && `),
+          }).toEqual({ name, gated: true });
+        }
+      });
+
+      then('wait-on is a declared devDependency', () => {
+        expect(devDependencies['wait-on']).toBeDefined();
+      });
+
+      then('no command echoes a run in place of the run itself (#620)', () => {
+        for (const command of Object.values(commands))
+          expect(command.startsWith('echo npm run')).toEqual(false);
+      });
+    });
+
+    when('[t2] the start commands are snapshotted for review', () => {
+      then('the start:* commands match snapshot', () => {
+        const starts = Object.fromEntries(
+          Object.entries(commands).filter(([name]) => name.startsWith('start:')),
+        );
+        expect(starts).toMatchSnapshot('start:* commands');
+      });
+    });
+  });
+
+  given('[case2] the deploy workflow web compile step (#619)', () => {
+    const workflow = parse(
+      readFileSync(
+        path.join(__dirname, 'best-practice/.github/workflows/.deploy-expo.yml'),
+        'utf-8',
+      ),
+    );
+    const steps: {
+      name?: string;
+      run?: string;
+      env?: Record<string, string>;
+    }[] = workflow.jobs['deploy-web'].steps;
+    const compile = steps.find((step) => step.name === 'compile');
+
+    when('[t0] the web compile step runs', () => {
+      then('it runs build:web', () => {
+        expect(compile?.run).toEqual('npm run build:web');
+      });
+
+      then('its env passes ACCESS from the access input', () => {
+        expect(compile?.env?.ACCESS).toEqual('${{ inputs.access }}');
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/cicd-app-react-native-expo/provision.yml.declapract.integration.test.ts

@@ -0,0 +1,131 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
+import { parse } from 'yaml';
+
+// executeApply is slow (usecase evaluation), so widen the jest budget
+jest.setTimeout(240_000);
+
+/**
+ * .what = end-to-end proof of the expo provision.yml merge-by-job declaration (#608)
+ * .why  = the expo usecase composes `provision-github`, whose migration deletes
+ *         `provision/github/**`; before this declaration no expo practice owned the
+ *         `provision.yml` caller, so the repo kept a terraform job over an empty dir and its
+ *         `github / plan` check failed on every branch. only a real apply proves declapract wires
+ *         the custom check + fix to this file: the `github` job lands as the declastruct call,
+ *         each job on the deleted dir leaves, and the repo's own aws job stays.
+ * .note = the lean declarations mirror holds only cicd-app-react-native-expo + typescript-expo,
+ *         so the apply evaluates two practices, not the full usecase
+ */
+
+const FIXTURE = './src/.test/assets/cicd-app-react-native-expo/demo-repo-expo';
+const DECLARATIONS_MIRROR =
+  './src/.test/assets/cicd-app-react-native-expo/declarations';
+const PROVISION_PATH = '.github/workflows/provision.yml';
+
+const genDemoRepo = (slug: string) =>
+  genTempDir({
+    slug,
+    clone: FIXTURE,
+    symlink: [
+      { at: 'declarations', to: DECLARATIONS_MIRROR },
+      { at: 'node_modules', to: 'node_modules' },
+    ],
+  });
+
+describe('expo provision.yml — merge-by-job, end to end (#608)', () => {
+  given('[case4] an expo repo with a provision.yml that holds a terraform github job and an aws job', () => {
+    const tempDir = genDemoRepo('declapract-expo-provision-merge');
+    const read = (rel: string) => fs.readFile(path.join(tempDir, rel), 'utf-8');
+    const apply = () =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        file: PROVISION_PATH,
+      });
+
+    const state = useBeforeAll(async () => {
+      const before = await read(PROVISION_PATH);
+      await apply();
+      const after1 = await read(PROVISION_PATH);
+      await apply();
+      const after2 = await read(PROVISION_PATH);
+      return { before, after1, after2 };
+    }, 230_000);
+
+    when('[t0] declapract apply', () => {
+      then('the github job calls the declastruct workflow with the github.repo wish', () => {
+        const github = parse(state.after1).jobs.github;
+        expect(github.uses).toEqual('./.github/workflows/.declastruct.yml');
+        expect(github.with['wish-path']).toEqual(
+          'provision/github.repo/resources.ts',
+        );
+      });
+
+      then('no job still points at the deleted provision/github/ dir', () => {
+        // read the parsed jobs, since a found comment may still name the dir as prose
+        const jobsBefore = JSON.stringify(parse(state.before).jobs);
+        const jobsAfter = JSON.stringify(parse(state.after1).jobs);
+        expect(jobsBefore).toContain('provision/github/');
+        expect(jobsAfter).not.toContain('provision/github/');
+        expect(parse(state.after1).jobs['github-environment']).toBeUndefined();
+      });
+
+      then('the aws job survives, unchanged', () => {
+        expect(parse(state.after1).jobs.aws).toEqual(
+          parse(state.before).jobs.aws,
+        );
+        expect(state.after1).toContain(
+          "# the repo's own aws job, which the practice never declares",
+        );
+      });
+
+      then('the oidc permissions block lands for the declastruct call', () => {
+        expect(parse(state.after1).permissions['id-token']).toEqual('write');
+      });
+
+      then('before + after match snapshot', () => {
+        expect(state.before).toMatchSnapshot('provision.yml — before');
+        expect(state.after1).toMatchSnapshot('provision.yml — after merge');
+      });
+    });
+
+    when('[t1] declapract apply again', () => {
+      then('zero bytes change', () => {
+        expect(state.after2).toEqual(state.after1);
+      });
+    });
+  });
+
+  given('[case5] an expo repo with no provision.yml', () => {
+    const tempDir = genDemoRepo('declapract-expo-provision-absent');
+    const read = (rel: string) =>
+      fs.readFile(path.join(tempDir, rel), 'utf-8').catch(() => null);
+
+    const state = useBeforeAll(async () => {
+      await fs.rm(path.join(tempDir, PROVISION_PATH));
+      const before = await read(PROVISION_PATH);
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        file: PROVISION_PATH,
+      });
+      const after = await read(PROVISION_PATH);
+      const template = await fs.readFile(
+        'src/practices/cicd-app-react-native-expo/best-practice/.github/workflows/provision.yml',
+        'utf-8',
+      );
+      return { before, after, template };
+    }, 230_000);
+
+    when('[t0] declapract apply', () => {
+      then('provision.yml exists with the github job, equal to the template', () => {
+        expect(state.before).toBeNull();
+        expect(state.after).toEqual(state.template);
+        expect(parse(state.after!).jobs.github.with['wish-path']).toEqual(
+          'provision/github.repo/resources.ts',
+        );
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/directory-structure-src/.declapract.integration.test.ts

@@ -0,0 +1,98 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+// executeApply is slow (full practice evaluation), so grant a generous limit
+jest.setTimeout(180_000);
+
+/**
+ * .what = end-to-end proof of the domain barrel move and the bare barrel import repoint (#655, #671).
+ * .why  = two barrels (`domain/index.ts` → `./objects`, and `domain/objects/index.ts`) both move onto
+ *   `domain.objects/index.ts`; the outer one, stripped, held no export and could win the path. and
+ *   a bare `'@src/domain'` / `'../domain'` import matched neither the check nor the fix. only the real
+ *   pipeline proves which file lands on the shared path.
+ * .note = the outer barrel is applied AFTER the inner one — the order in which it used to win.
+ */
+describe('directory-structure-src domain barrels and bare barrel imports', () => {
+  given('[case1] a repo with two domain barrels and bare barrel imports', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-dirs-two-barrels',
+      clone: './src/.test/assets/directory-structure-src/demo-repo-with-two-domain-barrels',
+      symlink: [
+        {
+          at: 'declarations',
+          to: './src/.test/assets/directory-structure-src/declarations',
+        },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const isPresent = (relativePath: string) =>
+      fs
+        .access(path.join(tempDir, relativePath))
+        .then(() => true)
+        .catch(() => false);
+    const applyOne = (input: { file: string }) =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'directory-structure-src',
+        file: input.file,
+      });
+
+    when('[t0] the input (before any fix)', () => {
+      then('the barrels and the importer match snapshot', async () => {
+        expect(await read('src/domain/index.ts')).toMatchSnapshot('outer barrel — before');
+        expect(await read('src/domain/objects/index.ts')).toMatchSnapshot('inner barrel — before');
+        expect(await read('src/domain.operations/getQuote.ts')).toMatchSnapshot('importer — before');
+      });
+    });
+
+    when('[t1] the moves and the import repoint are applied', () => {
+      const after = useThen('apply, outer barrel last', async () => {
+        await applyOne({ file: 'src/domain/objects/index.ts' });
+        await applyOne({ file: 'src/domain/objects/Quote.ts' });
+        await applyOne({ file: 'src/domain/index.ts' });
+        await applyOne({ file: 'src/domain.operations/getQuote.ts' });
+        return {
+          barrel: await read('src/domain.objects/index.ts'),
+          importer: await read('src/domain.operations/getQuote.ts'),
+          outerPresent: await isPresent('src/domain/index.ts'),
+          quotePresent: await isPresent('src/domain.objects/Quote.ts'),
+        };
+      });
+
+      then('domain.objects/index.ts holds the inner barrel list, never the stripped outer one (#655)', () => {
+        expect(after.barrel).toContain("export * from './Quote';");
+        expect(after.outerPresent).toBe(false);
+        expect(after.quotePresent).toBe(true);
+        expect(after.barrel).toMatchSnapshot('domain.objects/index.ts — after');
+      });
+
+      then('each bare barrel import is repointed, and a package subpath is left alone (#655, #671)', () => {
+        expect(after.importer).toContain("from '@src/domain.objects';");
+        expect(after.importer).toContain("from '../domain.objects';");
+        expect(after.importer).toContain("from 'some-pkg/domain';");
+        expect(after.importer).toMatchSnapshot('importer — after');
+      });
+    });
+
+    when('[t2] the importer and the barrel are applied a second time (idempotency)', () => {
+      const passes = useThen('a second apply over its own output', async () => {
+        const files = ['src/domain.objects/index.ts', 'src/domain.operations/getQuote.ts'];
+        const before = await Promise.all(files.map((file) => read(file)));
+        await applyOne({ file: files[0]! });
+        await applyOne({ file: files[1]! });
+        const after = await Promise.all(files.map((file) => read(file)));
+        return { before, after };
+      });
+
+      then('the second apply is a no-op', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,37 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t0] the input (before any fix) then: the barrels and the importer match snapshot: importer — before 1`] = `
+"import type { Quote } from '@src/domain';
+import type { Quote as QuoteRelative } from '../domain';
+import type { Widget } from 'some-pkg/domain';
+
+export const getQuote = (input: { quote: Quote; peer: QuoteRelative; widget: Widget }) =>
+  input.quote;
+"
+`;
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t0] the input (before any fix) then: the barrels and the importer match snapshot: inner barrel — before 1`] = `
+"export * from './Quote';
+"
+`;
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t0] the input (before any fix) then: the barrels and the importer match snapshot: outer barrel — before 1`] = `
+"// export * from './constants';
+export * from './objects';
+"
+`;
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t1] the moves and the import repoint are applied then: domain.objects/index.ts holds the inner barrel list, never the stripped outer one (#655): domain.objects/index.ts — after 1`] = `
+"export * from './Quote';
+"
+`;
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t1] the moves and the import repoint are applied then: each bare barrel import is repointed, and a package subpath is left alone (#655, #671): importer — after 1`] = `
+"import type { Quote } from '@src/domain.objects';
+import type { Quote as QuoteRelative } from '../domain.objects';
+import type { Widget } from 'some-pkg/domain';
+
+export const getQuote = (input: { quote: Quote; peer: QuoteRelative; widget: Widget }) =>
+  input.quote;
+"
+`;

package/dist/.test/assets/expo-migration/declarations/practices/directory-structure-src/bad-practices/domain-dir/src/<star><star>/domain/<star><star>/<star>.declapract.ts

@@ -1,14 +1,62 @@
 import { FileCheckType, type FileFixFunction } from 'declapract';
 
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
 // if files exist in any /domain/, this is a bad practice
 export const check = FileCheckType.EXISTS;
 
+/**
+ * .what = whether a file is an outer `domain/index.ts` barrel that only forwards `./objects`,
+ *         beside an inner `domain/objects/index.ts` barrel.
+ * .why  = both barrels move onto one path, `domain.objects/index.ts`. the outer one, once its
+ *         `./objects` forward is stripped, holds no export — and if it wins the path, every domain
+ *         export vanishes from the barrel with no error (#655). the inner barrel holds the real
+ *         list, so the outer one must yield the path to it.
+ */
+const isOuterBarrelBesideInner = (input: {
+  contents: string | null;
+  relativeFilePath: string;
+  projectRoot: string | null;
+}): boolean => {
+  if (!input.contents || !input.projectRoot) return false;
+  if (!/(?:^|\/)domain\/index\.ts$/.test(input.relativeFilePath)) return false;
+  const codeOnly = input.contents
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/^\s*\/\/.*$/gm, '')
+    .trim();
+  if (!/^export\s+\*\s+from\s+['"]\.\/objects['"];?$/.test(codeOnly))
+    return false;
+  // the inner barrel, before its move or after it (apply order is not guaranteed)
+  const domainDir = path.join(
+    input.projectRoot,
+    path.dirname(input.relativeFilePath),
+  );
+  return (
+    existsSync(path.join(domainDir, 'objects', 'index.ts')) ||
+    existsSync(path.join(path.dirname(domainDir), 'domain.objects', 'index.ts'))
+  );
+};
+
 export const fix: FileFixFunction = (contents, context) => {
+  // an outer barrel that only forwards ./objects yields the path to the inner barrel (#655)
+  if (
+    isOuterBarrelBesideInner({
+      contents,
+      relativeFilePath: context.relativeFilePath,
+      projectRoot: context.getProjectRootDirectory?.() ?? null,
+    })
+  )
+    return { contents: null };
+
   // move any /domain/objects/* to /domain.objects/*
   // move any /domain/* to /domain.objects/*
+  // .note = the lookahead leaves the slash after each segment unconsumed, so adjacent segments
+  //         (`/domain/domain/`) each move. a consumed slash left the second `domain` segment in
+  //         place, which the `src/**/domain/**/*` glob then matched again on the next apply.
   const newPath = context.relativeFilePath
-    .replace(/\/domain\/objects\//g, '/domain.objects/')
-    .replace(/\/domain\//g, '/domain.objects/');
+    .replace(/\/domain\/objects(?=\/)/g, '/domain.objects')
+    .replace(/\/domain(?=\/)/g, '/domain.objects');
 
   let fixedContents = contents;
 

package/dist/.test/assets/expo-migration/declarations/practices/directory-structure-src/bad-practices/old-import-paths/src/<star><star>/<star>.ts.declapract.ts

@@ -1,5 +1,9 @@
 import type { FileCheckFunction, FileFixFunction } from 'declapract';
 
+import {
+  hasBareDeprecatedDirSpecifier,
+  withBareDeprecatedDirSpecifiersRepointed,
+} from '../../../../../../utils/asBareDeprecatedDirSpecifierReplacement';
 import { isDeferredToDeprecatedDirMove } from '../../../../../../utils/isDeferredToDeprecatedDirMove';
 
 // patterns to detect old import paths
@@ -16,6 +20,32 @@ const OLD_PATH_PATTERNS = [
   /from\s+['"][^'"]*\/__nonpublished_modules__\//,
 ];
 
+/**
+ * .what = each slash-suffixed old dir specifier, repointed at its new dir
+ * .note = ordered most specific first, so `/data/dao` is read before `/data/`
+ */
+const withOldDirSpecifiersRepointed = (input: { contents: string }): string =>
+  input.contents
+    // data layer fixes
+    .replace(/(['"])([^'"]*?)\/data\/dao\b/g, '$1$2/access/daos')
+    .replace(/(['"])([^'"]*?)\/data\/clients\b/g, '$1$2/access/sdks')
+    .replace(/(['"])([^'"]*?)\/data\//g, '$1$2/access/')
+    // domain layer fixes
+    .replace(/(['"])([^'"]*?)\/domain\/objects\b/g, '$1$2/domain.objects')
+    .replace(/(['"])([^'"]*?)\/domain\//g, '$1$2/domain.objects/')
+    // logic layer fixes
+    .replace(/(['"])([^'"]*?)\/logic\//g, '$1$2/domain.operations/')
+    // model layer fixes (old structure before domain.objects)
+    .replace(/(['"])([^'"]*?)\/model\/domainObjects\b/g, '$1$2/domain.objects')
+    .replace(/(['"])([^'"]*?)\/model\//g, '$1$2/domain.objects/')
+    // services layer fixes (services = business logic, not service clients)
+    .replace(/(['"])([^'"]*?)\/services\//g, '$1$2/domain.operations/')
+    // nonpublished modules dir fix
+    .replace(
+      /(['"])([^'"]*?)\/__nonpublished_modules__\//g,
+      '$1$2/_topublish/',
+    );
+
 export const check: FileCheckFunction = (contents, context) => {
   if (!contents) throw new Error('no contents');
 
@@ -33,35 +63,31 @@ export const check: FileCheckFunction = (contents, context) => {
   const hasOldImport = OLD_PATH_PATTERNS.some((pattern) =>
     pattern.test(contents),
   );
-
   if (hasOldImport) return; // matches bad practice
+
+  // a bare barrel import ('@src/domain', '../../domain') — the same specifier set the fix repoints (#671)
+  if (
+    hasBareDeprecatedDirSpecifier({
+      contents,
+      relativeFilePath: context?.relativeFilePath ?? null,
+    })
+  )
+    return; // matches bad practice
+
   throw new Error('does not match bad practice');
 };
 
-export const fix: FileFixFunction = (contents) => {
+export const fix: FileFixFunction = (contents, context) => {
   if (!contents) return { contents };
 
-  // fix imports in order of specificity (most specific first)
-  const fixed = contents
-    // data layer fixes
-    .replace(/(['"])([^'"]*?)\/data\/dao\b/g, '$1$2/access/daos')
-    .replace(/(['"])([^'"]*?)\/data\/clients\b/g, '$1$2/access/sdks')
-    .replace(/(['"])([^'"]*?)\/data\//g, '$1$2/access/')
-    // domain layer fixes
-    .replace(/(['"])([^'"]*?)\/domain\/objects\b/g, '$1$2/domain.objects')
-    .replace(/(['"])([^'"]*?)\/domain\//g, '$1$2/domain.objects/')
-    // logic layer fixes
-    .replace(/(['"])([^'"]*?)\/logic\//g, '$1$2/domain.operations/')
-    // model layer fixes (old structure before domain.objects)
-    .replace(/(['"])([^'"]*?)\/model\/domainObjects\b/g, '$1$2/domain.objects')
-    .replace(/(['"])([^'"]*?)\/model\//g, '$1$2/domain.objects/')
-    // services layer fixes (services = business logic, not service clients)
-    .replace(/(['"])([^'"]*?)\/services\//g, '$1$2/domain.operations/')
-    // nonpublished modules dir fix
-    .replace(
-      /(['"])([^'"]*?)\/__nonpublished_modules__\//g,
-      '$1$2/_topublish/',
-    );
+  // repoint each bare barrel import first, so the slash-suffixed rewrites below never see it (#655)
+  const barrelsRepointed = withBareDeprecatedDirSpecifiersRepointed({
+    contents,
+    relativeFilePath: context?.relativeFilePath ?? null,
+  });
 
-  return { contents: fixed };
+  // repoint each slash-suffixed old dir specifier
+  return {
+    contents: withOldDirSpecifiersRepointed({ contents: barrelsRepointed }),
+  };
 };

package/dist/.test/assets/expo-migration/declarations/practices/directory-structure-src/best-practice/src/contract/<star><star>/<star>.ts.declapract.ts

@@ -1,4 +1,7 @@
-import { FileCheckType } from 'declapract';
+import { asPresenceCheck } from '../../../../../../utils/asPresenceCheck';
 
 // contract layer is required - there should be some contract in this service (api, sdk, cli, cmd)
-export const check = FileCheckType.EXISTS;
+export const check = asPresenceCheck({
+  expected: 'at least one contract under src/contract/',
+  hint: 'author the entrypoint this service exposes (an api, sdk, cli, or cmd)',
+});

package/dist/.test/assets/expo-migration/declarations/practices/directory-structure-src/best-practice/src/domain.objects/<star><star>/<star>.ts.declapract.ts

@@ -1,4 +1,7 @@
-import { FileCheckType } from 'declapract';
+import { asPresenceCheck } from '../../../../../../utils/asPresenceCheck';
 
 // domain objects are required - what is the purpose of a service without domain objects?
-export const check = FileCheckType.EXISTS;
+export const check = asPresenceCheck({
+  expected: 'at least one domain object under src/domain.objects/',
+  hint: 'declare the nouns this service operates on',
+});

package/dist/.test/assets/expo-migration/declarations/practices/directory-structure-src/best-practice/src/domain.operations/<star><star>/<star>.ts.declapract.ts

@@ -1,4 +1,7 @@
-import { FileCheckType } from 'declapract';
+import { asPresenceCheck } from '../../../../../../utils/asPresenceCheck';
 
 // domain operations are required - there should be business logic in the service
-export const check = FileCheckType.EXISTS;
+export const check = asPresenceCheck({
+  expected: 'at least one domain operation under src/domain.operations/',
+  hint: 'declare the operations this service performs',
+});

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

@@ -0,0 +1,47 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`domain X.contract() migration given: [case1] a repo whose handler refers to dobjs via .schema and a bare .contract when: [t0] the fix is applied, then applied again then: the handler refers to each dobj via X.contract(), and keeps internal .schema.safeParse: getChatThread.ts — after 1`] = `
+"import { z } from 'zod';
+
+import { ChatThread } from '@src/domain.objects/ChatThread';
+import { Transmission } from '@src/domain.objects/Transmission';
+
+const schemaInput = z.object({
+  thread: ChatThread.contract().ref('primary'),
+  transmission: Transmission.contract().ref('primary'),
+});
+
+const schemaOutput = z.object({
+  thread: ChatThread.contract().nullable(),
+  transmissions: z.array(Transmission.contract()),
+});
+
+export const isThreadShaped = (input: unknown) =>
+  ChatThread.schema.safeParse(input).success;
+
+export const schema = { input: schemaInput, output: schemaOutput };
+"
+`;
+
+exports[`domain X.contract() migration given: [case1] a repo whose handler refers to dobjs via .schema and a bare .contract when: [t0] the fix is applied, then applied again then: the handler refers to each dobj via X.contract(), and keeps internal .schema.safeParse: getChatThread.ts — before 1`] = `
+"import { z } from 'zod';
+
+import { ChatThread } from '@src/domain.objects/ChatThread';
+import { Transmission } from '@src/domain.objects/Transmission';
+
+const schemaInput = z.object({
+  thread: ChatThread.contract.ref('primary'),
+  transmission: Transmission.contract().ref('primary'),
+});
+
+const schemaOutput = z.object({
+  thread: ChatThread.schema.nullable(),
+  transmissions: z.array(Transmission.schema),
+});
+
+export const isThreadShaped = (input: unknown) =>
+  ChatThread.schema.safeParse(input).success;
+
+export const schema = { input: schemaInput, output: schemaOutput };
+"
+`;