better-ship 0.8.0 → 0.11.0

package/dist/{index-6XMPJu7u.d.ts → index-Bl0K1RQW.d.ts}

@@ -36,6 +36,94 @@ declare abstract class AppError extends Error {
   get name(): string;
 }
 //#endregion
+//#region src/core/email-address.d.ts
+/** A parsed email address for message payloads and webhook recipients. Ported from Typist's `EmailSchema`. */
+declare const EmailAddressSchema: z.core.$ZodBranded<z.ZodEmail, "EmailAddress", "out">;
+/** An address the schema accepted. */
+type EmailAddress = z.infer<typeof EmailAddressSchema>;
+//#endregion
+//#region src/core/email-idempotency-key.d.ts
+/** A key only `emailIdempotencyKey` mints, so every send carries one built by its rules. */
+type EmailIdempotencyKey = string & z.core.$brand<'EmailIdempotencyKey'>;
+/** A key outside 1 to 256 characters. Keys come from stable ids, so this is a defect, not a retry. */
+declare class InvalidEmailIdempotencyKeyError extends AppError {
+  readonly length: number;
+  readonly _tag = "InvalidEmailIdempotencyKeyError";
+  readonly classification = "terminal";
+  constructor(length: number);
+}
+/**
+ * `<scope>/<id>` for one logical send. Resend deduplicates it for 24 hours.
+ * Derive `id` from a stable identity: a message id, a job id, a user id with a template name.
+ * The same key must map to an identical payload; a changed body is rejected as terminal.
+ * A random `id` means every request is a deliberate new send, as a sign-in code resend is.
+ * Source: https://resend.com/docs/dashboard/emails/idempotency-keys
+ */
+declare function emailIdempotencyKey(scope: string, id: string): EmailIdempotencyKey;
+//#endregion
+//#region src/core/email-service.error.d.ts
+/** Why the provider rejected a send. The reason owns the classification, so the two never disagree. */
+type EmailSendFailureReason = 'rate_limited' | 'idempotency_conflict' | 'provider_error' | 'quota_exceeded' | 'invalid_request' | 'configuration';
+/**
+ * The provider rejected a send. The boundary that awaited the send logs once; the adapter never does.
+ * `retryAfter` is the server's delay in seconds when it sent one, so `retryAfterSecondsOf` reads it.
+ */
+declare class EmailServiceError extends AppError {
+  readonly _tag = "EmailServiceError";
+  readonly classification: FailureClassification;
+  readonly reason: EmailSendFailureReason;
+  readonly provider: string;
+  readonly providerCode: string;
+  readonly statusCode: number | null;
+  readonly retryAfter: number | null;
+  constructor(args: {
+    readonly reason: EmailSendFailureReason;
+    readonly provider: string;
+    readonly providerCode: string;
+    readonly statusCode: number | null;
+    readonly retryAfter: number | null;
+    readonly cause: unknown;
+  });
+}
+//#endregion
+//#region src/core/email-deliverability.d.ts
+/** The bounce classes Resend reports, ported from Typist's comm-eligibility.ts. */
+declare const BounceTypeSchema: z.ZodEnum<{
+  Permanent: "Permanent";
+  Transient: "Transient";
+  Undetermined: "Undetermined";
+}>;
+/** One bounce class. */
+type BounceType = z.infer<typeof BounceTypeSchema>;
+/** Parse a provider's bounce type. An unknown value is `Undetermined`, which suppresses. */
+declare function parseBounceType(value: string | undefined): BounceType;
+/** Keep the higher severity. Equal severity permits replacement; callers own timestamp ordering. */
+declare function shouldUpdateBounce(incoming: BounceType, current: BounceType | null): boolean;
+/** Typist's send policy: no complaint, and either no bounce or a transient one. Delivery is not guaranteed. */
+declare function isEmailDeliverable(bounceType: BounceType | null, complained: boolean): boolean;
+//#endregion
+//#region src/core/record-email-event.d.ts
+/**
+ * The payload of the command an application registers to record a bounce or a complaint.
+ * Register it under a name of the application's choice in `defineMessages`; `recordEmailEvent` handles it.
+ */
+declare const RecordEmailEventPayloadSchema: z.ZodObject<{
+  recipients: z.ZodArray<z.core.$ZodBranded<z.ZodEmail, "EmailAddress", "out">>;
+  event: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"bounced">;
+    bounceType: z.ZodEnum<{
+      Permanent: "Permanent";
+      Transient: "Transient";
+      Undetermined: "Undetermined";
+    }>;
+    bounceSubType: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"complained">;
+  }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+/** A parsed payload. */
+type RecordEmailEventPayload = z.infer<typeof RecordEmailEventPayloadSchema>;
+//#endregion
 //#region src/core/authentication.error.d.ts
 /** A protected operation requires a session that the caller did not provide. */
 declare class AuthenticationError extends AppError {
@@ -627,5 +715,5 @@ declare class Logger {
 /** Create a logger for one module. */
 declare function createLogger(module: string, config?: LoggerConfig): Logger;
 //#endregion
-export { unreachable as $, isTransientCloudflareRuntimeError as A, FailureClassification as At, PayloadSchemas as B, classifyBoundaryError as C, InternalServerError as Ct, isCloudflareObjectResetError as D, RateLimitError as Dt, CLOUDFLARE_TRANSIENT_ERROR_PATTERNS as E, StaleSessionError as Et, AppMessages as F, DomainMessage as G, defineMessages as H, CommandOf as I, Id as J, DomainQuery as K, EventOf as L, isTransientTransportError as M, shouldRetryFailure as Mt, Entity as N, isCloudflareOverloadedError as O, AuthenticationError as Ot, EntityData as P, notImplemented as Q, MessageDefinition as R, BoundaryErrorClassifier as S, ValidationProblemErrorSchema as St, retryAfterSecondsOf as T, NotAuthorizedError as Tt, DomainCommand as U, QueryOf as V, DomainEvent as W, IdOf as X, IdDefinition as Y, defineId as Z, createLogger as _, ProblemDetails as _t, LogFormat as a, ErrorPayloadOf as at, exponentialEqualJitterMs as b, ValidationProblemDetailsSchema as bt, LogThreshold as c, ResolvedError as ct, LoggerConfig as d, MalformedRequestError as dt, D1ConstraintKind as et, LoggerErrorHook as f, RequestTimeoutError as ft, consoleSink as g, ValidationIssue as gt, configureLogger as h, ValidationError as ht, LogFields as i, ErrorEntry as it, isAbortError as j, RetryOwner as jt, isCloudflareRetryableError as k, AppError as kt, LogValue as l, defineErrors as lt, SerializedError as m, UpgradeRequiredError as mt, ErrorLogContext as n, DatabaseFailure as nt, LogLevel as o, ErrorTable as ot, LoggerSettings as p, ResourceNotFoundError as pt, MessageId as q, LogEntry as r, ErrorEntries as rt, LogSink as s, ErrorTagOf as st, ErrorCaptureEntry as t, DatabaseError as tt, Logger as u, sharedErrors as ut, setLogSink as v, ProblemDetailsSchema as vt, classifyFailure as w, ServiceUnavailableError as wt, spreadJitterMs as x, ValidationProblemError as xt, setLoggerErrorHook as y, ValidationProblemDetails as yt, MessageOf as z };
-//# sourceMappingURL=index-6XMPJu7u.d.ts.map
+export { unreachable as $, isTransientCloudflareRuntimeError as A, RecordEmailEventPayloadSchema as At, PayloadSchemas as B, emailIdempotencyKey as Bt, classifyBoundaryError as C, InternalServerError as Ct, isCloudflareObjectResetError as D, RateLimitError as Dt, CLOUDFLARE_TRANSIENT_ERROR_PATTERNS as E, StaleSessionError as Et, AppMessages as F, shouldUpdateBounce as Ft, DomainMessage as G, RetryOwner as Gt, defineMessages as H, EmailAddressSchema as Ht, CommandOf as I, EmailSendFailureReason as It, Id as J, DomainQuery as K, shouldRetryFailure as Kt, EventOf as L, EmailServiceError as Lt, isTransientTransportError as M, BounceTypeSchema as Mt, Entity as N, isEmailDeliverable as Nt, isCloudflareOverloadedError as O, AuthenticationError as Ot, EntityData as P, parseBounceType as Pt, notImplemented as Q, MessageDefinition as R, EmailIdempotencyKey as Rt, BoundaryErrorClassifier as S, ValidationProblemErrorSchema as St, retryAfterSecondsOf as T, NotAuthorizedError as Tt, DomainCommand as U, AppError as Ut, QueryOf as V, EmailAddress as Vt, DomainEvent as W, FailureClassification as Wt, IdOf as X, IdDefinition as Y, defineId as Z, createLogger as _, ProblemDetails as _t, LogFormat as a, ErrorPayloadOf as at, exponentialEqualJitterMs as b, ValidationProblemDetailsSchema as bt, LogThreshold as c, ResolvedError as ct, LoggerConfig as d, MalformedRequestError as dt, D1ConstraintKind as et, LoggerErrorHook as f, RequestTimeoutError as ft, consoleSink as g, ValidationIssue as gt, configureLogger as h, ValidationError as ht, LogFields as i, ErrorEntry as it, isAbortError as j, BounceType as jt, isCloudflareRetryableError as k, RecordEmailEventPayload as kt, LogValue as l, defineErrors as lt, SerializedError as m, UpgradeRequiredError as mt, ErrorLogContext as n, DatabaseFailure as nt, LogLevel as o, ErrorTable as ot, LoggerSettings as p, ResourceNotFoundError as pt, MessageId as q, LogEntry as r, ErrorEntries as rt, LogSink as s, ErrorTagOf as st, ErrorCaptureEntry as t, DatabaseError as tt, Logger as u, sharedErrors as ut, setLogSink as v, ProblemDetailsSchema as vt, classifyFailure as w, ServiceUnavailableError as wt, spreadJitterMs as x, ValidationProblemError as xt, setLoggerErrorHook as y, ValidationProblemDetails as yt, MessageOf as z, InvalidEmailIdempotencyKeyError as zt };
+//# sourceMappingURL=index-Bl0K1RQW.d.ts.map

package/dist/index-Bl0K1RQW.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Bl0K1RQW.d.ts","names":[],"sources":["../src/core/failure-classification.ts","../src/core/app-error.ts","../src/core/email-address.ts","../src/core/email-idempotency-key.ts","../src/core/email-service.error.ts","../src/core/email-deliverability.ts","../src/core/record-email-event.ts","../src/core/authentication.error.ts","../src/core/rate-limit.error.ts","../src/core/stale-session.error.ts","../src/core/not-authorized.error.ts","../src/core/internal.errors.ts","../src/core/problem-details.ts","../src/core/request.errors.ts","../src/core/error-table.ts","../src/core/database.error.ts","../src/core/defects.ts","../src/core/identity.ts","../src/core/messages.ts","../src/core/define-messages.ts","../src/core/entity.ts","../src/core/transport-classification.ts","../src/core/cloudflare-classification.ts","../src/core/classify-failure.ts","../src/core/backoff.ts","../src/core/logger.ts"],"mappings":"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"}

package/dist/{index-_Cihfq1J.d.ts → index-DgDyeR5s.d.ts}

@@ -1,4 +1,4 @@
-import { G as DomainMessage, K as DomainQuery, U as DomainCommand, W as DomainEvent, kt as AppError, q as MessageId } from "./index-6XMPJu7u.js";
+import { G as DomainMessage, K as DomainQuery, Rt as EmailIdempotencyKey, U as DomainCommand, Ut as AppError, Vt as EmailAddress, W as DomainEvent, jt as BounceType, kt as RecordEmailEventPayload, q as MessageId } from "./index-Bl0K1RQW.js";
 //#region src/application/handlers.d.ts
 /**
  * Handles one command with the dependency container and returns the caller's value.
@@ -13,6 +13,61 @@ type QueryHandler<TQuery extends DomainQuery, QueryDeps, Value> = (query: TQuery
 /** Completes one subscriber's work for an event. Failures throw. */
 type EventHandler<TEvent extends DomainEvent, Deps> = (event: TEvent, deps: Deps) => Promise<void>;
 //#endregion
+//#region src/application/email-service.d.ts
+/** A media type such as `application/pdf`. */
+type MimeType = `${string}/${string}`;
+/** A file to attach. Binary content is bytes; the adapter encodes it for the provider. */
+type EmailAttachment = {
+  readonly filename: string;
+  readonly content: string | Uint8Array;
+  /** Optional MIME metadata; Resend accepts filename and content without it. */
+  readonly contentType?: MimeType;
+};
+/**
+ * One transactional email. Resend accepts 50 recipients, 75 tags with ASCII names and values,
+ * and 40 MB of attachments after base64. Sources: https://resend.com/docs/api-reference/emails/send-email
+ * and https://resend.com/docs/dashboard/emails/tags
+ */
+type OutboundEmail = {
+  readonly to: string | readonly string[];
+  readonly subject: string;
+  readonly html: string;
+  /** The stable identity of this send. Resend deduplicates it for 24 hours. */
+  readonly idempotencyKey: EmailIdempotencyKey;
+  /** Resend generates plain text from html when omitted. An empty string disables that generation. */
+  readonly text?: string;
+  readonly replyTo?: string;
+  /** Labels the provider stores with the email and returns on every delivery event. */
+  readonly tags?: Readonly<Record<string, string>>;
+  readonly attachments?: readonly EmailAttachment[];
+};
+/** The provider accepted the email and assigned its id. */
+type EmailAccepted = {
+  readonly providerId: string;
+};
+/**
+ * The port a handler sends through. The adapter owns the sender address and the provider error mapping.
+ * A provider rejection throws `EmailServiceError`; unexpected SDK rejections propagate unchanged.
+ */
+interface IEmailService {
+  /** Resolve after provider acceptance; this does not confirm delivery to the recipient. */
+  sendEmail(email: OutboundEmail): Promise<EmailAccepted>;
+}
+/** Records every send for a test. Provider ids count up as `recorded-1`, `recorded-2`. */
+declare class RecordingEmailService implements IEmailService {
+  /** Sends in call order, including repeated idempotency keys. */
+  readonly sent: OutboundEmail[];
+  /** Record the send before returning its provider id. */
+  sendEmail(email: OutboundEmail): Promise<EmailAccepted>;
+}
+//#endregion
+//#region src/application/event-collector.d.ts
+/** Records events in the current unit of work; the unit of work collects a snapshot for outbox persistence. */
+interface IEventCollector {
+  emit(event: DomainEvent): void;
+  collect(): ReadonlyArray<DomainEvent>;
+}
+//#endregion
 //#region src/application/message-store.d.ts
 /**
  * Stores processed messages and outgoing events in the same transaction as application writes.
@@ -25,6 +80,83 @@ interface IMessageStore {
   persistEvents(events: ReadonlyArray<DomainEvent>): Promise<void>;
 }
 //#endregion
+//#region src/application/outbox-relay.d.ts
+/**
+ * Delivers committed outbox rows. The unit of work only wakes it after a commit that wrote
+ * events; the app decides what a wake is: `waitUntil`, a Durable Object alarm, nothing.
+ * The sweep is the source of truth, so a lost wake loses no events.
+ */
+interface IOutboxRelay {
+  wake(): void;
+}
+//#endregion
+//#region src/application/transaction.d.ts
+/**
+ * Supplies `Tx` to participating repositories and resolves after their writes commit. Failure rolls back or discards writes.
+ * Nested calls reject with `UnitOfWorkAlreadyActiveError` before opening another boundary.
+ * Independent concurrent calls are allowed.
+ */
+interface ITransaction<Tx> {
+  transaction<T>(work: (tx: Tx) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/application/unit-of-work.d.ts
+/**
+ * Commits the processed-message record, repository writes, and emitted events together before resolving.
+ * An existing record rejects with `MessageAlreadyProcessedError`; external effects must run through the outbox after commit.
+ * Nested calls reject with `UnitOfWorkAlreadyActiveError`; independent concurrent calls are allowed.
+ */
+interface IUnitOfWork<Repos> {
+  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>;
+}
+type UnitOfWorkDeps<Tx, Repos> = {
+  readonly transaction: ITransaction<Tx>;
+  /** The processed-messages and outbox repository for this transaction. */
+  readonly messageStore: (tx: Tx) => IMessageStore;
+  /** Repositories participate in the current transaction. */
+  readonly createRepositories: (tx: Tx) => Repos;
+  readonly eventCollector: IEventCollector;
+  readonly relay: IOutboxRelay;
+};
+/** The unit of work: the boundary, the repositories, the events. Every database call is a port. */
+declare class UnitOfWork<Tx, Repos> implements IUnitOfWork<Repos> {
+  private readonly deps;
+  constructor(deps: UnitOfWorkDeps<Tx, Repos>);
+  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/application/record-email-event.d.ts
+/** What a bounce records for one address. */
+type EmailBounceRecord = {
+  readonly type: BounceType;
+  readonly subType: string | null;
+};
+/**
+ * The application's deliverability state per address. An implementation keeps the higher bounce
+ * severity with `shouldUpdateBounce`, and treats an unknown address as nothing to record.
+ */
+interface IEmailDeliverabilityStore {
+  /** Keep the higher severity atomically. Equal severity permits replacement; the store owns timestamp ordering. */
+  recordBounce(address: EmailAddress, bounce: EmailBounceRecord): Promise<void>;
+  /** Record a complaint without clearing existing suppression state. */
+  recordComplaint(address: EmailAddress): Promise<void>;
+}
+/** The repositories the handler needs from the unit of work. */
+type RecordEmailEventRepos = {
+  readonly emailDeliverability: IEmailDeliverabilityStore;
+};
+/** The container slice the handler reads. */
+type RecordEmailEventDeps = {
+  readonly uow: IUnitOfWork<RecordEmailEventRepos>;
+};
+/** The command, under whatever name the application registered the payload. */
+type RecordEmailEventCommand = DomainCommand & RecordEmailEventPayload;
+/**
+ * Record a bounce or a complaint for every recipient inside the command's unit of work.
+ * The command id is the provider's event id, so a redelivered webhook is `MessageAlreadyProcessedError`.
+ */
+declare function recordEmailEvent(command: RecordEmailEventCommand, deps: RecordEmailEventDeps): Promise<void>;
+//#endregion
 //#region src/application/registry.d.ts
 /** One slot per command. `unknown` keeps the slot covariant; `MessageResult` recovers the value. */
 type CommandRegistry<TCommand extends DomainCommand, Deps> = { readonly [M in TCommand as M['name']]: CommandHandler<M, Deps, unknown>; };
@@ -94,58 +226,6 @@ declare class MessageBus<Deps, TRegistry extends Handlers<Deps>> implements IMes
   private handleEvent;
 }
 //#endregion
-//#region src/application/outbox-relay.d.ts
-/**
- * Delivers committed outbox rows. The unit of work only wakes it after a commit that wrote
- * events; the app decides what a wake is: `waitUntil`, a Durable Object alarm, nothing.
- * The sweep is the source of truth, so a lost wake loses no events.
- */
-interface IOutboxRelay {
-  wake(): void;
-}
-//#endregion
-//#region src/application/transaction.d.ts
-/**
- * Supplies `Tx` to participating repositories and resolves after their writes commit. Failure rolls back or discards writes.
- * Nested calls reject with `UnitOfWorkAlreadyActiveError` before opening another boundary.
- * Independent concurrent calls are allowed.
- */
-interface ITransaction<Tx> {
-  transaction<T>(work: (tx: Tx) => Promise<T>): Promise<T>;
-}
-//#endregion
-//#region src/application/event-collector.d.ts
-/** Records events in the current unit of work; the unit of work collects a snapshot for outbox persistence. */
-interface IEventCollector {
-  emit(event: DomainEvent): void;
-  collect(): ReadonlyArray<DomainEvent>;
-}
-//#endregion
-//#region src/application/unit-of-work.d.ts
-/**
- * Commits the processed-message record, repository writes, and emitted events together before resolving.
- * An existing record rejects with `MessageAlreadyProcessedError`; external effects must run through the outbox after commit.
- * Nested calls reject with `UnitOfWorkAlreadyActiveError`; independent concurrent calls are allowed.
- */
-interface IUnitOfWork<Repos> {
-  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>;
-}
-type UnitOfWorkDeps<Tx, Repos> = {
-  readonly transaction: ITransaction<Tx>;
-  /** The processed-messages and outbox repository for this transaction. */
-  readonly messageStore: (tx: Tx) => IMessageStore;
-  /** Repositories participate in the current transaction. */
-  readonly createRepositories: (tx: Tx) => Repos;
-  readonly eventCollector: IEventCollector;
-  readonly relay: IOutboxRelay;
-};
-/** The unit of work: the boundary, the repositories, the events. Every database call is a port. */
-declare class UnitOfWork<Tx, Repos> implements IUnitOfWork<Repos> {
-  private readonly deps;
-  constructor(deps: UnitOfWorkDeps<Tx, Repos>);
-  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>;
-}
-//#endregion
 //#region src/application/message-already-processed.error.d.ts
 /** The message's effects already committed. A caller can skip duplicate delivery without repeating those effects. */
 declare class MessageAlreadyProcessedError extends AppError {
@@ -167,5 +247,5 @@ declare class UnitOfWorkAlreadyActiveError extends AppError {
   constructor();
 }
 //#endregion
-export { RegistryMessage as _, UnitOfWorkDeps as a, EventHandler as b, IOutboxRelay as c, CommandRegistry as d, EventRegistry as f, QueryRegistry as g, MessageResult as h, UnitOfWork as i, IMessageBus as l, MessageRegistry as m, MessageAlreadyProcessedError as n, IEventCollector as o, Handlers as p, IUnitOfWork as r, ITransaction as s, UnitOfWorkAlreadyActiveError as t, MessageBus as u, IMessageStore as v, QueryHandler as x, CommandHandler as y };
-//# sourceMappingURL=index-_Cihfq1J.d.ts.map
+export { RecordingEmailService as A, IMessageStore as C, IEmailService as D, EmailAttachment as E, EventHandler as M, QueryHandler as N, MimeType as O, IOutboxRelay as S, EmailAccepted as T, recordEmailEvent as _, CommandRegistry as a, UnitOfWorkDeps as b, MessageRegistry as c, RegistryMessage as d, EmailBounceRecord as f, RecordEmailEventRepos as g, RecordEmailEventDeps as h, MessageBus as i, CommandHandler as j, OutboundEmail as k, MessageResult as l, RecordEmailEventCommand as m, MessageAlreadyProcessedError as n, EventRegistry as o, IEmailDeliverabilityStore as p, IMessageBus as r, Handlers as s, UnitOfWorkAlreadyActiveError as t, QueryRegistry as u, IUnitOfWork as v, IEventCollector as w, ITransaction as x, UnitOfWork as y };
+//# sourceMappingURL=index-DgDyeR5s.d.ts.map

package/dist/index-DgDyeR5s.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DgDyeR5s.d.ts","names":[],"sources":["../src/application/handlers.ts","../src/application/email-service.ts","../src/application/event-collector.ts","../src/application/message-store.ts","../src/application/outbox-relay.ts","../src/application/transaction.ts","../src/application/unit-of-work.ts","../src/application/record-email-event.ts","../src/application/registry.ts","../src/application/message-bus.ts","../src/application/message-already-processed.error.ts","../src/application/unit-of-work.errors.ts"],"mappings":";;;;;;KAMY,eAAe,iBAAiB,eAAe,MAAM,UAC/D,SAAS,UACT,MAAM,SACH,QAAQ;;;;;KAMD,aAAa,eAAe,aAAa,WAAW,UAC9D,OAAO,QACP,MAAM,cACH,QAAQ;;KAGD,aAAa,eAAe,aAAa,SACnD,OAAO,QACP,MAAM,SACH;;;;KCrBO;;KAGA;WACD;WACA,kBAAkB;;WAElB,cAAc;;;;;;;KAQb;WACD;WACA;WACA;;WAEA,gBAAgB;;WAEhB;WACA;;WAEA,OAAO,SAAS;WAChB,uBAAuB;;;KAItB;WAA2B;;;;;;UAMtB;;EAEf,UAAU,OAAO,gBAAgB,QAAQ;;;cAI9B,iCAAiC;;WAEnC,MAAM;;EAGT,UAAU,OAAO,gBAAgB,QAAQ;;;;;UC/ChC;EACf,KAAK,OAAO;EACZ,WAAW,cAAc;;;;;;;;UCCV;;EAEf,MAAM,WAAW,YAAY;;EAE7B,cAAc,QAAQ,cAAc,eAAe;;;;;;;;;UCLpC;EACf;;;;;;;;;UCDe,aAAa;EAC5B,YAAY,GAAG,OAAO,IAAI,OAAO,QAAQ,KAAK,QAAQ;;;;;;;;;UCOvC,YAAY;EAC3B,IAAI,GAAG,WAAW,WAAW,OAAO,OAAO,UAAU,QAAQ,KAAK,QAAQ;;KAGhE,eAAe,IAAI;WACpB,aAAa,aAAa;;WAE1B,eAAe,IAAI,OAAO;;WAE1B,qBAAqB,IAAI,OAAO;WAChC,gBAAgB;WAChB,OAAO;;;cAIL,WAAW,IAAI,kBAAkB,YAAY;mBAC3B;EAA7B,YAA6B,MAAM,eAAe,IAAI;EAEhD,IAAI,GAAG,WAAW,WAAW,OAAO,OAAO,UAAU,QAAQ,KAAK,QAAQ;;;;;KC1BtE;WACD,MAAM;WACN;;;;;;UAOM;;EAEf,aAAa,SAAS,cAAc,QAAQ,oBAAoB;;EAEhE,gBAAgB,SAAS,eAAe;;;KAI9B;WAAmC,qBAAqB;;;KAGxD;WAAkC,KAAK,YAAY;;;KAGnD,0BAA0B,gBAAgB;;;;;iBAMhC,iBACpB,SAAS,yBACT,MAAM,uBACL;;;;KChCS,gBAAgB,iBAAiB,eAAe,oBAChD,KAAK,YAAY,YAAY,eAAe,GAAG;;KAI/C,cAAc,eAAe,aAAa,yBAC1C,KAAK,UAAU,YAAY,aAAa,GAAG;;;;;KAO3C,cAAc,eAAe,aAAa,oBAC1C,KAAK,UAAU,aAAa,cAAc,aAAa,GAAG;;;;;;KAQ1D,gBAAgB,iBAAiB,eAAe,aAAa,WAAW;WACzE,UAAU,gBAAgB,QAAQ,UAAU,gBAAgB;WAC5D,SAAS,cAAc,QAAQ,UAAU,cAAc;WACvD,QAAQ,cAAc,QAAQ,UAAU,cAAc;;KAK5D,KAAK;EAAU,OAAO,SAAS,eAAe,MAAM,OAAO;;KAC3D,aAAa;EAAU,OAAO,OAAO,aAAa,MAAM,OAAO;;;;;;KAMxD,SAAS;WACV,UAAU,SAAS,eAAe,KAAK;WACvC,SAAS,SAAS,eAAe,KAAK;WACtC,QAAQ,SAAS,QAAQ,eAAe,cAAc,aAAa;;KAGzE,YAAY,UAAU,WAAW,QAAQ,aAAa,SAAS;KAE/D,oBAAoB,UACvB,YAAY,aAAa,iBAAiB,oBAAoB,iBAC1D,WAAW,QAAQ,eAAe;;KAI5B,gBAAgB,kBAAkB,mBAC1C,YAAY,yBACZ,YAAY,wBACZ,oBAAoB;KAEnB,UAAU,QAAQ,wBAAwB,oBAAoB,SAC/D,QAAQ,WAAW,QAAQ,OAAO,QAAQ;;KAIlC,cACV,iBAAiB,eACjB,kBAAkB,mBAChB,iBAAiB,gBACjB,UAAU,uBAAuB,oBACjC,iBAAiB,cACf,UAAU,sBAAsB;;;;UCvDrB,YAAY,kBAAkB;EAC7C,OAAO,iBAAiB,gBAAgB,gBAAgB,YACtD,SAAS,WACR,QAAQ,cAAc,UAAU;;;;;;cAOxB,WAAW,MAAM,kBAAkB,SAAS,kBAAkB,YAAY;mBAElE;mBACA;EAFnB,YACmB,MAAM,MACN,UAAU;;EAIvB,OAAO,iBAAiB,gBAAgB,gBAAgB,YAC5D,SAAS,WACR,QAAQ,cAAc,UAAU;UAM3B;UASA;UASA;;;;;;UAWM;;;;;cCpEH,qCAAqC;WAKrC,WAAW;WAJb;WACA;EAET,YACW,WAAW,WACpB;aAAqB;;;SAMhB,KAAK,gBAAgB,WAAW,YAAY;;;;;cCZxC,qCAAqC;WACvC;WACA;EAET"}

package/dist/postgres.d.ts

@@ -1,6 +1,6 @@
-import { W as DomainEvent, nt as DatabaseFailure, q as MessageId, tt as DatabaseError } from "./index-6XMPJu7u.js";
-import { s as ITransaction, v as IMessageStore } from "./index-_Cihfq1J.js";
-import { n as DrizzleSchema, t as eventCollector } from "./unit-of-work-context-BWTJfYPW.js";
+import { W as DomainEvent, nt as DatabaseFailure, q as MessageId, tt as DatabaseError } from "./index-Bl0K1RQW.js";
+import { C as IMessageStore, x as ITransaction } from "./index-DgDyeR5s.js";
+import { n as DrizzleSchema, t as eventCollector } from "./unit-of-work-context-BzmnjlDa.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 { E as DatabaseError, U as AppError } from "./core-DC_4pOrI.js";
-import { i as MessageAlreadyProcessedError } from "./application-DYfcAy-Q.js";
-import { n as eventCollector, r as runWithUnitOfWorkContext } from "./unit-of-work-context-BFCmU92Z.js";
+import { E as DatabaseError, Q as AppError } from "./core-DG_cC8YT.js";
+import { i as MessageAlreadyProcessedError } from "./application-CIxo_BpK.js";
+import { n as eventCollector, r as runWithUnitOfWorkContext } from "./unit-of-work-context-BPE1In2f.js";
 import { DrizzleQueryError } from "drizzle-orm/errors";
 import { isNull } from "drizzle-orm";
 import { index, integer, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";

package/dist/resend.d.ts

@@ -0,0 +1,73 @@
+import { jt as BounceType } from "./index-Bl0K1RQW.js";
+import { D as IEmailService, T as EmailAccepted, k as OutboundEmail } from "./index-DgDyeR5s.js";
+import { r as WebhookVerifier, t as WebhookVerification } from "./webhook-verification-sZtwTI5n.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. */
+type ResendEmailClient = {
+  readonly emails: Pick<Resend['emails'], 'send'>;
+};
+/**
+ * Send without package retries or logs. Ported from Suparelay's resend-email-service.ts.
+ * The Resend SDK itself logs API errors outside production.
+ */
+export declare class ResendEmailService implements IEmailService {
+  private readonly createClient;
+  private readonly fromAddress;
+  /** Load the SDK on the first send. Constructing the service does not load it. */
+  static create(apiKey: string, fromAddress: string): ResendEmailService;
+  private client;
+  /** Supply an async factory. The service calls it once, on the first send, and keeps its promise. */
+  constructor(createClient: () => Promise<ResendEmailClient>, fromAddress: string);
+  /** Resolve after acceptance. Provider failures throw EmailServiceError; SDK defects retain their identity. */
+  sendEmail(email: OutboundEmail): Promise<EmailAccepted>;
+}
+//#endregion
+//#region src/infrastructure/resend/email-event.d.ts
+declare const SIMPLE_EMAIL_TYPES: readonly ['email.sent', 'email.scheduled', 'email.delivered', 'email.delivery_delayed', 'email.complained', 'email.opened', 'email.received', 'email.suppressed'];
+/** Resend email event names supported by this module. */
+type EmailEventType = (typeof SIMPLE_EMAIL_TYPES)[number] | 'email.bounced' | 'email.failed' | 'email.clicked';
+type EmailEventBase = {
+  readonly id: string;
+  readonly emailId: string;
+  readonly recipients: readonly string[];
+  readonly subject: string;
+  readonly tags: Readonly<Record<string, string>>;
+  readonly occurredAt: string;
+};
+/** A verified event. `id` is the Svix identity; use `resend:event:${id}` as the command id. */
+type EmailEvent = (EmailEventBase & {
+  readonly type: 'email.bounced';
+  readonly bounce: {
+    readonly type: BounceType;
+    readonly subType: string | null;
+    readonly message: string;
+  };
+}) | (EmailEventBase & {
+  readonly type: 'email.failed';
+  readonly reason: string;
+}) | (EmailEventBase & {
+  readonly type: 'email.clicked';
+  readonly link: string;
+}) | (EmailEventBase & {
+  readonly type: (typeof SIMPLE_EMAIL_TYPES)[number];
+});
+//#endregion
+//#region src/infrastructure/resend/resend-webhook.d.ts
+/** The SDK's local signature verifier. It makes no API request. */
+type ResendWebhookClient = Pick<Resend['webhooks'], 'verify'>;
+/** Verify Svix signatures and map Resend email events. Ported from Typist's Resend route. */
+export declare class ResendWebhook implements WebhookVerifier<EmailEvent> {
+  private readonly webhookSecret;
+  private readonly verifier;
+  /** Load the SDK on the first verification. Only the webhook secret is required. */
+  static create(webhookSecret: string): ResendWebhook;
+  private client;
+  /** Inject the local SDK verifier when testing. */
+  constructor(webhookSecret: string, verifier: () => Promise<ResendWebhookClient>);
+  /** Verify the raw body and Svix headers. Invalid requests return rejected; configuration and SDK defects propagate. */
+  verify(body: string, headers: Headers): Promise<WebhookVerification<EmailEvent>>;
+}
+//#endregion
+export type { EmailEvent, EmailEventType, ResendEmailClient, ResendWebhookClient };
+//# sourceMappingURL=resend.d.ts.map

package/dist/resend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resend.d.ts","names":[],"sources":["../src/infrastructure/resend/resend-email-service.ts","../src/infrastructure/resend/email-event.ts","../src/infrastructure/resend/resend-webhook.ts"],"mappings":";;;;;;KAsEY;WAA+B,QAAQ,KAAK;;;;;;qBAM3C,8BAA8B;mBAatB;mBACA;;SAZZ,OAAO,gBAAgB,sBAAsB;UAO5C;;EAGR,YACmB,oBAAoB,QAAQ,oBAC5B;;EAIb,UAAU,OAAO,gBAAgB,QAAQ;;;;cCzF3C;;KAYM,yBACA;KAgDP;WACM;WACA;WACA;WACA;WACA,MAAM,SAAS;WACf;;;KAIC,cACP;WACU;WACA;aACE,MAAM;aACN;aACA;;MAGZ;WAA4B;WAA+B;MAC3D;WAA4B;WAAgC;MAC5D;WAA4B,cAAc;;;;;KCvEnC,sBAAsB,KAAK;;qBAG1B,yBAAyB,gBAAgB;mBAcjC;mBACA;;SAbZ,OAAO,wBAAwB;UAQ9B;;EAGR,YACmB,uBACA,gBAAgB,QAAQ;;EAIrC,OAAO,cAAc,SAAS,UAAU,QAAQ,oBAAoB"}