declapract-typescript-ehmpathy 0.49.13 → 0.49.14

package/dist/practices/serverless/best-practice/serverless.yml.declapract.ts

@@ -1,19 +1,16 @@
-import type { FileFixFunction } from 'declapract';
+import type { FileContentsFunction, FileFixFunction } from 'declapract';
 import { FileCheckType } from 'declapract';
 
+import { readFile } from '../../../utils/readFile';
+import { getOneLambdaNodeRuntime } from '../getOneLambdaNodeRuntime';
+
 export const check = FileCheckType.CONTAINS; // i.e., check that the contents of the file contains what's declared (default is equals)
 
-// .note = ON A MISS, EVERY TRANSFORM SOFT-SKIPS (returns the contents unchanged); none throws.
-//   a soft-skip is NOT a silent break: the overall check is CONTAINS, so any declared line a
-//   transform could not land is absent from the output, which leaves `declapract plan` RED — that
-//   red IS the signal. a throw was the wrong mechanism for a miss: `fix` folds 14 transforms, so
-//   one throw aborts the whole chain and a very common arrival shape (a var before NODE_ENV, a
-//   pre-extant custom: block, an underscore in the service name) then blocks every unrelated repair
-//   — the runtime bump, the plugin removal, the IAM grants — from landing at all. CONTAINS already
-//   supplies the visibility a throw reached for, without that abort. the one true silent break a
-//   throw once guarded — a SECOND top-level key of a section the file already holds, a yaml
-//   last-wins clobber that PASSES CONTAINS — is prevented by NOT inserting when the section already
-//   exists (a soft-skip that declines the duplicate), which needs no throw either.
+// .note = on a miss, each transform returns the contents unchanged; none throws. the check is
+//   CONTAINS, so a declared line a transform could not land stays absent and `declapract plan`
+//   stays red, which names the miss. a throw would abort the whole 14-transform fold, so one odd
+//   arrival shape would block every unrelated repair in it. a transform never inserts a section the
+//   file already holds, since a second top-level key would clobber the first and still pass CONTAINS.
 
 /**
  * .what = convert crlf newlines to unix lf, as the first transform in the fold.
@@ -53,11 +50,28 @@ const accessByStageCustom = `custom:
 `;
 
 /**
- * .what = bump the lambda runtime to the current node major.
- * .why  = an old runtime string silently deploys onto an unsupported node version.
+ * .what = set the lambda runtime to the node major the repo's `.nvmrc` pins.
+ * .why  = the major that builds the artifact and the major that serves it must match, or a
+ *         dependency ships syntax the lambda cannot parse while every gate stays green (#552).
  */
-const withNodeRuntime = (input: { contents: string }): string =>
-  input.contents.replace(/runtime: nodejs\d\d.x/, 'runtime: nodejs22.x');
+const withNodeRuntime = (input: {
+  contents: string;
+  runtime: string;
+}): string =>
+  input.contents.replace(/runtime: nodejs\d+\.x/, `runtime: ${input.runtime}`);
+
+/**
+ * .what = declare the template, with its runtime line derived from the project's `.nvmrc`.
+ * .why  = the check is CONTAINS, so a template that pinned one major would demand it of a repo on
+ *         another — the fix and the check must name the same runtime, from the same one source.
+ */
+export const contents: FileContentsFunction = async (context) =>
+  withNodeRuntime({
+    contents: await readFile({ filePath: `${__dirname}/serverless.yml` }),
+    runtime: getOneLambdaNodeRuntime({
+      projectRoot: context.getProjectRootDirectory(),
+    }),
+  });
 
 /**
  * .what = drop the plugins serverless no longer needs.
@@ -608,7 +622,6 @@ const withSsmGetParameter = (input: { contents: string }): string => {
 // withNodeEnvProduction runs after withConnectionReuse, which anchors on the legacy NODE_ENV form.
 const transforms: Array<(input: { contents: string }) => string> = [
   withUnixNewlines,
-  withNodeRuntime,
   withoutDeprecatedPlugins,
   withNativeVariables,
   withSingleHashCommentHeaders,
@@ -646,7 +659,20 @@ const withTransformsApplied = (input: {
     input.contents,
   );
 
-export const fix: FileFixFunction = (contents) => {
+export const fix: FileFixFunction = (contents, context) => {
   if (!contents) return { contents }; // skip an absent file
-  return { contents: withTransformsApplied({ contents, transforms }) };
+
+  // the runtime comes from the project's `.nvmrc` (#552); a bare unit call has no project root
+  const runtime = getOneLambdaNodeRuntime({
+    projectRoot: context?.getProjectRootDirectory?.() ?? null,
+  });
+  return {
+    contents: withTransformsApplied({
+      contents,
+      transforms: [
+        (step) => withNodeRuntime({ contents: step.contents, runtime }),
+        ...transforms,
+      ],
+    }),
+  };
 };

package/dist/practices/serverless/deployment-bucket-account-scoped.declapract.integration.test.ts

@@ -62,7 +62,7 @@ describe('serverless deployment bucket is account-scoped by stage (#596)', () =>
 
       then('the emitted deploymentBucketByStage map matches snapshot', () => {
         // snapshot the governed map block itself, so a reshaped map that keeps the pinned
-        // per-tier tokens green (a reordered key, a rephrased bucket name) reddens a vibecheck
+        // per-key tokens green (a reordered key, a rephrased bucket name) reddens a vibecheck
         // in review (rule.require.contract-snapshot-exhaustiveness). match the header line plus
         // its indented dev/prep/prod entry lines — robust to a comment on any entry and to the
         // entry order.

package/dist/practices/serverless/getOneLambdaNodeRuntime.ts

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { ConstraintError } from 'helpful-errors';
+
+/**
+ * .what = the node major the node practice pins, as the lambda runtime it maps to
+ * .why  = the default when a repo declares no `.nvmrc` — the node practice ships `v22.*`
+ */
+const RUNTIME_DEFAULT = 'nodejs22.x';
+
+/**
+ * .what = cast the contents of a `.nvmrc` into the lambda runtime of the same node major
+ * .why  = the node major that BUILDS the artifact and the node major that SERVES it must match.
+ *         `build:artifact` copies third-party files verbatim, never down-levelled, so a skew lets a
+ *         dependency ship syntax the deploy runtime cannot parse — and every gate before prod stays
+ *         green (#552). one source (`.nvmrc`), so the two cannot drift.
+ * .note = an unreadable pin (`lts/*`, `node`, an empty file) fails loud: a guess here is the exact
+ *         silent skew this transformer exists to prevent.
+ */
+export const asLambdaNodeRuntime = (input: { nvmrc: string }): string => {
+  // read the major from `22`, `v22`, `22.21.0`, or `v22.21.0`
+  const major = input.nvmrc.trim().match(/^v?(\d+)(?:\.\d+){0,2}$/)?.[1];
+  if (!major)
+    throw new ConstraintError(
+      'serverless.yml runtime derives from .nvmrc, but .nvmrc names no node major',
+      {
+        nvmrc: input.nvmrc,
+        hint: "pin .nvmrc to a numeric version, e.g. 'v22.21.0' (an alias like 'lts/*' names no major)",
+      },
+    );
+  return `nodejs${major}.x`;
+};
+
+/**
+ * .what = the lambda runtime for the project, read from its `.nvmrc`
+ * .why  = serverless.yml's `provider.runtime` must follow the repo's node pin (#552)
+ * .note = no project root (a bare unit call) or no `.nvmrc` → the node practice's pinned major
+ */
+export const getOneLambdaNodeRuntime = (input: {
+  projectRoot: string | null;
+}): string => {
+  // locate the pin; absent → the node practice's default
+  if (!input.projectRoot) return RUNTIME_DEFAULT;
+  const nvmrcPath = path.join(input.projectRoot, '.nvmrc');
+  if (!existsSync(nvmrcPath)) return RUNTIME_DEFAULT;
+
+  // cast the pin into its runtime
+  return asLambdaNodeRuntime({ nvmrc: readFileSync(nvmrcPath, 'utf-8') });
+};

package/dist/practices/serverless/if-env-unfloored.declapract.integration.test.ts

@@ -0,0 +1,41 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { given, then, when } from 'test-fns';
+
+/**
+ * .what = clamps #660: the serverless practice floors no `if-env`
+ * .why  = every serverless package command gates on `ACCESS` in plain shell
+ *         (`[ "${ACCESS:-}" = 'prep' ]`), so a floor on `if-env` forced every adopter to install a
+ *         package no command calls
+ * .teeth = re-add `"if-env": "@declapract{check.minVersion('1.0.4')}"` to the serverless
+ *          package.json and case1 goes red
+ * .note = INTEGRATION by rule.forbid.unit.remote-boundaries: it reads the template on disk
+ */
+
+const template = readFileSync(
+  join(__dirname, 'best-practice/package.json'),
+  'utf-8',
+);
+const parsed = JSON.parse(template) as {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+};
+const commands = Object.entries(parsed.scripts ?? {});
+
+describe('serverless floors no if-env (#660)', () => {
+  given('[case1] the serverless best-practice package.json', () => {
+    when('[t0] its deps and commands are read', () => {
+      then('no dep section names if-env', () => {
+        expect(Object.keys(parsed.dependencies ?? {})).not.toContain('if-env');
+        expect(Object.keys(parsed.devDependencies ?? {})).not.toContain('if-env');
+      });
+
+      then('no package command calls if-env, so naught needs it', () => {
+        expect(commands.length).toBeGreaterThan(0);
+        expect(commands.filter(([, command]) => command.includes('if-env'))).toEqual([]);
+      });
+    });
+  });
+});

package/dist/practices/terraform-aws/best-practice/provision/aws/environments/test/main.tf.declapract.ts

@@ -0,0 +1,73 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import { ConstraintError } from 'helpful-errors';
+
+import {
+  defineExpectedContentsWithUsecaseInserts,
+  type UsecaseInsert,
+} from '../../../../../../../utils/defineExpectedContentsWithUsecaseInserts';
+
+/**
+ * .what = the test-environment `main.tf` terraform-aws declares, usecase-aware for persist-with-dynamodb
+ * .why  = terraform-aws is the one owner of this file (#630). a dynamodb service provisions the
+ *         tables of its test environment into the local dynamodb container, so its aws provider
+ *         gets an `endpoints` block — an insert on this owner, never a second declaration of the
+ *         same file (rule.avoid.runtime-forks).
+ * .why  = a FINDSERT, never EQUALS: the base must still equal the template, but the endpoints
+ *         block, once present, is kept under every scope — a narrow
+ *         `declapract apply --practice terraform-aws` never strips it.
+ */
+export const DYNAMODB_INSERTS: UsecaseInsert[] = [
+  {
+    after: 'provider "aws" {',
+    text: [
+      '',
+      '  endpoints {',
+      '    dynamodb = "http://localhost:7337/" # the test environment tables live in the local dynamodb',
+      '  }',
+      '',
+    ].join('\n'),
+  },
+];
+
+/**
+ * .what = the contents this declaration expects, for the repo's extant file and usecase
+ */
+const defineExpectedContents = (input: {
+  contents: string | null;
+  declared: string;
+  projectPractices: string[];
+}): string =>
+  defineExpectedContentsWithUsecaseInserts({
+    contents: input.contents,
+    declared: input.declared,
+    inserts: DYNAMODB_INSERTS,
+    usecaseInScope: input.projectPractices.includes('persist-with-dynamodb'),
+  });
+
+/**
+ * .what = throws when the repo's test main.tf differs from the declared base + its owed inserts
+ */
+export const check: FileCheckFunction = (contents, context) => {
+  const expected = defineExpectedContents({
+    contents,
+    declared: context.declaredFileContents ?? '',
+    projectPractices: context.projectPractices,
+  });
+  if (contents !== expected)
+    throw new ConstraintError(
+      'provision/aws/environments/test/main.tf differs from the declared template (plus its usecase inserts)',
+      { relativeFilePath: context.relativeFilePath },
+    );
+};
+
+/**
+ * .what = writes the declared base, plus the dynamodb endpoints block when owed or already present
+ * .note = a fixed point: `fix(fix(x)) === fix(x)`, and `check` passes on its output.
+ */
+export const fix: FileFixFunction = (contents, context) => ({
+  contents: defineExpectedContents({
+    contents,
+    declared: context.declaredFileContents ?? '',
+    projectPractices: context.projectPractices,
+  }),
+});

package/dist/practices/terraform-common/best-practice/.terraform-version

@@ -1 +1 @@
-0.14.11
+1.9.8

package/dist/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/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/practices/tests-any/.test/assets/repo-old-acceptance-utils/package.json

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

package/dist/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/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/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/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/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/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/practices/tests-any/__snapshots__/livedb-wake-branches.declapract.integration.test.ts.snap

@@ -0,0 +1,6 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`the useWakeOfLivedb decide-gate runs its real branches (executed, no live infra) given: the wake command fails when: it fails with a child-process shape (a non-zero exit) then: the wake-failure warn matches snapshot: useWakeOfLivedb wake-failure warn 1`] = `
+"useWakeOfLivedb: 'rhx use.rds.capacity --env prep' failed (non-fatal): {"status":1}
+"
+`;

package/dist/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');
+  });
+});
+"
+`;

package/dist/practices/tests-any/__snapshots__/test-kind-seam.declapract.integration.test.ts.snap

@@ -0,0 +1,9 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`#679 test-kind presence accepts the \`._.\` seam given: [case] the tests-any integration declaration, on a repo with no test of either form then: the check still fails 1`] = `"expected at least one test file under src/ named *.integration.test.ts or *._.intg.test.ts"`;
+
+exports[`#679 test-kind presence accepts the \`._.\` seam given: [case] the tests-service blackbox acceptance declaration, on a repo with no test of either form then: the check still fails 1`] = `"expected at least one test file under blackbox/ named *.acceptance.test.ts or *._.acpt.test.ts"`;
+
+exports[`#679 test-kind presence accepts the \`._.\` seam given: [case] the tests-service integration declaration, on a repo with no test of either form then: the check still fails 1`] = `"expected at least one test file under src/ named *.integration.test.ts or *._.intg.test.ts"`;
+
+exports[`#679 test-kind presence accepts the \`._.\` seam given: [case] the tests-service lambda acceptance declaration, on a repo with no test of either form then: the check still fails 1`] = `"expected at least one test file under blackbox/lambdas/ named *.acceptance.test.ts or *._.acpt.test.ts"`;

package/dist/practices/tests-any/autoprune-hooks.declapract.integration.test.ts

@@ -57,8 +57,15 @@ const configs: { relPath: string; composite: string | null }[] = [
     composite: 'src/practices/tests-node/best-practice/jest.acceptance.prepare.ts',
   },
   { relPath: 'src/practices/tests-expo/best-practice/jest.unit.config.ts', composite: null },
-  { relPath: 'src/practices/tests-expo/best-practice/jest.integration.config.ts', composite: null },
-  { relPath: 'src/practices/tests-expo/best-practice/jest.acceptance.config.ts', composite: null },
+  // #621: the expo integration + acceptance configs compose the livedb wake (via-gateway) too
+  {
+    relPath: 'src/practices/tests-expo/best-practice/jest.integration.config.ts',
+    composite: 'src/practices/tests-expo/best-practice/jest.integration.prepare.ts',
+  },
+  {
+    relPath: 'src/practices/tests-expo/best-practice/jest.acceptance.config.ts',
+    composite: 'src/practices/tests-expo/best-practice/jest.acceptance.prepare.ts',
+  },
 ];
 
 /**