better-ship 0.12.0 → 0.14.0

package/src/infrastructure/cloudflare/d1-outbox-repository.ts

@@ -0,0 +1,224 @@
+import { and, asc, eq, inArray, isNull, lt, lte, or, sql } from 'drizzle-orm'
+
+import type { DeadLetterReason, IOutboxRepository, OutboxClaim, OutboxMessage } from '@/application'
+import { exponentialDelayCapMs } from '@/core'
+
+import type { DrizzleSchema } from '../drizzle-schema.ts'
+import {
+  OUTBOX_REPOSITORY_DEFAULTS,
+  type OutboxRepositoryOptions,
+} from '../outbox-repository-options.ts'
+import { executeDatabase } from './d1-database-execution.ts'
+import type { D1Db } from './d1-database-types.ts'
+import { messageOutbox, processedMessages } from './d1-schema.ts'
+
+/**
+ * Typist's atomic D1 claims on a plain connection, outside a unit of work.
+ * Every write runs once; lease expiry and the scheduled sweep recover interrupted operations.
+ */
+export class D1OutboxRepository<Schema extends DrizzleSchema> implements IOutboxRepository {
+  private readonly options: Required<OutboxRepositoryOptions>
+
+  constructor(
+    private readonly db: D1Db<Schema>,
+    options: OutboxRepositoryOptions = {},
+    private readonly now: () => Date = () => new Date(),
+  ) {
+    this.options = { ...OUTBOX_REPOSITORY_DEFAULTS, ...options }
+  }
+
+  /** Lease due rows in one statement; increment attempts even when reclaiming an expired lease. */
+  async claimPending(batchSize: number): Promise<OutboxClaim> {
+    const token = crypto.randomUUID()
+    const now = this.now()
+    const rows = await executeDatabase('claim pending outbox messages', () =>
+      this.db
+        .update(messageOutbox)
+        .set({
+          claimToken: token,
+          claimExpiresAt: deadline(now.getTime() + this.options.leaseMs),
+          attempts: sql`${messageOutbox.attempts} + 1`,
+        })
+        .where(
+          inArray(
+            messageOutbox.id,
+            this.db
+              .select({ id: messageOutbox.id })
+              .from(messageOutbox)
+              .where(
+                and(
+                  isNull(messageOutbox.publishedAt),
+                  isNull(messageOutbox.failedAt),
+                  lte(messageOutbox.availableAt, now),
+                  or(isNull(messageOutbox.claimExpiresAt), lte(messageOutbox.claimExpiresAt, now)),
+                ),
+              )
+              .orderBy(
+                asc(messageOutbox.availableAt),
+                asc(messageOutbox.createdAt),
+                asc(messageOutbox.id),
+              )
+              .limit(batchSize),
+          ),
+        )
+        .returning({
+          payload: messageOutbox.payload,
+          attempts: messageOutbox.attempts,
+          availableAt: messageOutbox.availableAt,
+          createdAt: messageOutbox.createdAt,
+        }),
+    )
+    // UPDATE RETURNING does not preserve the selection order.
+    rows.sort(
+      (a, b) =>
+        a.availableAt.getTime() - b.availableAt.getTime() ||
+        a.createdAt.getTime() - b.createdAt.getTime() ||
+        a.payload.id.localeCompare(b.payload.id),
+    )
+    return { token, messages: rows.map(({ payload, attempts }) => ({ payload, attempts })) }
+  }
+
+  /** Mark only supplied rows that still hold this token as published. */
+  async markPublished(claim: OutboxClaim, messages: ReadonlyArray<OutboxMessage>): Promise<void> {
+    if (messages.length === 0) return
+    await executeDatabase('mark outbox messages published', () =>
+      this.db
+        .update(messageOutbox)
+        .set({ publishedAt: this.now(), claimToken: null, claimExpiresAt: null })
+        .where(
+          and(
+            inArray(messageOutbox.id, outboxIds(messages)),
+            eq(messageOutbox.claimToken, claim.token),
+          ),
+        ),
+    )
+  }
+
+  /** Release supplied rows with per-row backoff; a stale token cannot change a newer claim. */
+  async releaseClaim(claim: OutboxClaim, messages: ReadonlyArray<OutboxMessage>): Promise<void> {
+    const now = this.now()
+    for (const attempts of new Set(messages.map((row) => row.attempts))) {
+      const rows = messages.filter((row) => row.attempts === attempts)
+      const delay = exponentialDelayCapMs(
+        this.options.retryBaseDelayMs,
+        this.options.retryMaxDelayMs,
+        attempts,
+      )
+      // oxlint-disable-next-line no-await-in-loop -- Stop releasing rows on the first database failure.
+      await executeDatabase('release outbox claim', () =>
+        this.db
+          .update(messageOutbox)
+          .set({
+            availableAt: deadline(now.getTime() + delay),
+            claimToken: null,
+            claimExpiresAt: null,
+          })
+          .where(
+            and(
+              inArray(messageOutbox.id, outboxIds(rows)),
+              eq(messageOutbox.claimToken, claim.token),
+            ),
+          ),
+      )
+    }
+  }
+
+  /** Retain the full payload and record a closed reason with a readable error message. */
+  async deadLetter(
+    claim: OutboxClaim,
+    messages: ReadonlyArray<OutboxMessage>,
+    reason: DeadLetterReason,
+    errorMessage: string,
+  ): Promise<void> {
+    if (messages.length === 0) return
+    await executeDatabase('dead-letter outbox messages', () =>
+      this.db
+        .update(messageOutbox)
+        .set({
+          failedAt: this.now(),
+          lastError: `${reason}: ${errorMessage}`,
+          claimToken: null,
+          claimExpiresAt: null,
+        })
+        .where(
+          and(
+            inArray(messageOutbox.id, outboxIds(messages)),
+            eq(messageOutbox.claimToken, claim.token),
+          ),
+        ),
+    )
+  }
+
+  /** Delete at most batchSize published rows, strictly before the cutoff. */
+  async deletePublishedBefore(cutoff: Date, batchSize: number): Promise<number> {
+    const rows = await executeDatabase('delete published outbox messages', () =>
+      this.db
+        .delete(messageOutbox)
+        .where(
+          inArray(
+            messageOutbox.id,
+            this.db
+              .select({ id: messageOutbox.id })
+              .from(messageOutbox)
+              .where(lt(messageOutbox.publishedAt, cutoff))
+              .orderBy(asc(messageOutbox.publishedAt), asc(messageOutbox.id))
+              .limit(batchSize),
+          ),
+        )
+        .returning({ id: messageOutbox.id }),
+    )
+    return rows.length
+  }
+
+  /** Delete at most batchSize failed rows; pending and published rows remain untouched. */
+  async deleteFailedBefore(cutoff: Date, batchSize: number): Promise<number> {
+    const rows = await executeDatabase('delete failed outbox messages', () =>
+      this.db
+        .delete(messageOutbox)
+        .where(
+          inArray(
+            messageOutbox.id,
+            this.db
+              .select({ id: messageOutbox.id })
+              .from(messageOutbox)
+              .where(and(isNull(messageOutbox.publishedAt), lt(messageOutbox.failedAt, cutoff)))
+              .orderBy(asc(messageOutbox.failedAt), asc(messageOutbox.id))
+              .limit(batchSize),
+          ),
+        )
+        .returning({ id: messageOutbox.id }),
+    )
+    return rows.length
+  }
+
+  /** Delete at most batchSize receipts, strictly before the cutoff. */
+  async deleteReceiptsBefore(cutoff: Date, batchSize: number): Promise<number> {
+    const rows = await executeDatabase('delete message receipts', () =>
+      this.db
+        .delete(processedMessages)
+        .where(
+          inArray(
+            processedMessages.messageId,
+            this.db
+              .select({ messageId: processedMessages.messageId })
+              .from(processedMessages)
+              .where(lt(processedMessages.processedAt, cutoff))
+              .orderBy(asc(processedMessages.processedAt), asc(processedMessages.messageId))
+              .limit(batchSize),
+          ),
+        )
+        .returning({ messageId: processedMessages.messageId }),
+    )
+    return rows.length
+  }
+}
+
+// One JSON parameter keeps large claims below D1's 100-parameter limit.
+function outboxIds(messages: ReadonlyArray<OutboxMessage>) {
+  return sql`(select value from json_each(${JSON.stringify(messages.map((row) => row.payload.id))}))`
+}
+
+// D1 timestamps repository seconds; round future deadlines up so a lease or delay never ends early.
+function deadline(ms: number): Date {
+  return new Date(Math.ceil(ms / 1_000) * 1_000)
+}

package/src/infrastructure/cloudflare/index.ts

@@ -7,3 +7,5 @@ export type { D1Connection, D1Db, D1ReadDb, D1Tx } from './d1-database-types.ts'
 export { DatabaseError, type DatabaseFailure, type D1ConstraintKind } from '@/core'
 export { executeDatabase } from './d1-database-execution.ts'
 export { eventCollector } from '../unit-of-work-context.ts'
+export { D1OutboxRepository } from './d1-outbox-repository.ts'
+export type { OutboxRepositoryOptions } from '../outbox-repository-options.ts'

package/src/infrastructure/cloudflare/queue/index.ts

@@ -23,3 +23,4 @@ export {
   type QueueOperation,
 } from './queue.errors.ts'
 export { decideRedelivery, type RedeliveryDecision } from './redelivery-policy.ts'
+export { waitUntilWake } from './wait-until-wake.ts'

package/src/infrastructure/cloudflare/queue/queue-client.ts

@@ -35,7 +35,9 @@ export interface IQueueClient<TMessage extends QueueMessage> {
   send(message: TMessage, options?: QueueSendOptions): Promise<void>
   sendBatch(messages: ReadonlyArray<TMessage>): Promise<void>
   /** Sends every message within the limits and returns the oversized ones. */
-  sendBatchPartial(messages: ReadonlyArray<TMessage>): Promise<ReadonlyArray<TMessage>>
+  sendBatchPartial<Sent extends TMessage>(
+    messages: ReadonlyArray<Sent>,
+  ): Promise<ReadonlyArray<Sent>>
   /** Parks a delivered message's body as it arrived. */
   sendToDlq(message: Message): Promise<void>
 }
@@ -109,7 +111,9 @@ export class QueueClient<
     await this.sendSizedBatch(sized)
   }
 
-  async sendBatchPartial(messages: ReadonlyArray<TMessage>): Promise<ReadonlyArray<TMessage>> {
+  async sendBatchPartial<Sent extends TMessage>(
+    messages: ReadonlyArray<Sent>,
+  ): Promise<ReadonlyArray<Sent>> {
     const sized = sizeMessages(messages)
     await this.sendSizedBatch(sized.filter((item) => !isOversized(item)))
     return sized.filter(isOversized).map((item) => item.message)

package/src/infrastructure/cloudflare/queue/wait-until-wake.ts

@@ -0,0 +1,19 @@
+import type { IOutboxRelay, OutboxRelay } from '@/application'
+import { createLogger } from '@/core'
+
+const logger = createLogger('outbox-wake')
+
+/** Register delivery after commit; log a failed drain once and leave recovery to the scheduled sweep. */
+export function waitUntilWake(
+  context: Pick<ExecutionContext, 'waitUntil'>,
+  relay: Pick<OutboxRelay, 'drain'>,
+): IOutboxRelay {
+  return {
+    wake: () =>
+      context.waitUntil(
+        relay.drain().catch((cause: unknown) => {
+          logger.error('outbox_wake_failed', { error: cause })
+        }),
+      ),
+  }
+}

package/src/infrastructure/outbox-repository-options.ts

@@ -0,0 +1,9 @@
+/** Shared lease and delay defaults for both database adapters. */
+export const OUTBOX_REPOSITORY_DEFAULTS = {
+  leaseMs: 60_000,
+  retryBaseDelayMs: 1_000,
+  retryMaxDelayMs: 60_000,
+}
+
+/** Override lease and delay limits at the composition root. */
+export type OutboxRepositoryOptions = Readonly<Partial<typeof OUTBOX_REPOSITORY_DEFAULTS>>

package/src/infrastructure/postgres/index.ts

@@ -13,3 +13,5 @@ export { DatabaseError, type DatabaseFailure } from '@/core'
 export { executeDatabase } from './postgres-database-execution.ts'
 export { classifyPostgresError } from './classify-postgres-error.ts'
 export { eventCollector } from '../unit-of-work-context.ts'
+export { PostgresOutboxRepository } from './postgres-outbox-repository.ts'
+export type { OutboxRepositoryOptions } from '../outbox-repository-options.ts'

package/src/infrastructure/postgres/postgres-outbox-repository.ts

@@ -0,0 +1,216 @@
+import { and, asc, eq, inArray, isNull, lt, lte, or, sql } from 'drizzle-orm'
+
+import type { DeadLetterReason, IOutboxRepository, OutboxClaim, OutboxMessage } from '@/application'
+import { exponentialDelayCapMs } from '@/core'
+
+import type { DrizzleSchema } from '../drizzle-schema.ts'
+import {
+  OUTBOX_REPOSITORY_DEFAULTS,
+  type OutboxRepositoryOptions,
+} from '../outbox-repository-options.ts'
+import { executeDatabase } from './postgres-database-execution.ts'
+import type { PostgresDb } from './postgres-database-types.ts'
+import { messageOutbox, processedMessages } from './postgres-schema.ts'
+
+/**
+ * Typist's lease protocol with riposte's SKIP LOCKED selection on a plain connection, outside a unit of work.
+ * Every write runs once; lease expiry and the scheduled sweep recover interrupted operations.
+ */
+export class PostgresOutboxRepository implements IOutboxRepository {
+  private readonly options: Required<OutboxRepositoryOptions>
+
+  constructor(
+    private readonly db: PostgresDb<DrizzleSchema>,
+    options: OutboxRepositoryOptions = {},
+    private readonly now: () => Date = () => new Date(),
+  ) {
+    this.options = { ...OUTBOX_REPOSITORY_DEFAULTS, ...options }
+  }
+
+  /** Lease due rows in one statement; increment attempts even when reclaiming an expired lease. */
+  async claimPending(batchSize: number): Promise<OutboxClaim> {
+    const token = crypto.randomUUID()
+    const now = this.now()
+    const rows = await executeDatabase('claim pending outbox messages', () =>
+      this.db
+        .update(messageOutbox)
+        .set({
+          claimToken: token,
+          claimExpiresAt: new Date(now.getTime() + this.options.leaseMs),
+          attempts: sql`${messageOutbox.attempts} + 1`,
+        })
+        .where(
+          inArray(
+            messageOutbox.id,
+            this.db
+              .select({ id: messageOutbox.id })
+              .from(messageOutbox)
+              .where(
+                and(
+                  isNull(messageOutbox.publishedAt),
+                  isNull(messageOutbox.failedAt),
+                  lte(messageOutbox.availableAt, now),
+                  or(isNull(messageOutbox.claimExpiresAt), lte(messageOutbox.claimExpiresAt, now)),
+                ),
+              )
+              .orderBy(
+                asc(messageOutbox.availableAt),
+                asc(messageOutbox.createdAt),
+                asc(messageOutbox.id),
+              )
+              .limit(batchSize)
+              .for('update', { skipLocked: true }),
+          ),
+        )
+        .returning({
+          payload: messageOutbox.payload,
+          attempts: messageOutbox.attempts,
+          availableAt: messageOutbox.availableAt,
+          createdAt: messageOutbox.createdAt,
+        }),
+    )
+    // UPDATE RETURNING does not preserve the selection order.
+    rows.sort(
+      (a, b) =>
+        a.availableAt.getTime() - b.availableAt.getTime() ||
+        a.createdAt.getTime() - b.createdAt.getTime() ||
+        a.payload.id.localeCompare(b.payload.id),
+    )
+    return { token, messages: rows.map(({ payload, attempts }) => ({ payload, attempts })) }
+  }
+
+  /** Mark only supplied rows that still hold this token as published. */
+  async markPublished(claim: OutboxClaim, messages: ReadonlyArray<OutboxMessage>): Promise<void> {
+    if (messages.length === 0) return
+    await executeDatabase('mark outbox messages published', () =>
+      this.db
+        .update(messageOutbox)
+        .set({ publishedAt: this.now(), claimToken: null, claimExpiresAt: null })
+        .where(
+          and(
+            inArray(
+              messageOutbox.id,
+              messages.map((row) => row.payload.id),
+            ),
+            eq(messageOutbox.claimToken, claim.token),
+          ),
+        ),
+    )
+  }
+
+  /** Release supplied rows with per-row backoff; a stale token cannot change a newer claim. */
+  async releaseClaim(claim: OutboxClaim, messages: ReadonlyArray<OutboxMessage>): Promise<void> {
+    const now = this.now()
+    for (const attempts of new Set(messages.map((row) => row.attempts))) {
+      const ids = messages.filter((row) => row.attempts === attempts).map((row) => row.payload.id)
+      const delay = exponentialDelayCapMs(
+        this.options.retryBaseDelayMs,
+        this.options.retryMaxDelayMs,
+        attempts,
+      )
+      // oxlint-disable-next-line no-await-in-loop -- Stop releasing rows on the first database failure.
+      await executeDatabase('release outbox claim', () =>
+        this.db
+          .update(messageOutbox)
+          .set({
+            availableAt: new Date(now.getTime() + delay),
+            claimToken: null,
+            claimExpiresAt: null,
+          })
+          .where(and(inArray(messageOutbox.id, ids), eq(messageOutbox.claimToken, claim.token))),
+      )
+    }
+  }
+
+  /** Retain the full payload and record a closed reason with a readable error message. */
+  async deadLetter(
+    claim: OutboxClaim,
+    messages: ReadonlyArray<OutboxMessage>,
+    reason: DeadLetterReason,
+    errorMessage: string,
+  ): Promise<void> {
+    if (messages.length === 0) return
+    await executeDatabase('dead-letter outbox messages', () =>
+      this.db
+        .update(messageOutbox)
+        .set({
+          failedAt: this.now(),
+          lastError: `${reason}: ${errorMessage}`,
+          claimToken: null,
+          claimExpiresAt: null,
+        })
+        .where(
+          and(
+            inArray(
+              messageOutbox.id,
+              messages.map((row) => row.payload.id),
+            ),
+            eq(messageOutbox.claimToken, claim.token),
+          ),
+        ),
+    )
+  }
+
+  /** Delete at most batchSize published rows, strictly before the cutoff. */
+  async deletePublishedBefore(cutoff: Date, batchSize: number): Promise<number> {
+    const rows = await executeDatabase('delete published outbox messages', () =>
+      this.db
+        .delete(messageOutbox)
+        .where(
+          inArray(
+            messageOutbox.id,
+            this.db
+              .select({ id: messageOutbox.id })
+              .from(messageOutbox)
+              .where(lt(messageOutbox.publishedAt, cutoff))
+              .orderBy(asc(messageOutbox.publishedAt), asc(messageOutbox.id))
+              .limit(batchSize),
+          ),
+        )
+        .returning({ id: messageOutbox.id }),
+    )
+    return rows.length
+  }
+
+  /** Delete at most batchSize failed rows; pending and published rows remain untouched. */
+  async deleteFailedBefore(cutoff: Date, batchSize: number): Promise<number> {
+    const rows = await executeDatabase('delete failed outbox messages', () =>
+      this.db
+        .delete(messageOutbox)
+        .where(
+          inArray(
+            messageOutbox.id,
+            this.db
+              .select({ id: messageOutbox.id })
+              .from(messageOutbox)
+              .where(and(isNull(messageOutbox.publishedAt), lt(messageOutbox.failedAt, cutoff)))
+              .orderBy(asc(messageOutbox.failedAt), asc(messageOutbox.id))
+              .limit(batchSize),
+          ),
+        )
+        .returning({ id: messageOutbox.id }),
+    )
+    return rows.length
+  }
+
+  /** Delete at most batchSize receipts, strictly before the cutoff. */
+  async deleteReceiptsBefore(cutoff: Date, batchSize: number): Promise<number> {
+    const rows = await executeDatabase('delete message receipts', () =>
+      this.db
+        .delete(processedMessages)
+        .where(
+          inArray(
+            processedMessages.messageId,
+            this.db
+              .select({ messageId: processedMessages.messageId })
+              .from(processedMessages)
+              .where(lt(processedMessages.processedAt, cutoff))
+              .orderBy(asc(processedMessages.processedAt), asc(processedMessages.messageId))
+              .limit(batchSize),
+          ),
+        )
+        .returning({ messageId: processedMessages.messageId }),
+    )
+    return rows.length
+  }
+}

package/src/infrastructure/posthog/client.ts

@@ -0,0 +1,41 @@
+import posthog, { type PostHog, type PostHogConfig } from 'posthog-js'
+
+/** The application controls enablement; disabled initialization needs no project key. */
+export type PostHogClientConfig =
+  | { readonly enabled: false }
+  | {
+      readonly enabled: true
+      readonly apiKey: string
+      readonly environment: string
+      readonly source: string
+      readonly options?: Partial<PostHogConfig>
+    }
+
+/** Browser options from Typist and Porte; SDK option names and application overrides stay intact. */
+export function createPostHogClientOptions(
+  config: Extract<PostHogClientConfig, { enabled: true }>,
+): Partial<PostHogConfig> {
+  return {
+    api_host: '/relay',
+    ui_host: 'https://us.posthog.com',
+    person_profiles: 'identified_only',
+    defaults: '2026-08-29',
+    disable_surveys: true,
+    advanced_disable_feature_flags: true,
+    capture_performance: { web_vitals: false },
+    ...config.options,
+    loaded: (client) => {
+      client.register({ environment: config.environment, source: config.source })
+      config.options?.loaded?.(client)
+    },
+  }
+}
+
+/** Initialize once in the browser entrypoint; pass the returned SDK client to PostHogProvider. */
+export function initializePostHog(config: PostHogClientConfig): PostHog {
+  if (!config.enabled) return posthog
+  posthog.init(config.apiKey, createPostHogClientOptions(config))
+  return posthog
+}
+
+export { PostHogProvider, usePostHog } from '@posthog/react'

package/src/infrastructure/posthog/metrics.ts

@@ -0,0 +1,30 @@
+import type { PostHog } from 'posthog-node'
+
+import type { MetricOptions, MetricsService } from '@/application'
+
+/** PostHog Metrics with Worker lifetime management, ported from Typist's metrics-service.ts. */
+export class PostHogMetricsService implements MetricsService {
+  /** Use the analytics client's metrics; the runtime owns each flush promise. */
+  constructor(
+    private readonly client: Pick<PostHog, 'metrics'>,
+    private readonly waitUntil: (promise: Promise<unknown>) => void,
+  ) {}
+
+  /** Record a total and schedule its flush. */
+  count(name: string, value = 1, options?: MetricOptions): void {
+    this.client.metrics.count(name, value, options)
+    this.waitUntil(this.client.metrics.flush())
+  }
+
+  /** Record a current value and schedule its flush. */
+  gauge(name: string, value: number, options?: MetricOptions): void {
+    this.client.metrics.gauge(name, value, options)
+    this.waitUntil(this.client.metrics.flush())
+  }
+
+  /** Record an observation and schedule its flush. */
+  histogram(name: string, value: number, options?: MetricOptions): void {
+    this.client.metrics.histogram(name, value, options)
+    this.waitUntil(this.client.metrics.flush())
+  }
+}

package/src/infrastructure/posthog/proxy.ts

@@ -0,0 +1,47 @@
+/** Runtime resources and deployment hosts for Typist's same-origin proxy. */
+export interface PostHogProxyOptions {
+  readonly cache: Pick<Cache, 'match' | 'put'>
+  readonly waitUntil: (promise: Promise<void>) => void
+  readonly basePath?: string
+  readonly ingestHost?: string
+  readonly assetHost?: string
+  readonly fetch?: typeof globalThis.fetch
+}
+
+/**
+ * Mount at /relay/$ with GET, POST, and OPTIONS handlers. Supply Cloudflare's asset cache and waitUntil.
+ * The application must use the same base path in the browser's api_host option.
+ */
+export async function proxyPostHogRequest(
+  request: Request,
+  options: PostHogProxyOptions,
+): Promise<Response> {
+  const url = new URL(request.url)
+  const basePath = options.basePath ?? '/relay'
+  if (!url.pathname.startsWith(`${basePath}/`)) return new Response(null, { status: 404 })
+  const pathname = url.pathname.slice(basePath.length)
+  const pathWithSearch = pathname + url.search
+  const send = options.fetch ?? globalThis.fetch
+
+  if (pathname.startsWith('/static/') || pathname.startsWith('/array/')) {
+    const cached = await options.cache.match(request)
+    if (cached) return cached
+    const response = await send(
+      `https://${options.assetHost ?? 'us-assets.i.posthog.com'}${pathWithSearch}`,
+    )
+    options.waitUntil(options.cache.put(request, response.clone()))
+    return response
+  }
+
+  const headers = new Headers(request.headers)
+  headers.delete('cookie')
+  headers.delete('authorization')
+  headers.set('X-Forwarded-For', request.headers.get('CF-Connecting-IP') ?? '')
+  return await send(`https://${options.ingestHost ?? 'us.i.posthog.com'}${pathWithSearch}`, {
+    method: request.method,
+    headers,
+    body:
+      request.method !== 'GET' && request.method !== 'HEAD' ? await request.arrayBuffer() : null,
+    redirect: request.redirect,
+  })
+}