bunderstack 0.17.0-beta.2 → 0.17.0-beta.3

package/src/internal-tables.ts

@@ -1,149 +0,0 @@
-import { getTableName, is, isTable } from 'drizzle-orm'
-import { PgDatabase } from 'drizzle-orm/pg-core'
-import {
-  index,
-  integer,
-  primaryKey,
-  sqliteTable,
-  text,
-  uniqueIndex,
-} from 'drizzle-orm/sqlite-core'
-
-import { detectDialect } from './dialect'
-import {
-  bunderstackFilesPg,
-  bunderstackIdempotencyPg,
-  bunderstackJobsPg,
-} from './internal-tables-pg'
-
-export const bunderstackFiles = sqliteTable(
-  'bunderstack_file_meta',
-  {
-    fileId: text('file_id').primaryKey(),
-    bucket: text('bucket').notNull(),
-    ownerId: text('owner_id'),
-    scopeJson: text('scope_json'),
-    status: text('status').notNull(),
-    filename: text('filename'),
-    contentType: text('content_type'),
-    size: integer('size'),
-    createdAt: integer('created_at').notNull(),
-    confirmedAt: integer('confirmed_at'),
-  },
-  (t) => [
-    index('bfm_owner').on(t.ownerId),
-    index('bfm_scope').on(t.bucket, t.scopeJson),
-    index('bfm_sweep').on(t.status, t.createdAt),
-  ],
-)
-
-export const bunderstackIdempotency = sqliteTable(
-  '_bunderstack_idempotency',
-  {
-    key: text('key').notNull(),
-    tableName: text('table_name').notNull(),
-    bodyHash: text('body_hash').notNull(),
-    status: integer('status').notNull(),
-    response: text('response').notNull(),
-    expiresAt: integer('expires_at').notNull(),
-  },
-  (t) => [primaryKey({ columns: [t.key, t.tableName] })],
-)
-
-export const bunderstackJobs = sqliteTable(
-  '_bunderstack_jobs',
-  {
-    id: text('id').primaryKey(),
-    type: text('type').notNull(),
-    payloadJson: text('payload_json').notNull(),
-    status: text('status').notNull(), // pending | running | succeeded | failed
-    attempts: integer('attempts').notNull().default(0),
-    runAt: integer('run_at').notNull(),
-    lockedUntil: integer('locked_until'),
-    dedupeKey: text('dedupe_key'),
-    lastError: text('last_error'),
-    createdAt: integer('created_at').notNull(),
-    finishedAt: integer('finished_at'),
-  },
-  (t) => [
-    index('bjq_claim').on(t.status, t.runAt),
-    index('bjq_type_status').on(t.type, t.status),
-    // NULL dedupe keys are distinct in both dialects, so keyless jobs never collide.
-    uniqueIndex('bjq_dedupe').on(t.type, t.dedupeKey),
-  ],
-)
-
-export const INTERNAL_TABLES = {
-  bunderstackFiles,
-  bunderstackIdempotency,
-  bunderstackJobs,
-} as const
-
-export const INTERNAL_TABLE_NAMES: ReadonlySet<string> = new Set([
-  'bunderstack_file_meta',
-  '_bunderstack_idempotency',
-  '_bunderstack_jobs',
-])
-
-export const INTERNAL_TABLES_PG = {
-  bunderstackFiles: bunderstackFilesPg,
-  bunderstackIdempotency: bunderstackIdempotencyPg,
-  bunderstackJobs: bunderstackJobsPg,
-} as const
-
-// Both dialect twins count as "ours" for the re-export identity check.
-const INTERNAL_TABLE_CANDIDATES = new Map<string, readonly unknown[]>([
-  [getTableName(bunderstackFiles), [bunderstackFiles, bunderstackFilesPg]],
-  [
-    getTableName(bunderstackIdempotency),
-    [bunderstackIdempotency, bunderstackIdempotencyPg],
-  ],
-  [getTableName(bunderstackJobs), [bunderstackJobs, bunderstackJobsPg]],
-])
-
-/** Internal file-meta table matching the db's dialect. */
-export function filesTableFor(db: unknown) {
-  return is(db, PgDatabase) ? bunderstackFilesPg : bunderstackFiles
-}
-
-/** Internal idempotency table matching the db's dialect. */
-export function idempotencyTableFor(db: unknown) {
-  return is(db, PgDatabase) ? bunderstackIdempotencyPg : bunderstackIdempotency
-}
-
-/** Internal jobs table matching the db's dialect. */
-export function jobsTableFor(db: unknown) {
-  return is(db, PgDatabase) ? bunderstackJobsPg : bunderstackJobs
-}
-
-export function withInternalTables<TSchema extends Record<string, unknown>>(
-  schema: TSchema,
-): TSchema & typeof INTERNAL_TABLES {
-  const merged = { ...schema } as TSchema & typeof INTERNAL_TABLES
-
-  for (const value of Object.values(schema)) {
-    if (!isTable(value)) continue
-    const name = getTableName(value)
-    if (!INTERNAL_TABLE_NAMES.has(name)) continue
-
-    const candidates = INTERNAL_TABLE_CANDIDATES.get(name)
-    if (candidates?.includes(value)) {
-      // Re-exported from bunderstack/schema(-pg) — already in user schema.
-      continue
-    }
-
-    throw new Error(
-      `[bunderstack] table name "${name}" is reserved by bunderstack`,
-    )
-  }
-
-  const internal =
-    detectDialect(schema) === 'pg' ? INTERNAL_TABLES_PG : INTERNAL_TABLES
-  for (const [key, table] of Object.entries(internal)) {
-    if (!(key in merged)) {
-      ;(merged as Record<string, unknown>)[key] = table
-    }
-  }
-
-  return merged
-}

package/src/jobs/cron.ts

@@ -1,87 +0,0 @@
-// src/jobs/cron.ts — minimal 5-field cron parser, UTC, minute granularity.
-// Supports: * , lists (a,b) , ranges (a-b) , steps (*/n, a-b/n, a/n). No
-// month/day names, no seconds field, no @-shortcuts — YAGNI for v1.
-
-export type CronField = { any: boolean; values: ReadonlySet<number> }
-
-export type ParsedCron = {
-  minute: CronField
-  hour: CronField
-  dayOfMonth: CronField
-  month: CronField
-  dayOfWeek: CronField
-}
-
-const PART_RE = /^(\*|\d+(?:-\d+)?)(?:\/(\d+))?$/
-
-function parseField(
-  spec: string,
-  min: number,
-  max: number,
-  expr: string,
-): CronField {
-  if (spec === '*') return { any: true, values: new Set() }
-  const values = new Set<number>()
-  for (const part of spec.split(',')) {
-    const m = PART_RE.exec(part)
-    if (!m) throw new Error(`[bunderstack] invalid cron "${expr}": "${part}"`)
-    const step = m[2] !== undefined ? Number(m[2]) : 1
-    let lo: number
-    let hi: number
-    if (m[1] === '*') {
-      lo = min
-      hi = max
-    } else if (m[1]!.includes('-')) {
-      const [a, b] = m[1]!.split('-')
-      lo = Number(a)
-      hi = Number(b)
-    } else {
-      lo = Number(m[1])
-      // "5/15" means "starting at 5, every 15" per cron convention.
-      hi = step > 1 ? max : lo
-    }
-    if (step < 1 || lo < min || hi > max || lo > hi) {
-      throw new Error(`[bunderstack] invalid cron "${expr}": "${part}"`)
-    }
-    for (let v = lo; v <= hi; v += step) values.add(v)
-  }
-  return { any: false, values }
-}
-
-export function parseCron(expr: string): ParsedCron {
-  const parts = expr.trim().split(/\s+/)
-  if (parts.length !== 5) {
-    throw new Error(
-      `[bunderstack] invalid cron "${expr}": expected 5 fields (minute hour day-of-month month day-of-week)`,
-    )
-  }
-  const dow = parseField(parts[4]!, 0, 7, expr)
-  return {
-    minute: parseField(parts[0]!, 0, 59, expr),
-    hour: parseField(parts[1]!, 0, 23, expr),
-    dayOfMonth: parseField(parts[2]!, 1, 31, expr),
-    month: parseField(parts[3]!, 1, 12, expr),
-    // 7 is an alias for Sunday (0).
-    dayOfWeek: dow.any
-      ? dow
-      : { any: false, values: new Set([...dow.values].map((v) => v % 7)) },
-  }
-}
-
-function inField(field: CronField, value: number): boolean {
-  return field.any || field.values.has(value)
-}
-
-/** Whether the minute containing `epochMs` matches, evaluated in UTC. */
-export function cronMatches(cron: ParsedCron, epochMs: number): boolean {
-  const d = new Date(epochMs)
-  if (!inField(cron.minute, d.getUTCMinutes())) return false
-  if (!inField(cron.hour, d.getUTCHours())) return false
-  if (!inField(cron.month, d.getUTCMonth() + 1)) return false
-  const domOk = inField(cron.dayOfMonth, d.getUTCDate())
-  const dowOk = inField(cron.dayOfWeek, d.getUTCDay())
-  // Standard cron rule: when BOTH day fields are restricted, either may match.
-  return !cron.dayOfMonth.any && !cron.dayOfWeek.any
-    ? domOk || dowOk
-    : domOk && dowOk
-}

package/src/jobs/define.ts

@@ -1,283 +0,0 @@
-// src/jobs/define.ts — job definition types and the typed builder.
-// `createJobsBuilder` exists purely to carry
-// TSchema/TEnvResult typing into inline callbacks and extracted files.
-import type { StandardSchemaV1 } from '@standard-schema/spec'
-
-import type { DbFor } from '../db'
-import type { EmailFacade } from '../email'
-import type { StorageFacade } from '../index'
-
-import { parseCron } from './cron'
-import { CRON_PREFIX, type CatchUp } from './slots'
-
-export const DEFAULT_RETRIES = 3
-export const DEFAULT_TIMEOUT_MS = 60_000
-
-export type EnqueueOptions = {
-  /** Collapse duplicate enqueues while the queue row is non-terminal. */
-  dedupeKey?: string
-  /** Milliseconds from now until the job becomes claimable. */
-  delay?: number
-  /** Absolute time the job becomes claimable; wins over `delay`. */
-  runAt?: Date | number
-}
-
-export type TickResult = {
-  /** Rows moved from pending to running this tick. */
-  claimed: number
-  /** Handlers that completed successfully. */
-  ran: number
-  /** Handlers that threw, whether or not they will be retried. */
-  failed: number
-}
-
-/**
- * The untyped runtime facade. Job handlers and API context expose this shape;
- * `app.jobs` narrows `enqueue` to the declared job names/payloads.
- */
-export type JobsRuntimeFacade = {
-  enqueue(
-    name: string,
-    input?: unknown,
-    opts?: EnqueueOptions,
-  ): Promise<{ id: string }>
-  /** Run one poll cycle deterministically (tests). `now` defaults to Date.now(). */
-  tick(now?: number): Promise<TickResult>
-}
-
-import type { RealtimeFacade } from '../realtime/facade'
-
-export type JobContext<
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
-  TEnvResult = Record<string, unknown>,
-> = {
-  db: DbFor<TSchema>
-  env: TEnvResult
-  email: EmailFacade
-  storage: StorageFacade
-  jobs: JobsRuntimeFacade
-  realtime: RealtimeFacade<TSchema>
-}
-
-export type BunderstackJobContext<
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
-  TEnvResult = Record<string, unknown>,
-> = JobContext<TSchema, TEnvResult>
-
-export type QueueJobDefinition<
-  TInput,
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
-  TEnvResult = Record<string, unknown>,
-> = {
-  kind: 'job'
-  /** Standard Schema payload; parsed at enqueue AND before the handler runs. */
-  input?: StandardSchemaV1<unknown, TInput>
-  /** Attempts after the first failure. Default 3 (so 4 total attempts). */
-  retries?: number
-  /** Delay before retry N (1-based). Default exponential: 1s, 2s, 4s, … */
-  backoff?: ((attempt: number) => number) | { baseMs?: number; factor?: number }
-  /** Max simultaneous `running` rows of this type, enforced per worker. */
-  concurrency?: number
-  /** Lease duration in ms; an expired lease sends the job back to pending. */
-  timeout?: number
-  handler: (
-    input: TInput,
-    ctx: JobContext<TSchema, TEnvResult>,
-  ) => Promise<void> | void
-  /** Fires once, after the final attempt fails. Errors here are logged, never retried. */
-  onFailed?: (
-    input: TInput,
-    error: Error,
-    ctx: JobContext<TSchema, TEnvResult>,
-  ) => Promise<void> | void
-}
-
-export type CronInvocation = { scheduledFor: Date }
-
-export type CronDefinition<
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
-  TEnvResult = Record<string, unknown>,
-  TSchedule extends string = string,
-> = {
-  kind: 'cron'
-  schedule: TSchedule
-  /** Attempts after the first failure. Default 3 (so 4 total attempts). */
-  retries?: number
-  /** Delay before retry N (1-based). Default exponential: 1s, 2s, 4s, … */
-  backoff?: ((attempt: number) => number) | { baseMs?: number; factor?: number }
-  /** Lease duration in ms; an expired lease sends the slot back to pending. */
-  timeout?: number
-  /** How missed slots are handled on wake. Default 'latest'. */
-  catchUp?: CatchUp
-  /** How far back catch-up looks, in ms. Default 1 hour. */
-  catchUpWindow?: number
-  handler: (
-    invocation: CronInvocation,
-    ctx: JobContext<TSchema, TEnvResult>,
-  ) => Promise<void> | void
-  /** Fires once, after the final attempt fails. Errors here are logged, never retried. */
-  onFailed?: (
-    invocation: CronInvocation,
-    error: Error,
-    ctx: JobContext<TSchema, TEnvResult>,
-  ) => Promise<void> | void
-}
-
-export type BackgroundDefinition =
-  | QueueJobDefinition<any, any, any>
-  | CronDefinition<any, any>
-export type BackgroundDefs = Record<string, BackgroundDefinition>
-
-/** @deprecated Use QueueJobDefinition. */
-export type JobDefinition<
-  TInput,
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
-  TEnvResult = Record<string, unknown>,
-> = QueueJobDefinition<TInput, TSchema, TEnvResult>
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyJobDefinition = QueueJobDefinition<any, any, any>
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyBackgroundDefinition =
-  | QueueJobDefinition<any, any, any>
-  | CronDefinition<any, any, any>
-export type JobsDefs = BackgroundDefs
-
-export type QueueJobKeys<TDefs extends BackgroundDefs> = {
-  [K in keyof TDefs & string]: TDefs[K] extends QueueJobDefinition<
-    any,
-    any,
-    any
-  >
-    ? K
-    : never
-}[keyof TDefs & string]
-
-/** Throws when a definition is unusable. Safe to call more than once. */
-export function validateBackgroundDefs(defs: BackgroundDefs): void {
-  for (const [name, def] of Object.entries(defs)) {
-    if (typeof def.handler !== 'function') {
-      throw new Error(`[bunderstack] background task "${name}" has no handler`)
-    }
-    if (def.kind === 'job' && name.startsWith(CRON_PREFIX)) {
-      throw new Error(
-        `[bunderstack] job "${name}": the "${CRON_PREFIX}" prefix is reserved for cron tasks`,
-      )
-    }
-    if (
-      def.retries !== undefined &&
-      (def.retries < 0 || !Number.isInteger(def.retries))
-    ) {
-      throw new Error(
-        `[bunderstack] background task "${name}": retries must be a non-negative integer`,
-      )
-    }
-    if (def.timeout !== undefined && def.timeout <= 0) {
-      throw new Error(
-        `[bunderstack] background task "${name}": timeout must be positive`,
-      )
-    }
-    if (def.kind === 'cron') {
-      parseCron(def.schedule)
-      if ((def as { concurrency?: number }).concurrency !== undefined) {
-        throw new Error(
-          `[bunderstack] cron "${name}": concurrency is not supported for cron tasks — slots are already unique`,
-        )
-      }
-      if (def.catchUpWindow !== undefined && def.catchUpWindow <= 0) {
-        throw new Error(
-          `[bunderstack] cron "${name}": catchUpWindow must be positive`,
-        )
-      }
-      continue
-    }
-    if (
-      def.concurrency !== undefined &&
-      (def.concurrency < 1 || !Number.isInteger(def.concurrency))
-    ) {
-      throw new Error(
-        `[bunderstack] job "${name}": concurrency must be a positive integer`,
-      )
-    }
-  }
-}
-
-/** @deprecated Use validateBackgroundDefs. */
-export const validateJobsDefs = validateBackgroundDefs
-
-/**
- * Delay in ms before retry `attempt` (1-based = the attempt that just failed).
- * Jittered by ±20% so a shared outage does not retry every job in lockstep.
- * A caller-supplied backoff function is returned verbatim — the caller owns it.
- */
-export function backoffMs(
-  def: AnyBackgroundDefinition,
-  attempt: number,
-): number {
-  const b = def.backoff
-  if (typeof b === 'function') return b(attempt)
-  const baseMs = b?.baseMs ?? 1000
-  const factor = b?.factor ?? 2
-  const flat = baseMs * factor ** (attempt - 1)
-  return Math.round(flat * (0.8 + Math.random() * 0.4))
-}
-
-/**
- * Build the `j` instance bunderstack hands to the config's `jobs` builder
- * callback (and exports for multi-file job setups).
- */
-export function createJobsBuilder<
-  TSchema extends Record<string, unknown>,
-  TEnvResult = Record<string, unknown>,
->() {
-  return {
-    /** Identity with inference: pins TInput from the schema output. */
-    job<TInput = undefined>(
-      def: Omit<QueueJobDefinition<TInput, TSchema, TEnvResult>, 'kind'>,
-    ): QueueJobDefinition<TInput, TSchema, TEnvResult> {
-      return { kind: 'job', ...def }
-    },
-    cron<const TSchedule extends string>(
-      def: Omit<CronDefinition<TSchema, TEnvResult, TSchedule>, 'kind'>,
-    ): CronDefinition<TSchema, TEnvResult, TSchedule> {
-      parseCron(def.schedule)
-      return { kind: 'cron', ...def }
-    },
-    /** Identity with validation: returns the defs map, typed. */
-    define<TDefs extends BackgroundDefs>(defs: TDefs): TDefs {
-      validateBackgroundDefs(defs)
-      return defs
-    },
-  }
-}
-
-/** Type of the `j` instance — for builder callbacks declared in separate files. */
-export type BunderstackJobsBuilder<
-  TSchema extends Record<string, unknown>,
-  TEnvResult = Record<string, unknown>,
-> = ReturnType<typeof createJobsBuilder<TSchema, TEnvResult>>
-
-// Infers TInput from the JobDefinition's own type argument rather than
-// pattern-matching the (optional, so union-with-undefined) `input` property —
-// A required-property pattern fails structurally because `input` is optional,
-// so infer from the definition's own type argument instead.
-type JobInputOf<TDef> =
-  TDef extends QueueJobDefinition<infer TInput, any, any> ? TInput : undefined
-
-/**
- * `app.jobs`: `enqueue` narrowed to declared names + payloads. `Omit`s the
- * runtime facade's loose `enqueue` first — intersecting two same-named
- * methods instead would make TS treat them as overloaded, so the loose
- * `(name: string, ...)` signature would still accept any name.
- */
-export type JobsFacade<TDefs extends JobsDefs> = Omit<
-  JobsRuntimeFacade,
-  'enqueue'
-> & {
-  enqueue<K extends QueueJobKeys<TDefs>>(
-    name: K,
-    ...rest: JobInputOf<TDefs[K]> extends undefined
-      ? [input?: undefined, opts?: EnqueueOptions]
-      : [input: JobInputOf<TDefs[K]>, opts?: EnqueueOptions]
-  ): Promise<{ id: string }>
-}

package/src/jobs/index.ts

@@ -1,37 +0,0 @@
-// src/jobs/index.ts — module surface consumed by createBunderstack.
-export {
-  createJobsBuilder,
-  validateBackgroundDefs,
-  validateJobsDefs,
-  DEFAULT_RETRIES,
-  DEFAULT_TIMEOUT_MS,
-} from './define'
-export type {
-  AnyJobDefinition,
-  BackgroundDefinition,
-  BackgroundDefs,
-  BunderstackJobContext,
-  BunderstackJobsBuilder,
-  EnqueueOptions,
-  JobContext,
-  JobDefinition,
-  QueueJobDefinition,
-  CronDefinition,
-  CronInvocation,
-  QueueJobKeys,
-  JobsDefs,
-  JobsFacade,
-  JobsRuntimeFacade,
-} from './define'
-export { enqueueJob } from './queue'
-export { createJobRunner } from './worker'
-export { startJobWorker } from './runtime'
-export type {
-  StartWorkerOptions,
-  RunWorkerOptions,
-  WorkerHandle,
-} from './runtime'
-export { parseCron, cronMatches } from './cron'
-export { slotsDue, floorSlot, CRON_PREFIX, SLOT_MS } from './slots'
-export type { CatchUp } from './slots'
-export type { TickResult } from './define'

package/src/jobs/queue.ts

@@ -1,67 +0,0 @@
-// src/jobs/queue.ts — durable enqueue with constraint-backed dedupe.
-import { and, eq } from 'drizzle-orm'
-
-import type { AnyDb } from '../dialect'
-import type { EnqueueOptions, JobsDefs } from './define'
-
-import { jobsTableFor } from '../internal-tables'
-import { validateStandardSchema } from '../standard-schema'
-import { generate } from '../typeid'
-import { CRON_PREFIX } from './slots'
-
-export async function enqueueJob(
-  db: AnyDb,
-  defs: JobsDefs,
-  name: string,
-  input: unknown,
-  opts: EnqueueOptions = {},
-): Promise<{ id: string }> {
-  const def = defs[name]
-  if (!def) {
-    throw new Error(`[bunderstack] unknown background task "${name}"`)
-  }
-  const isCron = def.kind === 'cron'
-  const type = isCron ? `${CRON_PREFIX}${name}` : name
-  // Cron slots carry no payload; queue jobs validate theirs at the call site.
-  const parsed = isCron
-    ? null
-    : def.input
-      ? validateStandardSchema(def.input, input, `job "${name}" input`)
-      : null
-  const t = jobsTableFor(db)
-  const now = Date.now()
-  const runAt =
-    opts.runAt !== undefined
-      ? new Date(opts.runAt).getTime()
-      : now + (opts.delay ?? 0)
-
-  // Two rounds cover the race where the deduping row reaches a terminal state
-  // (clearing its key) between our failed insert and our read.
-  for (let round = 0; round < 2; round++) {
-    const id = generate('job')
-    const insertedRows = await db
-      .insert(t)
-      .values({
-        id,
-        type,
-        payloadJson: JSON.stringify(parsed),
-        status: 'pending',
-        attempts: 0,
-        runAt,
-        dedupeKey: opts.dedupeKey ?? null,
-        createdAt: now,
-      })
-      .onConflictDoNothing({ target: [t.type, t.dedupeKey] })
-      .returning({ id: t.id })
-    if (insertedRows[0]) return { id: String(insertedRows[0].id) }
-    const existing = await db
-      .select({ id: t.id })
-      .from(t)
-      .where(and(eq(t.type, type), eq(t.dedupeKey, opts.dedupeKey ?? '')))
-      .limit(1)
-    if (existing[0]) return { id: String(existing[0].id) }
-  }
-  throw new Error(
-    `[bunderstack] enqueue of "${name}" lost a dedupe race twice — please retry`,
-  )
-}

package/src/jobs/runtime.ts

@@ -1,58 +0,0 @@
-export type WorkerHandle = {
-  readonly closed: Promise<void>
-  close(): Promise<void>
-}
-
-export type StartWorkerOptions = {
-  signal?: AbortSignal
-  pollIntervalMs?: number
-  tick: (now: number) => Promise<void>
-  onError?: (error: Error) => void
-}
-
-export type RunWorkerOptions = StartWorkerOptions
-
-function toError(error: unknown): Error {
-  return error instanceof Error ? error : new Error(String(error))
-}
-
-function wait(ms: number, signal: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    if (signal.aborted) return resolve()
-    const timer = setTimeout(done, ms)
-    function done() {
-      clearTimeout(timer)
-      signal.removeEventListener('abort', done)
-      resolve()
-    }
-    signal.addEventListener('abort', done, { once: true })
-  })
-}
-
-export function startJobWorker(options: StartWorkerOptions): WorkerHandle {
-  const controller = new AbortController()
-  const pollIntervalMs = options.pollIntervalMs ?? 1_000
-  const abort = () => controller.abort()
-  options.signal?.addEventListener('abort', abort, { once: true })
-  if (options.signal?.aborted) abort()
-
-  const closed = (async () => {
-    try {
-      while (!controller.signal.aborted) {
-        try {
-          await options.tick(Date.now())
-        } catch (error) {
-          options.onError?.(toError(error))
-        }
-        await wait(pollIntervalMs, controller.signal)
-      }
-    } finally {
-      options.signal?.removeEventListener('abort', abort)
-    }
-  })()
-  const close = () => {
-    controller.abort()
-    return closed
-  }
-  return { closed, close }
-}