better-ship 0.4.1 → 0.6.0

package/src/infrastructure/tanstack/auth.middleware.ts

@@ -0,0 +1,89 @@
+import { createMiddleware, type Register, type RequestServerOptions } from '@tanstack/react-start'
+import { getRequestHeaders } from '@tanstack/react-start/server'
+import { getSessionCookie } from 'better-auth/cookies'
+
+import { AuthenticationError, StaleSessionError, createLogger } from '@/core'
+
+const logger = createLogger('auth-middleware')
+
+/** The fields middleware reads; generic callers retain every additional session and user field. */
+export type AuthSession = {
+  readonly user: { readonly id: string }
+  readonly session: { readonly id: string }
+}
+
+/** Authenticated context retains the application's complete user and session types. */
+export type RequiredAuthContext<Session extends AuthSession> = {
+  readonly user: Session['user']
+  readonly session: Session['session']
+}
+
+/** Optional authentication supplies both fields together or neither field. */
+export type AuthContext<Session extends AuthSession> =
+  | RequiredAuthContext<Session>
+  | {
+      readonly user: undefined
+      readonly session: undefined
+    }
+
+/** Select the current request's Better Auth instance from TanStack's registered context. */
+export type AuthMiddlewareOptions<Session extends AuthSession> = {
+  readonly getAuth: (context: RequestServerOptions<Register, undefined>['context']) => {
+    readonly api: {
+      readonly getSession: (options: { headers: Headers }) => Promise<Session | null>
+    }
+  }
+}
+
+/**
+ * Preserve Porte's function and request middleware contracts with application-owned services.
+ * Optional lookup failures log once and continue as guests. Required lookup failures propagate.
+ */
+export function createAuthMiddleware<Session extends AuthSession>(
+  options: AuthMiddlewareOptions<Session>,
+) {
+  const extractAuth = createMiddleware({ type: 'function' }).server<AuthContext<Session>>(
+    async ({ next, context }) => {
+      let resolved: Session | null
+      try {
+        resolved = await options.getAuth(context).api.getSession({ headers: getRequestHeaders() })
+      } catch (error) {
+        logger.error('get_session_failed', { error })
+        resolved = null
+      }
+      if (resolved === null)
+        return next<AuthContext<Session>>({ context: { user: undefined, session: undefined } })
+      return next<AuthContext<Session>>({
+        context: { user: resolved.user, session: resolved.session },
+      })
+    },
+  )
+
+  async function resolveRequiredSession(
+    context: RequestServerOptions<Register, undefined>['context'],
+    headers: Headers,
+  ): Promise<Session> {
+    const resolved = await options.getAuth(context).api.getSession({ headers })
+    if (resolved === null) {
+      if (getSessionCookie(headers)) throw new StaleSessionError()
+      throw new AuthenticationError()
+    }
+    return resolved
+  }
+
+  const requireAuth = createMiddleware({ type: 'function' }).server(async ({ next, context }) => {
+    const resolved = await resolveRequiredSession(context, getRequestHeaders())
+    return next<RequiredAuthContext<Session>>({
+      context: { user: resolved.user, session: resolved.session },
+    })
+  })
+  const requireAuthRequest = createMiddleware({ type: 'request' }).server(
+    async ({ request, next, context }) => {
+      const resolved = await resolveRequiredSession(context, request.headers)
+      return next<RequiredAuthContext<Session>>({
+        context: { user: resolved.user, session: resolved.session },
+      })
+    },
+  )
+  return { extractAuth, requireAuth, requireAuthRequest }
+}

package/src/infrastructure/tanstack/error.middleware.ts

@@ -0,0 +1,81 @@
+import { isNotFound, isRedirect, type AnyRedirect } from '@tanstack/react-router'
+import { createMiddleware, type Register, type RequestServerOptions } from '@tanstack/react-start'
+import type { BetterAuthCookies } from 'better-auth'
+
+import { StaleSessionError, type ErrorTable } from '@/core'
+
+import { createHttpErrorResponseConverter } from './http-error-response.ts'
+import { clearStaleSessionCookies } from './session-cookies.ts'
+import { createErrorPayloadConverter } from './to-error-payload.ts'
+
+type RequestContext = RequestServerOptions<Register, undefined>['context']
+
+/** The part of a Better Auth instance the boundary reads: its computed cookie definitions. */
+export type AuthCookieSource = {
+  readonly $context: Promise<{ readonly authCookies: BetterAuthCookies }>
+}
+
+/** The application's error table, its stale-session redirect, and its Better Auth instance. */
+export type ErrorMiddlewareOptions<Entries> = {
+  readonly errors: ErrorTable<Entries>
+  /** Build the redirect a server function throws for a stale session. */
+  readonly signIn: () => AnyRedirect
+  /** Select the request's Better Auth instance; its cookie definitions say what to clear. */
+  readonly getAuth: (context: RequestContext) => AuthCookieSource
+}
+
+/**
+ * Build both transport boundaries from one error table.
+ * Register `functionErrorMiddleware` globally. Put `routeErrorMiddleware` first in an API route's `server.middleware`.
+ */
+export function createErrorMiddleware<Entries>(options: ErrorMiddlewareOptions<Entries>) {
+  const toErrorPayload = createErrorPayloadConverter(options.errors)
+  const toHttpErrorResponse = createHttpErrorResponseConverter(options.errors)
+
+  async function clearSession(context: RequestContext): Promise<void> {
+    const { authCookies } = await options.getAuth(context).$context
+    clearStaleSessionCookies(authCookies)
+  }
+
+  async function handleFunctionError(cause: unknown, context: RequestContext): Promise<never> {
+    // oxlint-disable-next-line typescript/only-throw-error -- TanStack uses throwable control-flow objects.
+    if (isNotFound(cause) || isRedirect(cause)) throw cause
+    if (cause instanceof StaleSessionError) {
+      await clearSession(context)
+      // oxlint-disable-next-line typescript/only-throw-error -- Router redirects by throwing this.
+      throw options.signIn()
+    }
+    // oxlint-disable-next-line typescript/only-throw-error -- The client rejects with this and reads its tag.
+    throw toErrorPayload(cause)
+  }
+
+  // A route answers 401 instead of a redirect because fetch would follow it into the HTML shell.
+  async function handleRouteError(cause: unknown, context: RequestContext): Promise<Response> {
+    // oxlint-disable-next-line typescript/only-throw-error -- TanStack uses throwable control-flow objects.
+    if (isNotFound(cause) || isRedirect(cause)) throw cause
+    if (cause instanceof StaleSessionError) await clearSession(context)
+    return toHttpErrorResponse(cause)
+  }
+
+  const functionErrorMiddleware = createMiddleware({ type: 'function' }).server(
+    async ({ next, context }) => {
+      try {
+        return await next()
+      } catch (cause) {
+        return handleFunctionError(cause, context)
+      }
+    },
+  )
+
+  const routeErrorMiddleware = createMiddleware({ type: 'request' }).server(
+    async ({ next, context }) => {
+      try {
+        return await next()
+      } catch (cause) {
+        return handleRouteError(cause, context)
+      }
+    },
+  )
+
+  return { functionErrorMiddleware, routeErrorMiddleware, toErrorPayload, toHttpErrorResponse }
+}

package/src/infrastructure/tanstack/http-error-response.ts

@@ -0,0 +1,30 @@
+import { getReasonPhrase } from 'http-status-codes'
+import { z } from 'zod'
+
+import type { ErrorTable, ProblemDetails } from '@/core'
+
+import { resolveFailure } from './resolve-failure.ts'
+
+// A known delay becomes the header; a null delay sends no header.
+const RetryAfterSchema = z.object({ retryAfter: z.number() })
+
+/**
+ * Build the API route converter for one error table.
+ * The body is RFC 9457 problem details; public fields become extension members.
+ */
+export function createHttpErrorResponseConverter<Entries>(table: ErrorTable<Entries>) {
+  return function toHttpErrorResponse(cause: unknown): Response {
+    const { status, payload } = resolveFailure(table, cause)
+    const { _tag, message, ...fields } = payload
+    const body: ProblemDetails = {
+      type: 'about:blank',
+      title: getReasonPhrase(status),
+      detail: message,
+      ...fields,
+    }
+    const headers = new Headers({ 'Content-Type': 'application/problem+json' })
+    const retry = RetryAfterSchema.safeParse(payload)
+    if (retry.success) headers.set('Retry-After', String(retry.data.retryAfter))
+    return Response.json(body, { status, headers })
+  }
+}

package/src/infrastructure/tanstack/index.ts

@@ -0,0 +1,13 @@
+export {
+  createAuthMiddleware,
+  type AuthSession,
+  type AuthContext,
+  type RequiredAuthContext,
+  type AuthMiddlewareOptions,
+} from './auth.middleware.ts'
+export {
+  createErrorMiddleware,
+  type AuthCookieSource,
+  type ErrorMiddlewareOptions,
+} from './error.middleware.ts'
+export { getLastUsedLoginMethod } from './last-login-method.ts'

package/src/infrastructure/tanstack/last-login-method.ts

@@ -0,0 +1,13 @@
+import { getRequestHeaders } from '@tanstack/react-start/server'
+import { parseCookies } from 'better-auth/cookies'
+
+// Better Auth keeps the plugin default private; this is the value LastLoginMethodOptions.cookieName documents.
+const DEFAULT_COOKIE_NAME = 'better-auth.last_used_login_method'
+
+/**
+ * Read the method this browser last signed in with from the current request, for the sign-in loader on the server.
+ * Pass `cookieName` only when `integrations.lastLoginMethod.cookieName` is set. Returns `null` when the cookie is absent.
+ */
+export function getLastUsedLoginMethod(cookieName = DEFAULT_COOKIE_NAME): string | null {
+  return parseCookies(getRequestHeaders().get('cookie') ?? '').get(cookieName) ?? null
+}

package/src/infrastructure/tanstack/resolve-failure.ts

@@ -0,0 +1,24 @@
+import { AppError, createLogger, type ErrorTable, type ResolvedError } from '@/core'
+import type { ErrorPayloadOf } from '@/core'
+
+const logger = createLogger('error-boundary')
+
+/**
+ * Resolve one failure through the table or fall back to the generic replacement, and log it once.
+ * Both transport converters call this, so one rule decides the log level: mapped is a warning, unmapped is an error with the cause.
+ */
+export function resolveFailure<Entries>(
+  table: ErrorTable<Entries>,
+  cause: unknown,
+): ResolvedError<ErrorPayloadOf<ErrorTable<Entries>>> {
+  const resolved = table.resolve(cause)
+  if (resolved !== null) {
+    logger.warn('handled_error', {
+      details: { tag: resolved.payload._tag, status: resolved.status },
+    })
+    return resolved
+  }
+  const classification = cause instanceof AppError ? cause.classification : 'unknown'
+  logger.error('unexpected_error', { error: cause, details: { classification } })
+  return table.fallback(cause)
+}

package/src/infrastructure/tanstack/session-cookies.ts

@@ -0,0 +1,36 @@
+import { deleteCookie, getRequestHeaders } from '@tanstack/react-start/server'
+import type { BetterAuthCookies } from 'better-auth'
+import { parseCookies } from 'better-auth/cookies'
+
+type AuthCookie = BetterAuthCookies['sessionToken']
+type DeleteCookieOptions = NonNullable<Parameters<typeof deleteCookie>[1]>
+
+/**
+ * Delete the session, session cache, account cache, and remember-me cookies of one instance.
+ * Chunks present on the request go too. Names and attributes come from the instance, so custom prefixes and domain cookies clear.
+ */
+export function clearStaleSessionCookies(cookies: BetterAuthCookies): void {
+  const present = [...parseCookies(getRequestHeaders().get('cookie') ?? '').keys()]
+  const definitions = [
+    cookies.sessionToken,
+    cookies.sessionData,
+    cookies.accountData,
+    cookies.dontRememberToken,
+  ]
+  for (const cookie of definitions) {
+    // Better Auth names a chunk `${name}.${index}`, so a missed chunk would resurrect the value.
+    const chunks = present.filter((name) => name.startsWith(`${cookie.name}.`))
+    for (const name of new Set([cookie.name, ...chunks]))
+      deleteCookie(name, deletionOf(cookie.attributes))
+  }
+}
+
+function deletionOf(attributes: AuthCookie['attributes']): DeleteCookieOptions {
+  // Better Auth sets `/` and the secure flag at runtime; the types leave both optional.
+  const options: DeleteCookieOptions = {
+    path: attributes.path ?? '/',
+    secure: attributes.secure ?? false,
+  }
+  if (attributes.domain !== undefined) options.domain = attributes.domain
+  return options
+}

package/src/infrastructure/tanstack/to-error-payload.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod'
+
+import { ValidationError, type ErrorPayloadOf, type ErrorTable } from '@/core'
+
+import { resolveFailure } from './resolve-failure.ts'
+
+// TanStack serializes a validator's issues into `Error.message` as JSON.
+const SerializedIssuesSchema = z
+  .array(z.object({ message: z.string(), path: z.array(z.union([z.string(), z.number()])) }))
+  .min(1)
+
+function reconstructValidationError(cause: unknown): ValidationError | null {
+  if (!(cause instanceof Error)) return null
+  let message: unknown
+  try {
+    message = JSON.parse(cause.message)
+  } catch {
+    return null
+  }
+  const parsed = SerializedIssuesSchema.safeParse(message)
+  return parsed.success ? ValidationError.fromIssues(parsed.data) : null
+}
+
+/**
+ * Build the server-function converter for one error table.
+ * The result is a plain object, because only own data survives serialization.
+ */
+export function createErrorPayloadConverter<Entries>(table: ErrorTable<Entries>) {
+  return function toErrorPayload(cause: unknown): ErrorPayloadOf<ErrorTable<Entries>> {
+    return resolveFailure(table, reconstructValidationError(cause) ?? cause).payload
+  }
+}

package/src/infrastructure/unit-of-work-context.ts

@@ -3,9 +3,10 @@ import { AsyncLocalStorage } from 'node:async_hooks'
 import { panic } from 'better-result'
 import type { BatchItem } from 'drizzle-orm/batch'
 
-import { UnitOfWorkAlreadyActiveError, type Event, type IEventCollector } from '@/application'
+import { UnitOfWorkAlreadyActiveError, type IEventCollector } from '@/application'
+import type { DomainEvent } from '@/core'
 
-type UnitOfWorkContext = { readonly events: Event[] } & (
+type UnitOfWorkContext = { readonly events: DomainEvent[] } & (
   | { readonly database: 'd1'; readonly statements: BatchItem<'sqlite'>[] }
   | { readonly database: 'postgres' }
 )

package/dist/application-rpZoTfzU.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"application-rpZoTfzU.js","names":[],"sources":["../src/application/message-already-processed.error.ts","../src/application/message-bus.ts","../src/application/unit-of-work.ts","../src/application/unit-of-work.errors.ts"],"sourcesContent":["import { AppError, DatabaseError } from '@/core'\n\nimport type { MessageId } from './messages.ts'\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 { createLogger, unreachable } from '@/core'\n\nimport { MessageAlreadyProcessedError } from './message-already-processed.error.ts'\nimport type { Command, Event, Message, Query } from './messages.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 Message & 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 Message & 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: Message): 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: Command): 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: Query): 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: Event): 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 type { IEventCollector } from './event-collector.ts'\nimport { MessageAlreadyProcessedError } from './message-already-processed.error.ts'\nimport type { IMessageStore } from './message-store.ts'\nimport type { MessageId } from './messages.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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"}

package/dist/core-MjwyZJ4i.js

@@ -1,302 +0,0 @@
-import { panic } from "better-result";
-
-//#region src/core/app-error.ts
-/**
-* The base of every expected failure. A subclass declares its tag and its classification,
-* so no boundary has to guess what kind of failure it holds. A boundary tells our errors from
-* raw throws with `instanceof AppError`; a value that fails it was never judged.
-*
-* A `readonly` field with a literal initializer keeps the literal type, so
-* `readonly _tag = 'StoreUnavailable'` is enough for `Result` unions and `matchError`.
-*/
-var AppError = class extends Error {
-	get name() {
-		return this._tag;
-	}
-};
-
-//#endregion
-//#region src/core/database.error.ts
-/** Classification describes the failure; callers must separately establish whether repetition is safe. */
-var DatabaseError = class extends AppError {
-	operation;
-	classification;
-	details;
-	_tag = "DatabaseError";
-	constructor(operation, classification, details, options) {
-		super(`Database operation failed: ${operation}`, options);
-		this.operation = operation;
-		this.classification = classification;
-		this.details = details;
-	}
-};
-
-//#endregion
-//#region src/core/defects.ts
-/**
-* Mark a line the types say cannot run. A union member without a branch stops compilation here.
-*
-* @throws Panic when a value outside the union arrives at runtime.
-*/
-function unreachable(value) {
-	return panic(`Unreachable: ${String(value)}`);
-}
-/**
-* Mark a body that is not written yet. A defect, not an expected failure.
-*
-* @param what - The behavior the body will provide, such as `invoice export`.
-* @throws Panic always.
-*/
-function notImplemented(what) {
-	return panic(`Not implemented: ${what}`);
-}
-
-//#endregion
-//#region src/core/failure-classification.ts
-/** Decide whether one retry owner may repeat a failed operation. */
-function shouldRetryFailure(args) {
-	if (!args.repeatSafe) return false;
-	if (args.classification === "transient") return true;
-	if (args.classification === "terminal") return false;
-	return args.owner === "durable";
-}
-
-//#endregion
-//#region src/core/transport-classification.ts
-/**
-* Messages that the platform-neutral transports raise for a failure that may pass.
-*
-* A boundary that knows its own runtime adds its own patterns before these.
-*/
-const TRANSIENT_TRANSPORT_PATTERNS = [
-	/network/,
-	/fetch failed/,
-	/timeout/,
-	/timed?\s*out/,
-	/connection.*(lost|reset|refused|closed|aborted)/,
-	/econnreset/,
-	/econnrefused/,
-	/etimedout/,
-	/eai_again/
-];
-/** Cancellation is a decision, not a failure to repeat. */
-function isAbortError(cause) {
-	return cause instanceof Error && cause.name === "AbortError";
-}
-/** Match known transient transport messages while excluding explicit cancellation. */
-function isTransientTransportError(cause) {
-	if (!(cause instanceof Error) || isAbortError(cause)) return false;
-	const message = cause.message.toLowerCase();
-	return TRANSIENT_TRANSPORT_PATTERNS.some((pattern) => pattern.test(message));
-}
-
-//#endregion
-//#region src/core/logger.ts
-/**
-* The supported log severity levels, in ascending order.
-*
-* A const object, not an enum, so a parsed environment value typed `'INFO'` is a `LogLevel`.
-*/
-const LogLevel = {
-	DEBUG: "DEBUG",
-	INFO: "INFO",
-	WARN: "WARN",
-	ERROR: "ERROR"
-};
-const DEFAULT_SETTINGS = {
-	level: LogLevel.INFO,
-	format: "json"
-};
-let settings = DEFAULT_SETTINGS;
-/**
-* Set application settings, including for existing loggers. Per-logger overrides take priority.
-* Call at startup, never per request. An omitted field resets to INFO and JSON output.
-*/
-function configureLogger(config) {
-	settings = {
-		level: config.level ?? DEFAULT_SETTINGS.level,
-		format: config.format ?? DEFAULT_SETTINGS.format
-	};
-}
-let errorHook = null;
-/**
-* Register the function that receives each logged error.
-*
-* Set once at the process entry point. A later call replaces the earlier hook.
-*/
-function setLoggerErrorHook(fn) {
-	errorHook = fn;
-}
-const CONSOLE_METHOD = {
-	[LogLevel.DEBUG]: "debug",
-	[LogLevel.INFO]: "info",
-	[LogLevel.WARN]: "warn",
-	[LogLevel.ERROR]: "error"
-};
-const ESC = String.fromCharCode(27);
-const ANSI_RESET = `${ESC}[0m`;
-const ANSI_GRAY = `${ESC}[90m`;
-const ANSI_BLUE = `${ESC}[34m`;
-const LEVEL_ANSI = {
-	DEBUG: `${ESC}[2;36m`,
-	INFO: ANSI_BLUE,
-	WARN: `${ESC}[33m`,
-	ERROR: `${ESC}[1;31m`
-};
-function prettyLine(entry) {
-	const level = `[${entry.level}]`;
-	const module = `[${entry.module}]`;
-	if ("window" in globalThis) return `${entry.timestamp} ${level} ${module} ${entry.message}`;
-	return `${`${ANSI_GRAY}${entry.timestamp}${ANSI_RESET}`} ${`${LEVEL_ANSI[entry.level]}${level}${ANSI_RESET}`} ${`${ANSI_BLUE}${module}${ANSI_RESET}`} ${entry.message}`;
-}
-/**
-* JSON format writes the entry object. Pretty format writes one line, then the data,
-* the error, and the stack as separate console arguments.
-*/
-const consoleSink = (entry) => {
-	const write = console[CONSOLE_METHOD[entry.level]];
-	if (settings.format === "json") {
-		write(entry);
-		return;
-	}
-	const line = prettyLine(entry);
-	if (entry.error === void 0) {
-		write(line, ...entry.data);
-		return;
-	}
-	const { stack, ...error } = entry.error;
-	if (stack === void 0) write(line, ...entry.data, error);
-	else write(line, ...entry.data, error, `\n${stack}`);
-};
-let logSink = consoleSink;
-/**
-* Send every log entry somewhere other than `console`.
-*
-* Set once at the process entry point, never per module. A logger is created
-* by name and nothing else, so its destination is a fact about the process.
-*/
-function setLogSink(fn) {
-	logSink = fn;
-}
-const LOG_LEVELS = Object.values(LogLevel);
-const MAX_ERROR_DEPTH = 3;
-/**
-* Diagnostics worth keeping off an error, named one by one.
-*
-* An allowlist rather than every own property: an error raised by a library we
-* do not control may hang a request or a user payload off itself, and a log is
-* the wrong place to discover that. `_tag` and `classification` are what every `AppError`
-* declares. `remote` and the three flags after it are the ones workerd sets itself.
-*/
-const KEPT_ERROR_FIELDS = [
-	"_tag",
-	"classification",
-	"code",
-	"operation",
-	"status",
-	"statusCode",
-	"remote",
-	"retryable",
-	"overloaded",
-	"durableObjectReset"
-];
-const serializeError = (error, depth = 0) => {
-	if (depth > MAX_ERROR_DEPTH) return {
-		name: "Error",
-		message: "[error nesting truncated]"
-	};
-	const carrier = error;
-	const kept = KEPT_ERROR_FIELDS.filter((key) => carrier[key] !== void 0);
-	const serialized = {
-		name: error.name,
-		message: error.message
-	};
-	if (error.stack !== void 0) serialized.stack = error.stack;
-	if (kept.length > 0) serialized.fields = Object.fromEntries(kept.map((key) => [key, carrier[key]]));
-	if (error.cause instanceof Error) serialized.cause = serializeError(error.cause, depth + 1);
-	else if (error.cause !== void 0) serialized.cause = {
-		name: "Error",
-		message: "[non-error cause]"
-	};
-	if (error instanceof AggregateError) serialized.errors = error.errors.map((failure) => failure instanceof Error ? serializeError(failure, depth + 1) : {
-		name: "NonError",
-		message: "[non-error aggregate member]"
-	});
-	return serialized;
-};
-/** Write module-scoped logs with application defaults and optional overrides. */
-var Logger = class {
-	module;
-	config;
-	/** Create a logger for one module. */
-	constructor(module, overrideConfig) {
-		this.module = module;
-		this.config = { ...overrideConfig };
-	}
-	log(level, message, data, error) {
-		const threshold = this.config.level ?? settings.level;
-		if (threshold === "OFF") return;
-		if (LOG_LEVELS.indexOf(level) < LOG_LEVELS.indexOf(threshold)) return;
-		const entry = {
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			level,
-			module: this.module,
-			message,
-			data
-		};
-		logSink(error === void 0 ? entry : {
-			...entry,
-			error
-		});
-	}
-	/** Write a debug log. */
-	debug(message, ...values) {
-		this.log(LogLevel.DEBUG, message, values);
-	}
-	/** Write an information log. */
-	info(message, ...values) {
-		this.log(LogLevel.INFO, message, values);
-	}
-	/** Write a warning log. */
-	warn(message, ...values) {
-		this.log(LogLevel.WARN, message, values);
-	}
-	/**
-	* Write an error log and send the error to the configured hook.
-	*
-	* The details say which call this was, and the error says what went wrong
-	* inside it. The entry carries the details as data and the error beside them.
-	*/
-	error(message, context = {}) {
-		const details = context.details ?? {};
-		const thrown = context.error;
-		let error;
-		if (thrown instanceof Error) error = serializeError(thrown);
-		else if (thrown !== void 0) {
-			let json;
-			try {
-				json = JSON.stringify(thrown);
-			} catch {
-				json = "[non-serializable error]";
-			}
-			error = {
-				name: "NonError",
-				message: json
-			};
-		}
-		this.log(LogLevel.ERROR, message, context.details === void 0 ? [] : [details], error);
-		if (errorHook !== null && thrown !== void 0) errorHook({
-			error: thrown,
-			distinctId: context.userId,
-			context: details
-		});
-	}
-};
-/** Create a logger for one module. */
-function createLogger(module, config) {
-	return new Logger(module, config);
-}
-
-//#endregion
-export { createLogger as a, isAbortError as c, notImplemented as d, unreachable as f, consoleSink as i, isTransientTransportError as l, AppError as m, Logger as n, setLogSink as o, DatabaseError as p, configureLogger as r, setLoggerErrorHook as s, LogLevel as t, shouldRetryFailure as u };
-//# sourceMappingURL=core-MjwyZJ4i.js.map