better-ship 0.15.0 → 0.16.0

package/dist/postgres.d.ts

@@ -1,6 +1,6 @@
-import { G as DomainEvent, J as MessageId, nt as DatabaseError, rt as DatabaseFailure } from "./index-G1QG0P5g.js";
-import { A as IOutboxRepository, M as OutboxClaim, N as OutboxMessage, P as IMessageStore, k as DeadLetterReason, w as ITransaction } from "./index-B45Dr5gs.js";
-import { n as eventCollector, r as DrizzleSchema, t as OutboxRepositoryOptions } from "./outbox-repository-options-CwTTuy7B.js";
+import { X as MessageId, at as DatabaseFailure, it as DatabaseError, q as DomainEvent } from "./index-DvJUcSW1.js";
+import { A as IOutboxRepository, M as OutboxClaim, N as OutboxMessage, P as IMessageStore, k as DeadLetterReason, w as ITransaction } from "./index-Cchdg2aQ.js";
+import { n as eventCollector, r as DrizzleSchema, t as OutboxRepositoryOptions } from "./outbox-repository-options-AkihEaik.js";
 import { ExtractTablesWithRelations } from "drizzle-orm";
 import { PostgresJsDatabase, PostgresJsTransaction, drizzle } from "drizzle-orm/postgres-js";
 //#region src/infrastructure/postgres/postgres-database-types.d.ts

package/dist/postgres.js

@@ -1,6 +1,6 @@
-import { D as DatabaseError, c as exponentialDelayCapMs, tt as AppError } from "./core-hdaNiCOU.js";
-import { o as MessageAlreadyProcessedError } from "./application-C4JOf71r.js";
-import { i as runWithUnitOfWorkContext, r as eventCollector, t as OUTBOX_REPOSITORY_DEFAULTS } from "./outbox-repository-options-DOTpJH-e.js";
+import { c as exponentialDelayCapMs, k as DatabaseError, rt as AppError } from "./core-ClSP5-V9.js";
+import { o as MessageAlreadyProcessedError } from "./application-Cf9SER-i.js";
+import { i as runWithUnitOfWorkContext, r as eventCollector, t as OUTBOX_REPOSITORY_DEFAULTS } from "./outbox-repository-options-ICOF8g2h.js";
 import { DrizzleQueryError } from "drizzle-orm/errors";
 import { and, asc, eq, inArray, isNull, lt, lte, or, sql } from "drizzle-orm";
 import { index, integer, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";

package/dist/posthog/metrics.d.ts

@@ -1,4 +1,4 @@
-import { J as MetricsService, q as MetricOptions } from "../index-B45Dr5gs.js";
+import { J as MetricsService, q as MetricOptions } from "../index-Cchdg2aQ.js";
 import { PostHog } from "posthog-node";
 //#region src/infrastructure/posthog/metrics.d.ts
 /** PostHog Metrics with Worker lifetime management, ported from Typist's metrics-service.ts. */

package/dist/posthog/server.d.ts

@@ -1,5 +1,5 @@
-import { Jt as AnalyticsProperties, Kt as AnalyticsEventIdentity, qt as AnalyticsEventInput } from "../index-G1QG0P5g.js";
-import { X as AnalyticsService } from "../index-B45Dr5gs.js";
+import { Jt as AnalyticsEventIdentity, Xt as AnalyticsProperties, Yt as AnalyticsEventInput } from "../index-DvJUcSW1.js";
+import { X as AnalyticsService } from "../index-Cchdg2aQ.js";
 import { PostHogMetricsService } from "./metrics.js";
 import { PostHog, PostHogOptions } from "posthog-node";
 //#region src/infrastructure/posthog/server.d.ts

package/dist/posthog/server.js

@@ -1,4 +1,4 @@
-import { et as MissingConfigurationError } from "../core-hdaNiCOU.js";
+import { nt as MissingConfigurationError } from "../core-ClSP5-V9.js";
 import { PostHogMetricsService } from "./metrics.js";
 import { PostHog } from "posthog-node";
 

package/dist/resend.d.ts

@@ -1,6 +1,6 @@
-import { Mt as BounceType } from "./index-G1QG0P5g.js";
-import { B as OutboundEmail, I as EmailAccepted, R as IEmailService } from "./index-B45Dr5gs.js";
-import { r as WebhookVerifier, t as WebhookVerification } from "./webhook-verification-D7DIhH6C.js";
+import { Pt as BounceType } from "./index-DvJUcSW1.js";
+import { B as OutboundEmail, I as EmailAccepted, R as IEmailService } from "./index-Cchdg2aQ.js";
+import { r as WebhookVerifier, t as WebhookVerification } from "./webhook-verification-BcQQG-vY.js";
 import { Resend } from "resend";
 //#region src/infrastructure/resend/resend-email-service.d.ts
 /** The SDK operations required by the adapter; a test factory can return a plain object. */

package/dist/resend.js

@@ -1,5 +1,5 @@
-import { Q as EmailAddressSchema, Y as EmailServiceError, q as parseBounceType } from "./core-hdaNiCOU.js";
-import { t as WebhookVerificationError } from "./webhook-verification-trEgyz7I.js";
+import { Y as parseBounceType, Z as EmailServiceError, et as EmailAddressSchema } from "./core-ClSP5-V9.js";
+import { t as WebhookVerificationError } from "./webhook-verification-D6aGQfNi.js";
 import { z } from "zod";
 import { Buffer } from "node:buffer";
 

package/dist/sentry/client.d.ts

@@ -1,4 +1,4 @@
-import { f as LoggerErrorHook } from "../index-G1QG0P5g.js";
+import { f as LoggerErrorHook } from "../index-DvJUcSW1.js";
 import * as Sentry from "@sentry/tanstackstart-react";
 //#region src/infrastructure/sentry/client.d.ts
 /** Application settings use Sentry's names; enablement and environment belong to the application. */

package/dist/sentry/client.js

@@ -1,4 +1,4 @@
-import { s as setLoggerErrorHook } from "../core-hdaNiCOU.js";
+import { s as setLoggerErrorHook } from "../core-ClSP5-V9.js";
 import * as Sentry from "@sentry/tanstackstart-react";
 import { isNotFound, isRedirect } from "@tanstack/react-router";
 

package/dist/sentry/server.d.ts

@@ -1,5 +1,5 @@
-import { f as LoggerErrorHook } from "../index-G1QG0P5g.js";
-import { H as ObservabilityScope, U as ObservabilityService, W as ObservabilityUser } from "../index-B45Dr5gs.js";
+import { f as LoggerErrorHook } from "../index-DvJUcSW1.js";
+import { H as ObservabilityScope, U as ObservabilityService, W as ObservabilityUser } from "../index-Cchdg2aQ.js";
 import * as Sentry from "@sentry/cloudflare";
 //#region src/infrastructure/sentry/server.d.ts
 /** Application-owned deployment settings with the full Cloudflare SDK option contract. */

package/dist/tanstack.d.ts

@@ -1,4 +1,4 @@
-import { st as ErrorTable } from "./index-G1QG0P5g.js";
+import { lt as ErrorTable } from "./index-DvJUcSW1.js";
 import { Register } from "@tanstack/react-start";
 import { BetterAuthCookies } from "better-auth";
 //#region src/infrastructure/tanstack/request-context.d.ts

package/dist/tanstack.js

@@ -1,4 +1,4 @@
-import { L as ValidationError, U as AuthenticationError, V as StaleSessionError, a as createLogger, tt as AppError } from "./core-hdaNiCOU.js";
+import { G as AuthenticationError, U as StaleSessionError, a as createLogger, rt as AppError, z as ValidationError } from "./core-ClSP5-V9.js";
 import { z } from "zod";
 import { getReasonPhrase } from "http-status-codes";
 import { isNotFound, isRedirect, redirect } from "@tanstack/react-router";

package/dist/testing/outbox-repository.d.ts

@@ -1,5 +1,5 @@
-import { G as DomainEvent } from "../index-G1QG0P5g.js";
-import { A as IOutboxRepository } from "../index-B45Dr5gs.js";
+import { q as DomainEvent } from "../index-DvJUcSW1.js";
+import { A as IOutboxRepository } from "../index-Cchdg2aQ.js";
 //#region src/infrastructure/testing/outbox-repository-contract.d.ts
 /** Stored fields observed by the adapter contract, independent of a database library. */
 export type OutboxContractRow = {

package/dist/{webhook-verification-D7DIhH6C.d.ts → webhook-verification-BcQQG-vY.d.ts}

@@ -1,4 +1,4 @@
-import { Zt as AppError } from "./index-G1QG0P5g.js";
+import { $t as AppError } from "./index-DvJUcSW1.js";
 //#region src/infrastructure/http/webhook-verification.d.ts
 /** A webhook cannot be trusted or parsed. The HTTP handler logs the rejection once. */
 declare class WebhookVerificationError extends AppError {
@@ -26,4 +26,4 @@ interface WebhookVerifier<Event> {
 }
 //#endregion
 export { WebhookVerificationError as n, WebhookVerifier as r, WebhookVerification as t };
-//# sourceMappingURL=webhook-verification-D7DIhH6C.d.ts.map
+//# sourceMappingURL=webhook-verification-BcQQG-vY.d.ts.map

package/dist/{webhook-verification-D7DIhH6C.d.ts.map → webhook-verification-BcQQG-vY.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"webhook-verification-D7DIhH6C.d.ts","names":[],"sources":["../src/infrastructure/http/webhook-verification.ts"],"mappings":";;;cAGa,iCAAiC;WAMjC;WALF;WACA;;EAGT,YACW,qEACT;;;KAOQ,oBAAoB;WACjB;WAA2B,OAAO;;WAClC;WAA6B;;WAC7B;WAA8B,OAAO;;;UAGnC,gBAAgB;;EAE/B,OAAO,cAAc,SAAS,UAAU,QAAQ,oBAAoB"}
+{"version":3,"file":"webhook-verification-BcQQG-vY.d.ts","names":[],"sources":["../src/infrastructure/http/webhook-verification.ts"],"mappings":";;;cAGa,iCAAiC;WAMjC;WALF;WACA;;EAGT,YACW,qEACT;;;KAOQ,oBAAoB;WACjB;WAA2B,OAAO;;WAClC;WAA6B;;WAC7B;WAA8B,OAAO;;;UAGnC,gBAAgB;;EAE/B,OAAO,cAAc,SAAS,UAAU,QAAQ,oBAAoB"}

package/dist/{webhook-verification-trEgyz7I.js → webhook-verification-D6aGQfNi.js}

@@ -1,4 +1,4 @@
-import { tt as AppError } from "./core-hdaNiCOU.js";
+import { rt as AppError } from "./core-ClSP5-V9.js";
 
 //#region src/infrastructure/http/webhook-verification.ts
 /** A webhook cannot be trusted or parsed. The HTTP handler logs the rejection once. */
@@ -15,4 +15,4 @@ var WebhookVerificationError = class extends AppError {
 
 //#endregion
 export { WebhookVerificationError as t };
-//# sourceMappingURL=webhook-verification-trEgyz7I.js.map
+//# sourceMappingURL=webhook-verification-D6aGQfNi.js.map

package/dist/{webhook-verification-trEgyz7I.js.map → webhook-verification-D6aGQfNi.js.map}

@@ -1 +1 @@
-{"version":3,"file":"webhook-verification-trEgyz7I.js","names":[],"sources":["../src/infrastructure/http/webhook-verification.ts"],"sourcesContent":["import { AppError } from '@/core'\n\n/** A webhook cannot be trusted or parsed. The HTTP handler logs the rejection once. */\nexport class WebhookVerificationError extends AppError {\n  readonly _tag = 'WebhookVerificationError'\n  readonly classification = 'terminal'\n\n  /** Keep secrets and payload details out of the public message. */\n  constructor(\n    readonly reason: 'missing_headers' | 'invalid_signature' | 'invalid_payload',\n    cause?: unknown,\n  ) {\n    super(`Webhook rejected: ${reason}`, { cause })\n  }\n}\n\n/** A verified event, an ignored event, or an invalid request. */\nexport type WebhookVerification<Event> =\n  | { readonly outcome: 'event'; readonly event: Event }\n  | { readonly outcome: 'ignored'; readonly type: string }\n  | { readonly outcome: 'rejected'; readonly error: WebhookVerificationError }\n\n/** The provider owns signature verification, timestamp tolerance, and payload parsing. */\nexport interface WebhookVerifier<Event> {\n  /** Verify the exact body before parsing it. Return invalid requests; throw operational failures. */\n  verify(body: string, headers: Headers): Promise<WebhookVerification<Event>>\n}\n"],"mappings":";;;;AAGA,IAAa,2BAAb,cAA8C,SAAS;CAM1C;CALX,AAAS,OAAO;CAChB,AAAS,iBAAiB;;CAG1B,YACE,AAAS,QACT,OACA;EACA,MAAM,qBAAqB,UAAU,EAAE,MAAM,CAAC;EAHrC;CAIX;AACF"}
+{"version":3,"file":"webhook-verification-D6aGQfNi.js","names":[],"sources":["../src/infrastructure/http/webhook-verification.ts"],"sourcesContent":["import { AppError } from '@/core'\n\n/** A webhook cannot be trusted or parsed. The HTTP handler logs the rejection once. */\nexport class WebhookVerificationError extends AppError {\n  readonly _tag = 'WebhookVerificationError'\n  readonly classification = 'terminal'\n\n  /** Keep secrets and payload details out of the public message. */\n  constructor(\n    readonly reason: 'missing_headers' | 'invalid_signature' | 'invalid_payload',\n    cause?: unknown,\n  ) {\n    super(`Webhook rejected: ${reason}`, { cause })\n  }\n}\n\n/** A verified event, an ignored event, or an invalid request. */\nexport type WebhookVerification<Event> =\n  | { readonly outcome: 'event'; readonly event: Event }\n  | { readonly outcome: 'ignored'; readonly type: string }\n  | { readonly outcome: 'rejected'; readonly error: WebhookVerificationError }\n\n/** The provider owns signature verification, timestamp tolerance, and payload parsing. */\nexport interface WebhookVerifier<Event> {\n  /** Verify the exact body before parsing it. Return invalid requests; throw operational failures. */\n  verify(body: string, headers: Headers): Promise<WebhookVerification<Event>>\n}\n"],"mappings":";;;;AAGA,IAAa,2BAAb,cAA8C,SAAS;CAM1C;CALX,AAAS,OAAO;CAChB,AAAS,iBAAiB;;CAG1B,YACE,AAAS,QACT,OACA;EACA,MAAM,qBAAqB,UAAU,EAAE,MAAM,CAAC;EAHrC;CAIX;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "better-ship",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Foundation for applications on Cloudflare Workers: logger, errors, message bus, infrastructure adapters, and UI primitives",
   "license": "Apache-2.0",
   "repository": {

package/src/core/define-messages.ts

@@ -1,136 +1,242 @@
+import { panic } from 'better-result'
 import { v7 as uuidv7 } from 'uuid'
 import { z } from 'zod'
 
-import type { DomainCommand, DomainEvent, DomainQuery, MessageId } from './messages.ts'
+import { AppError } from './app-error.ts'
+import type { MessageId } from './messages.ts'
 
-/** Payload schemas keyed by message name. A payload never carries `type`, `name`, or `id`. */
+/** Payload schemas keyed by message name. Payloads cannot declare `type`, `name`, or `id`. */
 export type PayloadSchemas = Readonly<Record<string, z.ZodType<object>>>
 
-/** An application's messages: one list of payload schemas per kind. */
+/** Optional payload schema maps for one message collection. */
 export type MessageDefinition = {
-  readonly commands: PayloadSchemas
-  readonly events: PayloadSchemas
-  readonly queries: PayloadSchemas
+  readonly commands?: PayloadSchemas
+  readonly events?: PayloadSchemas
+  readonly queries?: PayloadSchemas
 }
 
-type AnyMessages = { readonly definition: MessageDefinition }
-type Def<Messages extends AnyMessages> = Messages['definition']
-type Payload<Schemas extends PayloadSchemas, Name extends keyof Schemas> = z.output<Schemas[Name]>
-
-/** Every command of an application: `CommandOf<typeof messages>`. */
-export type CommandOf<Messages extends AnyMessages> = {
-  [Name in keyof Def<Messages>['commands'] & string]: DomainCommand<Name> &
-    Payload<Def<Messages>['commands'], Name>
-}[keyof Def<Messages>['commands'] & string]
-
-/** Every event of an application: `EventOf<typeof messages>`. */
-export type EventOf<Messages extends AnyMessages> = {
-  [Name in keyof Def<Messages>['events'] & string]: DomainEvent<Name> &
-    Payload<Def<Messages>['events'], Name>
-}[keyof Def<Messages>['events'] & string]
-
-/** Every query of an application: `QueryOf<typeof messages>`. */
-export type QueryOf<Messages extends AnyMessages> = {
-  [Name in keyof Def<Messages>['queries'] & string]: DomainQuery<Name> &
-    Payload<Def<Messages>['queries'], Name>
-}[keyof Def<Messages>['queries'] & string]
-
-/** Every message of an application: what the registry and the bus are typed with. */
-export type MessageOf<Messages extends AnyMessages> =
-  | CommandOf<Messages>
-  | EventOf<Messages>
-  | QueryOf<Messages>
+const completed = Symbol('MessageCollection')
+const MessageIdSchema = z.string().min(1)
+const envelopes = {
+  command: z.object({ type: z.literal('command'), id: MessageIdSchema }),
+  event: z.object({ type: z.literal('event'), id: MessageIdSchema }),
+  query: z.object({ type: z.literal('query') }),
+}
 
-/**
- * What `defineMessages` returns. The factories build messages for in-process dispatch without
- * parsing; the data is already typed. The schemas parse untrusted input at a boundary.
- */
-export type AppMessages<Definition extends MessageDefinition> = {
-  readonly definition: Definition
-  /** Build a command. `id` defaults to a uuid v7; a webhook passes the provider's key, `stripe:event:evt_123`. */
-  createCommand<Name extends keyof Definition['commands'] & string>(
+type MessageKind = keyof typeof envelopes
+type RoutingField = 'type' | 'name' | 'id'
+type SchemaMap = Readonly<Record<string, z.ZodType<object>>>
+type EmptySchemas = Record<never, never>
+type SchemaMaps = {
+  readonly commandSchemas: SchemaMap
+  readonly eventSchemas: SchemaMap
+  readonly querySchemas: SchemaMap
+}
+type CompletedMessages = SchemaMaps & { readonly [completed]: true }
+type SchemaOf<Schemas extends SchemaMap> = Schemas[keyof Schemas & string]
+type Payload<Message> = Message extends object ? Omit<Message, RoutingField> : never
+
+/** Complete schemas, union schemas, and factories for one message collection. */
+export type MessageCollection<Maps extends SchemaMaps> = Maps & {
+  readonly [completed]: true
+  readonly commandSchema: z.ZodUnion<SchemaOf<Maps['commandSchemas']>[]>
+  readonly eventSchema: z.ZodUnion<SchemaOf<Maps['eventSchemas']>[]>
+  readonly querySchema: z.ZodUnion<SchemaOf<Maps['querySchemas']>[]>
+  /** Commands and events can cross a queue. Queries cannot. */
+  readonly queueSchema: z.ZodUnion<
+    (SchemaOf<Maps['commandSchemas']> | SchemaOf<Maps['eventSchemas']>)[]
+  >
+  /** Add the command envelope without parsing. The default ID is UUID v7; supplied IDs stay unchanged. */
+  createCommand<Name extends keyof Maps['commandSchemas'] & string>(
+    this: void,
     name: Name,
-    payload: Payload<Definition['commands'], Name>,
+    payload: Payload<z.output<Maps['commandSchemas'][NoInfer<Name>]>>,
     id?: MessageId,
-  ): DomainCommand<Name> & Payload<Definition['commands'], Name>
-  /** Build an event. `id` defaults to a uuid v7, which also orders it in time. */
-  createEvent<Name extends keyof Definition['events'] & string>(
+  ): z.output<Maps['commandSchemas'][Name]>
+  /** Add the event envelope without parsing. The default ID is UUID v7; supplied IDs stay unchanged. */
+  createEvent<Name extends keyof Maps['eventSchemas'] & string>(
+    this: void,
     name: Name,
-    payload: Payload<Definition['events'], Name>,
+    payload: Payload<z.output<Maps['eventSchemas'][NoInfer<Name>]>>,
     id?: MessageId,
-  ): DomainEvent<Name> & Payload<Definition['events'], Name>
-  /** Build a query. No id: nothing claims a read. */
-  createQuery<Name extends keyof Definition['queries'] & string>(
+  ): z.output<Maps['eventSchemas'][Name]>
+  /** Add the query envelope without parsing. Queries have no ID. */
+  createQuery<Name extends keyof Maps['querySchemas'] & string>(
+    this: void,
     name: Name,
-    payload: Payload<Definition['queries'], Name>,
-  ): DomainQuery<Name> & Payload<Definition['queries'], Name>
-  readonly commandSchema: z.ZodType<CommandOf<AppMessages<Definition>>>
-  readonly eventSchema: z.ZodType<EventOf<AppMessages<Definition>>>
-  readonly querySchema: z.ZodType<QueryOf<AppMessages<Definition>>>
-  /** What a queue body may be: a command or an event. Queries never cross a queue. */
-  readonly queueSchema: z.ZodType<
-    CommandOf<AppMessages<Definition>> | EventOf<AppMessages<Definition>>
-  >
+    payload: Payload<z.output<Maps['querySchemas'][NoInfer<Name>]>>,
+  ): z.output<Maps['querySchemas'][Name]>
 }
 
-type RoutingField = 'type' | 'name' | 'id'
+/** The command union inferred from a collection's complete schemas. */
+export type CommandOf<Messages extends CompletedMessages> = z.output<
+  SchemaOf<Messages['commandSchemas']>
+>
+
+/** The event union inferred from a collection's complete schemas. */
+export type EventOf<Messages extends CompletedMessages> = z.output<
+  SchemaOf<Messages['eventSchemas']>
+>
 
-/** A payload that declares a routing field maps to `never`, so `defineMessages` rejects it. */
+/** The query union inferred from a collection's complete schemas. */
+export type QueryOf<Messages extends CompletedMessages> = z.output<
+  SchemaOf<Messages['querySchemas']>
+>
+
+/** Every message inferred from a collection's complete schemas. */
+export type MessageOf<Messages extends CompletedMessages> =
+  | CommandOf<Messages>
+  | EventOf<Messages>
+  | QueryOf<Messages>
+
+type KeysOfUnion<Value> = Value extends Value ? keyof Value : never
 type WithoutRoutingFields<Schemas extends PayloadSchemas> = {
-  readonly [Name in keyof Schemas]: keyof z.output<Schemas[Name]> & RoutingField extends never
+  readonly [Name in keyof Schemas]: KeysOfUnion<z.output<Schemas[Name]>> &
+    RoutingField extends never
     ? Schemas[Name]
     : never
 }
 
-/** The compile-time rule: no payload of any kind declares `type`, `name`, or `id`. */
-type ValidDefinition<Definition extends MessageDefinition> = {
-  readonly commands: WithoutRoutingFields<Definition['commands']>
-  readonly events: WithoutRoutingFields<Definition['events']>
-  readonly queries: WithoutRoutingFields<Definition['queries']>
+function messageSchema<
+  Kind extends MessageKind,
+  Name extends string,
+  Schema extends z.ZodType<object>,
+>(kind: Kind, name: Name, payload: Schema) {
+  return z.intersection(envelopes[kind], z.object({ name: z.literal(name) })).and(payload)
 }
 
-const MessageIdSchema = z.string().min(1)
+type CompleteSchemas<Kind extends MessageKind, Schemas extends PayloadSchemas> = {
+  readonly [Name in keyof Schemas & string]: ReturnType<
+    typeof messageSchema<Kind, Name, Schemas[Name]>
+  >
+}
 
-/** One full message schema: the routing fields joined to the payload. */
-function messageSchema(
-  type: 'command' | 'event' | 'query',
-  name: string,
-  payload: z.ZodType<object>,
-) {
-  const routing =
-    type === 'query'
-      ? z.object({ type: z.literal(type), name: z.literal(name) })
-      : z.object({ type: z.literal(type), name: z.literal(name), id: MessageIdSchema })
-  return routing.and(payload)
+function completeSchemas<Kind extends MessageKind, Schemas extends PayloadSchemas>(
+  kind: Kind,
+  schemas: Schemas | undefined,
+): CompleteSchemas<Kind, Schemas> {
+  const entries = Object.entries<z.ZodType<object>>(schemas ?? {}).map(([name, payload]) => [
+    name,
+    messageSchema(kind, name, payload),
+  ])
+  // SAFETY: Each entry preserves its name and wraps its payload schema with the selected envelope.
+  return Object.freeze(Object.fromEntries(entries)) as CompleteSchemas<Kind, Schemas>
+}
+
+function unionOf<Schemas extends SchemaMap>(schemas: Schemas): z.ZodUnion<SchemaOf<Schemas>[]> {
+  // SAFETY: Object.values contains exactly the complete schemas indexed by this map's keys.
+  return z.union(Object.values(schemas)) as z.ZodUnion<SchemaOf<Schemas>[]>
 }
 
-/** A union over every message of one kind. Empty when the application has none of that kind. */
-function unionOf(type: 'command' | 'event' | 'query', schemas: PayloadSchemas) {
-  return z.union(
-    Object.entries(schemas).map(([name, payload]) => messageSchema(type, name, payload)),
-  )
+function collection<Maps extends SchemaMaps>(maps: Maps): MessageCollection<Maps> {
+  return Object.freeze<MessageCollection<Maps>>({
+    ...maps,
+    [completed]: true,
+    commandSchema: unionOf<Maps['commandSchemas']>(maps.commandSchemas),
+    eventSchema: unionOf<Maps['eventSchemas']>(maps.eventSchemas),
+    querySchema: unionOf<Maps['querySchemas']>(maps.querySchemas),
+    // SAFETY: The queue union contains the command and event schemas from these maps, without rebuilding them.
+    queueSchema: z.union([
+      ...Object.values(maps.commandSchemas),
+      ...Object.values(maps.eventSchemas),
+    ]) as MessageCollection<Maps>['queueSchema'],
+    createCommand: (name, payload, id = uuidv7()) => {
+      // SAFETY: The typed payload supplies all non-envelope fields for this name; the factory supplies its envelope.
+      return { ...payload, type: 'command', name, id } as z.output<
+        Maps['commandSchemas'][typeof name]
+      >
+    },
+    createEvent: (name, payload, id = uuidv7()) => {
+      // SAFETY: The typed payload supplies all non-envelope fields for this name; the factory supplies its envelope.
+      return { ...payload, type: 'event', name, id } as z.output<Maps['eventSchemas'][typeof name]>
+    },
+    createQuery: (name, payload) => {
+      // SAFETY: The typed payload supplies all non-envelope fields for this name; a query has no ID.
+      return { ...payload, type: 'query', name } as z.output<Maps['querySchemas'][typeof name]>
+    },
+  })
+}
+
+/** Build each complete schema once. Omitted kinds have empty maps and schemas that reject every input. */
+export function defineMessages<
+  const Commands extends PayloadSchemas = EmptySchemas,
+  const Events extends PayloadSchemas = EmptySchemas,
+  const Queries extends PayloadSchemas = EmptySchemas,
+>(definition: {
+  readonly commands?: Commands & WithoutRoutingFields<Commands>
+  readonly events?: Events & WithoutRoutingFields<Events>
+  readonly queries?: Queries & WithoutRoutingFields<Queries>
+}) {
+  return collection({
+    commandSchemas: completeSchemas<'command', Commands>('command', definition.commands),
+    eventSchemas: completeSchemas<'event', Events>('event', definition.events),
+    querySchemas: completeSchemas<'query', Queries>('query', definition.queries),
+  })
+}
+
+/** Two collections declare the same name within one message kind. */
+export class DuplicateMessageNameError extends AppError {
+  readonly _tag = 'DuplicateMessageNameError'
+  readonly classification = 'terminal'
+
+  /** Identify the duplicate kind and name so the application can correct its definitions. */
+  constructor(
+    readonly kind: MessageKind,
+    readonly messageName: string,
+  ) {
+    super(`Duplicate ${kind} name: ${messageName}`)
+  }
+}
+
+type SchemaAtName<Maps, Name extends PropertyKey> =
+  Maps extends Record<Name, infer Schema extends z.ZodType<object>> ? Schema : never
+type MergedMaps<Collections extends readonly CompletedMessages[]> = {
+  readonly [Key in keyof SchemaMaps]: {
+    readonly [Name in KeysOfUnion<Collections[number][Key]> & string]: SchemaAtName<
+      Collections[number][Key],
+      Name
+    >
+  }
+}
+type DuplicateNames<Collections extends readonly CompletedMessages[]> =
+  Collections extends readonly [
+    infer First extends CompletedMessages,
+    ...infer Rest extends readonly CompletedMessages[],
+  ]
+    ?
+        | {
+            [Key in keyof SchemaMaps]: keyof First[Key] & KeysOfUnion<Rest[number][Key]>
+          }[keyof SchemaMaps]
+        | DuplicateNames<Rest>
+    : never
+
+function mergeSchemas<
+  Collections extends readonly CompletedMessages[],
+  Key extends keyof SchemaMaps,
+>(collections: Collections, key: Key, kind: MessageKind): MergedMaps<Collections>[Key] {
+  const merged = new Map<string, z.ZodType<object>>()
+  for (const messages of collections) {
+    if (!messages?.[completed])
+      return panic('combineMessages requires completed message collections')
+    for (const [name, schema] of Object.entries(messages[key])) {
+      if (merged.has(name)) throw new DuplicateMessageNameError(kind, name)
+      merged.set(name, schema)
+    }
+  }
+  // SAFETY: Every schema comes from the selected complete map, and duplicate names are rejected before insertion.
+  return Object.freeze(Object.fromEntries(merged)) as MergedMaps<Collections>[Key]
 }
 
 /**
- * Define an application's messages once. The key is the name; the factories add the routing
- * fields `type`, `name`, and `id`. A payload that declares one of them is a compile error.
+ * Merge completed collections without rebuilding complete schemas.
+ * @throws DuplicateMessageNameError when two collections declare the same name within one kind.
  */
-export function defineMessages<const Definition extends MessageDefinition>(
-  definition: Definition & ValidDefinition<Definition>,
-): AppMessages<Definition> {
-  const commandSchema = unionOf('command', definition.commands)
-  const eventSchema = unionOf('event', definition.events)
-  const querySchema = unionOf('query', definition.queries)
-  return {
-    definition,
-    createCommand: (name, payload, id = uuidv7()) => ({ ...payload, type: 'command', name, id }),
-    createEvent: (name, payload, id = uuidv7()) => ({ ...payload, type: 'event', name, id }),
-    createQuery: (name, payload) => ({ ...payload, type: 'query', name }),
-    commandSchema: commandSchema.pipe(z.custom<CommandOf<AppMessages<Definition>>>()),
-    eventSchema: eventSchema.pipe(z.custom<EventOf<AppMessages<Definition>>>()),
-    querySchema: querySchema.pipe(z.custom<QueryOf<AppMessages<Definition>>>()),
-    queueSchema: z
-      .union([commandSchema, eventSchema])
-      .pipe(z.custom<CommandOf<AppMessages<Definition>> | EventOf<AppMessages<Definition>>>()),
-  }
+export function combineMessages<const Collections extends readonly CompletedMessages[]>(
+  ...collections: Collections & (DuplicateNames<Collections> extends never ? unknown : never)
+) {
+  return collection({
+    commandSchemas: mergeSchemas(collections, 'commandSchemas', 'command'),
+    eventSchemas: mergeSchemas(collections, 'eventSchemas', 'event'),
+    querySchemas: mergeSchemas(collections, 'querySchemas', 'query'),
+  })
 }

package/src/core/index.ts

@@ -62,7 +62,9 @@ export { notImplemented, unreachable } from './defects.ts'
 export { defineId, type Id, type IdDefinition, type IdOf } from './identity.ts'
 export {
   defineMessages,
-  type AppMessages,
+  combineMessages,
+  DuplicateMessageNameError,
+  type MessageCollection,
   type CommandOf,
   type EventOf,
   type MessageDefinition,

package/src/core/messages.ts

@@ -3,7 +3,7 @@
  *
  * Internal messages use UUID v7, so receipts sort by creation. External messages use the
  * provider's own key, `stripe:event:evt_123`, so a redelivered webhook is a duplicate by
- * construction. The app parses and generates ids; this package only carries them.
+ * construction. Message factories generate IDs; complete message schemas parse external IDs.
  */
 export type MessageId = string