create-qpq-app 0.1.25 → 0.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-qpq-app",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Scaffold a new quidproquo app: npx create-qpq-app my-app",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/esm/index.js",
@@ -55,7 +55,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.13.13",
-    "quidproquo-tsconfig": "0.1.25"
+    "quidproquo-tsconfig": "0.1.27"
   },
   "bin": {
     "create-qpq-app": "./lib/commonjs/bin/createQpqApp.js"

package/template/README.md

@@ -103,3 +103,7 @@ npx qpq go             # interactive aws deploy: pick app, services, stacks (inf
 1. Create its `config`, `models`, `x-models`, `shared-logic`, `x-logic`, `service-utils`, and `service` packages.
 2. Each lib gets a `package.json` with `"build": "tsc -b"` and the dist-pointing `main`, `types`, and `exports`; a `tsconfig.json` (extends the root base, **no paths**, references `./tsconfig.lib.json`); and a `tsconfig.lib.json` (`composite`, `outDir ./dist`, `rootDir .`, with `references` to its workspace deps' `tsconfig.lib.json`). There is no root-level list to touch, since `npm run build --workspaces` discovers the new lib automatically.
 3. `service/` gets a `package.json` (`@qpqjs/<svc>-service`, `private`, `"build": "tsc -p tsconfig.app.json"`) and a `tsconfig.app.json`. No rspack.config.ts and no bundle script, because `qpq go` bundles it by convention. `npm run build` then picks it up automatically.
+
+## Test
+
+Adding a note to test build / deploy - this is a second test.

package/template/apps/qpqjs/account.qpq.ts

@@ -7,6 +7,7 @@ import { QPQConfig } from 'quidproquo';
 import {
   AwsDataStoreRemovalPolicy,
   defineAccountBudget,
+  defineAccountEmailReceiving,
   defineAccountGithubOidcProvider,
   defineAccountSecurityServices,
   defineAwsDataStoreRemovalPolicy,
@@ -21,6 +22,9 @@ export default (): QPQConfig => [
   // GitHub Actions OIDC provider, trusted by every app's deploy role in this account.
   defineAccountGithubOidcProvider(),
 
+  // The one active SES receipt rule set; every app's inbound-email rules live in it.
+  defineAccountEmailReceiving(),
+
   defineAccountSecurityServices({
     // GuardDuty is org-managed for this account
     // (delegated admin 816650600287 auto-enables detectors - a stack-created one

package/template/apps/qpqjs/bootstrap.qpq.ts

@@ -2,7 +2,12 @@
 // domain certificates. The identity plumbing (defineApplication +
 // defineAwsServiceAccountInfo) is provided by quidproquo-deploy-awscdk's
 // workspace CDK app; this fragment must not declare its own.
-import { defineApi, defineDns, QPQConfig } from 'quidproquo';
+import {
+  defineApi,
+  defineDns,
+  defineEmailReceivingDomain,
+  QPQConfig,
+} from 'quidproquo';
 import {
   defineAwsGithubDeployRole,
   defineBootstrapWaf,
@@ -17,8 +22,14 @@ import { QPQJS_DOMAINS, QpqjsServiceEnum } from '@qpqjs/constants';
 export default ({ region }: QpqAppDeployContext): QPQConfig => [
   defineDns(QPQJS_DOMAINS),
 
+  // inbox.<env>.<root>: verified with SES and MX-routed to it, for every defineEmailReceiver.
+  defineEmailReceivingDomain('inbox'),
+
   // The role the deploy workflow assumes (ids from `gh api repos/qpqjs/quidproquo`).
-  defineAwsGithubDeployRole('qpqjs/quidproquo', { ownerId: 314167689, repositoryId: 571382961 }),
+  defineAwsGithubDeployRole('qpqjs/quidproquo', {
+    ownerId: 314167689,
+    repositoryId: 571382961,
+  }),
 
   defineBootstrapWaf({
     rateLimits: [{ name: 'all-traffic', limit: 2000 }],

package/template/apps/qpqjs/packages/service-utils/src/defineQpqjsService.ts

@@ -6,6 +6,7 @@ import {
   defineCache,
   defineDefaultRouteOptions,
   defineDns,
+  defineEmailReceivingDomain,
   defineFrontendBundleOptions,
   QPQConfig,
 } from 'quidproquo';
@@ -59,6 +60,9 @@ export const defineQpqjsService = (
   ),
 
   defineDns(QPQJS_DOMAINS),
+  // Same domain bootstrap.qpq.ts declares: bootstrap owns the records, a service's
+  // defineEmailReceiver resolves its recipients from it.
+  defineEmailReceivingDomain('inbox'),
 
   defineAdminUserDirectory({
     owner: {

package/template/apps/qpqjs/services/test/models/src/SmokeProbeRecord.ts

@@ -5,4 +5,16 @@ export type SmokeProbeRecord = {
   probeId: string;
   category: string;
   value: number;
+
+  // Set by the storage drive event and kvs stream handlers: what the event
+  // said its scope and path/key were, and (for file events) the ambient
+  // storage scope the handler ran under, so a test can prove both agree.
+  scope?: string;
+  ambientScope?: string;
+  path?: string;
+  // Set by the kvs stream handler: the attribute names on the record's image,
+  // so a test can prove no backend bookkeeping attribute reaches a handler.
+  imageAttributes?: string[];
+  // Set by the email handler: the provider's spf/dkim verdicts on the message.
+  authentication?: string;
 };

package/template/apps/qpqjs/services/test/models/src/SmokeRunSummary.ts

@@ -4,9 +4,16 @@ import { z } from 'zod/v4';
 // cannot drift from the entries themselves.
 export const SmokeRunSummarySchema = z.object({
   total: z.int().nonnegative().describe('Tests registered for the run'),
-  completed: z.int().nonnegative().describe('Tests that have passed or failed'),
+  completed: z
+    .int()
+    .nonnegative()
+    .describe('Tests that have passed, failed or been skipped'),
   passed: z.int().nonnegative(),
   failed: z.int().nonnegative(),
+  skipped: z
+    .int()
+    .nonnegative()
+    .describe('Deployed-only tests not run on this platform'),
 });
 
 export type SmokeRunSummary = z.infer<typeof SmokeRunSummarySchema>;

package/template/apps/qpqjs/services/test/models/src/SmokeTestStatus.ts

@@ -3,4 +3,6 @@ export enum SmokeTestStatus {
   running = 'running',
   passed = 'passed',
   failed = 'failed',
+  // Deployed-only test on a platform with no equivalent; never queued, never counts either way.
+  skipped = 'skipped',
 }

package/template/apps/qpqjs/services/test/service/src/infrastructure.ts

@@ -3,9 +3,7 @@ import { defineDevServerOptions } from 'quidproquo-dev-server/config';
 import { QpqjsServiceEnum } from '@qpqjs/constants';
 import { defineQpqjsService } from '@qpqjs/service-utils';
 
-import { defineEcho } from './echo/config/defineEcho';
 import { defineSmoke } from './smoke/config/defineSmoke';
-import { defineTick } from './tick/config/defineTick';
 
 export default [
   defineDevServerOptions({ port: 3083 }),
@@ -18,8 +16,4 @@ export default [
   ),
 
   defineSmoke(),
-
-  defineEcho(),
-
-  defineTick(),
 ];

package/template/apps/qpqjs/services/test/service/src/smoke/config/defineSmoke.ts

@@ -1,176 +1,10 @@
-import {
-  defineEventBus,
-  defineKeyValueStore,
-  defineParameter,
-  defineQueue,
-  defineRoute,
-  defineSecret,
-  defineSigningKey,
-  defineStorageDrive,
-  QPQConfig,
-  QpqFunctionRuntime,
-} from 'quidproquo';
-import { defineEventDoc } from 'quidproquo-features';
+import { QPQConfig } from 'quidproquo';
 
-import { z } from 'zod/v4';
-import {
-  SMOKE_PROBE_DRIVE,
-  SMOKE_PROBE_SIGNING_KEY,
-  SMOKE_PROBE_STORE,
-} from '@qpqjs/constants';
-import {
-  SmokeProbeRecord,
-  SmokeRunStartedSchema,
-  SmokeRunWithSummarySchema,
-} from '@qpqjs/test-models';
+import { defineSmokeHarness } from '../harness/config/defineSmokeHarness';
+import { smokeSuites } from '../suites/smokeSuites';
 
-import { SMOKE_RUNS_STORE } from '../constants/SMOKE_RUNS_STORE';
-import {
-  SMOKE_EVENT_DOC_APPEND_MESSAGE_TYPE,
-  SMOKE_EVENT_DOC_APPEND_QUEUE,
-  SMOKE_EVENT_DOC_BASE_PATH,
-} from '../constants/smokeEventDoc';
-import {
-  SMOKE_PROBE_EVENT_BUS,
-  SMOKE_PROBE_EVENT_QUEUE,
-  SMOKE_PROBE_EVENT_TYPE,
-  SMOKE_PROBE_PARAMETER,
-  SMOKE_PROBE_PARAMETER_VALUE,
-  SMOKE_PROBE_SECRET,
-} from '../constants/smokeProbe';
-import {
-  SMOKE_RUN_QUEUE,
-  SMOKE_TEST_REQUESTED_MESSAGE_TYPE,
-} from '../constants/smokeRunQueue';
-import { smokeProbeDocDefinition } from '../eventDoc/smokeProbeDocDefinition';
-
-// Everything the smoke feature needs: the run store, the queue runs execute
-// on, and the two routes. Runtimes are located relative to this file, so the
-// module can move as a unit.
-//
-// The routes look public (no user directory, no api keys) but carry a
-// per-runtime action processor override that swaps the route auth decode for
-// the GitHub OIDC validator - so ONLY a GitHub Actions run of our repo,
-// holding an OIDC token with the qpq-smoke audience and matching pinned
-// claims, gets past the preamble. Everything else 401s, tokenless included.
-export const defineSmoke = (): QPQConfig => {
-  const githubOidcAuth: QpqFunctionRuntime[] = [
-    {
-      basePath: __dirname,
-      relativePath: '../processors/github/getGithubOidcAuthProcessors',
-      functionName: 'getGithubOidcAuthProcessors',
-    },
-  ];
-
-  return [
-    // One record per run, keyed by runId; the queue workers each write their
-    // own test's entry as it completes and the GET route polls it.
-    defineKeyValueStore(SMOKE_RUNS_STORE, 'runId'),
-
-    // One message per test per run. Not FIFO and no concurrency cap, so the
-    // tests of a run fan out and execute in parallel.
-    defineQueue(SMOKE_RUN_QUEUE, {
-      [SMOKE_TEST_REQUESTED_MESSAGE_TYPE]: {
-        basePath: __dirname,
-        relativePath: '../queue/onSmokeTestRequested',
-        functionName: 'onSmokeTestRequested',
-      },
-    }),
-
-    // Throwaway probe resources, one per kind of owned resource the tag-based
-    // IAM grants cover. The store's `category` index is what the KVS test
-    // queries through, proving the `table/*/index/*` half of the grant.
-    defineKeyValueStore<SmokeProbeRecord>(SMOKE_PROBE_STORE, 'probeId', [], {
-      indexes: ['category'],
-    }),
-    defineParameter(SMOKE_PROBE_PARAMETER, {
-      value: SMOKE_PROBE_PARAMETER_VALUE,
-    }),
-    defineSecret(SMOKE_PROBE_SECRET),
-    defineStorageDrive(SMOKE_PROBE_DRIVE),
-    // An owned RSA signing key: kms:Sign + kms:GetPublicKey through the
-    // alias-conditioned grant. testa declares the same key foreign (see
-    // defineCrossServiceProbe) for the cross-service verify test.
-    defineSigningKey(SMOKE_PROBE_SIGNING_KEY),
-
-    // Event bus test path: publish to the bus, the subscribed queue's entry
-    // writes a marker into the probe store, the test polls for it.
-    defineEventBus(SMOKE_PROBE_EVENT_BUS),
-    defineQueue(
-      SMOKE_PROBE_EVENT_QUEUE,
-      {
-        [SMOKE_PROBE_EVENT_TYPE]: {
-          basePath: __dirname,
-          relativePath: '../queue/onSmokeProbeEvent',
-          functionName: 'onSmokeProbeEvent',
-        },
-      },
-      { eventBusSubscriptions: [SMOKE_PROBE_EVENT_BUS] }
-    ),
-
-    // The event-doc probe collection: a full registered collection (stores, stream
-    // projector, dynamic functions, routes) so the smoke tests exercise event docs the
-    // way a real service does. NOTE the routes mount with no auth - the test service
-    // has no user directory - so the collection is world-writable; it holds nothing
-    // but throwaway probe docs. The queue fans a test's writers out one invocation
-    // each, so their appends race across lambdas.
-    defineEventDoc(
-      smokeProbeDocDefinition,
-      {
-        basePath: __dirname,
-        relativePath: '../eventDoc/smokeProbeDocDefinition',
-        functionName: 'smokeProbeDocDefinition',
-      },
-      { basePath: SMOKE_EVENT_DOC_BASE_PATH }
-    ),
-    defineQueue(SMOKE_EVENT_DOC_APPEND_QUEUE, {
-      [SMOKE_EVENT_DOC_APPEND_MESSAGE_TYPE]: {
-        basePath: __dirname,
-        relativePath: '../queue/onSmokeEventDocAppend',
-        functionName: 'onSmokeEventDocAppend',
-      },
-    }),
-
-    // The zod models double as the routes' published contract, flattened to
-    // JSON Schema here for the OpenAPI document at /v1/docs.
-    defineRoute(
-      'POST',
-      '/smoke/run',
-      {
-        basePath: __dirname,
-        relativePath: '../controller/askRunSmokeTests',
-        functionName: 'askRunSmokeTests',
-        actionProcessors: githubOidcAuth,
-      },
-      {
-        schema: {
-          summary: 'Start a smoke run',
-          description:
-            'Queues every registered smoke test and returns the run id to poll. Requires a GitHub Actions OIDC token for this repo.',
-          tags: ['smoke'],
-          responseJsonSchema: z.toJSONSchema(SmokeRunStartedSchema),
-        },
-      }
-    ),
-
-    defineRoute(
-      'GET',
-      '/smoke/run/{runId}',
-      {
-        basePath: __dirname,
-        relativePath: '../controller/askGetSmokeRun',
-        functionName: 'askGetSmokeRun',
-        actionProcessors: githubOidcAuth,
-      },
-      {
-        schema: {
-          summary: 'Get a smoke run',
-          description:
-            'The stored run plus pass/fail counts. Poll until status leaves running.',
-          tags: ['smoke'],
-          responseJsonSchema: z.toJSONSchema(SmokeRunWithSummarySchema),
-        },
-      }
-    ),
-  ];
-};
+/** The whole smoke feature: the harness plus the resources of every registered suite. */
+export const defineSmoke = (): QPQConfig => [
+  defineSmokeHarness(),
+  smokeSuites.map((suite) => suite.defineConfig?.() ?? []),
+];

package/template/apps/qpqjs/services/test/service/src/smoke/harness/assert/askSmokePollForMarker.ts

@@ -0,0 +1,44 @@
+import {
+  askDelay,
+  askKeyValueStoreDelete,
+  askKeyValueStoreGet,
+  AskResponse,
+  Nullable,
+} from 'quidproquo';
+
+import { SMOKE_PROBE_STORE } from '@qpqjs/constants';
+import { SmokeProbeRecord } from '@qpqjs/test-models';
+
+import { askSmokeAssert } from './askSmokeAssert';
+
+const POLL_ATTEMPTS = 15;
+const POLL_INTERVAL_MS = 2000;
+
+// Fan-in for every async probe: polls the probe store for the marker row an
+// event handler writes, fails the test if it never arrives, and removes it
+// so a rerun starts clean. The default wait covers the dev server's file
+// watcher settle window and S3 / stream delivery latency; a slower path
+// (mail delivery) asks for more attempts.
+export function* askSmokePollForMarker(
+  markerId: string,
+  via: string,
+  attempts: number = POLL_ATTEMPTS
+): AskResponse<SmokeProbeRecord> {
+  let marker: Nullable<SmokeProbeRecord> = null;
+  for (let attempt = 0; attempt < attempts && !marker; attempt += 1) {
+    yield* askDelay(POLL_INTERVAL_MS);
+    marker = yield* askKeyValueStoreGet<SmokeProbeRecord>(
+      SMOKE_PROBE_STORE,
+      markerId
+    );
+  }
+
+  yield* askSmokeAssert(
+    !!marker,
+    `marker [${markerId}] never arrived via ${via}`
+  );
+
+  yield* askKeyValueStoreDelete(SMOKE_PROBE_STORE, markerId);
+
+  return marker!;
+}

package/template/apps/qpqjs/services/test/service/src/smoke/harness/assert/index.ts

@@ -0,0 +1,2 @@
+export * from './askSmokeAssert';
+export * from './askSmokePollForMarker';

package/template/apps/qpqjs/services/test/service/src/smoke/harness/config/defineSmokeHarness.ts

@@ -0,0 +1,115 @@
+import {
+  defineKeyValueStore,
+  defineQueue,
+  defineRoute,
+  defineStorageDrive,
+  QPQConfig,
+  QpqFunctionRuntime,
+} from 'quidproquo';
+
+import { z } from 'zod/v4';
+import { SMOKE_PROBE_DRIVE, SMOKE_PROBE_STORE } from '@qpqjs/constants';
+import {
+  SmokeProbeRecord,
+  SmokeRunStartedSchema,
+  SmokeRunWithSummarySchema,
+} from '@qpqjs/test-models';
+
+import { SMOKE_RUNS_STORE } from '../constants/SMOKE_RUNS_STORE';
+import {
+  SMOKE_RUN_QUEUE,
+  SMOKE_TEST_REQUESTED_MESSAGE_TYPE,
+} from '../constants/smokeRunQueue';
+
+/**
+ * The part of the smoke feature every suite relies on: the run store, the
+ * queue runs execute on, the shared probe store and drive, and the two
+ * routes. Knows nothing about individual suites; defineSmoke adds theirs
+ * alongside.
+ *
+ * The routes look public (no user directory, no api keys) but carry a
+ * per-runtime action processor override that swaps the route auth decode for
+ * the GitHub OIDC validator, so ONLY a GitHub Actions run of our repo holding
+ * an OIDC token with the qpq-smoke audience and matching pinned claims gets
+ * past the preamble. Everything else 401s, tokenless included.
+ */
+export const defineSmokeHarness = (): QPQConfig => {
+  const githubOidcAuth: QpqFunctionRuntime[] = [
+    {
+      basePath: __dirname,
+      relativePath: '../processors/github/getGithubOidcAuthProcessors',
+      functionName: 'getGithubOidcAuthProcessors',
+    },
+  ];
+
+  return [
+    // One record per run, keyed by runId; the queue workers each write their
+    // own test's entry as it completes and the GET route polls it.
+    defineKeyValueStore(SMOKE_RUNS_STORE, 'runId'),
+
+    // One message per test per run. Not FIFO and no concurrency cap, so the
+    // tests of a run fan out and execute in parallel.
+    defineQueue(SMOKE_RUN_QUEUE, {
+      [SMOKE_TEST_REQUESTED_MESSAGE_TYPE]: {
+        basePath: __dirname,
+        relativePath: '../queue/onSmokeTestRequested',
+        functionName: 'onSmokeTestRequested',
+      },
+    }),
+
+    // Every async suite's handler writes its marker here for
+    // askSmokePollForMarker. The keyValueStore suite queries its `category`
+    // index, proving the `table/*/index/*` half of the tag-conditioned grant,
+    // and testa reaches it cross-service.
+    defineKeyValueStore<SmokeProbeRecord>(SMOKE_PROBE_STORE, 'probeId', [], {
+      indexes: ['category'],
+    }),
+
+    // The unscoped probe drive: the storageDrive suite's subject, testa's
+    // cross-service target, and the drive the scopedStorageDrive suite proves
+    // refuses a scope.
+    defineStorageDrive(SMOKE_PROBE_DRIVE),
+
+    // The zod models double as the routes' published contract, flattened to
+    // JSON Schema here for the OpenAPI document at /v1/docs.
+    defineRoute(
+      'POST',
+      '/smoke/run',
+      {
+        basePath: __dirname,
+        relativePath: '../controller/askRunSmokeTests',
+        functionName: 'askRunSmokeTests',
+        actionProcessors: githubOidcAuth,
+      },
+      {
+        schema: {
+          summary: 'Start a smoke run',
+          description:
+            'Queues every registered smoke test and returns the run id to poll. Requires a GitHub Actions OIDC token for this repo.',
+          tags: ['smoke'],
+          responseJsonSchema: z.toJSONSchema(SmokeRunStartedSchema),
+        },
+      }
+    ),
+
+    defineRoute(
+      'GET',
+      '/smoke/run/{runId}',
+      {
+        basePath: __dirname,
+        relativePath: '../controller/askGetSmokeRun',
+        functionName: 'askGetSmokeRun',
+        actionProcessors: githubOidcAuth,
+      },
+      {
+        schema: {
+          summary: 'Get a smoke run',
+          description:
+            'The stored run plus pass/fail counts. Poll until status leaves running.',
+          tags: ['smoke'],
+          responseJsonSchema: z.toJSONSchema(SmokeRunWithSummarySchema),
+        },
+      }
+    ),
+  ];
+};

package/template/apps/qpqjs/services/test/service/src/smoke/harness/config/index.ts

@@ -0,0 +1 @@
+export * from './defineSmokeHarness';

package/template/apps/qpqjs/services/test/service/src/smoke/{constants → harness/constants}/index.ts

@@ -1,5 +1,3 @@
 export * from './githubOidc';
 export * from './SMOKE_RUNS_STORE';
-export * from './smokeEventDoc';
-export * from './smokeProbe';
 export * from './smokeRunQueue';

package/template/apps/qpqjs/services/test/service/src/smoke/harness/index.ts

@@ -0,0 +1,10 @@
+export * from './assert';
+export * from './config';
+export * from './constants';
+export * from './controller';
+export * from './data';
+export * from './logic';
+export * from './models';
+export * from './processors';
+export * from './queue';
+export * from './types';

package/template/apps/qpqjs/services/test/service/src/smoke/{logic → harness/logic}/smokeRun/askExecuteSmokeTest.ts

@@ -16,8 +16,8 @@ import {
 import { askGetSmokeRunById } from '../../data/askGetSmokeRunById';
 import { askRecordSmokeTestResult } from '../../data/askRecordSmokeTestResult';
 import { askSetSmokeRunOutcome } from '../../data/askSetSmokeRunOutcome';
-import { SmokeTestDefinition } from '../../tests/SmokeTestDefinition';
-import { smokeTestRegistry } from '../../tests/smokeTestRegistry';
+import { SmokeTestDefinition } from '../../types/SmokeTestDefinition';
+import { listSmokeTests } from './listSmokeTests';
 
 // Runs one registered test, returning its completed result entry.
 function* askRunSmokeTest(
@@ -40,7 +40,8 @@ function* askRunSmokeTest(
 
 const isTerminal = (result: SmokeTestResult): boolean =>
   result.status === SmokeTestStatus.passed ||
-  result.status === SmokeTestStatus.failed;
+  result.status === SmokeTestStatus.failed ||
+  result.status === SmokeTestStatus.skipped;
 
 // Executes one registered test for an existing run (created by
 // askStartSmokeRun) and records its result. Every test of a run executes
@@ -52,7 +53,7 @@ export function* askExecuteSmokeTest(
   runId: string,
   testName: string
 ): AskResponse<SmokeRun> {
-  const test = smokeTestRegistry.find((t) => t.name === testName);
+  const test = listSmokeTests().find((t) => t.name === testName);
   if (!test) {
     return yield* askThrowError(
       ErrorTypeEnum.NotFound,
@@ -86,7 +87,7 @@ export function* askExecuteSmokeTest(
 
   const finishedAt = yield* askDateNow();
   const anyFailed = recorded.tests.some(
-    (t) => t.status !== SmokeTestStatus.passed
+    (t) => t.status === SmokeTestStatus.failed
   );
 
   return yield* askSetSmokeRunOutcome(

package/template/apps/qpqjs/services/test/service/src/smoke/harness/logic/smokeRun/askStartSmokeRun.ts

@@ -0,0 +1,85 @@
+import {
+  askDateNow,
+  askNewGuid,
+  askPlatformGetName,
+  askQueueSendMessages,
+  AskResponse,
+  QueueMessage,
+} from 'quidproquo';
+
+import {
+  SmokeRun,
+  SmokeRunStatus,
+  SmokeTestResult,
+  SmokeTestStatus,
+} from '@qpqjs/test-models';
+
+import {
+  SMOKE_RUN_QUEUE,
+  SMOKE_TEST_REQUESTED_MESSAGE_TYPE,
+} from '../../constants/smokeRunQueue';
+import { askSaveSmokeRun } from '../../data/askSaveSmokeRun';
+import { SmokeTestRequestedPayload } from '../../models/SmokeTestRequestedQueueEvent';
+import { SmokeTestDefinition } from '../../types/SmokeTestDefinition';
+import { listSmokeTests } from './listSmokeTests';
+
+const createInitialResult = (
+  test: SmokeTestDefinition,
+  index: number,
+  skip: boolean
+): SmokeTestResult => ({
+  id: index + 1,
+  name: test.name,
+  status: skip ? SmokeTestStatus.skipped : SmokeTestStatus.pending,
+  message: skip ? 'deployed only' : '',
+  startedAt: null,
+  finishedAt: null,
+});
+
+const createTestRequestedMessage = (
+  runId: string,
+  test: SmokeTestDefinition
+): QueueMessage<SmokeTestRequestedPayload> => ({
+  type: SMOKE_TEST_REQUESTED_MESSAGE_TYPE,
+  payload: { runId, testName: test.name },
+});
+
+// Creates the run record with every registered test pending (or skipped, for
+// a deployed-only test on the dev server), then sends one queue message per
+// pending test so they execute in parallel. The record exists before the
+// messages are sent so a poll (or a worker) that races the queue still finds
+// it. A run of nothing but skips never gets a worker, so it is finished here.
+export function* askStartSmokeRun(): AskResponse<SmokeRun> {
+  const runId = yield* askNewGuid();
+  const startedAt = yield* askDateNow();
+  const platformName = yield* askPlatformGetName();
+
+  const shouldSkip = (test: SmokeTestDefinition): boolean =>
+    !!test.deployedOnly && platformName === 'devServer';
+
+  const smokeTests = listSmokeTests();
+  const queued = smokeTests.filter((test) => !shouldSkip(test));
+
+  const smokeRun: SmokeRun = {
+    runId,
+    status:
+      queued.length === 0 ? SmokeRunStatus.passed : SmokeRunStatus.running,
+    startedAt,
+    finishedAt: queued.length === 0 ? startedAt : null,
+    tests: smokeTests.map((test, index) =>
+      createInitialResult(test, index, shouldSkip(test))
+    ),
+  };
+
+  yield* askSaveSmokeRun(smokeRun);
+
+  const messages = queued.map((test) =>
+    createTestRequestedMessage(runId, test)
+  );
+
+  if (messages.length > 0) {
+    yield* askQueueSendMessages(SMOKE_RUN_QUEUE, ...messages);
+  }
+
+  return smokeRun;
+}

package/template/apps/qpqjs/services/test/service/src/smoke/{logic → harness/logic}/smokeRun/index.ts

@@ -1,4 +1,5 @@
 export * from './askExecuteSmokeTest';
 export * from './askFindSmokeRun';
 export * from './askStartSmokeRun';
+export * from './listSmokeTests';
 export * from './summarizeSmokeRun';

package/template/apps/qpqjs/services/test/service/src/smoke/harness/logic/smokeRun/listSmokeTests.ts

@@ -0,0 +1,6 @@
+import { smokeSuites } from '../../../suites/smokeSuites';
+import { SmokeTestDefinition } from '../../types/SmokeTestDefinition';
+
+/** Every registered test across all suites, in list order; a test's 1-based position is its run record id. */
+export const listSmokeTests = (): SmokeTestDefinition[] =>
+  smokeSuites.flatMap((suite) => suite.tests);