declapract-typescript-ehmpathy 0.49.13 → 0.49.14

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

@@ -8,14 +8,14 @@ import { defineExpectedGitignoreContents } from '../../../utils/defineExpectedGi
  *
  * .why = rhachet boots roles which write scratch state into `.agent/.cache/`, and the
  *        claude-code harness those roles run writes machine-local scheduler state into
- *        `.claude/scheduled_tasks*` (a lock + queue). the practice that creates a dir
+ *        `.claude/scheduled_tasks*` at any depth (a lock + queue). the practice that creates a dir
  *        declares the ignore for it, so a repo that takes `rhachet` is never left with
  *        cruft it did not ask for:
  *        - a worktree teardown is not snagged by untracked scratch
  *        - a hurried `git add .` cannot sweep a machine-local lock or a debug file that
  *          holds a secret
  *
- * .note = `.claude/scheduled_tasks*` is machine-local by nature -- a lock/queue for THIS
+ * .note = `.claude/scheduled_tasks*` at any depth is machine-local by nature -- a lock/queue for THIS
  *         host's scheduler, never shared across a team -- so it is ignored, never tracked.
  *         it belongs HERE, not in `git`: rhachet's role-boot harness is what creates it, and
  *         a practice declares the ignore for the dirs IT creates. (`*.local.json`, the other
@@ -33,9 +33,22 @@ import { defineExpectedGitignoreContents } from '../../../utils/defineExpectedGi
  */
 const ignoresSortable: readonly string[] = [
   '.agent/.cache/',
-  '.claude/scheduled_tasks*',
+  // role scratch notes (e.g. a draft issue comment); host-local, never source (#688)
+  '.agent/.notes/',
+  // `**/` so the actor brain's own `.agent/.actors/<actor>/brain/.claude/` lock is
+  // ignored too; a line with a slash anchors to the repo root otherwise (#667)
+  '**/.claude/scheduled_tasks*',
 ];
 
+/**
+ * .what = lines this practice once declared and now replaces
+ * .why  = the root-anchored `.claude/scheduled_tasks*` is superseded by the any-depth form;
+ *         a union alone would leave it in every extant file forever
+ * .note = a lock already tracked stays tracked until `git rm --cached` — an ignore never
+ *         untracks a file
+ */
+const ignoresRetired: readonly string[] = ['.claude/scheduled_tasks*'];
+
 /**
  * .what = emits the `.gitignore` this practice declares, given the repo's extant one
  * .why  = the algorithm AND the ordered tail are imported, not declared here, because
@@ -48,7 +61,11 @@ const ignoresSortable: readonly string[] = [
  *         the generic scratch. the shared part is shared; the owned part is owned.
  */
 const defineExpectedContents = (contents: string | null): string =>
-  defineExpectedGitignoreContents({ contents, ignoresSortable });
+  defineExpectedGitignoreContents({
+    contents,
+    ignoresSortable,
+    ignoresRetired,
+  });
 
 /**
  * .what = throws when the repo's `.gitignore` does not carry what this practice declares

package/dist/.test/assets/expo-fullusecase/declarations/practices/rhachet/best-practice/package.json

@@ -1,13 +1,14 @@
 {
   "devDependencies": {
-    "rhachet": "@declapract{check.minVersion('1.47.5')}",
+    "rhachet": "@declapract{check.minVersion('1.49.2')}",
     "rhachet-brains-anthropic": "@declapract{check.minVersion('0.4.3')}",
-    "rhachet-brains-fireworksai": "@declapract{check.minVersion('0.1.6')}",
+    "rhachet-brains-fireworksai": "@declapract{check.minVersion('0.2.3')}",
+    "rhachet-brains-openrouter": "@declapract{check.minVersion('0.1.3')}",
     "rhachet-brains-xai": "@declapract{check.minVersion('0.3.3')}",
-    "rhachet-roles-bhrain": "@declapract{check.minVersion('0.34.1')}",
+    "rhachet-roles-bhrain": "@declapract{check.minVersion('0.40.0')}",
     "rhachet-roles-bhrowser": "@declapract{check.minVersion('0.1.0')}",
-    "rhachet-roles-bhuild": "@declapract{check.minVersion('0.21.36')}",
-    "rhachet-roles-ehmpathy": "@declapract{check.minVersion('1.38.12')}",
+    "rhachet-roles-bhuild": "@declapract{check.minVersion('0.23.2')}",
+    "rhachet-roles-ehmpathy": "@declapract{check.minVersion('1.39.5')}",
     "rhachet-roles-ghlitch": "@declapract{check.minVersion('0.3.0')}",
     "rhachet-roles-rhachet": "@declapract{check.minVersion('0.1.7')}"
   },

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

@@ -1,3 +1,51 @@
-import { FileCheckType } from 'declapract';
+import { FileCheckType, type FileContentsFunction } from 'declapract';
+
+import { getFileTextOrNull } from '../../../utils/getFileTextOrNull';
+import { readFile } from '../../../utils/readFile';
+
+/**
+ * .what = whether a package.json declares a `link:.` self-dep (a rhachet roles package)
+ * .why  = such a repo links its own roles, and `rhachet init` loads their hooks from `dist/`; any
+ *         dep whose value is `link:.` counts, so a self-dep under an alias still keys the build
+ */
+const hasSelfLinkDep = (input: { packageJson: string }): boolean => {
+  const parsed = JSON.parse(input.packageJson) as {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+  return [
+    ...Object.values(parsed.dependencies ?? {}),
+    ...Object.values(parsed.devDependencies ?? {}),
+  ].some((version) => version === 'link:.' || version === 'link:./');
+};
+
+/**
+ * .what = declare the rhachet package.json, with `npm run build && ` before `rhachet init` in a
+ *         repo that self-links its own roles (#520)
+ * .why  = a `link:.` repo boots its own roles, whose hooks load from the compiled `dist/`; with no
+ *         build first, hook discovery fails before jest starts. CONTAINS used to strip a hand-added
+ *         build step; a branch on the repo's own package.json keeps it (rule.avoid.runtime-forks)
+ */
+export const contents: FileContentsFunction = async (context) => {
+  // grab the declared package.json
+  const declared = await readFile({ filePath: `${__dirname}/package.json` });
+
+  // read the repo's own package.json, if any, to see whether it self-links
+  const repoPackageJson = getFileTextOrNull({
+    root: context.getProjectRootDirectory(),
+    relativePath: 'package.json',
+  });
+  const isSelfLinked =
+    repoPackageJson !== null &&
+    hasSelfLinkDep({ packageJson: repoPackageJson });
+
+  // a self-linked repo builds before it inits
+  return isSelfLinked
+    ? declared.replace(
+        '"prepare:rhachet": "rhachet init ',
+        '"prepare:rhachet": "npm run build && rhachet init ',
+      )
+    : declared;
+};
 
 export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/expo-fullusecase/declarations/practices/rhachet/boot-refs-glossary.declapract.integration.test.ts

@@ -53,9 +53,11 @@ describe('rhachet boot.yml defaults to say, refs only deep glossary variants', (
         expect(contents).not.toMatch(/^\s*say:/m);
       });
 
-      then('it refs the deep glossary variants via globs', () => {
+      then('it drops the deep glossary variants via globs under not, never ref (#689)', () => {
         expect(contents).toContain(REASON_REF);
         expect(contents).toContain(EXAMPLE_REF);
+        expect(contents).toMatch(/^ {2}not:\n {4}- briefs\/domain\.terms\/term=\*\._\.choice\.reason\.md$/m);
+        expect(contents).not.toMatch(/^ {2}ref:/m);
       });
 
       then('it does not ref the choice root (it stays say-level)', () => {

package/dist/.test/assets/expo-fullusecase/declarations/practices/rhachet/boot-yml-findsert.declapract.integration.test.ts

@@ -27,7 +27,7 @@ describe('rhachet — boot.yml findsert (req 1: consumer entries survive)', () =
       slug: 'declapract-rhachet-boot-findsert',
       clone:
         './src/practices/rhachet/.test/assets/demo-repo-with-consumer-boot',
-      symlink: [{ at: 'src', to: 'src' }],
+      symlink: [{ at: 'declarations', to: 'src' }],
     });
 
     const bootPath = '.agent/repo=.this/role=any/boot.yml';
@@ -48,6 +48,8 @@ describe('rhachet — boot.yml findsert (req 1: consumer entries survive)', () =
         const before = await read(bootPath);
         expect(before).toContain('briefs/my-own-brief.md');
         expect(before).toContain('briefs/my-own-deep-variant.md');
+        // the consumer carries the old practice shape: a declared glob under ref (#689)
+        expect(yaml.parse(before).briefs.ref).toContain(REASON_REF);
         // the consumer predates the budget cap — it carries none (the findsert-add path)
         expect(yaml.parse(before).budget).toBeUndefined();
         expect(before).toMatchSnapshot('boot.yml — before');
@@ -65,11 +67,13 @@ describe('rhachet — boot.yml findsert (req 1: consumer entries survive)', () =
           const after = await read(bootPath);
           const parsed = yaml.parse(after);
 
-          // the two declared deep-variant globs were unioned into the consumer's ref list
-          expect(parsed.briefs.ref).toContain(REASON_REF);
-          expect(parsed.briefs.ref).toContain(EXAMPLE_REF);
-          // the consumer's OWN ref pick survives (the whole-overwrite failure would drop it)
-          expect(parsed.briefs.ref).toContain('briefs/my-own-deep-variant.md');
+          // the two declared deep-variant globs landed under not (#689) — the one the old
+          // practice shape put under ref was moved, never duplicated
+          expect(parsed.briefs.not).toEqual([REASON_REF, EXAMPLE_REF]);
+          expect(parsed.briefs.ref).not.toContain(REASON_REF);
+          expect(parsed.briefs.ref).not.toContain(EXAMPLE_REF);
+          // the consumer's OWN ref pick survives, and is all that ref holds now
+          expect(parsed.briefs.ref).toEqual(['briefs/my-own-deep-variant.md']);
           // the consumer's OWN say pick survives untouched
           expect(parsed.briefs.say).toContain('briefs/my-own-brief.md');
           // it stayed simple mode — the fix created no top-level always: key
@@ -106,7 +110,7 @@ describe('rhachet — boot.yml findsert (req 1: consumer entries survive)', () =
       slug: 'declapract-rhachet-boot-budget-preserved',
       clone:
         './src/practices/rhachet/.test/assets/demo-repo-with-consumer-boot',
-      symlink: [{ at: 'src', to: 'src' }],
+      symlink: [{ at: 'declarations', to: 'src' }],
     });
 
     const bootPath = '.agent/repo=.this/role=any/boot.yml';

package/dist/.test/assets/expo-fullusecase/declarations/practices/rhachet/keyrack-yml-findsert.declapract.integration.test.ts

@@ -0,0 +1,105 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import yaml from 'yaml';
+import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
+
+// executeApply evaluates the whole usecase, so widen the jest budget
+jest.setTimeout(180_000);
+
+/**
+ * .what = pipeline test for the usecase-aware keyrack.yml findsert (#491, #487)
+ * .why  = the unit grain proves check/fix in memory; only executeApply proves declapract matches
+ *         `.agent/keyrack.yml`, feeds the aws practice into context.projectPractices, and writes the
+ *         upgrade into a real repo file — and that a second apply is a no-op
+ * .note = filter by `file` only, never `practice`: a practice filter narrows projectPractices and
+ *         would silence the aws branch
+ */
+describe('rhachet — keyrack.yml AWS_PROFILE findsert', () => {
+  const keyrackPath = '.agent/keyrack.yml';
+  const DECLARED = {
+    key: 'AWS_PROFILE',
+    'is-optional-if-has': 'AWS_ACCESS_KEY_ID',
+  };
+
+  given('[case1] an aws repo whose keyrack.yml holds a bare AWS_PROFILE', () => {
+    const tempDir = genTempDir({
+      slug: 'rhachet-keyrack-aws',
+      clone: './src/practices/rhachet/.test/assets/repo-keyrack-extant',
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/rhachet/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const state = useBeforeAll(async () => {
+      const config = path.join(tempDir, 'declapract.use.yml');
+      const read = () => fs.readFile(path.join(tempDir, keyrackPath), 'utf-8');
+      const before = await read();
+      await executeApply({ config, file: keyrackPath });
+      const after1 = await read();
+      await executeApply({ config, file: keyrackPath });
+      const after2 = await read();
+      return { before, after1, after2 };
+    }, 170_000);
+
+    when('[t0] the rhachet practice is applied', () => {
+      then('the bare AWS_PROFILE is upgraded in place to is-optional-if-has', () => {
+        const parsed = yaml.parse(state.after1);
+        expect(parsed['env.test']).toEqual([DECLARED]);
+        expect(parsed['env.all']).toBeUndefined();
+      });
+
+      then("the repo's own keys, extends, and comment survive", () => {
+        const parsed = yaml.parse(state.after1);
+        expect(parsed['env.prep']).toEqual(['OPENROUTER_API_KEY']);
+        expect(parsed.extends).toEqual([
+          '.agent/repo=ehmpathy/role=mechanic/keyrack.yml',
+        ]);
+        expect(state.after1).toContain(
+          '# the local aws login, from before is-optional-if-has',
+        );
+      });
+
+      then('the before + after contents match snapshot', () => {
+        expect(state.before).toMatchSnapshot('keyrack.yml — before');
+        expect(state.after1).toMatchSnapshot('keyrack.yml — after');
+      });
+    });
+
+    when('[t1] the practice is applied a second time', () => {
+      then('the second apply is a no-op', () => {
+        expect(state.after2).toEqual(state.after1);
+      });
+    });
+  });
+
+  given('[case2] the same repo with no aws practice in its usecase', () => {
+    const tempDir = genTempDir({
+      slug: 'rhachet-keyrack-node',
+      clone: './src/practices/rhachet/.test/assets/repo-keyrack-extant',
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/rhachet/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const state = useBeforeAll(async () => {
+      const read = () => fs.readFile(path.join(tempDir, keyrackPath), 'utf-8');
+      const before = await read();
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.node.yml'),
+        file: keyrackPath,
+      });
+      return { before, after: await read() };
+    }, 170_000);
+
+    when('[t0] the rhachet practice is applied', () => {
+      then('the keyrack.yml is left byte for byte', () => {
+        expect(state.after).toEqual(state.before);
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-fullusecase/declarations/practices/rhachet/self-link-build-order.declapract.integration.test.ts

@@ -0,0 +1,88 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
+
+// executeApply evaluates the whole usecase, so widen the jest budget
+jest.setTimeout(180_000);
+
+/**
+ * .what = pipeline test for the rhachet package.json build order in a self-linked repo (#520)
+ * .why  = a `link:.` repo boots its own roles, whose hooks load from `dist/`, so `prepare:rhachet`
+ *         must build before `rhachet init`. the CONTAINS fix used to strip a hand-added build; now
+ *         the contents fn reads the repo's own package.json and declares the build for a self-link
+ * .note = declapract's CONTAINS fix writes a dep the repo lacks as its raw `@declapract{…}` marker,
+ *         and only the next apply resolves it (ehmpathy/declapract; dream
+ *         `v2026_10_14.reseed.declapract-contains-json-adds-raw-minversion-markers`). so the second
+ *         apply resolves the marker, and the third proves the fixed point. [t0] asserts the marker,
+ *         so the day declapract resolves it in one apply, [t0] reddens and this note retires
+ */
+describe('rhachet — prepare:rhachet builds first in a self-linked repo', () => {
+  given('[case1] a rhachet roles package with a link:. self-dep and no build before init', () => {
+    const tempDir = genTempDir({
+      slug: 'rhachet-self-linked',
+      clone: './src/practices/rhachet/.test/assets/repo-self-linked',
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/rhachet/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const state = useBeforeAll(async () => {
+      const config = path.join(tempDir, 'declapract.use.yml');
+      const read = () =>
+        fs.readFile(path.join(tempDir, 'package.json'), 'utf-8');
+      const before = await read();
+      await executeApply({ config, file: 'package.json' });
+      const after1 = await read();
+      await executeApply({ config, file: 'package.json' });
+      const after2 = await read();
+      await executeApply({ config, file: 'package.json' });
+      const after3 = await read();
+      return { before, after1, after2, after3 };
+    }, 170_000);
+
+    when('[t0] the rhachet practice is applied', () => {
+      then('prepare:rhachet runs npm run build before rhachet init', () => {
+        const commands = JSON.parse(state.after1).scripts;
+        expect(commands['prepare:rhachet']).toMatch(
+          /^npm run build && rhachet init --keys --hooks --roles /,
+        );
+      });
+
+      then('the self-dep and the build command survive', () => {
+        const parsed = JSON.parse(state.after1);
+        expect(parsed.devDependencies['rhachet-roles-demo']).toEqual('link:.');
+        expect(parsed.scripts.build).toEqual('tsc -p ./tsconfig.build.json');
+      });
+
+      then('a dep the repo lacked lands as its raw declapract marker (upstream defect)', () => {
+        expect(JSON.parse(state.after1).devDependencies['rhachet-brains-openrouter']).toMatch(
+          /^@declapract\{check\.minVersion\('[\d.]+'\)\}$/,
+        );
+      });
+
+      then('the before + after contents match snapshot', () => {
+        expect(state.before).toMatchSnapshot('package.json — before');
+        expect(state.after1).toMatchSnapshot('package.json — after');
+      });
+    });
+
+    when('[t1] the practice is applied a second time', () => {
+      then('every raw marker resolves to a version, and the build step is kept', () => {
+        expect(state.after2).not.toContain('@declapract{');
+        expect(JSON.parse(state.after2).scripts['prepare:rhachet']).toMatch(
+          /^npm run build && rhachet init /,
+        );
+        expect(state.after2).toMatchSnapshot('package.json — after the second apply');
+      });
+    });
+
+    when('[t2] the practice is applied a third time', () => {
+      then('the third apply is a no-op', () => {
+        expect(state.after3).toEqual(state.after2);
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils/blackbox/lambdas/consumeSESEmailEventFromSNS.acceptance.test.ts

@@ -0,0 +1,23 @@
+import { SNSEventRecord, SNSMessage, SNSEvent } from 'aws-lambda';
+
+import { exampleEmailClickEvent } from '../../src/.test/assets/exampleEmailClickEvent';
+import { invokeLambda } from '../_utils/invokeLambda';
+
+describe('consumeSESEmailEventFromSNS', () => {
+  it('should be possible to invoke the lambda', async () => {
+    const exampleSnsEvent: SNSEvent = {
+      Records: [
+        {
+          Sns: {
+            Message: JSON.stringify(exampleEmailClickEvent),
+          } as SNSMessage,
+        } as SNSEventRecord,
+      ],
+    };
+    const response = await invokeLambda({
+      name: 'consumeSESEmailEventFromSNS',
+      data: exampleSnsEvent,
+    });
+    expect(response).toBeDefined();
+  });
+});

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils/declapract.use.yml

@@ -0,0 +1,9 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/tests-any-only/declarations
+#         the variables stay: the fix reads projectName from this file for the `which` it emits
+declarations: 'declarations/declapract.declare.yml'
+useCase: tests-any-only
+variables:
+  organizationName: 'test-org'
+  projectName: 'svc-notifications'
+  reviewers:
+    users: ['user1']

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils/package.json

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

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-2/blackbox/lambdas/addDecoratedImage.acceptance.test.ts

@@ -0,0 +1,19 @@
+import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';
+
+import { locally } from '../__test_utils__/environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await invokeLambdaForTesting({
+      service: 'svc-images',
+      function: 'addDecoratedImage',
+      locally,
+      event: {
+        url: 'https://some.url',
+        description: 'bo vine at his gig, moooooin the lawn',
+        focalArea: null,
+      },
+    });
+    expect(response.image).toHaveProperty('uuid');
+  });
+});

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-2/declapract.use.yml

@@ -0,0 +1,9 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/tests-any-only/declarations
+#         the variables stay: the fix reads projectName from this file for the `which` it emits
+declarations: 'declarations/declapract.declare.yml'
+useCase: tests-any-only
+variables:
+  organizationName: 'test-org'
+  projectName: 'svc-images'
+  reviewers:
+    users: ['user1']

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-2/package.json

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

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-3/blackbox/lambdas/addDecoratedImage.acceptance.test.ts

@@ -0,0 +1,19 @@
+import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';
+
+import { locally } from '../_utils/environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await invokeLambdaForTesting({
+      service: 'svc-images',
+      function: 'addDecoratedImage',
+      locally,
+      event: {
+        url: 'https://some.url',
+        description: 'bo vine at his gig, moooooin the lawn',
+        focalArea: null,
+      },
+    });
+    expect(response.image).toHaveProperty('uuid');
+  });
+});

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-3/declapract.use.yml

@@ -0,0 +1,9 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/tests-any-only/declarations
+#         the variables stay: the fix reads projectName from this file for the `which` it emits
+declarations: 'declarations/declapract.declare.yml'
+useCase: tests-any-only
+variables:
+  organizationName: 'test-org'
+  projectName: 'svc-images'
+  reviewers:
+    users: ['user1']

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-3/package.json

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

package/dist/.test/assets/expo-fullusecase/declarations/practices/tests-any/__snapshots__/old-acceptance-test-utils.declapract.integration.test.ts.snap

@@ -0,0 +1,162 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`tests-any old-acceptance-test-utils given: [case1] a repo on the old-acceptance-test-utils shape when: [t0] the input (before any fix) then: the file holds the old import, and matches snapshot: old-acceptance-test-utils — before 1`] = `
+"import { SNSEventRecord, SNSMessage, SNSEvent } from 'aws-lambda';
+
+import { exampleEmailClickEvent } from '../../src/.test/assets/exampleEmailClickEvent';
+import { invokeLambda } from '../_utils/invokeLambda';
+
+describe('consumeSESEmailEventFromSNS', () => {
+  it('should be possible to invoke the lambda', async () => {
+    const exampleSnsEvent: SNSEvent = {
+      Records: [
+        {
+          Sns: {
+            Message: JSON.stringify(exampleEmailClickEvent),
+          } as SNSMessage,
+        } as SNSEventRecord,
+      ],
+    };
+    const response = await invokeLambda({
+      name: 'consumeSESEmailEventFromSNS',
+      data: exampleSnsEvent,
+    });
+    expect(response).toBeDefined();
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case1] a repo on the old-acceptance-test-utils shape when: [t1] the fix is applied then: no template token leaks, and the file matches snapshot: old-acceptance-test-utils — after 1`] = `
+"import { SNSEventRecord, SNSMessage, SNSEvent } from 'aws-lambda';
+
+import { exampleEmailClickEvent } from '../../src/.test/assets/exampleEmailClickEvent';
+import { runLambdaEndpoint } from 'sdk-aws-lambda';
+import { sdkAwsLambdaEnvAccessContemp } from '@src/access/sdks/sdkAwsLambdaEnvAccessContemp';
+import { log } from '@src/utils/logger';
+import { locally } from '../environment';
+
+describe('consumeSESEmailEventFromSNS', () => {
+  it('should be possible to invoke the lambda', async () => {
+    const exampleSnsEvent: SNSEvent = {
+      Records: [
+        {
+          Sns: {
+            Message: JSON.stringify(exampleEmailClickEvent),
+          } as SNSMessage,
+        } as SNSEventRecord,
+      ],
+    };
+    const response = await runLambdaEndpoint.onSerialized<unknown, Record<string, any>>(
+      {
+        which: { service: 'svc-notifications', function: 'consumeSESEmailEventFromSNS' },
+        event: exampleSnsEvent,
+        at: locally ? 'local' : 'cloud',
+      },
+      { log, env: { access: sdkAwsLambdaEnvAccessContemp() } },
+    );
+    expect(response).toBeDefined();
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case2] a repo on the old-acceptance-test-utils-2 shape when: [t0] the input (before any fix) then: the file holds the old import, and matches snapshot: old-acceptance-test-utils-2 — before 1`] = `
+"import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';
+
+import { locally } from '../__test_utils__/environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await invokeLambdaForTesting({
+      service: 'svc-images',
+      function: 'addDecoratedImage',
+      locally,
+      event: {
+        url: 'https://some.url',
+        description: 'bo vine at his gig, moooooin the lawn',
+        focalArea: null,
+      },
+    });
+    expect(response.image).toHaveProperty('uuid');
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case2] a repo on the old-acceptance-test-utils-2 shape when: [t1] the fix is applied then: no template token leaks, and the file matches snapshot: old-acceptance-test-utils-2 — after 1`] = `
+"import { runLambdaEndpoint } from 'sdk-aws-lambda';
+import { sdkAwsLambdaEnvAccessContemp } from '@src/access/sdks/sdkAwsLambdaEnvAccessContemp';
+import { log } from '@src/utils/logger';
+
+import { locally } from '../environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await runLambdaEndpoint.onSerialized<unknown, Record<string, any>>(
+      {
+        which: { service: 'svc-images', function: 'addDecoratedImage' },
+        event: {
+          url: 'https://some.url',
+          description: 'bo vine at his gig, moooooin the lawn',
+          focalArea: null,
+        },
+        at: locally ? 'local' : 'cloud',
+      },
+      { log, env: { access: sdkAwsLambdaEnvAccessContemp() } },
+    );
+    expect(response.image).toHaveProperty('uuid');
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case3] a repo on the old-acceptance-test-utils-3 shape when: [t0] the input (before any fix) then: the file holds the old import, and matches snapshot: old-acceptance-test-utils-3 — before 1`] = `
+"import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';
+
+import { locally } from '../_utils/environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await invokeLambdaForTesting({
+      service: 'svc-images',
+      function: 'addDecoratedImage',
+      locally,
+      event: {
+        url: 'https://some.url',
+        description: 'bo vine at his gig, moooooin the lawn',
+        focalArea: null,
+      },
+    });
+    expect(response.image).toHaveProperty('uuid');
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case3] a repo on the old-acceptance-test-utils-3 shape when: [t1] the fix is applied then: no template token leaks, and the file matches snapshot: old-acceptance-test-utils-3 — after 1`] = `
+"import { runLambdaEndpoint } from 'sdk-aws-lambda';
+import { sdkAwsLambdaEnvAccessContemp } from '@src/access/sdks/sdkAwsLambdaEnvAccessContemp';
+import { log } from '@src/utils/logger';
+
+import { locally } from '../environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await runLambdaEndpoint.onSerialized<unknown, Record<string, any>>(
+      {
+        which: { service: 'svc-images', function: 'addDecoratedImage' },
+        event: {
+          url: 'https://some.url',
+          description: 'bo vine at his gig, moooooin the lawn',
+          focalArea: null,
+        },
+        at: locally ? 'local' : 'cloud',
+      },
+      { log, env: { access: sdkAwsLambdaEnvAccessContemp() } },
+    );
+    expect(response.image).toHaveProperty('uuid');
+  });
+});
+"
+`;