better-ship 0.14.0 → 0.16.0

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
 

package/src/infrastructure/cloudflare/durable-object-client.ts

@@ -0,0 +1,70 @@
+import { Result } from 'better-result'
+
+import { isAbortError, shouldRetryFailure } from '@/core'
+
+import {
+  classifyDurableObjectError,
+  DurableObjectCallError,
+  isClassifiedDurableObjectError,
+} from './durable-object-errors.ts'
+
+/** Resolve a fresh stub on every call, including calls after a failed attempt. */
+export type DurableObjectResolver<Object extends object> = {
+  getByName(name: string): Object | Promise<Object>
+}
+
+type Call<Object extends object, R> = (object: Object) => Promise<R>
+
+/** Product clients name operations and establish repeat safety; this client owns transport retries. */
+export abstract class DurableObjectClient<
+  T extends Rpc.DurableObjectBranded,
+  Object extends object = DurableObjectStub<T>,
+> {
+  constructor(private readonly objects: DurableObjectResolver<Object>) {}
+
+  /** Retry transient failures only when repeating the entire callback is safe. */
+  protected repeatable<R>(name: string, work: Call<Object, R>): Promise<R> {
+    return this.run(name, work, true)
+  }
+
+  /** Make one attempt when repetition is unsafe or another caller owns retries. */
+  protected once<R>(name: string, work: Call<Object, R>): Promise<R> {
+    return this.run(name, work, false)
+  }
+
+  private async run<R>(name: string, work: Call<Object, R>, repeatSafe: boolean): Promise<R> {
+    const result = await Result.tryPromise(
+      {
+        // A failed RPC can break the stub permanently, so every attempt resolves it again.
+        try: async () => work(await this.objects.getByName(name)),
+        catch: (cause) => cause,
+      },
+      {
+        retry: {
+          times: 2,
+          delayMs: 25,
+          backoff: 'exponential',
+          jitter: true,
+          shouldRetry: (cause) => {
+            if (isAbortError(cause) || isClassifiedDurableObjectError(cause)) return false
+            return shouldRetryFailure({
+              classification: classifyDurableObjectError(cause),
+              repeatSafe,
+              owner: 'immediate',
+            })
+          },
+        },
+      },
+    )
+    if (result.isOk()) return result.value
+    if (
+      isAbortError(result.error) ||
+      isClassifiedDurableObjectError(result.error) ||
+      classifyDurableObjectError(result.error) === 'unknown'
+    ) {
+      // oxlint-disable-next-line typescript/only-throw-error -- Preserve raw failures for the owning error boundary.
+      throw result.error
+    }
+    throw new DurableObjectCallError({ cause: result.error })
+  }
+}

package/src/infrastructure/cloudflare/durable-object-errors.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod'
+
+import {
+  AppError,
+  isAbortError,
+  isCloudflareOverloadedError,
+  isCloudflareRetryableError,
+  isTransientCloudflareRuntimeError,
+  isTransientTransportError,
+  type FailureClassification,
+} from '@/core'
+
+/** Stable tag for a failed Durable Object call. */
+export const DURABLE_OBJECT_CALL_ERROR = 'DurableObjectCallError'
+
+const RemoteClassifiedErrorSchema = z.object({
+  _tag: z.string(),
+  classification: z.enum(['transient', 'terminal', 'unknown']),
+  remote: z.literal(true),
+})
+
+const RemoteCallErrorSchema = RemoteClassifiedErrorSchema.extend({
+  _tag: z.literal(DURABLE_OBJECT_CALL_ERROR),
+  cause: z.unknown(),
+})
+
+/** Recognize a judged local or remote error without admitting its tag to the public error table. */
+export function isClassifiedDurableObjectError(
+  cause: unknown,
+): cause is AppError | (Error & z.output<typeof RemoteClassifiedErrorSchema>) {
+  return (
+    cause instanceof AppError ||
+    (cause instanceof Error && RemoteClassifiedErrorSchema.safeParse(cause).success)
+  )
+}
+
+/** Classify the error itself. Its cause remains diagnostic evidence, not a second retry decision. */
+export function classifyDurableObjectError(cause: unknown): FailureClassification {
+  if (isAbortError(cause)) return 'terminal'
+  if (isClassifiedDurableObjectError(cause)) return cause.classification
+  if (isCloudflareOverloadedError(cause)) return 'terminal'
+  if (
+    isCloudflareRetryableError(cause) ||
+    isTransientCloudflareRuntimeError(cause) ||
+    isTransientTransportError(cause)
+  )
+    return 'transient'
+  return 'unknown'
+}
+
+/** Identify a local call error or its validated Workers RPC representation. */
+export function isDurableObjectCallError(
+  cause: unknown,
+): cause is DurableObjectCallError | (Error & z.output<typeof RemoteCallErrorSchema>) {
+  return (
+    cause instanceof DurableObjectCallError ||
+    (cause instanceof Error && RemoteCallErrorSchema.safeParse(cause).success)
+  )
+}
+
+/** A call failed after retries stopped. Classification does not establish repeat safety. */
+export class DurableObjectCallError extends AppError {
+  readonly _tag = DURABLE_OBJECT_CALL_ERROR
+  readonly classification: FailureClassification
+
+  constructor(args: { readonly cause: unknown }) {
+    super('Durable Object call failed', { cause: args.cause })
+    this.classification = classifyDurableObjectError(args.cause)
+  }
+}

package/src/infrastructure/resend/resend-email-service.ts

@@ -109,7 +109,10 @@ export class ResendEmailService implements IEmailService {
     if (email.tags !== undefined)
       payload.tags = Object.entries(email.tags).map(([name, value]) => ({ name, value }))
     if (email.attachments !== undefined) payload.attachments = email.attachments.map(toAttachment)
-    const result = await client.emails.send(payload, { idempotencyKey: email.idempotencyKey })
+    const result = await client.emails.send(
+      payload,
+      email.idempotencyKey === undefined ? undefined : { idempotencyKey: email.idempotencyKey },
+    )
     if (result.error !== null) {
       throw new EmailServiceError({
         reason: reasonFromResend(result.error),

package/dist/application-C4JOf71r.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"application-C4JOf71r.js","names":["logger"],"sources":["../src/application/analytics-service.ts","../src/application/metrics-service.ts","../src/application/email-service.ts","../src/application/record-email-event.ts","../src/application/message-already-processed.error.ts","../src/application/message-bus.ts","../src/application/outbox-relay.ts","../src/application/outbox-retention.ts","../src/application/unit-of-work.ts","../src/application/unit-of-work.errors.ts"],"sourcesContent":["import type { AnalyticsEventIdentity, AnalyticsEventInput, AnalyticsProperties } from '@/core'\n\n/** Product analytics without an SDK dependency, ported from Typist and Porte. */\nexport interface AnalyticsService<TEvent extends AnalyticsEventInput = AnalyticsEventInput> {\n  /** Attach traits to one person. */\n  identify(distinctId: string, properties?: AnalyticsProperties): void\n  /** Merge a previous ID into this person; the application must establish that both identify the same person. */\n  alias(distinctId: string, previousDistinctId: string): void\n  /** Schedule an event for a person; returning does not confirm remote acceptance. */\n  track(event: TEvent, distinctId: string, identity?: AnalyticsEventIdentity): void\n  /** Schedule an event without creating a person profile for its distinct ID. */\n  trackAnonymous(event: TEvent, distinctId: string, identity?: AnalyticsEventIdentity): void\n}\n\n/** Reports to nobody. The composition root selects this service when analytics is disabled. */\nexport const NULL_ANALYTICS: AnalyticsService = {\n  identify: () => {},\n  alias: () => {},\n  track: () => {},\n  trackAnonymous: () => {},\n}\n","/** A metric dimension; use a small, bounded value set and never user or request IDs. */\nexport type MetricAttributeValue = string | number | boolean\n\n/** Dimensions shared by observations in one time series. */\nexport type MetricAttributes = Readonly<Record<string, MetricAttributeValue>>\n\n/** Unit and dimensions for an operational measurement. */\nexport interface MetricOptions {\n  readonly attributes?: MetricAttributes\n  readonly unit?: string\n}\n\n/** Operational measurements, ported from Typist's metrics-service.ts; applications own metric names. */\nexport interface MetricsService<TName extends string = string> {\n  /** Add a nonnegative value to a total; the default increment is one. */\n  count(name: TName, value?: number, options?: MetricOptions): void\n  /** Record a current value. */\n  gauge(name: TName, value: number, options?: MetricOptions): void\n  /** Record one observation in a distribution. */\n  histogram(name: TName, value: number, options?: MetricOptions): void\n}\n\n/** Records nothing when the composition root disables metrics. */\nexport const NULL_METRICS_SERVICE: MetricsService = {\n  count: () => {},\n  gauge: () => {},\n  histogram: () => {},\n}\n","import type { EmailIdempotencyKey } from '@/core'\n\n/** A media type such as `application/pdf`. */\nexport type MimeType = `${string}/${string}`\n\n/** A file to attach. Binary content is bytes; the adapter encodes it for the provider. */\nexport type EmailAttachment = {\n  readonly filename: string\n  readonly content: string | Uint8Array\n  /** Optional MIME metadata; Resend accepts filename and content without it. */\n  readonly contentType?: MimeType\n}\n\n/**\n * One transactional email. Resend accepts 50 recipients, 75 tags with ASCII names and values,\n * and 40 MB of attachments after base64. Sources: https://resend.com/docs/api-reference/emails/send-email\n * and https://resend.com/docs/dashboard/emails/tags\n */\nexport type OutboundEmail = {\n  /** Override the default for this email, for example \"Display Name <address@domain.com>\". */\n  readonly from?: string\n  readonly to: string | readonly string[]\n  readonly subject: string\n  readonly html: string\n  /** The stable identity of this send. Resend deduplicates it for 24 hours. */\n  readonly idempotencyKey: EmailIdempotencyKey\n  /** Resend generates plain text from html when omitted. An empty string disables that generation. */\n  readonly text?: string\n  readonly replyTo?: string\n  /** Labels the provider stores with the email and returns on every delivery event. */\n  readonly tags?: Readonly<Record<string, string>>\n  readonly attachments?: readonly EmailAttachment[]\n}\n\n/** The provider accepted the email and assigned its id. */\nexport type EmailAccepted = { readonly providerId: string }\n\n/**\n * The adapter supplies the default sender and maps provider errors. Each email can override the sender.\n * A provider rejection throws `EmailServiceError`; unexpected SDK rejections propagate unchanged.\n */\nexport interface IEmailService {\n  /** Resolve after provider acceptance; this does not confirm delivery to the recipient. */\n  sendEmail(email: OutboundEmail): Promise<EmailAccepted>\n}\n\n/** Records every send for a test. Provider ids count up as `recorded-1`, `recorded-2`. */\nexport class RecordingEmailService implements IEmailService {\n  /** Sends in call order, including repeated idempotency keys. */\n  readonly sent: OutboundEmail[] = []\n\n  /** Record the send before returning its provider id. */\n  async sendEmail(email: OutboundEmail): Promise<EmailAccepted> {\n    this.sent.push(email)\n    return { providerId: `recorded-${this.sent.length}` }\n  }\n}\n","import type { BounceType, DomainCommand, EmailAddress, RecordEmailEventPayload } from '@/core'\n\nimport type { IUnitOfWork } from './unit-of-work.ts'\n\n/** What a bounce records for one address. */\nexport type EmailBounceRecord = {\n  readonly type: BounceType\n  readonly subType: string | null\n}\n\n/**\n * The application's deliverability state per address. An implementation keeps the higher bounce\n * severity with `shouldUpdateBounce`, and treats an unknown address as nothing to record.\n */\nexport interface IEmailDeliverabilityStore {\n  /** Keep the higher severity atomically. Equal severity permits replacement; the store owns timestamp ordering. */\n  recordBounce(address: EmailAddress, bounce: EmailBounceRecord): Promise<void>\n  /** Record a complaint without clearing existing suppression state. */\n  recordComplaint(address: EmailAddress): Promise<void>\n}\n\n/** The repositories the handler needs from the unit of work. */\nexport type RecordEmailEventRepos = { readonly emailDeliverability: IEmailDeliverabilityStore }\n\n/** The container slice the handler reads. */\nexport type RecordEmailEventDeps = { readonly uow: IUnitOfWork<RecordEmailEventRepos> }\n\n/** The command, under whatever name the application registered the payload. */\nexport type RecordEmailEventCommand = DomainCommand & RecordEmailEventPayload\n\n/**\n * Record a bounce or a complaint for every recipient inside the command's unit of work.\n * The command id is the provider's event id, so a redelivered webhook is `MessageAlreadyProcessedError`.\n */\nexport async function recordEmailEvent(\n  command: RecordEmailEventCommand,\n  deps: RecordEmailEventDeps,\n): Promise<void> {\n  await deps.uow.run(command.id, async ({ emailDeliverability }) => {\n    for (const address of command.recipients) {\n      if (command.event.type === 'bounced') {\n        // oxlint-disable-next-line no-await-in-loop -- Finish each transaction write before starting another; a failure must leave no pending writes.\n        await emailDeliverability.recordBounce(address, {\n          type: command.event.bounceType,\n          subType: command.event.bounceSubType,\n        })\n      } else {\n        // oxlint-disable-next-line no-await-in-loop -- A rejected write must stop the transaction before another write starts.\n        await emailDeliverability.recordComplaint(address)\n      }\n    }\n  })\n}\n","import { AppError, DatabaseError, type MessageId } from '@/core'\n\n/** The message's effects already committed. A caller can skip duplicate delivery without repeating those effects. */\nexport class MessageAlreadyProcessedError extends AppError {\n  readonly _tag = 'MessageAlreadyProcessedError'\n  readonly classification = 'terminal'\n\n  constructor(\n    readonly messageId: MessageId,\n    options?: { readonly cause: unknown },\n  ) {\n    super(`message ${messageId} already processed`, options)\n  }\n\n  /** Recognize only the processed-message primary key; preserve other failures unchanged at the call site. */\n  static from(cause: unknown, messageId: MessageId): MessageAlreadyProcessedError | undefined {\n    if (cause instanceof MessageAlreadyProcessedError) return cause\n    if (!(cause instanceof DatabaseError)) return undefined\n    const details = cause.details\n    const duplicate =\n      details.database === 'd1'\n        ? details.kind === 'unique' &&\n          details.table === 'processed_messages' &&\n          details.column === 'message_id'\n        : details.code === '23505' &&\n          details.table_name === 'processed_messages' &&\n          details.constraint_name === 'processed_messages_pkey'\n    if (!duplicate) return undefined\n    return new MessageAlreadyProcessedError(messageId, { cause })\n  }\n}\n","import { panic } from 'better-result'\n\nimport {\n  createLogger,\n  unreachable,\n  type DomainCommand,\n  type DomainEvent,\n  type DomainMessage,\n  type DomainQuery,\n} from '@/core'\n\nimport { MessageAlreadyProcessedError } from './message-already-processed.error.ts'\nimport type { Handlers, MessageResult, RegistryMessage } from './registry.ts'\n\nconst logger = createLogger('message-bus')\n\n/** The port an entrypoint dispatches through. `AppDeps` names this as `IMessageBus<typeof registry>`. */\nexport interface IMessageBus<TRegistry extends Handlers<never>> {\n  handle<TMessage extends DomainMessage & RegistryMessage<TRegistry>>(\n    message: TMessage,\n  ): Promise<MessageResult<TMessage, TRegistry>>\n}\n\n/**\n * Routes one message to its slot. The bus opens no transaction and keeps no outbox:\n * a handler that writes opens the unit of work itself.\n */\nexport class MessageBus<Deps, TRegistry extends Handlers<Deps>> implements IMessageBus<TRegistry> {\n  constructor(\n    private readonly deps: Deps,\n    private readonly registry: TRegistry,\n  ) {}\n\n  /** Resolves to the handler's own value for a command or query, and to void for an event. */\n  async handle<TMessage extends DomainMessage & RegistryMessage<TRegistry>>(\n    message: TMessage,\n  ): Promise<MessageResult<TMessage, TRegistry>> {\n    // SAFETY: the slot for this name is what `MessageResult` names, and dispatch returns its value.\n    return (await this.dispatch(message)) as MessageResult<TMessage, TRegistry>\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- one table holds every slot's value; `handle` names it.\n  private dispatch(message: DomainMessage): Promise<unknown> {\n    if (message.type === 'command') return this.handleCommand(message)\n    if (message.type === 'query') return this.handleQuery(message)\n    if (message.type === 'event') return this.handleEvent(message)\n    // A message parsed at a boundary cannot reach here; one that does must not resolve silently.\n    return unreachable(message)\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- see dispatch.\n  private handleCommand(command: DomainCommand): Promise<unknown> {\n    // `satisfies` proved the registry complete, so a missing slot is a broken registry object.\n    const handler = this.registry.commands[command.name]\n    if (handler === undefined) return panic(`No handler for command ${command.name}`)\n    logger.debug('handling_command', { name: command.name, id: command.id })\n    return handler(command, this.deps)\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- see dispatch.\n  private handleQuery(query: DomainQuery): Promise<unknown> {\n    const handler = this.registry.queries[query.name]\n    if (handler === undefined) return panic(`No handler for query ${query.name}`)\n    return handler(query, this.deps)\n  }\n\n  /**\n   * Every subscriber runs to completion. One failure is rethrown as is. Several are thrown as\n   * one `AggregateError`. A `MessageAlreadyProcessedError` means that subscriber already committed on\n   * an earlier delivery, so it counts as delivered.\n   */\n  private async handleEvent(event: DomainEvent): Promise<void> {\n    const subscriptions = this.registry.events[event.name] ?? []\n    const outcomes = await Promise.allSettled(\n      subscriptions.map((subscription) => subscription(event, this.deps)),\n    )\n    const failures: unknown[] = []\n    for (const [subscriber, outcome] of outcomes.entries()) {\n      if (outcome.status === 'fulfilled') continue\n      if (outcome.reason instanceof MessageAlreadyProcessedError) {\n        // The bus swallows this error, so this line is the only record that the skip happened.\n        logger.info('duplicate_subscriber_ignored', { event: event.name, id: event.id, subscriber })\n        continue\n      }\n      failures.push(outcome.reason)\n    }\n    if (failures.length === 1) throw failures[0]\n    if (failures.length > 1) {\n      throw new AggregateError(failures, `${event.name}: ${failures.length} subscribers failed`)\n    }\n  }\n}\n","import { classifyFailure, createLogger, type DomainEvent } from '@/core'\n\nimport type {\n  DeadLetterReason,\n  IOutboxRepository,\n  OutboxClaim,\n  OutboxMessage,\n} from './outbox-repository.ts'\n\n/**\n * Delivers committed outbox rows. The unit of work only wakes it after a commit that wrote\n * events; the app decides what a wake is: `waitUntil`, a Durable Object alarm, nothing.\n * The sweep is the source of truth, so a lost wake loses no events.\n */\nexport interface IOutboxRelay {\n  wake(): void\n}\n\n/** The publisher sends valid events and returns oversized events. QueueClient satisfies this port directly. */\nexport interface IOutboxPublisher {\n  /** Resolves after queue acceptance; a rejected batch may already have sent some events. */\n  sendBatchPartial(messages: ReadonlyArray<DomainEvent>): Promise<ReadonlyArray<DomainEvent>>\n}\n\n/** Optional limits for one relay; durable attempts exclude the publisher's immediate retries. */\nexport type OutboxRelayOptions = {\n  readonly batchSize?: number\n  readonly maxBatches?: number\n  readonly maxAttempts?: number\n}\n\nconst logger = createLogger('outbox-relay')\n\n/**\n * Publishes committed events with bounded durable retries. Ported from Typist's relay with per-row exhaustion.\n * Send failures are recorded; repository failures propagate to the wake or scheduled boundary.\n */\nexport class OutboxRelay {\n  private readonly options: Required<OutboxRelayOptions>\n\n  constructor(\n    private readonly publisher: IOutboxPublisher,\n    private readonly repository: IOutboxRepository,\n    options: OutboxRelayOptions = {},\n  ) {\n    this.options = {\n      batchSize: options.batchSize ?? 50,\n      maxBatches: options.maxBatches ?? 10,\n      maxAttempts: options.maxAttempts ?? 10,\n    }\n  }\n\n  /** Return the claimed count, including released and dead-lettered rows. Zero means no due rows. */\n  async flush(): Promise<number> {\n    const claim = await this.repository.claimPending(this.options.batchSize)\n    const exhausted = claim.messages.filter((row) => row.attempts > this.options.maxAttempts)\n    await this.deadLetter(claim, exhausted, 'exhausted', 'Claim attempt limit exceeded')\n    const pending = claim.messages.filter((row) => row.attempts <= this.options.maxAttempts)\n    if (pending.length === 0) return claim.messages.length\n\n    let oversized: ReadonlyArray<DomainEvent>\n    try {\n      oversized = await this.publisher.sendBatchPartial(pending.map((row) => row.payload))\n    } catch (error) {\n      await this.handleSendFailure(claim, pending, error)\n      return claim.messages.length\n    }\n\n    const oversizedIds = new Set(oversized.map((event) => event.id))\n    await this.deadLetter(\n      claim,\n      pending.filter((row) => oversizedIds.has(row.payload.id)),\n      'oversized',\n      'Exceeds queue message size limit',\n    )\n    const sent = pending.filter((row) => !oversizedIds.has(row.payload.id))\n    if (sent.length > 0) await this.repository.markPublished(claim, sent)\n    return claim.messages.length\n  }\n\n  /** Drain until an empty claim or the batch limit; return the total claimed count. */\n  async drain(): Promise<number> {\n    let total = 0\n    for (let batch = 0; batch < this.options.maxBatches; batch += 1) {\n      // oxlint-disable-next-line no-await-in-loop -- An empty claim must stop the drain before another claim starts.\n      const claimed = await this.flush()\n      total += claimed\n      if (claimed === 0) break\n    }\n    return total\n  }\n\n  private async handleSendFailure(\n    claim: OutboxClaim,\n    pending: ReadonlyArray<OutboxMessage>,\n    cause: unknown,\n  ): Promise<void> {\n    const classification = classifyFailure(cause)\n    const message =\n      cause instanceof Error ? cause.message : 'Publisher rejected with a non-error value'\n    if (classification === 'terminal') {\n      await this.deadLetter(claim, pending, 'terminal', message, cause)\n      return\n    }\n    const exhausted = pending.filter((row) => row.attempts >= this.options.maxAttempts)\n    await this.deadLetter(claim, exhausted, 'exhausted', message, cause)\n    const retry = pending.filter((row) => row.attempts < this.options.maxAttempts)\n    if (retry.length > 0) await this.repository.releaseClaim(claim, retry)\n  }\n\n  private async deadLetter(\n    claim: OutboxClaim,\n    messages: ReadonlyArray<OutboxMessage>,\n    reason: DeadLetterReason,\n    errorMessage: string,\n    cause?: unknown,\n  ): Promise<void> {\n    if (messages.length === 0) return\n    await this.repository.deadLetter(claim, messages, reason, errorMessage)\n    logger.error('outbox_messages_dead_lettered', {\n      error: cause,\n      details: { claimToken: claim.token, count: messages.length, reason },\n    })\n  }\n}\n","import type { IOutboxRetentionRepository } from './outbox-repository.ts'\n\n/** Typist's retention defaults; receipt retention must cover the application's supported replay period. */\nexport type OutboxRetentionOptions = {\n  readonly publishedRetentionMs?: number\n  readonly failedRetentionMs?: number\n  readonly receiptRetentionMs?: number\n  readonly batchSize?: number\n  readonly maxBatches?: number\n}\n\n/** Deleted records per category during one bounded sweep. */\nexport type OutboxRetentionResult = {\n  readonly published: number\n  readonly failed: number\n  readonly receipts: number\n}\n\n/** Bounded cleanup ported from Typist's message retention handler. The application schedules each sweep. */\nexport class OutboxRetention {\n  private readonly options: Required<OutboxRetentionOptions>\n\n  constructor(\n    private readonly repository: IOutboxRetentionRepository,\n    options: OutboxRetentionOptions = {},\n  ) {\n    this.options = {\n      publishedRetentionMs: options.publishedRetentionMs ?? 86_400_000,\n      failedRetentionMs: options.failedRetentionMs ?? 30 * 86_400_000,\n      receiptRetentionMs: options.receiptRetentionMs ?? 7 * 86_400_000,\n      batchSize: options.batchSize ?? 1_000,\n      maxBatches: options.maxBatches ?? 10,\n    }\n  }\n\n  /** Calculate all cutoffs from one supplied time; propagate repository failures to the calling boundary. */\n  async sweep(at: Date): Promise<OutboxRetentionResult> {\n    const { publishedRetentionMs, failedRetentionMs, receiptRetentionMs } = this.options\n    const published = await this.deleteBatches((size) =>\n      this.repository.deletePublishedBefore(new Date(at.getTime() - publishedRetentionMs), size),\n    )\n    const failed = await this.deleteBatches((size) =>\n      this.repository.deleteFailedBefore(new Date(at.getTime() - failedRetentionMs), size),\n    )\n    const receipts = await this.deleteBatches((size) =>\n      this.repository.deleteReceiptsBefore(new Date(at.getTime() - receiptRetentionMs), size),\n    )\n    return { published, failed, receipts }\n  }\n\n  private async deleteBatches(deleteBatch: (size: number) => Promise<number>): Promise<number> {\n    let total = 0\n    for (let batch = 0; batch < this.options.maxBatches; batch += 1) {\n      // oxlint-disable-next-line no-await-in-loop -- The delete count decides whether another batch is needed.\n      const deleted = await deleteBatch(this.options.batchSize)\n      total += deleted\n      if (deleted < this.options.batchSize) break\n    }\n    return total\n  }\n}\n","import type { MessageId } from '@/core'\n\nimport type { IEventCollector } from './event-collector.ts'\nimport { MessageAlreadyProcessedError } from './message-already-processed.error.ts'\nimport type { IMessageStore } from './message-store.ts'\nimport type { IOutboxRelay } from './outbox-relay.ts'\nimport type { ITransaction } from './transaction.ts'\n\n/**\n * Commits the processed-message record, repository writes, and emitted events together before resolving.\n * An existing record rejects with `MessageAlreadyProcessedError`; external effects must run through the outbox after commit.\n * Nested calls reject with `UnitOfWorkAlreadyActiveError`; independent concurrent calls are allowed.\n */\nexport interface IUnitOfWork<Repos> {\n  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>\n}\n\nexport type UnitOfWorkDeps<Tx, Repos> = {\n  readonly transaction: ITransaction<Tx>\n  /** The processed-messages and outbox repository for this transaction. */\n  readonly messageStore: (tx: Tx) => IMessageStore\n  /** Repositories participate in the current transaction. */\n  readonly createRepositories: (tx: Tx) => Repos\n  readonly eventCollector: IEventCollector\n  readonly relay: IOutboxRelay\n}\n\n/** The unit of work: the boundary, the repositories, the events. Every database call is a port. */\nexport class UnitOfWork<Tx, Repos> implements IUnitOfWork<Repos> {\n  constructor(private readonly deps: UnitOfWorkDeps<Tx, Repos>) {}\n\n  async run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T> {\n    const { transaction, messageStore, createRepositories, eventCollector, relay } = this.deps\n    let written = 0\n\n    let value: T\n    try {\n      value = await transaction.transaction(async (tx) => {\n        const store = messageStore(tx)\n        await store.claim(messageId)\n        const repos = createRepositories(tx)\n        const result = await work(repos)\n        const pending = eventCollector.collect()\n        await store.persistEvents(pending)\n        written = pending.length\n        return result\n      })\n    } catch (error) {\n      throw MessageAlreadyProcessedError.from(error, messageId) ?? error\n    }\n\n    if (written > 0) relay.wake()\n    return value\n  }\n}\n","import { AppError } from '@/core'\n\n/** A boundary was opened inside another. One message, one atomic scope. */\nexport class UnitOfWorkAlreadyActiveError extends AppError {\n  readonly _tag = 'UnitOfWorkAlreadyActiveError'\n  readonly classification = 'terminal'\n\n  constructor() {\n    super('a unit of work is already active')\n  }\n}\n"],"mappings":"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"}