@open-mercato/shared 0.7.1-develop.7149.1.7efa6e1612 → 0.7.1-develop.7151.1.00d0391847

package/src/lib/data/engine.ts

@@ -64,6 +64,19 @@ type QueuedCrudSideEffect = {
   indexer?: CrudIndexerConfig<unknown>
 }
 
+/**
+ * A `makeCrudRoute` route-level `indexer:` declaration, handed to the data engine for the
+ * duration of one command-bus write. Command handlers own the side-effect mark on the
+ * `actions.*` path, and most of them mark `events:` only — without this the route's
+ * declaration would reach no code at all. `entityClass` scopes the default to the route's
+ * own ORM entity so a handler that also marks a sibling entity in the same request (a tag
+ * assignment alongside a tag, say) is never indexed under the route's `entityType`.
+ */
+export type DefaultCrudIndexerConfig = {
+  indexer: CrudIndexerConfig<unknown>
+  entityClass: abstract new (...args: never[]) => object
+}
+
 export interface DataEngine {
   setCustomFields(opts: {
     entityId: string
@@ -149,6 +162,20 @@ export interface DataEngine {
    * is responsible for rebuilding the `query_index` afterwards.
    */
   flushOrmEntityChanges(suppress?: BulkImportSuppression): Promise<void>
+
+  /**
+   * Declare the indexer a CRUD route configured, for marks made during one command-bus
+   * write that do not carry an indexer of their own. Pass `null` to clear it. Optional so
+   * third-party `DataEngine` implementations stay valid; callers invoke it with `?.`.
+   */
+  setDefaultIndexerConfig?(config: DefaultCrudIndexerConfig | null): void
+
+  /**
+   * Whether any side effect drained since the current default was declared carried an
+   * indexer for that default's entity class — false means the declared query-index
+   * obligation was discharged by nobody. Optional for the same reason as the setter.
+   */
+  hasIndexedDefaultEntityClass?(): boolean
 }
 
 export const SYSTEM_ENTITY_RECORDS_BLOCKED_CODE = 'system_entity_records_blocked'
@@ -188,8 +215,43 @@ export function assertCustomEntityStorageEntityId(em: EntityManager, entityId: s
 
 export class DefaultDataEngine implements DataEngine {
   private pendingSideEffects = new Map<string, QueuedCrudSideEffect>()
+  private defaultIndexer: DefaultCrudIndexerConfig | null = null
+  private indexedDefaultEntityClass = false
   constructor(private em: EntityManager, private container: AwilixContainer) {}
 
+  /**
+   * Per-command state, deliberately held on the engine instance rather than threaded through
+   * `CommandRuntimeContext` the way the bulk-import flags are. That is sound only because
+   * `createRequestContainer()` registers `dataEngine` per request (`lib/di/container.ts`), so
+   * one engine instance never spans two requests, and no `makeCrudRoute` verb runs two commands
+   * concurrently against it. An application that re-registers `dataEngine` as a transient would
+   * break both assumptions: the command would mark on a different instance than the route
+   * declared on, so nothing is indexed and every write logs the undischarged-declaration warning.
+   */
+  setDefaultIndexerConfig(config: DefaultCrudIndexerConfig | null): void {
+    this.defaultIndexer = config
+    this.indexedDefaultEntityClass = false
+  }
+
+  hasIndexedDefaultEntityClass(): boolean {
+    return this.indexedDefaultEntityClass
+  }
+
+  private matchesDefaultEntityClass(entity: unknown): boolean {
+    const declared = this.defaultIndexer?.entityClass
+    // `OrmEntityConfig.entity` is `any` and this repository treats `EntitySchema` instances as a
+    // first-class entity shape (`lib/bootstrap/types.ts`). An `EntitySchema` is an object rather
+    // than a constructor, so `instanceof` against it throws — and it would throw inside
+    // `markOrmEntityChange`, outside the best-effort try/catch that guards the flush, turning
+    // every write on such a route into a 500.
+    if (typeof declared !== 'function') return false
+    return entity instanceof declared
+  }
+
+  private resolveDefaultIndexer(entity: unknown): CrudIndexerConfig<unknown> | undefined {
+    return this.matchesDefaultEntityClass(entity) ? this.defaultIndexer?.indexer : undefined
+  }
+
   async setCustomFields(opts: Parameters<DataEngine['setCustomFields']>[0]): Promise<void> {
     const { entityId, recordId, organizationId = null, tenantId = null, values } = opts
     const sanitizedValues = await sanitizeCustomFieldHtmlRichTextValuesServer(this.em, {
@@ -728,6 +790,10 @@ export class DefaultDataEngine implements DataEngine {
     const { entity, identifiers } = opts
     if (!entity) return
     if (!identifiers?.id) return
+    // A command handler that marks `events:` only still discharges the route's declared
+    // query-index obligation — the route hands its `indexer:` down as the default so the
+    // handler's own entity and identifiers (the accurate ones) drive the projection write.
+    const indexer = opts.indexer ?? this.resolveDefaultIndexer(entity)
     const key = this.buildSideEffectKey(opts.action, identifiers)
     const existing = this.pendingSideEffects.get(key)
     if (existing) {
@@ -740,7 +806,11 @@ export class DefaultDataEngine implements DataEngine {
       existing.syncOrigin = opts.syncOrigin ?? null
       existing.actorUserId = opts.actorUserId ?? null
       if (opts.events) existing.events = opts.events as CrudEventsConfig<unknown>
+      // Explicit always wins, on the merge branch too: a second `events:`-only mark on the same
+      // key must not let the route default overwrite the `indexer:` an earlier mark installed,
+      // which would silently drop that handler's own `buildUpsertPayload`.
       if (opts.indexer) existing.indexer = opts.indexer as CrudIndexerConfig<unknown>
+      else if (!existing.indexer && indexer) existing.indexer = indexer
       this.pendingSideEffects.set(key, existing)
       return
     }
@@ -756,7 +826,7 @@ export class DefaultDataEngine implements DataEngine {
       actorUserId: opts.actorUserId ?? null,
     }
     if (opts.events) entry.events = opts.events as CrudEventsConfig<unknown>
-    if (opts.indexer) entry.indexer = opts.indexer as CrudIndexerConfig<unknown>
+    if (indexer) entry.indexer = indexer
     this.pendingSideEffects.set(key, entry)
   }
 
@@ -765,6 +835,9 @@ export class DefaultDataEngine implements DataEngine {
     const entries = Array.from(this.pendingSideEffects.values())
     this.pendingSideEffects.clear()
     for (const entry of entries) {
+      if (entry.indexer && !suppress?.skipReindex && this.matchesDefaultEntityClass(entry.entity)) {
+        this.indexedDefaultEntityClass = true
+      }
       try {
         await this.emitOrmEntityEvent({
           action: entry.action,

package/src/lib/email/__tests__/send.test.ts

@@ -2,32 +2,25 @@ import React from 'react'
 import { mkdtemp, readFile, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
+import { isEmailDeliveryConfigured } from '../config'
 import { sendEmail } from '../send'
-
-var sendMock: jest.Mock
-var ResendMock: jest.Mock
-
-jest.mock('resend', () => {
-  sendMock = jest.fn().mockResolvedValue({ data: { id: 'email-1' } })
-  ResendMock = jest.fn().mockImplementation(() => ({
-    emails: { send: sendMock },
-  }))
-
-  return { Resend: ResendMock }
-})
+import {
+  clearRegisteredEmailTransportForTests,
+  registerEmailTransport,
+} from '../transport'
 
 describe('sendEmail', () => {
   const originalEnv = process.env
+  let sendMock: jest.Mock
   let tempDir: string | null = null
 
   beforeEach(() => {
     process.env = {
       ...originalEnv,
-      RESEND_API_KEY: 'test-key',
       EMAIL_FROM: 'from@example.com',
     }
-    sendMock.mockClear()
-    ResendMock.mockClear()
+    sendMock = jest.fn().mockResolvedValue(undefined)
+    clearRegisteredEmailTransportForTests()
   })
 
   afterEach(async () => {
@@ -36,79 +29,99 @@ describe('sendEmail', () => {
       tempDir = null
     }
     process.env = originalEnv
+    clearRegisteredEmailTransportForTests()
   })
 
-  it('maps replyTo to reply_to in Resend payload', async () => {
+  it('delegates normalized payloads to the registered transport', async () => {
+    registerEmailTransport({ id: 'test', send: sendMock })
+
     await sendEmail({
       to: 'user@example.com',
       subject: 'Hello',
       react: React.createElement('div', null, 'Hi'),
       replyTo: 'reply@example.com',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      attachments: [
+        {
+          filename: 'invoice.pdf',
+          content: 'dGVzdA==',
+          contentType: 'application/pdf',
+        },
+      ],
     })
 
-    expect(ResendMock).toHaveBeenCalledWith('test-key')
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        to: 'user@example.com',
-        subject: 'Hello',
-        from: 'from@example.com',
-        reply_to: 'reply@example.com',
-      })
-    )
+    expect(sendMock).toHaveBeenCalledWith({
+      to: 'user@example.com',
+      subject: 'Hello',
+      from: 'from@example.com',
+      fromIsInstanceDefault: true,
+      react: expect.any(Object),
+      html: undefined,
+      text: undefined,
+      replyTo: 'reply@example.com',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      attachments: [
+        {
+          filename: 'invoice.pdf',
+          content: 'dGVzdA==',
+          contentType: 'application/pdf',
+        },
+      ],
+    })
   })
 
-  it('omits reply_to when replyTo is not provided', async () => {
+  it('delegates html and text bodies without provider-specific rendering', async () => {
+    registerEmailTransport({ id: 'test', send: sendMock })
+
     await sendEmail({
       to: 'user@example.com',
       subject: 'Hello',
-      react: React.createElement('div', null, 'Hi'),
+      html: '<p>Hello</p>',
+      text: 'Hello',
     })
 
-    const payload = sendMock.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(payload).toBeDefined()
-    expect(payload.reply_to).toBeUndefined()
+    expect(sendMock).toHaveBeenCalledWith(expect.objectContaining({
+      html: '<p>Hello</p>',
+      text: 'Hello',
+    }))
   })
 
-  it('passes attachments to Resend payload when provided', async () => {
+  it('marks an inherited sender so transports can prefer a tenant-configured one', async () => {
+    registerEmailTransport({ id: 'test', send: sendMock })
+
     await sendEmail({
       to: 'user@example.com',
       subject: 'Hello',
       react: React.createElement('div', null, 'Hi'),
-      attachments: [
-        {
-          filename: 'invoice.pdf',
-          content: 'dGVzdA==',
-          contentType: 'application/pdf',
-        },
-      ],
     })
 
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        attachments: [
-          {
-            filename: 'invoice.pdf',
-            content: 'dGVzdA==',
-            contentType: 'application/pdf',
-          },
-        ],
-      })
-    )
+    expect(sendMock).toHaveBeenCalledWith(expect.objectContaining({
+      fromIsInstanceDefault: true,
+    }))
   })
 
-  it('throws when Resend returns an error', async () => {
-    sendMock.mockResolvedValueOnce({ error: { message: 'invalid domain' } })
+  it('does not mark a sender the caller passed explicitly', async () => {
+    registerEmailTransport({ id: 'test', send: sendMock })
 
-    await expect(sendEmail({
+    await sendEmail({
       to: 'user@example.com',
       subject: 'Hello',
+      from: 'chosen@example.com',
       react: React.createElement('div', null, 'Hi'),
-    })).rejects.toThrow('RESEND_SEND_FAILED: invalid domain')
+    })
+
+    expect(sendMock).toHaveBeenCalledWith(expect.objectContaining({
+      from: 'chosen@example.com',
+      fromIsInstanceDefault: false,
+    }))
   })
 
   it('falls back to NOTIFICATIONS_EMAIL_FROM when EMAIL_FROM is not set', async () => {
     delete process.env.EMAIL_FROM
     process.env.NOTIFICATIONS_EMAIL_FROM = 'notifications@example.com'
+    registerEmailTransport({ id: 'test', send: sendMock })
 
     await sendEmail({
       to: 'user@example.com',
@@ -116,17 +129,16 @@ describe('sendEmail', () => {
       react: React.createElement('div', null, 'Hi'),
     })
 
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        from: 'notifications@example.com',
-      })
-    )
+    expect(sendMock).toHaveBeenCalledWith(expect.objectContaining({
+      from: 'notifications@example.com',
+    }))
   })
 
   it('falls back to ADMIN_EMAIL when sender-specific env vars are not set', async () => {
     delete process.env.EMAIL_FROM
     delete process.env.NOTIFICATIONS_EMAIL_FROM
     process.env.ADMIN_EMAIL = 'admin@example.com'
+    registerEmailTransport({ id: 'test', send: sendMock })
 
     await sendEmail({
       to: 'user@example.com',
@@ -134,17 +146,16 @@ describe('sendEmail', () => {
       react: React.createElement('div', null, 'Hi'),
     })
 
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        from: 'admin@example.com',
-      })
-    )
+    expect(sendMock).toHaveBeenCalledWith(expect.objectContaining({
+      from: 'admin@example.com',
+    }))
   })
 
   it('throws a clear error when no sender address is configured', async () => {
     delete process.env.EMAIL_FROM
     delete process.env.NOTIFICATIONS_EMAIL_FROM
     delete process.env.ADMIN_EMAIL
+    registerEmailTransport({ id: 'test', send: sendMock })
 
     await expect(sendEmail({
       to: 'user@example.com',
@@ -153,9 +164,17 @@ describe('sendEmail', () => {
     })).rejects.toThrow('EMAIL_FROM_NOT_CONFIGURED')
   })
 
-  it('skips external delivery in test mode when email delivery is disabled', async () => {
-    process.env.OM_DISABLE_EMAIL_DELIVERY = '1'
-    delete process.env.RESEND_API_KEY
+  it('throws a clear error when no transport is registered', async () => {
+    await expect(sendEmail({
+      to: 'user@example.com',
+      subject: 'Hello',
+      react: React.createElement('div', null, 'Hi'),
+    })).rejects.toThrow('EMAIL_TRANSPORT_NOT_CONFIGURED')
+  })
+
+  it('skips transport delivery when email delivery is disabled', async () => {
+    process.env.OM_DISABLE_EMAIL_DELIVERY = 'yes'
+    registerEmailTransport({ id: 'test', send: sendMock })
 
     await sendEmail({
       to: 'user@example.com',
@@ -163,16 +182,59 @@ describe('sendEmail', () => {
       react: React.createElement('div', null, 'Hi'),
     })
 
-    expect(ResendMock).not.toHaveBeenCalled()
     expect(sendMock).not.toHaveBeenCalled()
   })
 
+  it('keeps the established boolean tokens for test-mode delivery suppression', async () => {
+    process.env.OM_TEST_MODE = 'on'
+    registerEmailTransport({ id: 'test', send: sendMock })
+
+    await sendEmail({
+      to: 'user@example.com',
+      subject: 'Hello',
+      react: React.createElement('div', null, 'Hi'),
+    })
+
+    expect(sendMock).not.toHaveBeenCalled()
+  })
+
+  it('does not let OM_DISABLE_EMAIL_DELIVERY=0 override test-mode delivery suppression', async () => {
+    process.env.OM_TEST_MODE = '1'
+    process.env.OM_DISABLE_EMAIL_DELIVERY = '0'
+    registerEmailTransport({ id: 'test', send: sendMock })
+
+    await sendEmail({
+      to: 'user@example.com',
+      subject: 'Hello',
+      react: React.createElement('div', null, 'Hi'),
+    })
+
+    expect(sendMock).not.toHaveBeenCalled()
+  })
+
+  it('allows test-mode delivery only for the explicitly enabled capture adapter', async () => {
+    process.env.OM_TEST_MODE = '1'
+    process.env.OM_DISABLE_EMAIL_DELIVERY = '0'
+    process.env.OM_ENABLE_TEST_CHANNEL_SEEDING = 'true'
+    process.env.OM_ENABLE_TEST_EMAIL_CAPTURE_DELIVERY = 'true'
+    process.env.SYSTEM_EMAIL_PROVIDER = '__test_seed__'
+    registerEmailTransport({ id: 'test', send: sendMock })
+
+    await sendEmail({
+      to: 'user@example.com',
+      subject: 'Hello',
+      react: React.createElement('div', null, 'Hi'),
+    })
+
+    expect(sendMock).toHaveBeenCalledTimes(1)
+  })
+
   it('captures email links in OM_TEST_MODE without external delivery', async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'om-email-capture-'))
     const capturePath = join(tempDir, 'emails.jsonl')
     process.env.OM_TEST_MODE = '1'
     process.env.OM_TEST_EMAIL_CAPTURE_PATH = capturePath
-    delete process.env.RESEND_API_KEY
+    registerEmailTransport({ id: 'test', send: sendMock })
 
     await sendEmail({
       to: 'user@example.com',
@@ -191,7 +253,16 @@ describe('sendEmail', () => {
       links: ['https://example.com/portal/invite?token=raw'],
       text: 'Accept your invite Accept',
     }))
-    expect(ResendMock).not.toHaveBeenCalled()
     expect(sendMock).not.toHaveBeenCalled()
   })
+
+  it('reports configured only when a sender and configured transport are present', () => {
+    expect(isEmailDeliveryConfigured()).toBe(false)
+
+    registerEmailTransport({ id: 'test', send: sendMock, isConfigured: () => false })
+    expect(isEmailDeliveryConfigured()).toBe(false)
+
+    registerEmailTransport({ id: 'test', send: sendMock, isConfigured: () => true })
+    expect(isEmailDeliveryConfigured()).toBe(true)
+  })
 })

package/src/lib/email/config.ts

@@ -1,4 +1,7 @@
-function normalizeEnvString(value: string | null | undefined): string | undefined {
+import { parseBooleanWithDefault } from '../boolean'
+import { getRegisteredEmailTransport } from './transport'
+
+export function normalizeEnvString(value: string | null | undefined): string | undefined {
   if (typeof value !== 'string') return undefined
   const trimmed = value.trim()
   return trimmed.length > 0 ? trimmed : undefined
@@ -11,3 +14,25 @@ export function resolveDefaultEmailFromAddress(): string | undefined {
     normalizeEnvString(process.env.ADMIN_EMAIL)
   )
 }
+
+export function isEmailDeliveryDisabled(): boolean {
+  const explicitlyDisabled = parseBooleanWithDefault(process.env.OM_DISABLE_EMAIL_DELIVERY, false)
+  if (explicitlyDisabled) return true
+
+  const testMode = parseBooleanWithDefault(process.env.OM_TEST_MODE, false)
+  if (!testMode) return false
+
+  const testCaptureDeliveryEnabled =
+    process.env.SYSTEM_EMAIL_PROVIDER === '__test_seed__'
+    && parseBooleanWithDefault(process.env.OM_ENABLE_TEST_CHANNEL_SEEDING, false)
+    && parseBooleanWithDefault(process.env.OM_ENABLE_TEST_EMAIL_CAPTURE_DELIVERY, false)
+  return !testCaptureDeliveryEnabled
+}
+
+export function isEmailDeliveryConfigured(): boolean {
+  if (isEmailDeliveryDisabled()) return false
+  if (!resolveDefaultEmailFromAddress()) return false
+  const transport = getRegisteredEmailTransport()
+  if (!transport) return false
+  return transport.isConfigured ? transport.isConfigured() : true
+}

package/src/lib/email/send.ts

@@ -1,22 +1,51 @@
-import { Resend } from 'resend'
 import React from 'react'
 import { appendFile, mkdir } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { parseBooleanWithDefault } from '../boolean'
-import { resolveDefaultEmailFromAddress } from './config'
+import {
+  isEmailDeliveryDisabled,
+  resolveDefaultEmailFromAddress,
+} from './config'
+import { getRegisteredEmailTransport } from './transport'
+
+export type EmailAttachment = {
+  filename: string
+  content: string
+  contentType?: string
+}
 
 export type SendEmailOptions = {
   to: string
   subject: string
-  react: React.ReactElement
+  react?: React.ReactElement
+  html?: string
+  text?: string
   from?: string
   replyTo?: string
-  attachments?: Array<{
-    filename: string
-    content: string
-    contentType?: string
-  }>
+  attachments?: EmailAttachment[]
+  tenantId?: string
+  organizationId?: string | null
+}
+
+export type ResolvedEmailPayload = {
+  to: string
+  subject: string
+  react?: React.ReactElement
+  html?: string
+  text?: string
+  from: string
+  /**
+   * True when `from` was filled in from the instance-wide environment defaults rather than chosen by
+   * the caller. Transports use this to decide whether a tenant's own configured sender may take
+   * precedence: `from` is never empty by the time it reaches a transport, so without this flag a
+   * per-tenant sender is unreachable. Absent means "caller chose it" for older transports.
+   */
+  fromIsInstanceDefault?: boolean
+  replyTo?: string
+  attachments?: EmailAttachment[]
+  tenantId?: string
+  organizationId?: string | null
 }
 
 type CapturedEmail = {
@@ -92,38 +121,31 @@ async function captureEmailForTests(options: SendEmailOptions): Promise<void> {
   await appendFile(capturePath, `${JSON.stringify(record)}\n`, 'utf8')
 }
 
-export async function sendEmail({ to, subject, react, from, replyTo, attachments }: SendEmailOptions) {
-  const emailDisabled =
-    parseBooleanWithDefault(process.env.OM_DISABLE_EMAIL_DELIVERY, false) ||
-    parseBooleanWithDefault(process.env.OM_TEST_MODE, false)
-
-  await captureEmailForTests({ to, subject, react, from, replyTo, attachments })
+export async function sendEmail(options: SendEmailOptions): Promise<void> {
+  await captureEmailForTests(options)
+  if (isEmailDeliveryDisabled()) return
 
-  if (emailDisabled) return
-
-  const apiKey = process.env.RESEND_API_KEY
-  if (!apiKey) throw new Error('RESEND_API_KEY is not set')
-  const resend = new Resend(apiKey)
-  const fromAddr = from || resolveDefaultEmailFromAddress()
+  const fromAddr = options.from || resolveDefaultEmailFromAddress()
   if (!fromAddr) {
     throw new Error('EMAIL_FROM_NOT_CONFIGURED: set NOTIFICATIONS_EMAIL_FROM, EMAIL_FROM, or ADMIN_EMAIL')
   }
-  const payload = {
-    to,
-    subject,
-    from: fromAddr,
-    react,
-    ...(replyTo ? { reply_to: replyTo } : {}),
-    ...(attachments?.length ? { attachments } : {}),
-  }
-  const result = await resend.emails.send(payload)
-  const errorMessage =
-    typeof (result as any)?.error === 'string'
-      ? (result as any).error
-      : typeof (result as any)?.error?.message === 'string'
-        ? (result as any).error.message
-        : null
-  if (errorMessage) {
-    throw new Error(`RESEND_SEND_FAILED: ${errorMessage}`)
+
+  const transport = getRegisteredEmailTransport()
+  if (!transport) {
+    throw new Error('EMAIL_TRANSPORT_NOT_CONFIGURED: enable an outbound email provider module')
   }
+
+  await transport.send({
+    to: options.to,
+    subject: options.subject,
+    react: options.react,
+    html: options.html,
+    text: options.text,
+    from: fromAddr,
+    fromIsInstanceDefault: !options.from,
+    replyTo: options.replyTo,
+    attachments: options.attachments,
+    tenantId: options.tenantId,
+    organizationId: options.organizationId,
+  })
 }

package/src/lib/email/transport.ts

@@ -0,0 +1,29 @@
+import type { ResolvedEmailPayload } from './send'
+
+export type EmailTransport = {
+  id: string
+  send: (payload: ResolvedEmailPayload) => Promise<void>
+  isConfigured?: () => boolean
+}
+
+const EMAIL_TRANSPORT_REGISTRY = Symbol.for('open-mercato.email.transport')
+
+type EmailTransportRegistryGlobal = typeof globalThis & {
+  [EMAIL_TRANSPORT_REGISTRY]?: EmailTransport | null
+}
+
+function emailTransportRoot(): EmailTransportRegistryGlobal {
+  return globalThis as EmailTransportRegistryGlobal
+}
+
+export function registerEmailTransport(transport: EmailTransport): void {
+  emailTransportRoot()[EMAIL_TRANSPORT_REGISTRY] = transport
+}
+
+export function getRegisteredEmailTransport(): EmailTransport | null {
+  return emailTransportRoot()[EMAIL_TRANSPORT_REGISTRY] ?? null
+}
+
+export function clearRegisteredEmailTransportForTests(): void {
+  emailTransportRoot()[EMAIL_TRANSPORT_REGISTRY] = null
+}