@mettlecast/domain-cdk-packer 0.2.0

package/dist/constructs/dashboard-construct.d.ts

@@ -0,0 +1,15 @@
+import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
+import { Construct } from 'constructs';
+export interface DashboardConstructProps {
+    domainId: string;
+    envCode: string;
+    /** List of endpointIds per primitiveClass for dashboard panels. */
+    endpoints: Array<{
+        id: string;
+        primitiveClass: string;
+    }>;
+}
+export declare class DashboardConstruct extends Construct {
+    readonly dashboard: cloudwatch.Dashboard;
+    constructor(scope: Construct, id: string, props: DashboardConstructProps);
+}

package/dist/constructs/dashboard-construct.js

@@ -0,0 +1,62 @@
+import * as cdk from 'aws-cdk-lib';
+import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
+import { Construct } from 'constructs';
+export class DashboardConstruct extends Construct {
+    dashboard;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { domainId, envCode, endpoints } = props;
+        const namespace = `TIB/Domain/${domainId}`;
+        const widgets = [];
+        // Group endpoints by primitiveClass for rows
+        const byClass = endpoints.reduce((acc, ep) => {
+            (acc[ep.primitiveClass] ??= []).push(ep.id);
+            return acc;
+        }, {});
+        for (const [primitiveClass, endpointIds] of Object.entries(byClass)) {
+            // Row title
+            widgets.push(new cloudwatch.TextWidget({
+                markdown: `## ${primitiveClass.toUpperCase()} — ${domainId}`,
+                width: 24,
+                height: 1,
+            }));
+            for (const endpointId of endpointIds) {
+                const dims = { domainId, endpointId, primitiveClass };
+                widgets.push(new cloudwatch.GraphWidget({
+                    title: `${endpointId} — latency`,
+                    width: 6,
+                    height: 6,
+                    left: [
+                        new cloudwatch.Metric({ namespace, metricName: 'latency_ms', dimensionsMap: dims, statistic: 'p50', label: 'p50' }),
+                        new cloudwatch.Metric({ namespace, metricName: 'latency_ms', dimensionsMap: dims, statistic: 'p95', label: 'p95' }),
+                        new cloudwatch.Metric({ namespace, metricName: 'latency_ms', dimensionsMap: dims, statistic: 'p99', label: 'p99' }),
+                    ],
+                }), new cloudwatch.GraphWidget({
+                    title: `${endpointId} — errors & cold starts`,
+                    width: 6,
+                    height: 6,
+                    left: [
+                        new cloudwatch.Metric({ namespace, metricName: 'errors', dimensionsMap: dims, statistic: 'Sum', label: 'errors' }),
+                        new cloudwatch.Metric({ namespace, metricName: 'cold_starts', dimensionsMap: dims, statistic: 'Sum', label: 'cold_starts' }),
+                    ],
+                }), new cloudwatch.GraphWidget({
+                    title: `${endpointId} — DB & events`,
+                    width: 6,
+                    height: 6,
+                    left: [
+                        new cloudwatch.Metric({ namespace, metricName: 'db_query_ms', dimensionsMap: dims, statistic: 'Average', label: 'db_ms_avg' }),
+                        new cloudwatch.Metric({ namespace, metricName: 'event_publish_count', dimensionsMap: dims, statistic: 'Sum', label: 'events' }),
+                    ],
+                }));
+            }
+        }
+        this.dashboard = new cloudwatch.Dashboard(this, 'Dashboard', {
+            dashboardName: `TIB-${envCode}-domain-${domainId}`,
+            widgets: [widgets],
+        });
+        new cdk.CfnOutput(scope, 'DashboardArn', {
+            value: this.dashboard.dashboardArn,
+            exportName: `TIB-${envCode}-domain-${domainId}-DashboardArn`,
+        });
+    }
+}

package/dist/constructs/health-construct.d.ts

@@ -0,0 +1,11 @@
+import * as nodejs from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+export interface HealthConstructProps {
+    domainId: string;
+    environment: Record<string, string>;
+}
+export declare class HealthConstruct extends Construct {
+    readonly healthFn: nodejs.NodejsFunction;
+    readonly readyFn: nodejs.NodejsFunction;
+    constructor(scope: Construct, id: string, props: HealthConstructProps);
+}

package/dist/constructs/health-construct.js

@@ -0,0 +1,29 @@
+import * as cdk from 'aws-cdk-lib';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as nodejs from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+export class HealthConstruct extends Construct {
+    healthFn;
+    readyFn;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const commonProps = {
+            runtime: lambda.Runtime.NODEJS_20_X,
+            environment: props.environment,
+            timeout: cdk.Duration.seconds(10),
+            memorySize: 128,
+        };
+        this.healthFn = new nodejs.NodejsFunction(this, 'HealthFn', {
+            ...commonProps,
+            entry: require.resolve('@mettlecast/domain-runtime/runtime/health-handler'),
+            handler: 'healthHandler',
+            description: `${props.domainId} /_health — Lambda warm check`,
+        });
+        this.readyFn = new nodejs.NodejsFunction(this, 'ReadyFn', {
+            ...commonProps,
+            entry: require.resolve('@mettlecast/domain-runtime/runtime/health-handler'),
+            handler: 'readinessHandler',
+            description: `${props.domainId} /_ready — dependency reachability check`,
+        });
+    }
+}

package/dist/constructs/job-construct.d.ts

@@ -0,0 +1,33 @@
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+import { Construct } from 'constructs';
+import { LambdaFactory } from '../lambda-factory.js';
+import { IamPolicyBuilder } from '../iam/iam-policy-builder.js';
+import type { DomainRegistry } from '../registry.js';
+/**
+ * Configuration properties for JobConstruct.
+ */
+export interface JobConstructProps {
+    /** Domain registry containing job definitions. */
+    registry: DomainRegistry;
+    /** Factory for creating Lambda functions. */
+    lambdaFactory: LambdaFactory;
+    /** Builder for generating IAM policies. */
+    iamBuilder: IamPolicyBuilder;
+}
+/**
+ * CDK Construct that synthesizes Lambda functions with SQS queues, dead-letter queues,
+ * and event source mappings for background jobs defined in the domain registry.
+ */
+export declare class JobConstruct extends Construct {
+    /**
+     * Map of job IDs to their corresponding SQS queues.
+     */
+    readonly queues: Map<string, sqs.Queue>;
+    /**
+     * Create a new JobConstruct.
+     * @param scope - Parent CDK scope
+     * @param id - Construct identifier
+     * @param props - Configuration properties
+     */
+    constructor(scope: Construct, id: string, props: JobConstructProps);
+}

package/dist/constructs/job-construct.js

@@ -0,0 +1,54 @@
+import * as cdk from 'aws-cdk-lib';
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+import * as lambdaEventSources from 'aws-cdk-lib/aws-lambda-event-sources';
+import { Construct } from 'constructs';
+/**
+ * CDK Construct that synthesizes Lambda functions with SQS queues, dead-letter queues,
+ * and event source mappings for background jobs defined in the domain registry.
+ */
+export class JobConstruct extends Construct {
+    /**
+     * Map of job IDs to their corresponding SQS queues.
+     */
+    queues;
+    /**
+     * Create a new JobConstruct.
+     * @param scope - Parent CDK scope
+     * @param id - Construct identifier
+     * @param props - Configuration properties
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.queues = new Map();
+        for (const entry of props.registry.jobs) {
+            const pascalId = toPascalCase(entry.id);
+            const dlq = new sqs.Queue(this, `${pascalId}Dlq`, {
+                retentionPeriod: cdk.Duration.days(14),
+            });
+            const queue = new sqs.Queue(this, `${pascalId}Queue`, {
+                visibilityTimeout: cdk.Duration.seconds(entry.visibilityTimeoutSeconds),
+                deadLetterQueue: {
+                    queue: dlq,
+                    maxReceiveCount: entry.maxRetries,
+                },
+            });
+            this.queues.set(entry.id, queue);
+            const fn = props.lambdaFactory.createFunction(entry, entry.deployment);
+            props.iamBuilder
+                .forJob({ queueArn: queue.queueArn, dlqArn: dlq.queueArn })
+                .forEach((s) => fn.addToRolePolicy(s));
+            fn.addEventSource(new lambdaEventSources.SqsEventSource(queue, { batchSize: 1 }));
+        }
+    }
+}
+/**
+ * Convert a kebab-case or snake_case string to PascalCase.
+ * @param s - Input string to convert
+ * @returns PascalCase string
+ */
+function toPascalCase(s) {
+    return s
+        .split(/[-_]/)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+}

package/dist/constructs/schedule-construct.d.ts

@@ -0,0 +1,27 @@
+import { Construct } from 'constructs';
+import { LambdaFactory } from '../lambda-factory.js';
+import { IamPolicyBuilder } from '../iam/iam-policy-builder.js';
+import type { DomainRegistry } from '../registry.js';
+/**
+ * Configuration properties for ScheduleConstruct.
+ */
+export interface ScheduleConstructProps {
+    /** Domain registry containing schedule definitions */
+    registry: DomainRegistry;
+    /** Lambda factory for creating schedule handler functions */
+    lambdaFactory: LambdaFactory;
+    /** IAM policy builder for schedule handler permissions */
+    iamBuilder: IamPolicyBuilder;
+}
+/**
+ * CDK Construct that synthesises Lambda functions and EventBridge Scheduler rules per schedule entry.
+ */
+export declare class ScheduleConstruct extends Construct {
+    /**
+     * Create a new ScheduleConstruct.
+     * @param scope - Parent CDK Construct scope
+     * @param id - Logical ID for this construct
+     * @param props - Configuration properties
+     */
+    constructor(scope: Construct, id: string, props: ScheduleConstructProps);
+}

package/dist/constructs/schedule-construct.js

@@ -0,0 +1,54 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as scheduler from 'aws-cdk-lib/aws-scheduler';
+import { Construct } from 'constructs';
+/**
+ * CDK Construct that synthesises Lambda functions and EventBridge Scheduler rules per schedule entry.
+ */
+export class ScheduleConstruct extends Construct {
+    /**
+     * Create a new ScheduleConstruct.
+     * @param scope - Parent CDK Construct scope
+     * @param id - Logical ID for this construct
+     * @param props - Configuration properties
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        for (const entry of props.registry.schedules) {
+            const pascalId = toPascalCase(entry.id);
+            // Create the Lambda function for this schedule
+            const fn = props.lambdaFactory.createFunction(entry, entry.deployment);
+            // Attach schedule-specific IAM policies
+            props.iamBuilder.forSchedule().forEach((statement) => {
+                fn.addToRolePolicy(statement);
+            });
+            // Create a dedicated IAM role for the EventBridge Scheduler to assume
+            const schedulerRole = new iam.Role(this, `${pascalId}SchedulerRole`, {
+                assumedBy: new iam.ServicePrincipal('scheduler.amazonaws.com'),
+            });
+            // Grant the scheduler role permission to invoke the Lambda
+            fn.grantInvoke(schedulerRole);
+            // Create the EventBridge Scheduler rule
+            new scheduler.CfnSchedule(this, `${pascalId}Schedule`, {
+                scheduleExpression: entry.cron,
+                flexibleTimeWindow: { mode: 'OFF' },
+                state: entry.enabled ? 'ENABLED' : 'DISABLED',
+                target: {
+                    arn: fn.functionArn,
+                    roleArn: schedulerRole.roleArn,
+                    input: JSON.stringify({}),
+                },
+            });
+        }
+    }
+}
+/**
+ * Convert a kebab-case or snake_case string to PascalCase.
+ * @param s - Input string
+ * @returns PascalCase string
+ */
+function toPascalCase(s) {
+    return s
+        .split(/[-_]/)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+}

package/dist/constructs/subscriber-construct.d.ts

@@ -0,0 +1,30 @@
+import * as events from 'aws-cdk-lib/aws-events';
+import { Construct } from 'constructs';
+import { LambdaFactory } from '../lambda-factory.js';
+import { IamPolicyBuilder } from '../iam/iam-policy-builder.js';
+import type { DomainRegistry } from '../registry.js';
+/**
+ * Configuration properties for SubscriberConstruct.
+ */
+export interface SubscriberConstructProps {
+    /** Domain registry containing all subscriber entries. */
+    registry: DomainRegistry;
+    /** Factory for creating Lambda functions from registry entries. */
+    lambdaFactory: LambdaFactory;
+    /** IAM policy builder for granting permissions to Lambda roles. */
+    iamBuilder: IamPolicyBuilder;
+    /** EventBridge event bus for routing subscriber events. */
+    eventBus: events.IEventBus;
+}
+/**
+ * CDK Construct that synthesises Lambda + SQS + EventBridge rule per registered subscriber.
+ */
+export declare class SubscriberConstruct extends Construct {
+    /**
+     * Create a new SubscriberConstruct instance.
+     * @param scope - Parent CDK scope.
+     * @param id - Construct identifier.
+     * @param props - Construct properties.
+     */
+    constructor(scope: Construct, id: string, props: SubscriberConstructProps);
+}

package/dist/constructs/subscriber-construct.js

@@ -0,0 +1,63 @@
+import * as cdk from 'aws-cdk-lib';
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as eventsTargets from 'aws-cdk-lib/aws-events-targets';
+import * as lambdaEventSources from 'aws-cdk-lib/aws-lambda-event-sources';
+import { Construct } from 'constructs';
+/**
+ * CDK Construct that synthesises Lambda + SQS + EventBridge rule per registered subscriber.
+ */
+export class SubscriberConstruct extends Construct {
+    /**
+     * Create a new SubscriberConstruct instance.
+     * @param scope - Parent CDK scope.
+     * @param id - Construct identifier.
+     * @param props - Construct properties.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        for (const entry of props.registry.subscribers) {
+            const pascalId = toPascalCase(entry.id);
+            // Create dead-letter queue
+            const dlq = new sqs.Queue(this, `${pascalId}Dlq`, {
+                retentionPeriod: cdk.Duration.days(14),
+            });
+            // Create main queue with dead-letter queue configuration
+            const queue = new sqs.Queue(this, `${pascalId}Queue`, {
+                visibilityTimeout: cdk.Duration.seconds(180),
+                deadLetterQueue: {
+                    queue: dlq,
+                    maxReceiveCount: 3,
+                },
+            });
+            // Create Lambda function from registry entry
+            const fn = props.lambdaFactory.createFunction(entry, entry.deployment);
+            // Add IAM policies for SQS access
+            props.iamBuilder.forSubscriber({ queueArn: queue.queueArn, dlqArn: dlq.queueArn }).forEach((statement) => {
+                fn.addToRolePolicy(statement);
+            });
+            // Add SQS as event source for Lambda
+            fn.addEventSource(new lambdaEventSources.SqsEventSource(queue, {
+                batchSize: 10,
+                maxConcurrency: entry.concurrency ?? 5,
+            }));
+            // Create EventBridge rule targeting SQS queue
+            new events.Rule(this, `${pascalId}Rule`, {
+                eventBus: props.eventBus,
+                eventPattern: { detailType: [entry.event] },
+                targets: [new eventsTargets.SqsQueue(queue)],
+            });
+        }
+    }
+}
+/**
+ * Convert kebab-case or snake_case string to PascalCase.
+ * @param s - Input string.
+ * @returns PascalCase string.
+ */
+function toPascalCase(s) {
+    return s
+        .split(/[-_]/)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+}

package/dist/constructs/waf-construct.d.ts

@@ -0,0 +1,13 @@
+import * as wafv2 from 'aws-cdk-lib/aws-wafv2';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import { Construct } from 'constructs';
+export interface WafConstructProps {
+    domainId: string;
+    httpApi: apigwv2.HttpApi;
+    /** Requests per 5-minute window per IP before blocking. Default: 2000. */
+    rateLimit?: number;
+}
+export declare class WafConstruct extends Construct {
+    readonly webAcl: wafv2.CfnWebACL;
+    constructor(scope: Construct, id: string, props: WafConstructProps);
+}

package/dist/constructs/waf-construct.js

@@ -0,0 +1,75 @@
+import * as cdk from 'aws-cdk-lib';
+import * as wafv2 from 'aws-cdk-lib/aws-wafv2';
+import { Construct } from 'constructs';
+export class WafConstruct extends Construct {
+    webAcl;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const rateLimit = props.rateLimit ?? 2000;
+        this.webAcl = new wafv2.CfnWebACL(this, 'WebAcl', {
+            name: `tib-${props.domainId}-waf`,
+            scope: 'REGIONAL',
+            defaultAction: { allow: {} },
+            visibilityConfig: {
+                sampledRequestsEnabled: true,
+                cloudWatchMetricsEnabled: true,
+                metricName: `tib-${props.domainId}-waf`,
+            },
+            rules: [
+                {
+                    name: 'AWSManagedRulesCommonRuleSet',
+                    priority: 1,
+                    overrideAction: { none: {} },
+                    statement: {
+                        managedRuleGroupStatement: {
+                            vendorName: 'AWS',
+                            name: 'AWSManagedRulesCommonRuleSet',
+                        },
+                    },
+                    visibilityConfig: {
+                        sampledRequestsEnabled: true,
+                        cloudWatchMetricsEnabled: true,
+                        metricName: `tib-${props.domainId}-common-rules`,
+                    },
+                },
+                {
+                    name: 'AWSManagedRulesKnownBadInputsRuleSet',
+                    priority: 2,
+                    overrideAction: { none: {} },
+                    statement: {
+                        managedRuleGroupStatement: {
+                            vendorName: 'AWS',
+                            name: 'AWSManagedRulesKnownBadInputsRuleSet',
+                        },
+                    },
+                    visibilityConfig: {
+                        sampledRequestsEnabled: true,
+                        cloudWatchMetricsEnabled: true,
+                        metricName: `tib-${props.domainId}-bad-inputs`,
+                    },
+                },
+                {
+                    name: 'IpRateLimit',
+                    priority: 3,
+                    action: { block: {} },
+                    statement: {
+                        rateBasedStatement: {
+                            limit: rateLimit,
+                            aggregateKeyType: 'IP',
+                        },
+                    },
+                    visibilityConfig: {
+                        sampledRequestsEnabled: true,
+                        cloudWatchMetricsEnabled: true,
+                        metricName: `tib-${props.domainId}-rate-limit`,
+                    },
+                },
+            ],
+        });
+        // Associate WAF with the API Gateway stage
+        new wafv2.CfnWebACLAssociation(this, 'WebAclAssociation', {
+            resourceArn: `arn:aws:apigateway:${cdk.Stack.of(this).region}::/restapis/${props.httpApi.httpApiId}/stages/$default`,
+            webAclArn: this.webAcl.attrArn,
+        });
+    }
+}

package/dist/constructs/webhook-construct.d.ts

@@ -0,0 +1,33 @@
+import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import { Construct } from 'constructs';
+import { LambdaFactory } from '../lambda-factory.js';
+import { IamPolicyBuilder } from '../iam/iam-policy-builder.js';
+import type { DomainRegistry } from '../registry.js';
+/**
+ * Configuration properties for WebhookConstruct.
+ */
+export interface WebhookConstructProps {
+    /** Domain registry containing all webhook entries. */
+    registry: DomainRegistry;
+    /** Shared HttpApi to route requests to Lambdas. */
+    httpApi: apigwv2.HttpApi;
+    /** Factory for creating Lambda functions from registry entries. */
+    lambdaFactory: LambdaFactory;
+    /** IAM policy builder for granting permissions to Lambda roles. */
+    iamBuilder: IamPolicyBuilder;
+}
+/**
+ * CDK Construct that synthesises one Lambda per registered webhook, one shared DynamoDB dedupe table, and adds webhook routes to the HttpApi.
+ */
+export declare class WebhookConstruct extends Construct {
+    /** Shared webhook deduplication table. */
+    readonly dedupeTable: dynamodb.Table;
+    /**
+     * Create a new WebhookConstruct instance.
+     * @param scope - Parent CDK scope.
+     * @param id - Construct identifier.
+     * @param props - Construct properties.
+     */
+    constructor(scope: Construct, id: string, props: WebhookConstructProps);
+}

package/dist/constructs/webhook-construct.js

@@ -0,0 +1,50 @@
+import * as cdk from 'aws-cdk-lib';
+import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigwv2integrations from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import { Construct } from 'constructs';
+/**
+ * CDK Construct that synthesises one Lambda per registered webhook, one shared DynamoDB dedupe table, and adds webhook routes to the HttpApi.
+ */
+export class WebhookConstruct extends Construct {
+    /** Shared webhook deduplication table. */
+    dedupeTable;
+    /**
+     * Create a new WebhookConstruct instance.
+     * @param scope - Parent CDK scope.
+     * @param id - Construct identifier.
+     * @param props - Construct properties.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.dedupeTable = new dynamodb.Table(this, 'DedupeTable', {
+            partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },
+            billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+            timeToLiveAttribute: 'expiresAt',
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        for (const entry of props.registry.webhooks) {
+            const fn = props.lambdaFactory.createFunction(entry, entry.deployment);
+            props.iamBuilder.forWebhook({ dedupeTableArn: this.dedupeTable.tableArn }).forEach((statement) => {
+                fn.addToRolePolicy(statement);
+            });
+            this.dedupeTable.grantReadWriteData(fn);
+            props.httpApi.addRoutes({
+                path: entry.path,
+                methods: [apigwv2.HttpMethod.POST],
+                integration: new apigwv2integrations.HttpLambdaIntegration(`${id}${toPascalCase(entry.id)}Integration`, fn),
+            });
+        }
+    }
+}
+/**
+ * Convert kebab-case or snake_case string to PascalCase.
+ * @param s - Input string.
+ * @returns PascalCase string.
+ */
+function toPascalCase(s) {
+    return s
+        .split(/[-_]/)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+}

package/dist/flow-registry.d.ts

@@ -0,0 +1,81 @@
+/** Plain JSON-serialisable mirror of FlowStep types from domain-runtime. */
+export interface SerialDomainActionStep {
+    type: 'domain-action';
+    name: string;
+    domainId: string;
+    actionId: string;
+    parameters?: Record<string, unknown>;
+    waitForTaskToken?: boolean;
+    next?: string;
+}
+export interface SerialDomainApiStep {
+    type: 'domain-api';
+    name: string;
+    domainId: string;
+    apiId: string;
+    parameters?: Record<string, unknown>;
+    next?: string;
+}
+export interface SerialDomainEventStep {
+    type: 'domain-event';
+    name: string;
+    eventId: string;
+    payload: Record<string, unknown>;
+    version: number;
+    next?: string;
+}
+export type SerialFlowControlStep = {
+    type: 'flow-control';
+    control: 'choice';
+    name: string;
+    choices: Array<{
+        when: string;
+        next: string;
+    }>;
+    default?: string;
+} | {
+    type: 'flow-control';
+    control: 'parallel';
+    name: string;
+    branches: SerialFlowStep[][];
+    next?: string;
+} | {
+    type: 'flow-control';
+    control: 'wait';
+    name: string;
+    seconds: number;
+    next?: string;
+} | {
+    type: 'flow-control';
+    control: 'succeed';
+    name: string;
+} | {
+    type: 'flow-control';
+    control: 'fail';
+    name: string;
+    cause?: string;
+    error?: string;
+} | {
+    type: 'flow-control';
+    control: 'pass';
+    name: string;
+    result?: unknown;
+    next?: string;
+};
+export type SerialFlowStep = SerialDomainActionStep | SerialDomainApiStep | SerialDomainEventStep | SerialFlowControlStep;
+export interface FlowRegistryEntry {
+    id: string;
+    owningDomain?: string;
+    type?: 'express' | 'standard';
+    name: string;
+    steps: SerialFlowStep[];
+    trigger?: {
+        type: 'event';
+        eventId: string;
+        semverRange: string;
+    };
+}
+export interface FlowRegistry {
+    schemaVersion: '1';
+    flows: FlowRegistryEntry[];
+}

package/dist/flow-registry.js

@@ -0,0 +1,2 @@
+/** Plain JSON-serialisable mirror of FlowStep types from domain-runtime. */
+export {};