@shipfox/api-workflows-dto 2.0.0

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@shipfox/api-workflows-dto",
+  "license": "MIT",
+  "version": "2.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
+    "directory": "libs/api/workflows-dto"
+  },
+  "private": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "imports": {
+    "#test/*": "./test/*",
+    "#*": {
+      "workspace-source": "./src/*",
+      "development": "./src/*",
+      "default": "./dist/*"
+    }
+  },
+  "exports": {
+    ".": {
+      "development": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@shipfox/ts-config": "1.3.8",
+    "@shipfox/depcruise": "1.0.1",
+    "@shipfox/swc": "1.2.5",
+    "@shipfox/biome": "1.8.1",
+    "@shipfox/typescript": "1.1.6",
+    "@shipfox/vitest": "1.2.2"
+  },
+  "scripts": {
+    "build": "shipfox-swc",
+    "check": "shipfox-biome-check",
+    "check:fix": "shipfox-biome-check --write",
+    "depcruise": "shipfox-depcruise",
+    "test": "shipfox-vitest-run",
+    "test:watch": "shipfox-vitest-watch",
+    "type": "shipfox-tsc-check",
+    "type:emit": "shipfox-tsc-emit"
+  }
+}

package/src/events.test.ts

@@ -0,0 +1,362 @@
+import {
+  WORKFLOWS_JOB_ACTIVATED,
+  WORKFLOWS_JOB_EVENT_DELIVERED,
+  WORKFLOWS_JOB_EXECUTION_TIMED_OUT,
+  WORKFLOWS_JOB_STEPS_SETTLED,
+  WORKFLOWS_JOB_TERMINATED,
+  WORKFLOWS_STEP_ATTEMPT_TERMINATED,
+  WORKFLOWS_STEP_RESTART_ENQUEUED,
+  WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED,
+  WORKFLOWS_WORKFLOW_RUN_CANCELLED,
+  WORKFLOWS_WORKFLOW_RUN_TERMINATED,
+  workflowsEventSchemas,
+  workflowsJobActivatedSchema,
+  workflowsJobEventDeliveredSchema,
+  workflowsJobExecutionTimedOutSchema,
+  workflowsJobStepsSettledSchema,
+  workflowsJobTerminatedSchema,
+  workflowsStepAttemptTerminatedSchema,
+  workflowsStepRestartEnqueuedSchema,
+  workflowsWorkflowRunAttemptCreatedSchema,
+  workflowsWorkflowRunCancelledSchema,
+  workflowsWorkflowRunTerminatedSchema,
+} from './events.js';
+
+const validRunCreated = {
+  workflowRunId: 'run-1',
+  workflowRunAttemptId: 'attempt-1',
+  attempt: 1,
+  workspaceId: 'ws-1',
+  projectId: 'proj-1',
+  definitionId: 'def-1',
+};
+
+const validJobTerminated = {
+  jobId: 'job-1',
+  workflowRunId: 'run-1',
+  workflowRunAttemptId: 'attempt-1',
+  status: 'succeeded',
+  statusReason: null,
+};
+
+const validRunTerminated = {
+  workflowRunId: 'run-1',
+  workflowRunAttemptId: 'attempt-1',
+  projectId: 'proj-1',
+  status: 'failed',
+};
+
+const validRunCancelled = {
+  workflowRunId: 'run-1',
+  workflowRunAttemptId: 'attempt-1',
+  projectId: 'proj-1',
+};
+
+const validJobExecutionTimedOut = {
+  jobId: 'job-1',
+  jobExecutionId: 'execution-1',
+  workflowRunAttemptId: 'attempt-1',
+};
+
+const validJobActivated = {
+  jobId: 'job-1',
+  workflowRunId: 'run-1',
+  workspaceId: 'ws-1',
+  mode: 'listening',
+  on: [{source: 'github', event: 'pull_request_review', inputs: {state: 'approved'}}],
+  until: [{source: 'github', event: 'pull_request_closed'}],
+};
+
+const validJobEventDelivered = {
+  jobId: 'job-1',
+  disposition: 'fire',
+  eventRef: 'delivery-1',
+  eventName: 'pull_request_review',
+};
+
+const validJobStepsSettled = {
+  jobId: 'job-1',
+  jobExecutionId: 'execution-1',
+  workflowRunId: 'run-1',
+  workflowRunAttemptId: 'attempt-1',
+  status: 'failed',
+};
+
+const validStepRestartEnqueued = {
+  jobId: 'job-1',
+  workflowRunId: 'run-1',
+  workflowRunAttemptId: 'attempt-1',
+  failedStepId: 'step-1',
+  failedStepAttempt: 2,
+  restartFromStepId: 'step-0',
+  feedback: 'gate failed',
+};
+
+const validStepAttemptTerminated = {
+  jobId: 'job-1',
+  workflowRunId: 'run-1',
+  workflowRunAttemptId: 'attempt-1',
+  workspaceId: 'ws-1',
+  projectId: 'proj-1',
+  stepId: 'step-1',
+  attempt: 1,
+  logOutcome: 'drained',
+};
+
+describe('workflowsJobTerminatedSchema', () => {
+  it('parses a valid job-terminated payload unchanged', () => {
+    const result = workflowsJobTerminatedSchema.parse(validJobTerminated);
+
+    expect(result).toEqual(validJobTerminated);
+  });
+
+  it('rejects a payload missing a required field', () => {
+    const {workflowRunId: _runId, ...withoutWorkflowRunId} = validJobTerminated;
+
+    const parse = () => workflowsJobTerminatedSchema.parse(withoutWorkflowRunId);
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects a status outside the terminal set', () => {
+    const input = {...validJobTerminated, status: 'running'};
+
+    const parse = () => workflowsJobTerminatedSchema.parse(input);
+
+    expect(parse).toThrow();
+  });
+
+  it('accepts skipped as a job-only terminal status with a reason', () => {
+    const input = {
+      ...validJobTerminated,
+      status: 'skipped',
+      statusReason: 'dependency_not_completed',
+    };
+
+    const result = workflowsJobTerminatedSchema.parse(input);
+
+    expect(result).toEqual(input);
+  });
+
+  it('strips unknown keys (tolerant of forward-compatible producer additions)', () => {
+    const input = {...validJobTerminated, addedLater: 'ignored'};
+
+    const result = workflowsJobTerminatedSchema.parse(input);
+
+    expect(result).toEqual(validJobTerminated);
+  });
+});
+
+describe('workflowsWorkflowRunTerminatedSchema', () => {
+  it('parses a valid run-terminated payload unchanged', () => {
+    const result = workflowsWorkflowRunTerminatedSchema.parse(validRunTerminated);
+
+    expect(result).toEqual(validRunTerminated);
+  });
+
+  it('rejects a payload missing a required field', () => {
+    const {projectId: _projectId, ...withoutProjectId} = validRunTerminated;
+
+    const parse = () => workflowsWorkflowRunTerminatedSchema.parse(withoutProjectId);
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects a status outside the terminal set', () => {
+    const input = {...validRunTerminated, status: 'running'};
+
+    const parse = () => workflowsWorkflowRunTerminatedSchema.parse(input);
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects skipped because runs do not have a skipped terminal status', () => {
+    const input = {...validRunTerminated, status: 'skipped'};
+
+    const parse = () => workflowsWorkflowRunTerminatedSchema.parse(input);
+
+    expect(parse).toThrow();
+  });
+
+  it('strips unknown keys (tolerant of forward-compatible producer additions)', () => {
+    const input = {...validRunTerminated, addedLater: 'ignored'};
+
+    const result = workflowsWorkflowRunTerminatedSchema.parse(input);
+
+    expect(result).toEqual(validRunTerminated);
+  });
+});
+
+describe('workflowsJobActivatedSchema', () => {
+  it('requires at least one on matcher for listening jobs', () => {
+    const withoutMatchers = {...validJobActivated, on: []};
+
+    const parse = () => workflowsJobActivatedSchema.parse(withoutMatchers);
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects null on matchers for listening jobs', () => {
+    const withoutMatchers = {...validJobActivated, on: null};
+
+    const parse = () => workflowsJobActivatedSchema.parse(withoutMatchers);
+
+    expect(parse).toThrow();
+  });
+
+  it('allows one-shot jobs without listener matchers', () => {
+    const payload = {
+      jobId: 'job-1',
+      workflowRunId: 'run-1',
+      workspaceId: 'ws-1',
+      mode: 'one_shot',
+    };
+
+    const result = workflowsJobActivatedSchema.parse(payload);
+
+    expect(result).toEqual(payload);
+  });
+
+  it('retains resolved listener filter snapshots on job-activated matchers', () => {
+    const payload = {
+      ...validJobActivated,
+      on: [
+        {
+          source: 'github',
+          event: 'pull_request_review',
+          filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
+          filter_snapshot: {jobs: {build: {outputs: {pr_number: 42}}}},
+        },
+      ],
+      until: [
+        {
+          source: 'github',
+          event: 'pull_request',
+          filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
+          filter_snapshot: {jobs: {build: {outputs: {pr_number: 42}}}},
+        },
+      ],
+    };
+
+    const result = workflowsJobActivatedSchema.parse(payload);
+
+    expect(result).toEqual(payload);
+  });
+
+  it('keeps authoring-shaped matchers compatible when no snapshot is present', () => {
+    const payload = {
+      ...validJobActivated,
+      on: [{source: 'github', event: 'pull_request_review', filter: 'event.action == "opened"'}],
+      until: [{source: 'github', event: 'pull_request'}],
+    };
+
+    const result = workflowsJobActivatedSchema.parse(payload);
+
+    expect(result).toEqual(payload);
+  });
+});
+
+describe('workflowsStepRestartEnqueuedSchema', () => {
+  it('rejects empty restart feedback', () => {
+    const input = {...validStepRestartEnqueued, feedback: ''};
+
+    const parse = () => workflowsStepRestartEnqueuedSchema.parse(input);
+
+    expect(parse).toThrow();
+  });
+});
+
+describe.each([
+  [
+    'workflowsWorkflowRunAttemptCreatedSchema',
+    workflowsWorkflowRunAttemptCreatedSchema,
+    validRunCreated,
+    'workflowRunAttemptId',
+  ],
+  [
+    'workflowsWorkflowRunCancelledSchema',
+    workflowsWorkflowRunCancelledSchema,
+    validRunCancelled,
+    'projectId',
+  ],
+  [
+    'workflowsJobExecutionTimedOutSchema',
+    workflowsJobExecutionTimedOutSchema,
+    validJobExecutionTimedOut,
+    'jobId',
+  ],
+  ['workflowsJobActivatedSchema', workflowsJobActivatedSchema, validJobActivated, 'mode'],
+  [
+    'workflowsJobEventDeliveredSchema',
+    workflowsJobEventDeliveredSchema,
+    validJobEventDelivered,
+    'eventRef',
+  ],
+  [
+    'workflowsJobStepsSettledSchema',
+    workflowsJobStepsSettledSchema,
+    validJobStepsSettled,
+    'status',
+  ],
+  [
+    'workflowsStepRestartEnqueuedSchema',
+    workflowsStepRestartEnqueuedSchema,
+    validStepRestartEnqueued,
+    'failedStepAttempt',
+  ],
+  [
+    'workflowsStepAttemptTerminatedSchema',
+    workflowsStepAttemptTerminatedSchema,
+    validStepAttemptTerminated,
+    'logOutcome',
+  ],
+] as const)('%s', (_name, schema, validPayload, requiredKey) => {
+  it('parses a valid payload unchanged', () => {
+    const result = schema.parse(validPayload);
+
+    expect(result).toEqual(validPayload);
+  });
+
+  it('rejects a payload missing a required field', () => {
+    const withoutRequiredKey = Object.fromEntries(
+      Object.entries(validPayload).filter(([key]) => key !== requiredKey),
+    );
+
+    const parse = () => schema.parse(withoutRequiredKey);
+
+    expect(parse).toThrow();
+  });
+});
+
+describe('workflowsEventSchemas', () => {
+  it('registers every workflows publisher event type', () => {
+    const registeredTypes = Object.keys(workflowsEventSchemas).sort();
+
+    expect(registeredTypes).toEqual(
+      [
+        WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED,
+        WORKFLOWS_WORKFLOW_RUN_TERMINATED,
+        WORKFLOWS_WORKFLOW_RUN_CANCELLED,
+        WORKFLOWS_JOB_EXECUTION_TIMED_OUT,
+        WORKFLOWS_JOB_ACTIVATED,
+        WORKFLOWS_JOB_EVENT_DELIVERED,
+        WORKFLOWS_JOB_TERMINATED,
+        WORKFLOWS_JOB_STEPS_SETTLED,
+        WORKFLOWS_STEP_RESTART_ENQUEUED,
+        WORKFLOWS_STEP_ATTEMPT_TERMINATED,
+      ].sort(),
+    );
+  });
+
+  it('does not register retired listener pseudo-entity events', () => {
+    const registeredTypes = Object.keys(workflowsEventSchemas);
+
+    expect(registeredTypes).toEqual(
+      expect.not.arrayContaining([
+        'workflows.listener.started',
+        'workflows.listener.resolved',
+        'workflows.listener.cancelled',
+      ]),
+    );
+  });
+});

package/src/events.ts

@@ -0,0 +1,180 @@
+import {z} from 'zod';
+import {jobStatusReasonSchema} from './schemas/job.js';
+import {listeningTriggerSchema} from './schemas/job-listening.js';
+import {logOutcomeSchema} from './schemas/log-outcome.js';
+
+const nonEmptyStringSchema = z.string().nonempty();
+
+export const WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED =
+  'workflows.workflow_run_attempt.created' as const;
+// Terminal fact for a workflow run, written in the same transaction as the status flip.
+export const WORKFLOWS_WORKFLOW_RUN_TERMINATED = 'workflows.workflow_run.terminated' as const;
+// Intent fact for cooperative run cancellation. Consumers use this to stop orchestration.
+export const WORKFLOWS_WORKFLOW_RUN_CANCELLED = 'workflows.workflow_run.cancelled' as const;
+export const WORKFLOWS_JOB_EXECUTION_TIMED_OUT = 'workflows.job_execution.timed_out' as const;
+export const WORKFLOWS_JOB_ACTIVATED = 'workflows.job.activated' as const;
+export const WORKFLOWS_JOB_EVENT_DELIVERED = 'workflows.job_event.delivered' as const;
+// Terminal fact for a job: the single reliable "this job is over" signal, written in
+// the same transaction as the status flip, on every terminal path.
+export const WORKFLOWS_JOB_TERMINATED = 'workflows.job.terminated' as const;
+// Internal signal, not a terminal fact: a job's steps have all settled, so the
+// on-job-steps-settled subscriber can raise the Temporal JOB_FINISHED_SIGNAL. Fires
+// before the job row is terminal; observe WORKFLOWS_JOB_TERMINATED for the outcome.
+export const WORKFLOWS_JOB_STEPS_SETTLED = 'workflows.job.steps_settled' as const;
+// Written in the same transaction as a durable gate restart: the failed attempt
+// plus the rewind of the projection from `restart_from`. The pull-based runner
+// re-dispatches the rewound step on its next pull, so consumers must treat this
+// at-least-once outbox event as idempotent audit data.
+export const WORKFLOWS_STEP_RESTART_ENQUEUED = 'workflows.step.restart_enqueued' as const;
+export const WORKFLOWS_STEP_ATTEMPT_TERMINATED = 'workflows.step_attempt.terminated' as const;
+
+export const workflowsWorkflowRunAttemptCreatedSchema = z.object({
+  workflowRunId: nonEmptyStringSchema,
+  workflowRunAttemptId: nonEmptyStringSchema,
+  attempt: z.number().int().positive(),
+  workspaceId: nonEmptyStringSchema,
+  projectId: nonEmptyStringSchema,
+  definitionId: nonEmptyStringSchema,
+});
+export type WorkflowsWorkflowRunAttemptCreatedEventDto = z.infer<
+  typeof workflowsWorkflowRunAttemptCreatedSchema
+>;
+
+// Keep outbox terminal statuses narrower than the public status schemas, which
+// also carry pending/running and job-only skipped.
+export const workflowRunTerminalStatusSchema = z.enum(['succeeded', 'failed', 'cancelled']);
+export const jobTerminalStatusSchema = z.enum(['succeeded', 'failed', 'cancelled', 'skipped']);
+export const terminalStatusSchema = workflowRunTerminalStatusSchema;
+
+export const workflowsWorkflowRunTerminatedSchema = z.object({
+  workflowRunId: nonEmptyStringSchema,
+  workflowRunAttemptId: nonEmptyStringSchema,
+  projectId: nonEmptyStringSchema,
+  status: workflowRunTerminalStatusSchema,
+});
+export type WorkflowsWorkflowRunTerminatedEventDto = z.infer<
+  typeof workflowsWorkflowRunTerminatedSchema
+>;
+
+export const workflowsWorkflowRunCancelledSchema = z.object({
+  workflowRunId: nonEmptyStringSchema,
+  workflowRunAttemptId: nonEmptyStringSchema,
+  projectId: nonEmptyStringSchema,
+});
+export type WorkflowsWorkflowRunCancelledEventDto = z.infer<
+  typeof workflowsWorkflowRunCancelledSchema
+>;
+
+export const workflowsJobExecutionTimedOutSchema = z.object({
+  jobId: nonEmptyStringSchema,
+  jobExecutionId: nonEmptyStringSchema,
+  workflowRunAttemptId: nonEmptyStringSchema,
+});
+export type WorkflowsJobExecutionTimedOutEventDto = z.infer<
+  typeof workflowsJobExecutionTimedOutSchema
+>;
+
+const workflowsJobActivatedBaseSchema = z.object({
+  jobId: nonEmptyStringSchema,
+  workflowRunId: nonEmptyStringSchema,
+  workspaceId: nonEmptyStringSchema,
+});
+
+const resolvedListeningTriggerSchema = listeningTriggerSchema.extend({
+  filter_snapshot: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const workflowsJobActivatedSchema = z.discriminatedUnion('mode', [
+  workflowsJobActivatedBaseSchema.extend({
+    mode: z.literal('one_shot'),
+    on: z.array(resolvedListeningTriggerSchema).nullable().optional(),
+    until: z.array(resolvedListeningTriggerSchema).nullable().optional(),
+  }),
+  workflowsJobActivatedBaseSchema.extend({
+    mode: z.literal('listening'),
+    on: z.array(resolvedListeningTriggerSchema).nonempty(),
+    until: z.array(resolvedListeningTriggerSchema).nullable(),
+  }),
+]);
+export type WorkflowsJobActivatedEventDto = z.infer<typeof workflowsJobActivatedSchema>;
+
+export const workflowsJobEventDeliveredSchema = z.object({
+  jobId: nonEmptyStringSchema,
+  disposition: z.enum(['fire', 'resolve']),
+  eventRef: nonEmptyStringSchema,
+  eventName: nonEmptyStringSchema,
+});
+export type WorkflowsJobEventDeliveredEventDto = z.infer<typeof workflowsJobEventDeliveredSchema>;
+
+export const workflowsJobTerminatedSchema = z.object({
+  jobId: nonEmptyStringSchema,
+  workflowRunId: nonEmptyStringSchema,
+  workflowRunAttemptId: nonEmptyStringSchema,
+  status: jobTerminalStatusSchema,
+  statusReason: jobStatusReasonSchema.nullable(),
+});
+export type WorkflowsJobTerminatedEventDto = z.infer<typeof workflowsJobTerminatedSchema>;
+
+const settledStatusSchema = z.enum(['succeeded', 'failed']);
+
+export const workflowsJobStepsSettledSchema = z.object({
+  jobId: nonEmptyStringSchema,
+  jobExecutionId: nonEmptyStringSchema,
+  workflowRunId: nonEmptyStringSchema,
+  workflowRunAttemptId: nonEmptyStringSchema,
+  status: settledStatusSchema,
+});
+export type WorkflowsJobStepsSettledEventDto = z.infer<typeof workflowsJobStepsSettledSchema>;
+
+export const workflowsStepRestartEnqueuedSchema = z.object({
+  jobId: nonEmptyStringSchema,
+  workflowRunId: nonEmptyStringSchema,
+  workflowRunAttemptId: nonEmptyStringSchema,
+  failedStepId: nonEmptyStringSchema,
+  failedStepAttempt: z.number(),
+  restartFromStepId: nonEmptyStringSchema,
+  feedback: nonEmptyStringSchema,
+});
+export type WorkflowsStepRestartEnqueuedEventDto = z.infer<
+  typeof workflowsStepRestartEnqueuedSchema
+>;
+
+export const workflowsStepAttemptTerminatedSchema = z.object({
+  jobId: nonEmptyStringSchema,
+  workflowRunId: nonEmptyStringSchema,
+  workflowRunAttemptId: nonEmptyStringSchema,
+  workspaceId: nonEmptyStringSchema,
+  projectId: nonEmptyStringSchema,
+  stepId: nonEmptyStringSchema,
+  attempt: z.number().int().positive(),
+  logOutcome: logOutcomeSchema,
+});
+export type WorkflowsStepAttemptTerminatedEventDto = z.infer<
+  typeof workflowsStepAttemptTerminatedSchema
+>;
+
+export interface WorkflowsEventMapDto {
+  [WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED]: WorkflowsWorkflowRunAttemptCreatedEventDto;
+  [WORKFLOWS_WORKFLOW_RUN_TERMINATED]: WorkflowsWorkflowRunTerminatedEventDto;
+  [WORKFLOWS_WORKFLOW_RUN_CANCELLED]: WorkflowsWorkflowRunCancelledEventDto;
+  [WORKFLOWS_JOB_EXECUTION_TIMED_OUT]: WorkflowsJobExecutionTimedOutEventDto;
+  [WORKFLOWS_JOB_ACTIVATED]: WorkflowsJobActivatedEventDto;
+  [WORKFLOWS_JOB_EVENT_DELIVERED]: WorkflowsJobEventDeliveredEventDto;
+  [WORKFLOWS_JOB_TERMINATED]: WorkflowsJobTerminatedEventDto;
+  [WORKFLOWS_JOB_STEPS_SETTLED]: WorkflowsJobStepsSettledEventDto;
+  [WORKFLOWS_STEP_RESTART_ENQUEUED]: WorkflowsStepRestartEnqueuedEventDto;
+  [WORKFLOWS_STEP_ATTEMPT_TERMINATED]: WorkflowsStepAttemptTerminatedEventDto;
+}
+
+export const workflowsEventSchemas = {
+  [WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED]: workflowsWorkflowRunAttemptCreatedSchema,
+  [WORKFLOWS_WORKFLOW_RUN_TERMINATED]: workflowsWorkflowRunTerminatedSchema,
+  [WORKFLOWS_WORKFLOW_RUN_CANCELLED]: workflowsWorkflowRunCancelledSchema,
+  [WORKFLOWS_JOB_EXECUTION_TIMED_OUT]: workflowsJobExecutionTimedOutSchema,
+  [WORKFLOWS_JOB_ACTIVATED]: workflowsJobActivatedSchema,
+  [WORKFLOWS_JOB_EVENT_DELIVERED]: workflowsJobEventDeliveredSchema,
+  [WORKFLOWS_JOB_TERMINATED]: workflowsJobTerminatedSchema,
+  [WORKFLOWS_JOB_STEPS_SETTLED]: workflowsJobStepsSettledSchema,
+  [WORKFLOWS_STEP_RESTART_ENQUEUED]: workflowsStepRestartEnqueuedSchema,
+  [WORKFLOWS_STEP_ATTEMPT_TERMINATED]: workflowsStepAttemptTerminatedSchema,
+} satisfies Record<keyof WorkflowsEventMapDto, z.ZodType>;