@storyshelf/core 0.6.2 → 0.8.0

package/dist/capture/db-queue/codec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.mjs","names":[],"sources":["../../../src/capture/db-queue/codec.ts"],"sourcesContent":["/** Codec of the database queue: job payload JSON and the row → job / queue-entry mappings. */\nimport type { JobStatus, QueueEntry } from \"../../adapters/capture-queue.ts\";\nimport { attemptRowId } from \"../../models/capture-job.ts\";\nimport type { CaptureJobRow } from \"../../schema/capture-job.ts\";\nimport type { DatabaseJob, QueueJobInput } from \"./types.ts\";\n\n/** What the `payload` column holds. */\ninterface StoredPayload {\n  reqId?: string;\n  traceparent?: string;\n  data?: Record<string, unknown>;\n}\n\n/** Serialize the request id, trace context and kind-specific fields of a job; null when empty. */\nexport function encodePayload(job: QueueJobInput): string | null {\n  const stored: StoredPayload = {};\n  if (job.reqId !== undefined) {\n    stored.reqId = job.reqId;\n  }\n  if (job.traceparent !== undefined) {\n    stored.traceparent = job.traceparent;\n  }\n  if (job.data !== undefined && Object.keys(job.data).length > 0) {\n    stored.data = job.data;\n  }\n  return Object.keys(stored).length === 0 ? null : JSON.stringify(stored);\n}\n\n/** Parse a stored payload. A malformed one (a poison row) decodes as empty rather than throwing. */\nexport function decodePayload(raw: string | null): StoredPayload {\n  if (raw === null || raw === \"\") {\n    return {};\n  }\n  try {\n    const parsed: unknown = JSON.parse(raw);\n    return isRecord(parsed) ? pickPayload(parsed) : {};\n  } catch {\n    return {};\n  }\n}\n\n/** The job handed to a consumer for attempt `attempt` of a job row. */\nexport function toDatabaseJob(row: CaptureJobRow, attempt: number, leaseMs: number): DatabaseJob {\n  const payload = decodePayload(row.payload);\n  const job: DatabaseJob = {\n    buildId: row.buildId ?? \"\",\n    jobId: row.jobId,\n    kind: row.kind,\n    attempt,\n    attempts: attempt - 1,\n    maxAttempts: row.maxAttempts,\n    receipt: attemptRowId(row.jobId, attempt),\n    leaseMs,\n    data: payload.data ?? {},\n  };\n  return withOptional(job, row, payload);\n}\n\n/** The queue-view entry of a job row. */\nexport function toQueueEntry(row: CaptureJobRow): QueueEntry {\n  const entry: QueueEntry = {\n    buildId: row.buildId ?? \"\",\n    status: entryStatus(row.status),\n    queuedAt: row.createdAt,\n  };\n  if (row.shardId !== null) {\n    entry.shard = row.shardId;\n  }\n  if (row.startedAt !== null) {\n    entry.startedAt = row.startedAt;\n  }\n  if (row.finishedAt !== null) {\n    entry.finishedAt = row.finishedAt;\n  }\n  if (row.error !== null) {\n    entry.error = row.error;\n  }\n  return entry;\n}\n\nfunction withOptional(job: DatabaseJob, row: CaptureJobRow, payload: StoredPayload): DatabaseJob {\n  if (row.shardId !== null) {\n    job.shard = row.shardId;\n  }\n  if (payload.reqId !== undefined) {\n    job.reqId = payload.reqId;\n  }\n  if (payload.traceparent !== undefined) {\n    job.traceparent = payload.traceparent;\n  }\n  return job;\n}\n\nfunction entryStatus(status: CaptureJobRow[\"status\"]): JobStatus {\n  if (status === \"done\") {\n    return \"completed\";\n  }\n  if (status === \"expired\") {\n    return \"failed\";\n  }\n  return status;\n}\n\nfunction pickPayload(parsed: Record<string, unknown>): StoredPayload {\n  const stored: StoredPayload = {};\n  if (typeof parsed[\"reqId\"] === \"string\") {\n    stored.reqId = parsed[\"reqId\"];\n  }\n  if (typeof parsed[\"traceparent\"] === \"string\") {\n    stored.traceparent = parsed[\"traceparent\"];\n  }\n  if (isRecord(parsed[\"data\"])) {\n    stored.data = parsed[\"data\"];\n  }\n  return stored;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n"],"mappings":";;;;;;AAcA,SAAgB,cAAc,KAAmC;CAC/D,MAAM,SAAwB,CAAC;CAC/B,IAAI,IAAI,UAAU,KAAA,GAChB,OAAO,QAAQ,IAAI;CAErB,IAAI,IAAI,gBAAgB,KAAA,GACtB,OAAO,cAAc,IAAI;CAE3B,IAAI,IAAI,SAAS,KAAA,KAAa,OAAO,KAAK,IAAI,IAAI,CAAC,CAAC,SAAS,GAC3D,OAAO,OAAO,IAAI;CAEpB,OAAO,OAAO,KAAK,MAAM,CAAC,CAAC,WAAW,IAAI,OAAO,KAAK,UAAU,MAAM;AACxE;;AAGA,SAAgB,cAAc,KAAmC;CAC/D,IAAI,QAAQ,QAAQ,QAAQ,IAC1B,OAAO,CAAC;CAEV,IAAI;EACF,MAAM,SAAkB,KAAK,MAAM,GAAG;EACtC,OAAO,SAAS,MAAM,IAAI,YAAY,MAAM,IAAI,CAAC;CACnD,QAAQ;EACN,OAAO,CAAC;CACV;AACF;;AAGA,SAAgB,cAAc,KAAoB,SAAiB,SAA8B;CAC/F,MAAM,UAAU,cAAc,IAAI,OAAO;CAYzC,OAAO,aAAa;EAVlB,SAAS,IAAI,WAAW;EACxB,OAAO,IAAI;EACX,MAAM,IAAI;EACV;EACA,UAAU,UAAU;EACpB,aAAa,IAAI;EACjB,SAAS,aAAa,IAAI,OAAO,OAAO;EACxC;EACA,MAAM,QAAQ,QAAQ,CAAC;CAEH,GAAG,KAAK,OAAO;AACvC;;AAGA,SAAgB,aAAa,KAAgC;CAC3D,MAAM,QAAoB;EACxB,SAAS,IAAI,WAAW;EACxB,QAAQ,YAAY,IAAI,MAAM;EAC9B,UAAU,IAAI;CAChB;CACA,IAAI,IAAI,YAAY,MAClB,MAAM,QAAQ,IAAI;CAEpB,IAAI,IAAI,cAAc,MACpB,MAAM,YAAY,IAAI;CAExB,IAAI,IAAI,eAAe,MACrB,MAAM,aAAa,IAAI;CAEzB,IAAI,IAAI,UAAU,MAChB,MAAM,QAAQ,IAAI;CAEpB,OAAO;AACT;AAEA,SAAS,aAAa,KAAkB,KAAoB,SAAqC;CAC/F,IAAI,IAAI,YAAY,MAClB,IAAI,QAAQ,IAAI;CAElB,IAAI,QAAQ,UAAU,KAAA,GACpB,IAAI,QAAQ,QAAQ;CAEtB,IAAI,QAAQ,gBAAgB,KAAA,GAC1B,IAAI,cAAc,QAAQ;CAE5B,OAAO;AACT;AAEA,SAAS,YAAY,QAA4C;CAC/D,IAAI,WAAW,QACb,OAAO;CAET,IAAI,WAAW,WACb,OAAO;CAET,OAAO;AACT;AAEA,SAAS,YAAY,QAAgD;CACnE,MAAM,SAAwB,CAAC;CAC/B,IAAI,OAAO,OAAO,aAAa,UAC7B,OAAO,QAAQ,OAAO;CAExB,IAAI,OAAO,OAAO,mBAAmB,UACnC,OAAO,cAAc,OAAO;CAE9B,IAAI,SAAS,OAAO,OAAO,GACzB,OAAO,OAAO,OAAO;CAEvB,OAAO;AACT;AAEA,SAAS,SAAS,OAAkD;CAClE,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E"}

package/dist/capture/db-queue/index.d.mts

@@ -0,0 +1,18 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { DatabaseAdapter } from "../../adapter/database.mjs";
+import { DEFAULT_LEASE_MS, DEFAULT_RETRIES, DatabaseCaptureQueue, DatabaseCaptureQueueOptions, DatabaseJob, QueueJobInput } from "./types.mjs";
+import { LEASE_EXHAUSTED_ERROR } from "./claim.mjs";
+import { MAX_NACK_DELAY_MS } from "./poll.mjs";
+/** What the database queue reports about itself; hosts show it before the queue is built. */
+declare const DATABASE_QUEUE_METADATA: {
+  readonly name: "Database Queue";
+  readonly version: string;
+  readonly description: "Capture queue on the app database (capture_jobs)";
+  readonly kind: "database";
+  readonly category: "capture-queue";
+};
+/** A `PollableCaptureQueue` over `db`'s `capture_jobs` table. */
+declare function createDatabaseCaptureQueue(db: DatabaseAdapter, options?: DatabaseCaptureQueueOptions): DatabaseCaptureQueue;
+export { DATABASE_QUEUE_METADATA, DEFAULT_LEASE_MS, DEFAULT_RETRIES, type DatabaseCaptureQueue, type DatabaseCaptureQueueOptions, type DatabaseJob, LEASE_EXHAUSTED_ERROR, MAX_NACK_DELAY_MS, type QueueJobInput, createDatabaseCaptureQueue };
+//# sourceMappingURL=index.d.mts.map

package/dist/capture/db-queue/index.mjs

@@ -0,0 +1,89 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { ulid } from "../../utils/ulid.mjs";
+import { CaptureJobModel } from "../../models/capture-job.mjs";
+import { LEASE_EXHAUSTED_ERROR } from "./claim.mjs";
+import { MAX_NACK_DELAY_MS, ackJob, nackJob, pollJob } from "./poll.mjs";
+import { extendJob, inspectJob } from "./lease.mjs";
+import { buildQueueLifecycle } from "./lifecycle.mjs";
+import { activeEntries, cancelJobs, enqueueCapture, enqueueJob, recentEntries, statusOf } from "./operations.mjs";
+import { DEFAULT_LEASE_MS, DEFAULT_RETRIES } from "./types.mjs";
+import { createWakeSignal } from "./wake.mjs";
+import { hostname } from "node:os";
+// src/capture/db-queue/index.ts
+/**
+* Create the database capture queue (ADR 0006, decision 4): `capture_jobs` on the app's own
+* `DatabaseAdapter` is the queue, safe with any number of instances.
+*
+* Composition root: wires the runtime, lifecycle, enqueue/cancel/views (`operations`), the claim
+* (`claim`, `poll`) and the lease (`lease`) into a `PollableCaptureQueue`. Every attempt has its own
+* row `<jobId>:<attempt>`, created by a unique-key insert, so claiming needs no compare-and-swap and
+* a holder only ever writes its own attempt row.
+*/
+/** What the database queue reports about itself; hosts show it before the queue is built. */
+const DATABASE_QUEUE_METADATA = {
+	name: "Database Queue",
+	version: "0.8.0",
+	description: "Capture queue on the app database (capture_jobs)",
+	kind: "database",
+	category: "capture-queue"
+};
+/** A `PollableCaptureQueue` over `db`'s `capture_jobs` table. */
+function createDatabaseCaptureQueue(db, options = {}) {
+	const rt = resolveRuntime(db, options);
+	return {
+		metadata: DATABASE_QUEUE_METADATA,
+		lifecycle: buildQueueLifecycle(rt),
+		setLogger(bound) {
+			rt.logger ??= bound;
+		},
+		enqueue: async (job) => {
+			await enqueueCapture(rt, job);
+		},
+		enqueueJob: async (job) => await enqueueJob(rt, job),
+		status: async (buildId) => await statusOf(rt, buildId),
+		active: async () => await activeEntries(rt),
+		recent: async (limit) => await recentEntries(rt, limit),
+		cancel: async (id) => await cancelJobs(rt, id),
+		poll: async (pollOptions) => await pollJob(rt, pollOptions),
+		ack: async (job) => {
+			await ackJob(rt, job);
+		},
+		nack: async (job, nackOptions) => {
+			await nackJob(rt, job, nackOptions);
+		},
+		extend: async (job) => await extendJob(rt, job),
+		inspect: async (job) => await inspectJob(rt, job),
+		waitForWork: async (ms) => await rt.wake.wait(ms, rt.pollVersion)
+	};
+}
+function resolveRuntime(db, options) {
+	const kinds = options.kinds ?? ["capture"];
+	const retries = options.retries ?? 2;
+	if (kinds.length === 0) throw new Error("createDatabaseCaptureQueue: `kinds` must name at least one job kind");
+	if (!Number.isInteger(retries) || retries < 0) throw new Error("createDatabaseCaptureQueue: `retries` must be a non-negative integer");
+	return withHooks({
+		model: new CaptureJobModel(db),
+		kinds,
+		leaseMs: positive(options.leaseMs, DEFAULT_LEASE_MS),
+		maxAttempts: retries + 1,
+		owner: options.owner ?? `${hostname()}:${String(process.pid)}:${ulid().slice(-6)}`,
+		now: options.now ?? Date.now,
+		timers: options.timers,
+		wake: createWakeSignal(options.timers),
+		pollVersion: 0
+	}, options);
+}
+/** The optional logger and exhausted-job hook, when given. */
+function withHooks(rt, options) {
+	if (options.logger !== void 0) rt.logger = options.logger;
+	if (options.onExhausted !== void 0) rt.onExhausted = options.onExhausted;
+	return rt;
+}
+function positive(value, fallback) {
+	return value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+export { DATABASE_QUEUE_METADATA, DEFAULT_LEASE_MS, DEFAULT_RETRIES, LEASE_EXHAUSTED_ERROR, MAX_NACK_DELAY_MS, createDatabaseCaptureQueue };
+
+//# sourceMappingURL=index.mjs.map

package/dist/capture/db-queue/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/capture/db-queue/index.ts"],"sourcesContent":["/**\n * Create the database capture queue (ADR 0006, decision 4): `capture_jobs` on the app's own\n * `DatabaseAdapter` is the queue, safe with any number of instances.\n *\n * Composition root: wires the runtime, lifecycle, enqueue/cancel/views (`operations`), the claim\n * (`claim`, `poll`) and the lease (`lease`) into a `PollableCaptureQueue`. Every attempt has its own\n * row `<jobId>:<attempt>`, created by a unique-key insert, so claiming needs no compare-and-swap and\n * a holder only ever writes its own attempt row.\n */\nimport { hostname } from \"node:os\";\nimport type { DatabaseAdapter } from \"../../adapters/database.ts\";\nimport type { Logger } from \"../../logger.ts\";\nimport { CaptureJobModel } from \"../../models/capture-job.ts\";\nimport { ulid } from \"../../utils/ulid.ts\";\nimport { extendJob, inspectJob } from \"./lease.ts\";\nimport { buildQueueLifecycle } from \"./lifecycle.ts\";\nimport {\n  activeEntries,\n  cancelJobs,\n  enqueueCapture,\n  enqueueJob,\n  recentEntries,\n  statusOf,\n} from \"./operations.ts\";\nimport { ackJob, nackJob, pollJob } from \"./poll.ts\";\nimport {\n  DEFAULT_LEASE_MS,\n  DEFAULT_RETRIES,\n  type DatabaseCaptureQueue,\n  type DatabaseCaptureQueueOptions,\n  type QueueRuntime,\n} from \"./types.ts\";\nimport { createWakeSignal } from \"./wake.ts\";\n\ndeclare const __PKG_VERSION__: string | undefined;\n\n/** What the database queue reports about itself; hosts show it before the queue is built. */\nexport const DATABASE_QUEUE_METADATA = {\n  name: \"Database Queue\",\n  version: typeof __PKG_VERSION__ === \"string\" ? __PKG_VERSION__ : \"0.0.0\",\n  description: \"Capture queue on the app database (capture_jobs)\",\n  kind: \"database\",\n  category: \"capture-queue\",\n} as const;\n\n/** A `PollableCaptureQueue` over `db`'s `capture_jobs` table. */\nexport function createDatabaseCaptureQueue(\n  db: DatabaseAdapter,\n  options: DatabaseCaptureQueueOptions = {},\n): DatabaseCaptureQueue {\n  const rt = resolveRuntime(db, options);\n  return {\n    metadata: DATABASE_QUEUE_METADATA,\n    lifecycle: buildQueueLifecycle(rt),\n    setLogger(bound: Logger): void {\n      rt.logger ??= bound;\n    },\n    enqueue: async (job) => {\n      await enqueueCapture(rt, job);\n    },\n    enqueueJob: async (job) => await enqueueJob(rt, job),\n    status: async (buildId) => await statusOf(rt, buildId),\n    active: async () => await activeEntries(rt),\n    recent: async (limit) => await recentEntries(rt, limit),\n    cancel: async (id) => await cancelJobs(rt, id),\n    poll: async (pollOptions) => await pollJob(rt, pollOptions),\n    ack: async (job) => {\n      await ackJob(rt, job);\n    },\n    nack: async (job, nackOptions) => {\n      await nackJob(rt, job, nackOptions);\n    },\n    extend: async (job) => await extendJob(rt, job),\n    inspect: async (job) => await inspectJob(rt, job),\n    waitForWork: async (ms) => await rt.wake.wait(ms, rt.pollVersion),\n  };\n}\n\nfunction resolveRuntime(db: DatabaseAdapter, options: DatabaseCaptureQueueOptions): QueueRuntime {\n  const kinds = options.kinds ?? [\"capture\"];\n  const retries = options.retries ?? DEFAULT_RETRIES;\n  if (kinds.length === 0) {\n    throw new Error(\"createDatabaseCaptureQueue: `kinds` must name at least one job kind\");\n  }\n  if (!Number.isInteger(retries) || retries < 0) {\n    throw new Error(\"createDatabaseCaptureQueue: `retries` must be a non-negative integer\");\n  }\n  const rt: QueueRuntime = {\n    model: new CaptureJobModel(db),\n    kinds,\n    leaseMs: positive(options.leaseMs, DEFAULT_LEASE_MS),\n    maxAttempts: retries + 1,\n    owner: options.owner ?? `${hostname()}:${String(process.pid)}:${ulid().slice(-6)}`,\n    now: options.now ?? Date.now,\n    timers: options.timers,\n    wake: createWakeSignal(options.timers),\n    pollVersion: 0,\n  };\n  return withHooks(rt, options);\n}\n\n/** The optional logger and exhausted-job hook, when given. */\nfunction withHooks(rt: QueueRuntime, options: DatabaseCaptureQueueOptions): QueueRuntime {\n  if (options.logger !== undefined) {\n    rt.logger = options.logger;\n  }\n  if (options.onExhausted !== undefined) {\n    rt.onExhausted = options.onExhausted;\n  }\n  return rt;\n}\n\nfunction positive(value: number | undefined, fallback: number): number {\n  return value !== undefined && Number.isFinite(value) && value > 0 ? value : fallback;\n}\n\nexport {\n  DEFAULT_LEASE_MS,\n  DEFAULT_RETRIES,\n  type DatabaseCaptureQueue,\n  type DatabaseCaptureQueueOptions,\n  type DatabaseJob,\n  type QueueJobInput,\n} from \"./types.ts\";\nexport { LEASE_EXHAUSTED_ERROR } from \"./claim.ts\";\nexport { MAX_NACK_DELAY_MS } from \"./poll.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,0BAA0B;CACrC,MAAM;CACN,SAAA;CACA,aAAa;CACb,MAAM;CACN,UAAU;AACZ;;AAGA,SAAgB,2BACd,IACA,UAAuC,CAAC,GAClB;CACtB,MAAM,KAAK,eAAe,IAAI,OAAO;CACrC,OAAO;EACL,UAAU;EACV,WAAW,oBAAoB,EAAE;EACjC,UAAU,OAAqB;GAC7B,GAAG,WAAW;EAChB;EACA,SAAS,OAAO,QAAQ;GACtB,MAAM,eAAe,IAAI,GAAG;EAC9B;EACA,YAAY,OAAO,QAAQ,MAAM,WAAW,IAAI,GAAG;EACnD,QAAQ,OAAO,YAAY,MAAM,SAAS,IAAI,OAAO;EACrD,QAAQ,YAAY,MAAM,cAAc,EAAE;EAC1C,QAAQ,OAAO,UAAU,MAAM,cAAc,IAAI,KAAK;EACtD,QAAQ,OAAO,OAAO,MAAM,WAAW,IAAI,EAAE;EAC7C,MAAM,OAAO,gBAAgB,MAAM,QAAQ,IAAI,WAAW;EAC1D,KAAK,OAAO,QAAQ;GAClB,MAAM,OAAO,IAAI,GAAG;EACtB;EACA,MAAM,OAAO,KAAK,gBAAgB;GAChC,MAAM,QAAQ,IAAI,KAAK,WAAW;EACpC;EACA,QAAQ,OAAO,QAAQ,MAAM,UAAU,IAAI,GAAG;EAC9C,SAAS,OAAO,QAAQ,MAAM,WAAW,IAAI,GAAG;EAChD,aAAa,OAAO,OAAO,MAAM,GAAG,KAAK,KAAK,IAAI,GAAG,WAAW;CAClE;AACF;AAEA,SAAS,eAAe,IAAqB,SAAoD;CAC/F,MAAM,QAAQ,QAAQ,SAAS,CAAC,SAAS;CACzC,MAAM,UAAU,QAAQ,WAAA;CACxB,IAAI,MAAM,WAAW,GACnB,MAAM,IAAI,MAAM,qEAAqE;CAEvF,IAAI,CAAC,OAAO,UAAU,OAAO,KAAK,UAAU,GAC1C,MAAM,IAAI,MAAM,sEAAsE;CAaxF,OAAO,UAAU;EAVf,OAAO,IAAI,gBAAgB,EAAE;EAC7B;EACA,SAAS,SAAS,QAAQ,SAAS,gBAAgB;EACnD,aAAa,UAAU;EACvB,OAAO,QAAQ,SAAS,GAAG,SAAS,EAAE,GAAG,OAAO,QAAQ,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE;EAC/E,KAAK,QAAQ,OAAO,KAAK;EACzB,QAAQ,QAAQ;EAChB,MAAM,iBAAiB,QAAQ,MAAM;EACrC,aAAa;CAEG,GAAG,OAAO;AAC9B;;AAGA,SAAS,UAAU,IAAkB,SAAoD;CACvF,IAAI,QAAQ,WAAW,KAAA,GACrB,GAAG,SAAS,QAAQ;CAEtB,IAAI,QAAQ,gBAAgB,KAAA,GAC1B,GAAG,cAAc,QAAQ;CAE3B,OAAO;AACT;AAEA,SAAS,SAAS,OAA2B,UAA0B;CACrE,OAAO,UAAU,KAAA,KAAa,OAAO,SAAS,KAAK,KAAK,QAAQ,IAAI,QAAQ;AAC9E"}

package/dist/capture/db-queue/keeper.d.mts

@@ -0,0 +1,34 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Logger } from "../../logger.mjs";
+import { LeaseRenewal, PollableCaptureQueue, PollableJob } from "../../adapter/capture-queue.mjs";
+import { QueueTimers } from "./timers.mjs";
+/** Longest gap between two renewals while progress keeps coming. */
+declare const RENEW_THROTTLE_MS = 30000;
+/** Why a held job must stop. */
+type LeaseEnd = Exclude<LeaseRenewal, "ok">;
+/** Options of {@link keepJobLease}. */
+interface LeaseKeeperOptions {
+  /** Renew at most this often (default `min(RENEW_THROTTLE_MS, leaseMs / 3)`). */
+  renewEveryMs?: number;
+  /** State check interval (default {@link CANCEL_CHECK_MS}). */
+  checkMs?: number;
+  /** Clock in epoch ms (default `Date.now`). */
+  now?: () => number;
+  /** Timers of the state check (default the global timers). */
+  timers?: QueueTimers;
+  logger?: Logger;
+}
+/** Handle on a held job's lease. */
+interface JobLeaseKeeper {
+  /** Report progress: renews the lease when the throttle allows. */
+  touch(): void;
+  /** Resolves once, when the job was cancelled or the lease lost; never while the job is ours. */
+  readonly ended: Promise<LeaseEnd>;
+  /** Stop checking; idempotent. */
+  stop(): void;
+}
+/** Keep `job`'s lease on `queue` while the caller reports progress through `touch`. */
+declare function keepJobLease(queue: Pick<PollableCaptureQueue, "extend" | "inspect">, job: PollableJob, options?: LeaseKeeperOptions): JobLeaseKeeper;
+export { JobLeaseKeeper, LeaseEnd, LeaseKeeperOptions, RENEW_THROTTLE_MS, keepJobLease };
+//# sourceMappingURL=keeper.d.mts.map

package/dist/capture/db-queue/keeper.mjs

@@ -0,0 +1,91 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { REAL_TIMERS, repeatEvery } from "./timers.mjs";
+import "./cadence.mjs";
+// src/capture/db-queue/keeper.ts
+/** Longest gap between two renewals while progress keeps coming. */
+const RENEW_THROTTLE_MS = 3e4;
+/** Keep `job`'s lease on `queue` while the caller reports progress through `touch`. */
+function keepJobLease(queue, job, options = {}) {
+	const now = options.now ?? Date.now;
+	const { promise, resolve } = Promise.withResolvers();
+	const state = {
+		lastRenewAt: now(),
+		renewing: false,
+		warned: false,
+		stopped: false,
+		settle: (end) => {
+			state.stopped = true;
+			resolve(end);
+		}
+	};
+	const stopChecks = startChecks(queue, job, state, options);
+	const stopBeat = startHeartbeat(queue, job, state, {
+		...options,
+		now
+	});
+	const stop = () => {
+		state.stopped = true;
+		stopChecks();
+		stopBeat();
+	};
+	promise.then(stop, stop);
+	return {
+		touch: () => {
+			renewIfDue(queue, job, state, {
+				...options,
+				now
+			});
+		},
+		ended: promise,
+		stop
+	};
+}
+function startChecks(queue, job, state, options) {
+	const { inspect } = queue;
+	if (inspect === void 0) return () => {};
+	return repeatEvery(options.timers ?? REAL_TIMERS, options.checkMs ?? 5e3, () => {
+		if (!state.stopped) report(state, inspect(job), options.logger, job).catch(() => {});
+	});
+}
+/** Renew on a timer, so a silent stage keeps its lease; progress renewals count toward the interval. */
+function startHeartbeat(queue, job, state, options) {
+	if (queue.extend === void 0) return () => {};
+	return repeatEvery(options.timers ?? REAL_TIMERS, renewInterval(job, options), () => {
+		renewIfDue(queue, job, state, options);
+	});
+}
+function renewIfDue(queue, job, state, options) {
+	const { extend } = queue;
+	const at = options.now();
+	if (extend === void 0 || state.stopped || state.renewing || at - state.lastRenewAt < renewInterval(job, options)) return;
+	state.renewing = true;
+	state.lastRenewAt = at;
+	report(state, extend(job), options.logger, job).finally(() => {
+		state.renewing = false;
+	}).catch(() => {});
+}
+/** Settle on a non-ok outcome; a failed call is transient (warned once, the next one retries). */
+async function report(state, outcome, logger, job) {
+	try {
+		const result = await outcome;
+		if (result !== "ok" && !state.stopped) state.settle(result);
+	} catch (error) {
+		if (!state.warned) {
+			state.warned = true;
+			logger?.warn({
+				err: error,
+				buildId: job.buildId
+			}, "failed to renew or check queue lease");
+		}
+	}
+}
+function renewInterval(job, options) {
+	if (options.renewEveryMs !== void 0) return options.renewEveryMs;
+	const third = job.leaseMs === void 0 ? RENEW_THROTTLE_MS : Math.floor(job.leaseMs / 3);
+	return Math.max(1, Math.min(RENEW_THROTTLE_MS, third));
+}
+export { RENEW_THROTTLE_MS, keepJobLease };
+
+//# sourceMappingURL=keeper.mjs.map

package/dist/capture/db-queue/keeper.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keeper.mjs","names":[],"sources":["../../../src/capture/db-queue/keeper.ts"],"sourcesContent":["/**\n * The holder's side of a lease: while the handler is alive the lease is renewed by a heartbeat\n * timer (every `min(30 s, lease / 3)`) and by progress (throttled to the same interval), so a stage\n * that prints nothing for longer than the lease is not redelivered. A holder that dies stops\n * renewing and its lease expires. A separate timer reads the job's state every 5 s, so cancel and\n * takeover are seen within that interval even while the run is hung. The heartbeat stops with the\n * keeper: on completion, on a lost lease and on cancel.\n */\nimport type {\n  LeaseRenewal,\n  PollableCaptureQueue,\n  PollableJob,\n} from \"../../adapters/capture-queue.ts\";\nimport type { Logger } from \"../../logger.ts\";\nimport { CANCEL_CHECK_MS } from \"./cadence.ts\";\nimport { REAL_TIMERS, repeatEvery, type QueueTimers } from \"./timers.ts\";\n\n/** Longest gap between two renewals while progress keeps coming. */\nexport const RENEW_THROTTLE_MS = 30_000;\n\n/** Why a held job must stop. */\nexport type LeaseEnd = Exclude<LeaseRenewal, \"ok\">;\n\n/** Options of {@link keepJobLease}. */\nexport interface LeaseKeeperOptions {\n  /** Renew at most this often (default `min(RENEW_THROTTLE_MS, leaseMs / 3)`). */\n  renewEveryMs?: number;\n  /** State check interval (default {@link CANCEL_CHECK_MS}). */\n  checkMs?: number;\n  /** Clock in epoch ms (default `Date.now`). */\n  now?: () => number;\n  /** Timers of the state check (default the global timers). */\n  timers?: QueueTimers;\n  logger?: Logger;\n}\n\n/** Handle on a held job's lease. */\nexport interface JobLeaseKeeper {\n  /** Report progress: renews the lease when the throttle allows. */\n  touch(): void;\n  /** Resolves once, when the job was cancelled or the lease lost; never while the job is ours. */\n  readonly ended: Promise<LeaseEnd>;\n  /** Stop checking; idempotent. */\n  stop(): void;\n}\n\ninterface KeeperState {\n  lastRenewAt: number;\n  renewing: boolean;\n  warned: boolean;\n  stopped: boolean;\n  settle: (end: LeaseEnd) => void;\n}\n\n/** Keep `job`'s lease on `queue` while the caller reports progress through `touch`. */\nexport function keepJobLease(\n  queue: Pick<PollableCaptureQueue, \"extend\" | \"inspect\">,\n  job: PollableJob,\n  options: LeaseKeeperOptions = {},\n): JobLeaseKeeper {\n  const now = options.now ?? Date.now;\n  const { promise, resolve } = Promise.withResolvers<LeaseEnd>();\n  const state: KeeperState = {\n    lastRenewAt: now(),\n    renewing: false,\n    warned: false,\n    stopped: false,\n    settle: (end) => {\n      state.stopped = true;\n      resolve(end);\n    },\n  };\n  const stopChecks = startChecks(queue, job, state, options);\n  const stopBeat = startHeartbeat(queue, job, state, { ...options, now });\n  const stop = (): void => {\n    state.stopped = true;\n    stopChecks();\n    stopBeat();\n  };\n  promise.then(stop, stop);\n  return {\n    touch: () => {\n      renewIfDue(queue, job, state, { ...options, now });\n    },\n    ended: promise,\n    stop,\n  };\n}\n\nfunction startChecks(\n  queue: Pick<PollableCaptureQueue, \"inspect\">,\n  job: PollableJob,\n  state: KeeperState,\n  options: LeaseKeeperOptions,\n): () => void {\n  const { inspect } = queue;\n  if (inspect === undefined) {\n    return () => {};\n  }\n  return repeatEvery(options.timers ?? REAL_TIMERS, options.checkMs ?? CANCEL_CHECK_MS, () => {\n    if (!state.stopped) {\n      report(state, inspect(job), options.logger, job).catch(() => {});\n    }\n  });\n}\n\n/** Renew on a timer, so a silent stage keeps its lease; progress renewals count toward the interval. */\nfunction startHeartbeat(\n  queue: Pick<PollableCaptureQueue, \"extend\">,\n  job: PollableJob,\n  state: KeeperState,\n  options: LeaseKeeperOptions & { now: () => number },\n): () => void {\n  if (queue.extend === undefined) {\n    return () => {};\n  }\n  return repeatEvery(options.timers ?? REAL_TIMERS, renewInterval(job, options), () => {\n    renewIfDue(queue, job, state, options);\n  });\n}\n\nfunction renewIfDue(\n  queue: Pick<PollableCaptureQueue, \"extend\">,\n  job: PollableJob,\n  state: KeeperState,\n  options: LeaseKeeperOptions & { now: () => number },\n): void {\n  const { extend } = queue;\n  const at = options.now();\n  if (\n    extend === undefined ||\n    state.stopped ||\n    state.renewing ||\n    at - state.lastRenewAt < renewInterval(job, options)\n  ) {\n    return;\n  }\n  state.renewing = true;\n  state.lastRenewAt = at;\n  report(state, extend(job), options.logger, job)\n    .finally(() => {\n      state.renewing = false;\n    })\n    .catch(() => {});\n}\n\n/** Settle on a non-ok outcome; a failed call is transient (warned once, the next one retries). */\nasync function report(\n  state: KeeperState,\n  outcome: Promise<LeaseRenewal>,\n  logger: Logger | undefined,\n  job: PollableJob,\n): Promise<void> {\n  try {\n    const result = await outcome;\n    if (result !== \"ok\" && !state.stopped) {\n      state.settle(result);\n    }\n  } catch (error) {\n    if (!state.warned) {\n      state.warned = true;\n      logger?.warn({ err: error, buildId: job.buildId }, \"failed to renew or check queue lease\");\n    }\n  }\n}\n\nfunction renewInterval(job: PollableJob, options: LeaseKeeperOptions): number {\n  if (options.renewEveryMs !== undefined) {\n    return options.renewEveryMs;\n  }\n  const third = job.leaseMs === undefined ? RENEW_THROTTLE_MS : Math.floor(job.leaseMs / 3);\n  return Math.max(1, Math.min(RENEW_THROTTLE_MS, third));\n}\n"],"mappings":";;;;;;;AAkBA,MAAa,oBAAoB;;AAqCjC,SAAgB,aACd,OACA,KACA,UAA8B,CAAC,GACf;CAChB,MAAM,MAAM,QAAQ,OAAO,KAAK;CAChC,MAAM,EAAE,SAAS,YAAY,QAAQ,cAAwB;CAC7D,MAAM,QAAqB;EACzB,aAAa,IAAI;EACjB,UAAU;EACV,QAAQ;EACR,SAAS;EACT,SAAS,QAAQ;GACf,MAAM,UAAU;GAChB,QAAQ,GAAG;EACb;CACF;CACA,MAAM,aAAa,YAAY,OAAO,KAAK,OAAO,OAAO;CACzD,MAAM,WAAW,eAAe,OAAO,KAAK,OAAO;EAAE,GAAG;EAAS;CAAI,CAAC;CACtE,MAAM,aAAmB;EACvB,MAAM,UAAU;EAChB,WAAW;EACX,SAAS;CACX;CACA,QAAQ,KAAK,MAAM,IAAI;CACvB,OAAO;EACL,aAAa;GACX,WAAW,OAAO,KAAK,OAAO;IAAE,GAAG;IAAS;GAAI,CAAC;EACnD;EACA,OAAO;EACP;CACF;AACF;AAEA,SAAS,YACP,OACA,KACA,OACA,SACY;CACZ,MAAM,EAAE,YAAY;CACpB,IAAI,YAAY,KAAA,GACd,aAAa,CAAC;CAEhB,OAAO,YAAY,QAAQ,UAAU,aAAa,QAAQ,WAAA,WAAkC;EAC1F,IAAI,CAAC,MAAM,SACT,OAAO,OAAO,QAAQ,GAAG,GAAG,QAAQ,QAAQ,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC;CAEnE,CAAC;AACH;;AAGA,SAAS,eACP,OACA,KACA,OACA,SACY;CACZ,IAAI,MAAM,WAAW,KAAA,GACnB,aAAa,CAAC;CAEhB,OAAO,YAAY,QAAQ,UAAU,aAAa,cAAc,KAAK,OAAO,SAAS;EACnF,WAAW,OAAO,KAAK,OAAO,OAAO;CACvC,CAAC;AACH;AAEA,SAAS,WACP,OACA,KACA,OACA,SACM;CACN,MAAM,EAAE,WAAW;CACnB,MAAM,KAAK,QAAQ,IAAI;CACvB,IACE,WAAW,KAAA,KACX,MAAM,WACN,MAAM,YACN,KAAK,MAAM,cAAc,cAAc,KAAK,OAAO,GAEnD;CAEF,MAAM,WAAW;CACjB,MAAM,cAAc;CACpB,OAAO,OAAO,OAAO,GAAG,GAAG,QAAQ,QAAQ,GAAG,CAAC,CAC5C,cAAc;EACb,MAAM,WAAW;CACnB,CAAC,CAAC,CACD,YAAY,CAAC,CAAC;AACnB;;AAGA,eAAe,OACb,OACA,SACA,QACA,KACe;CACf,IAAI;EACF,MAAM,SAAS,MAAM;EACrB,IAAI,WAAW,QAAQ,CAAC,MAAM,SAC5B,MAAM,OAAO,MAAM;CAEvB,SAAS,OAAO;EACd,IAAI,CAAC,MAAM,QAAQ;GACjB,MAAM,SAAS;GACf,QAAQ,KAAK;IAAE,KAAK;IAAO,SAAS,IAAI;GAAQ,GAAG,sCAAsC;EAC3F;CACF;AACF;AAEA,SAAS,cAAc,KAAkB,SAAqC;CAC5E,IAAI,QAAQ,iBAAiB,KAAA,GAC3B,OAAO,QAAQ;CAEjB,MAAM,QAAQ,IAAI,YAAY,KAAA,IAAY,oBAAoB,KAAK,MAAM,IAAI,UAAU,CAAC;CACxF,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,mBAAmB,KAAK,CAAC;AACvD"}

package/dist/capture/db-queue/lease.mjs

@@ -0,0 +1,45 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { isTerminalJob } from "../../models/capture-job.mjs";
+import { isoAt } from "./clock.mjs";
+import { attemptRef } from "./poll.mjs";
+// src/capture/db-queue/lease.ts
+/**
+* Renew the lease by another `leaseMs`. The write touches only the holder's attempt row and returns
+* it: an attempt retired by another instance reads `expired` (lost), a flagged one `cancelled`.
+* When the attempt is still ours, the job row is read too, so a job finished by another attempt or
+* cancelled is noticed at this progress touch.
+*/
+async function extendJob(rt, job) {
+	const row = await renewOwn(rt, attemptRef(job).receipt);
+	const own = attemptState(row);
+	if (row !== null && row.status !== "running") await rt.model.clearVisibility(row.id, isoAt(rt));
+	return own === "ok" ? await inspectJob(rt, job) : own;
+}
+/** The job's state for the holder of `job`, without renewing: the periodic cancel check. */
+async function inspectJob(rt, job) {
+	const ref = attemptRef(job);
+	return jobState(await rt.model.get(ref.jobId), ref.attempt);
+}
+function attemptState(row) {
+	if (row?.status !== "running") return "lost";
+	return row.cancelRequestedAt === null ? "ok" : "cancelled";
+}
+function jobState(row, attempt) {
+	if (row === null) return "lost";
+	if (row.status === "cancelled" || row.cancelRequestedAt !== null && !isTerminalJob(row)) return "cancelled";
+	return isTerminalJob(row) || row.attempt !== attempt ? "lost" : "ok";
+}
+/** Renew an attempt row; a row that no longer exists is lost, any other failure is transient. */
+async function renewOwn(rt, receipt) {
+	try {
+		return await rt.model.renew(receipt, isoAt(rt, rt.leaseMs), isoAt(rt));
+	} catch (error) {
+		if (await rt.model.get(receipt) === null) return null;
+		throw error;
+	}
+}
+export { extendJob, inspectJob };
+
+//# sourceMappingURL=lease.mjs.map

package/dist/capture/db-queue/lease.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lease.mjs","names":[],"sources":["../../../src/capture/db-queue/lease.ts"],"sourcesContent":["/**\n * Lease operations of the database queue: `extend` renews the holder's own attempt row (and never\n * any other), `inspect` reads the job row for cancel and supersession without renewing anything.\n */\nimport type { LeaseRenewal, PollableJob } from \"../../adapters/capture-queue.ts\";\nimport { isTerminalJob } from \"../../models/capture-job.ts\";\nimport type { CaptureJobRow } from \"../../schema/capture-job.ts\";\nimport { isoAt } from \"./clock.ts\";\nimport { attemptRef } from \"./poll.ts\";\nimport type { QueueRuntime } from \"./types.ts\";\n\n/**\n * Renew the lease by another `leaseMs`. The write touches only the holder's attempt row and returns\n * it: an attempt retired by another instance reads `expired` (lost), a flagged one `cancelled`.\n * When the attempt is still ours, the job row is read too, so a job finished by another attempt or\n * cancelled is noticed at this progress touch.\n */\nexport async function extendJob(rt: QueueRuntime, job: PollableJob): Promise<LeaseRenewal> {\n  const ref = attemptRef(job);\n  const row = await renewOwn(rt, ref.receipt);\n  const own = attemptState(row);\n  if (row !== null && row.status !== \"running\") {\n    // A late renewal of a retired row put a lease back on it; take the row out of the poll's range.\n    await rt.model.clearVisibility(row.id, isoAt(rt));\n  }\n  return own === \"ok\" ? await inspectJob(rt, job) : own;\n}\n\n/** The job's state for the holder of `job`, without renewing: the periodic cancel check. */\nexport async function inspectJob(rt: QueueRuntime, job: PollableJob): Promise<LeaseRenewal> {\n  const ref = attemptRef(job);\n  return jobState(await rt.model.get(ref.jobId), ref.attempt);\n}\n\nfunction attemptState(row: CaptureJobRow | null): LeaseRenewal {\n  if (row?.status !== \"running\") {\n    return \"lost\";\n  }\n  return row.cancelRequestedAt === null ? \"ok\" : \"cancelled\";\n}\n\nfunction jobState(row: CaptureJobRow | null, attempt: number): LeaseRenewal {\n  if (row === null) {\n    return \"lost\";\n  }\n  if (row.status === \"cancelled\" || (row.cancelRequestedAt !== null && !isTerminalJob(row))) {\n    return \"cancelled\";\n  }\n  return isTerminalJob(row) || row.attempt !== attempt ? \"lost\" : \"ok\";\n}\n\n/** Renew an attempt row; a row that no longer exists is lost, any other failure is transient. */\nasync function renewOwn(rt: QueueRuntime, receipt: string): Promise<CaptureJobRow | null> {\n  try {\n    return await rt.model.renew(receipt, isoAt(rt, rt.leaseMs), isoAt(rt));\n  } catch (error) {\n    if ((await rt.model.get(receipt)) === null) {\n      return null;\n    }\n    throw error;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,eAAsB,UAAU,IAAkB,KAAyC;CAEzF,MAAM,MAAM,MAAM,SAAS,IADf,WAAW,GACU,CAAC,CAAC,OAAO;CAC1C,MAAM,MAAM,aAAa,GAAG;CAC5B,IAAI,QAAQ,QAAQ,IAAI,WAAW,WAEjC,MAAM,GAAG,MAAM,gBAAgB,IAAI,IAAI,MAAM,EAAE,CAAC;CAElD,OAAO,QAAQ,OAAO,MAAM,WAAW,IAAI,GAAG,IAAI;AACpD;;AAGA,eAAsB,WAAW,IAAkB,KAAyC;CAC1F,MAAM,MAAM,WAAW,GAAG;CAC1B,OAAO,SAAS,MAAM,GAAG,MAAM,IAAI,IAAI,KAAK,GAAG,IAAI,OAAO;AAC5D;AAEA,SAAS,aAAa,KAAyC;CAC7D,IAAI,KAAK,WAAW,WAClB,OAAO;CAET,OAAO,IAAI,sBAAsB,OAAO,OAAO;AACjD;AAEA,SAAS,SAAS,KAA2B,SAA+B;CAC1E,IAAI,QAAQ,MACV,OAAO;CAET,IAAI,IAAI,WAAW,eAAgB,IAAI,sBAAsB,QAAQ,CAAC,cAAc,GAAG,GACrF,OAAO;CAET,OAAO,cAAc,GAAG,KAAK,IAAI,YAAY,UAAU,SAAS;AAClE;;AAGA,eAAe,SAAS,IAAkB,SAAgD;CACxF,IAAI;EACF,OAAO,MAAM,GAAG,MAAM,MAAM,SAAS,MAAM,IAAI,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC;CACvE,SAAS,OAAO;EACd,IAAK,MAAM,GAAG,MAAM,IAAI,OAAO,MAAO,MACpC,OAAO;EAET,MAAM;CACR;AACF"}

package/dist/capture/db-queue/lifecycle.mjs

@@ -0,0 +1,35 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+// src/capture/db-queue/lifecycle.ts
+/** Id no row ever has: the health probe is a primary-key read that finds nothing. */
+const HEALTH_PROBE_ID = "~health";
+/**
+* Setup is a no-op (the database adapter's own setup creates `capture_jobs`); teardown releases any
+* poll waiting on a local wake; health reads the table by primary key.
+*/
+function buildQueueLifecycle(rt) {
+	return {
+		setup: async () => {
+			await Promise.resolve();
+		},
+		teardown: async () => {
+			rt.wake.close();
+			await Promise.resolve();
+		},
+		health: async () => {
+			try {
+				await rt.model.get(HEALTH_PROBE_ID);
+				return { ok: true };
+			} catch (error) {
+				return {
+					ok: false,
+					detail: error instanceof Error ? error.message : String(error)
+				};
+			}
+		}
+	};
+}
+export { buildQueueLifecycle };
+
+//# sourceMappingURL=lifecycle.mjs.map

package/dist/capture/db-queue/lifecycle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.mjs","names":[],"sources":["../../../src/capture/db-queue/lifecycle.ts"],"sourcesContent":["/** Lifecycle of the database queue: the database adapter owns its connection, the queue its waiters. */\nimport type { AdapterLifecycle } from \"../../adapters/metadata.ts\";\nimport type { QueueRuntime } from \"./types.ts\";\n\n/** Id no row ever has: the health probe is a primary-key read that finds nothing. */\nconst HEALTH_PROBE_ID = \"~health\";\n\n/**\n * Setup is a no-op (the database adapter's own setup creates `capture_jobs`); teardown releases any\n * poll waiting on a local wake; health reads the table by primary key.\n */\nexport function buildQueueLifecycle(rt: QueueRuntime): AdapterLifecycle {\n  return {\n    setup: async () => {\n      await Promise.resolve();\n    },\n    teardown: async () => {\n      rt.wake.close();\n      await Promise.resolve();\n    },\n    health: async () => {\n      try {\n        await rt.model.get(HEALTH_PROBE_ID);\n        return { ok: true };\n      } catch (error) {\n        return { ok: false, detail: error instanceof Error ? error.message : String(error) };\n      }\n    },\n  };\n}\n"],"mappings":";;;;;AAKA,MAAM,kBAAkB;;;;;AAMxB,SAAgB,oBAAoB,IAAoC;CACtE,OAAO;EACL,OAAO,YAAY;GACjB,MAAM,QAAQ,QAAQ;EACxB;EACA,UAAU,YAAY;GACpB,GAAG,KAAK,MAAM;GACd,MAAM,QAAQ,QAAQ;EACxB;EACA,QAAQ,YAAY;GAClB,IAAI;IACF,MAAM,GAAG,MAAM,IAAI,eAAe;IAClC,OAAO,EAAE,IAAI,KAAK;GACpB,SAAS,OAAO;IACd,OAAO;KAAE,IAAI;KAAO,QAAQ,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;IAAE;GACrF;EACF;CACF;AACF"}

package/dist/capture/db-queue/operations.mjs

@@ -0,0 +1,93 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { ulid } from "../../utils/ulid.mjs";
+import { attemptRowId, isTerminalJob } from "../../models/capture-job.mjs";
+import { encodePayload, toQueueEntry } from "./codec.mjs";
+import { isoAt } from "./clock.mjs";
+// src/capture/db-queue/operations.ts
+/** Insert a queued job row and wake this instance's poller; resolves to the job id. */
+async function enqueueJob(rt, job) {
+	const id = ulid();
+	const now = isoAt(rt);
+	await rt.model.create({
+		id,
+		kind: job.kind,
+		buildId: job.buildId ?? null,
+		shardId: job.shard ?? null,
+		maxAttempts: job.maxAttempts ?? rt.maxAttempts,
+		payload: encodePayload(job)
+	}, now);
+	rt.logger?.info({
+		jobId: id,
+		kind: job.kind,
+		buildId: job.buildId
+	}, "job queued");
+	rt.wake.notify();
+	return id;
+}
+/**
+* The kinds the queue's views (`status`, `active`, `recent`, `cancel`) show: every polled kind but
+* `notify` (unless it is the only one), whose many short delivery jobs would bury a build's capture and publish jobs.
+*/
+function viewKinds(rt) {
+	const shown = rt.kinds.filter((kind) => kind !== "notify");
+	return shown.length > 0 ? shown : rt.kinds;
+}
+/** `CaptureQueue.enqueue`: a capture job for a build or one of its shards. */
+async function enqueueCapture(rt, job) {
+	await enqueueJob(rt, {
+		...job,
+		kind: "capture"
+	});
+}
+/** The build's own job most recently queued, as a queue entry. */
+async function statusOf(rt, buildId) {
+	const row = await rt.model.latestForBuild(buildId, viewKinds(rt));
+	return row === null ? null : toQueueEntry(row);
+}
+/** Queued and running jobs of this queue's kinds on every instance, oldest first. */
+async function activeEntries(rt) {
+	return (await rt.model.listActive(viewKinds(rt))).map((row) => toQueueEntry(row));
+}
+/** The newest jobs of this queue's kinds, newest first. */
+async function recentEntries(rt, limit) {
+	return (await rt.model.listRecent(viewKinds(rt), limit)).map((row) => toQueueEntry(row));
+}
+/**
+* Cancel a job (by job id) or every unfinished job of a build (by build id), of every kind that
+* shares the table (capture, publish and notify), whichever kinds this queue polls. A queued job ends `cancelled` at once; a running one is flagged on its job row and on
+* its current attempt row, so the holder sees it on its next renewal or cancel check.
+*/
+async function cancelJobs(rt, id) {
+	const targets = (await targetsOf(rt, id)).filter((row) => !isTerminalJob(row));
+	await Promise.all(targets.map(async (row) => {
+		await cancelOne(rt, row);
+	}));
+	if (targets.length > 0) rt.logger?.info({
+		id,
+		jobs: targets.length
+	}, "cancel requested");
+	return targets.length > 0;
+}
+async function targetsOf(rt, id) {
+	const row = await rt.model.get(id);
+	if (row?.entry === "job") return [row];
+	return await rt.model.listForBuild(id);
+}
+async function cancelOne(rt, row) {
+	const now = isoAt(rt);
+	await rt.model.flagCancel(row.jobId, now);
+	if (row.status === "queued") {
+		await rt.model.finishJob(row.jobId, "cancelled", now);
+		await flagAttempt(rt, attemptRowId(row.jobId, row.attempt + 1), now);
+		return;
+	}
+	await flagAttempt(rt, attemptRowId(row.jobId, row.attempt), now);
+}
+async function flagAttempt(rt, attemptId, now) {
+	if ((await rt.model.get(attemptId))?.status === "running") await rt.model.flagCancel(attemptId, now);
+}
+export { activeEntries, cancelJobs, enqueueCapture, enqueueJob, recentEntries, statusOf };
+
+//# sourceMappingURL=operations.mjs.map

package/dist/capture/db-queue/operations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.mjs","names":[],"sources":["../../../src/capture/db-queue/operations.ts"],"sourcesContent":["/** Enqueue, cancel and the cross-instance views (`status`/`active`/`recent`) of the database queue. */\nimport type { CaptureJob, QueueEntry } from \"../../adapters/capture-queue.ts\";\nimport { attemptRowId, isTerminalJob } from \"../../models/capture-job.ts\";\nimport type { CaptureJobKind, CaptureJobRow } from \"../../schema/capture-job.ts\";\nimport { ulid } from \"../../utils/ulid.ts\";\nimport { isoAt } from \"./clock.ts\";\nimport { encodePayload, toQueueEntry } from \"./codec.ts\";\nimport type { QueueJobInput, QueueRuntime } from \"./types.ts\";\n\n/** Insert a queued job row and wake this instance's poller; resolves to the job id. */\nexport async function enqueueJob(rt: QueueRuntime, job: QueueJobInput): Promise<string> {\n  const id = ulid();\n  const now = isoAt(rt);\n  await rt.model.create(\n    {\n      id,\n      kind: job.kind,\n      buildId: job.buildId ?? null,\n      shardId: job.shard ?? null,\n      maxAttempts: job.maxAttempts ?? rt.maxAttempts,\n      payload: encodePayload(job),\n    },\n    now,\n  );\n  rt.logger?.info({ jobId: id, kind: job.kind, buildId: job.buildId }, \"job queued\");\n  rt.wake.notify();\n  return id;\n}\n\n/**\n * The kinds the queue's views (`status`, `active`, `recent`, `cancel`) show: every polled kind but\n * `notify` (unless it is the only one), whose many short delivery jobs would bury a build's capture and publish jobs.\n */\nfunction viewKinds(rt: QueueRuntime): readonly CaptureJobKind[] {\n  const shown = rt.kinds.filter((kind) => kind !== \"notify\");\n  return shown.length > 0 ? shown : rt.kinds;\n}\n\n/** `CaptureQueue.enqueue`: a capture job for a build or one of its shards. */\nexport async function enqueueCapture(rt: QueueRuntime, job: CaptureJob): Promise<void> {\n  await enqueueJob(rt, { ...job, kind: \"capture\" });\n}\n\n/** The build's own job most recently queued, as a queue entry. */\nexport async function statusOf(rt: QueueRuntime, buildId: string): Promise<QueueEntry | null> {\n  const row = await rt.model.latestForBuild(buildId, viewKinds(rt));\n  return row === null ? null : toQueueEntry(row);\n}\n\n/** Queued and running jobs of this queue's kinds on every instance, oldest first. */\nexport async function activeEntries(rt: QueueRuntime): Promise<QueueEntry[]> {\n  return (await rt.model.listActive(viewKinds(rt))).map((row) => toQueueEntry(row));\n}\n\n/** The newest jobs of this queue's kinds, newest first. */\nexport async function recentEntries(rt: QueueRuntime, limit: number): Promise<QueueEntry[]> {\n  return (await rt.model.listRecent(viewKinds(rt), limit)).map((row) => toQueueEntry(row));\n}\n\n/**\n * Cancel a job (by job id) or every unfinished job of a build (by build id), of every kind that\n * shares the table (capture, publish and notify), whichever kinds this queue polls. A queued job ends `cancelled` at once; a running one is flagged on its job row and on\n * its current attempt row, so the holder sees it on its next renewal or cancel check.\n */\nexport async function cancelJobs(rt: QueueRuntime, id: string): Promise<boolean> {\n  const targets = (await targetsOf(rt, id)).filter((row) => !isTerminalJob(row));\n  await Promise.all(\n    targets.map(async (row) => {\n      await cancelOne(rt, row);\n    }),\n  );\n  if (targets.length > 0) {\n    rt.logger?.info({ id, jobs: targets.length }, \"cancel requested\");\n  }\n  return targets.length > 0;\n}\n\nasync function targetsOf(rt: QueueRuntime, id: string): Promise<CaptureJobRow[]> {\n  const row = await rt.model.get(id);\n  if (row?.entry === \"job\") {\n    return [row];\n  }\n  return await rt.model.listForBuild(id);\n}\n\nasync function cancelOne(rt: QueueRuntime, row: CaptureJobRow): Promise<void> {\n  const now = isoAt(rt);\n  // The flag goes first: it is never cleared, so a claim racing this cancel still sees it.\n  await rt.model.flagCancel(row.jobId, now);\n  if (row.status === \"queued\") {\n    await rt.model.finishJob(row.jobId, \"cancelled\", now);\n    // A claimer may have inserted the next attempt between our read and the write above.\n    await flagAttempt(rt, attemptRowId(row.jobId, row.attempt + 1), now);\n    return;\n  }\n  await flagAttempt(rt, attemptRowId(row.jobId, row.attempt), now);\n}\n\nasync function flagAttempt(rt: QueueRuntime, attemptId: string, now: string): Promise<void> {\n  const attempt = await rt.model.get(attemptId);\n  if (attempt?.status === \"running\") {\n    await rt.model.flagCancel(attemptId, now);\n  }\n}\n"],"mappings":";;;;;;;;;AAUA,eAAsB,WAAW,IAAkB,KAAqC;CACtF,MAAM,KAAK,KAAK;CAChB,MAAM,MAAM,MAAM,EAAE;CACpB,MAAM,GAAG,MAAM,OACb;EACE;EACA,MAAM,IAAI;EACV,SAAS,IAAI,WAAW;EACxB,SAAS,IAAI,SAAS;EACtB,aAAa,IAAI,eAAe,GAAG;EACnC,SAAS,cAAc,GAAG;CAC5B,GACA,GACF;CACA,GAAG,QAAQ,KAAK;EAAE,OAAO;EAAI,MAAM,IAAI;EAAM,SAAS,IAAI;CAAQ,GAAG,YAAY;CACjF,GAAG,KAAK,OAAO;CACf,OAAO;AACT;;;;;AAMA,SAAS,UAAU,IAA6C;CAC9D,MAAM,QAAQ,GAAG,MAAM,QAAQ,SAAS,SAAS,QAAQ;CACzD,OAAO,MAAM,SAAS,IAAI,QAAQ,GAAG;AACvC;;AAGA,eAAsB,eAAe,IAAkB,KAAgC;CACrF,MAAM,WAAW,IAAI;EAAE,GAAG;EAAK,MAAM;CAAU,CAAC;AAClD;;AAGA,eAAsB,SAAS,IAAkB,SAA6C;CAC5F,MAAM,MAAM,MAAM,GAAG,MAAM,eAAe,SAAS,UAAU,EAAE,CAAC;CAChE,OAAO,QAAQ,OAAO,OAAO,aAAa,GAAG;AAC/C;;AAGA,eAAsB,cAAc,IAAyC;CAC3E,QAAQ,MAAM,GAAG,MAAM,WAAW,UAAU,EAAE,CAAC,EAAA,CAAG,KAAK,QAAQ,aAAa,GAAG,CAAC;AAClF;;AAGA,eAAsB,cAAc,IAAkB,OAAsC;CAC1F,QAAQ,MAAM,GAAG,MAAM,WAAW,UAAU,EAAE,GAAG,KAAK,EAAA,CAAG,KAAK,QAAQ,aAAa,GAAG,CAAC;AACzF;;;;;;AAOA,eAAsB,WAAW,IAAkB,IAA8B;CAC/E,MAAM,WAAW,MAAM,UAAU,IAAI,EAAE,EAAA,CAAG,QAAQ,QAAQ,CAAC,cAAc,GAAG,CAAC;CAC7E,MAAM,QAAQ,IACZ,QAAQ,IAAI,OAAO,QAAQ;EACzB,MAAM,UAAU,IAAI,GAAG;CACzB,CAAC,CACH;CACA,IAAI,QAAQ,SAAS,GACnB,GAAG,QAAQ,KAAK;EAAE;EAAI,MAAM,QAAQ;CAAO,GAAG,kBAAkB;CAElE,OAAO,QAAQ,SAAS;AAC1B;AAEA,eAAe,UAAU,IAAkB,IAAsC;CAC/E,MAAM,MAAM,MAAM,GAAG,MAAM,IAAI,EAAE;CACjC,IAAI,KAAK,UAAU,OACjB,OAAO,CAAC,GAAG;CAEb,OAAO,MAAM,GAAG,MAAM,aAAa,EAAE;AACvC;AAEA,eAAe,UAAU,IAAkB,KAAmC;CAC5E,MAAM,MAAM,MAAM,EAAE;CAEpB,MAAM,GAAG,MAAM,WAAW,IAAI,OAAO,GAAG;CACxC,IAAI,IAAI,WAAW,UAAU;EAC3B,MAAM,GAAG,MAAM,UAAU,IAAI,OAAO,aAAa,GAAG;EAEpD,MAAM,YAAY,IAAI,aAAa,IAAI,OAAO,IAAI,UAAU,CAAC,GAAG,GAAG;EACnE;CACF;CACA,MAAM,YAAY,IAAI,aAAa,IAAI,OAAO,IAAI,OAAO,GAAG,GAAG;AACjE;AAEA,eAAe,YAAY,IAAkB,WAAmB,KAA4B;CAE1F,KAAI,MADkB,GAAG,MAAM,IAAI,SAAS,EAAA,EAC/B,WAAW,WACtB,MAAM,GAAG,MAAM,WAAW,WAAW,GAAG;AAE5C"}

package/dist/capture/db-queue/poll-loop.d.mts

@@ -0,0 +1,28 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Logger } from "../../logger.mjs";
+import { PollCadence } from "./cadence.mjs";
+import { DatabaseCaptureQueue, DatabaseJob } from "./types.mjs";
+/** Options of {@link startPollLoop}. */
+interface PollLoopOptions {
+  queue: Pick<DatabaseCaptureQueue, "poll" | "waitForWork">;
+  /** Jobs this instance runs at once (`testing.concurrency`). */
+  slots: number;
+  /** Run one claimed job to its end (ack or nack it); rejections are logged, never fatal. */
+  run: (job: DatabaseJob) => Promise<void>;
+  cadence?: PollCadence;
+  now?: () => number;
+  random?: () => number;
+  logger?: Logger;
+}
+/** Handle on a running poll loop. */
+interface PollLoop {
+  /** Jobs running right now. */
+  readonly busy: number;
+  /** Stop polling and wait for the jobs in flight to finish; idempotent. */
+  stop(): Promise<void>;
+}
+/** Start polling `queue` with `slots` concurrent jobs. */
+declare function startPollLoop(options: PollLoopOptions): PollLoop;
+export { PollLoop, PollLoopOptions, startPollLoop };
+//# sourceMappingURL=poll-loop.d.mts.map

package/dist/capture/db-queue/poll-loop.mjs

@@ -0,0 +1,88 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { DEFAULT_CADENCE, nextPollDelay } from "./cadence.mjs";
+// src/capture/db-queue/poll-loop.ts
+/** Start polling `queue` with `slots` concurrent jobs. */
+function startPollLoop(options) {
+	const state = {
+		busy: 0,
+		stopped: false,
+		lastWorkAt: null,
+		inFlight: /* @__PURE__ */ new Set(),
+		nudge: () => {}
+	};
+	const done = loop(options, state);
+	return {
+		get busy() {
+			return state.busy;
+		},
+		stop: async () => {
+			state.stopped = true;
+			state.nudge();
+			await done;
+			await Promise.allSettled(state.inFlight);
+		}
+	};
+}
+async function loop(options, state) {
+	const now = options.now ?? Date.now;
+	while (!state.stopped) await step(options, state, now);
+}
+/** One turn: wait for a slot (no poll while all are busy), else probe once and run or idle. */
+async function step(options, state, now) {
+	if (state.busy >= options.slots) {
+		await nudged(state);
+		return;
+	}
+	const job = await pollOnce(options);
+	if (job === null) {
+		await idle(options, state, now);
+		return;
+	}
+	state.lastWorkAt = now();
+	launch(options, state, job);
+}
+async function pollOnce(options) {
+	try {
+		return await options.queue.poll();
+	} catch (error) {
+		options.logger?.warn({ err: error }, "queue poll failed");
+		return null;
+	}
+}
+async function idle(options, state, now) {
+	const delay = nextPollDelay(state.lastWorkAt, now(), options.cadence ?? DEFAULT_CADENCE, options.random);
+	if (await Promise.race([options.queue.waitForWork(delay), nudged(state).then(() => false)])) state.lastWorkAt = now();
+}
+function launch(options, state, job) {
+	state.busy += 1;
+	const running = runSafely(options, job).finally(() => {
+		state.busy -= 1;
+		state.inFlight.delete(running);
+		state.nudge();
+	});
+	state.inFlight.add(running);
+}
+async function runSafely(options, job) {
+	try {
+		await options.run(job);
+	} catch (error) {
+		options.logger?.error({
+			err: error,
+			jobId: job.jobId
+		}, "queue job run failed");
+	}
+}
+/** A promise the next nudge (slot freed, stop) resolves. */
+async function nudged(state) {
+	if (state.stopped) return;
+	const { promise, resolve } = Promise.withResolvers();
+	state.nudge = () => {
+		resolve(null);
+	};
+	await promise;
+}
+export { startPollLoop };
+
+//# sourceMappingURL=poll-loop.mjs.map

package/dist/capture/db-queue/poll-loop.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"poll-loop.mjs","names":[],"sources":["../../../src/capture/db-queue/poll-loop.ts"],"sourcesContent":["/**\n * The slot-aware poll loop over the database queue: an instance polls only while it has a free\n * slot, at the cadence of `cadence.ts`, and dispatches at once on a local enqueue. Each claimed job\n * runs in a slot; the caller's `run` owns ack/nack and the lease. The full consumer (retries, the\n * final-attempt rule, drain on SIGTERM) builds on this loop.\n */\nimport type { Logger } from \"../../logger.ts\";\nimport { DEFAULT_CADENCE, nextPollDelay, type PollCadence } from \"./cadence.ts\";\nimport type { DatabaseCaptureQueue, DatabaseJob } from \"./types.ts\";\n\n/** Options of {@link startPollLoop}. */\nexport interface PollLoopOptions {\n  queue: Pick<DatabaseCaptureQueue, \"poll\" | \"waitForWork\">;\n  /** Jobs this instance runs at once (`testing.concurrency`). */\n  slots: number;\n  /** Run one claimed job to its end (ack or nack it); rejections are logged, never fatal. */\n  run: (job: DatabaseJob) => Promise<void>;\n  cadence?: PollCadence;\n  now?: () => number;\n  random?: () => number;\n  logger?: Logger;\n}\n\n/** Handle on a running poll loop. */\nexport interface PollLoop {\n  /** Jobs running right now. */\n  readonly busy: number;\n  /** Stop polling and wait for the jobs in flight to finish; idempotent. */\n  stop(): Promise<void>;\n}\n\ninterface LoopState {\n  busy: number;\n  stopped: boolean;\n  lastWorkAt: number | null;\n  inFlight: Set<Promise<void>>;\n  /** Resolves the current idle wait early (slot freed or stop). */\n  nudge: () => void;\n}\n\n/** Start polling `queue` with `slots` concurrent jobs. */\nexport function startPollLoop(options: PollLoopOptions): PollLoop {\n  const state: LoopState = {\n    busy: 0,\n    stopped: false,\n    lastWorkAt: null,\n    inFlight: new Set(),\n    nudge: () => {},\n  };\n  const done = loop(options, state);\n  return {\n    get busy() {\n      return state.busy;\n    },\n    stop: async () => {\n      state.stopped = true;\n      state.nudge();\n      await done;\n      await Promise.allSettled(state.inFlight);\n    },\n  };\n}\n\nasync function loop(options: PollLoopOptions, state: LoopState): Promise<void> {\n  const now = options.now ?? Date.now;\n  while (!state.stopped) {\n    // oxlint-disable-next-line no-await-in-loop -- one step at a time is the loop\n    await step(options, state, now);\n  }\n}\n\n/** One turn: wait for a slot (no poll while all are busy), else probe once and run or idle. */\nasync function step(options: PollLoopOptions, state: LoopState, now: () => number): Promise<void> {\n  if (state.busy >= options.slots) {\n    await nudged(state);\n    return;\n  }\n  const job = await pollOnce(options);\n  if (job === null) {\n    await idle(options, state, now);\n    return;\n  }\n  state.lastWorkAt = now();\n  launch(options, state, job);\n}\n\nasync function pollOnce(options: PollLoopOptions): Promise<DatabaseJob | null> {\n  try {\n    return await options.queue.poll();\n  } catch (error) {\n    options.logger?.warn({ err: error }, \"queue poll failed\");\n    return null;\n  }\n}\n\nasync function idle(options: PollLoopOptions, state: LoopState, now: () => number): Promise<void> {\n  const delay = nextPollDelay(\n    state.lastWorkAt,\n    now(),\n    options.cadence ?? DEFAULT_CADENCE,\n    options.random,\n  );\n  const woken = await Promise.race([\n    options.queue.waitForWork(delay),\n    nudged(state).then(() => false),\n  ]);\n  if (woken) {\n    state.lastWorkAt = now();\n  }\n}\n\nfunction launch(options: PollLoopOptions, state: LoopState, job: DatabaseJob): void {\n  state.busy += 1;\n  const running = runSafely(options, job).finally(() => {\n    state.busy -= 1;\n    state.inFlight.delete(running);\n    state.nudge();\n  });\n  state.inFlight.add(running);\n}\n\nasync function runSafely(options: PollLoopOptions, job: DatabaseJob): Promise<void> {\n  try {\n    await options.run(job);\n  } catch (error) {\n    options.logger?.error({ err: error, jobId: job.jobId }, \"queue job run failed\");\n  }\n}\n\n/** A promise the next nudge (slot freed, stop) resolves. */\nasync function nudged(state: LoopState): Promise<void> {\n  if (state.stopped) {\n    return;\n  }\n  const { promise, resolve } = Promise.withResolvers<null>();\n  state.nudge = (): void => {\n    resolve(null);\n  };\n  await promise;\n}\n"],"mappings":";;;;;;AAyCA,SAAgB,cAAc,SAAoC;CAChE,MAAM,QAAmB;EACvB,MAAM;EACN,SAAS;EACT,YAAY;EACZ,0BAAU,IAAI,IAAI;EAClB,aAAa,CAAC;CAChB;CACA,MAAM,OAAO,KAAK,SAAS,KAAK;CAChC,OAAO;EACL,IAAI,OAAO;GACT,OAAO,MAAM;EACf;EACA,MAAM,YAAY;GAChB,MAAM,UAAU;GAChB,MAAM,MAAM;GACZ,MAAM;GACN,MAAM,QAAQ,WAAW,MAAM,QAAQ;EACzC;CACF;AACF;AAEA,eAAe,KAAK,SAA0B,OAAiC;CAC7E,MAAM,MAAM,QAAQ,OAAO,KAAK;CAChC,OAAO,CAAC,MAAM,SAEZ,MAAM,KAAK,SAAS,OAAO,GAAG;AAElC;;AAGA,eAAe,KAAK,SAA0B,OAAkB,KAAkC;CAChG,IAAI,MAAM,QAAQ,QAAQ,OAAO;EAC/B,MAAM,OAAO,KAAK;EAClB;CACF;CACA,MAAM,MAAM,MAAM,SAAS,OAAO;CAClC,IAAI,QAAQ,MAAM;EAChB,MAAM,KAAK,SAAS,OAAO,GAAG;EAC9B;CACF;CACA,MAAM,aAAa,IAAI;CACvB,OAAO,SAAS,OAAO,GAAG;AAC5B;AAEA,eAAe,SAAS,SAAuD;CAC7E,IAAI;EACF,OAAO,MAAM,QAAQ,MAAM,KAAK;CAClC,SAAS,OAAO;EACd,QAAQ,QAAQ,KAAK,EAAE,KAAK,MAAM,GAAG,mBAAmB;EACxD,OAAO;CACT;AACF;AAEA,eAAe,KAAK,SAA0B,OAAkB,KAAkC;CAChG,MAAM,QAAQ,cACZ,MAAM,YACN,IAAI,GACJ,QAAQ,WAAW,iBACnB,QAAQ,MACV;CAKA,IAAI,MAJgB,QAAQ,KAAK,CAC/B,QAAQ,MAAM,YAAY,KAAK,GAC/B,OAAO,KAAK,CAAC,CAAC,WAAW,KAAK,CAChC,CAAC,GAEC,MAAM,aAAa,IAAI;AAE3B;AAEA,SAAS,OAAO,SAA0B,OAAkB,KAAwB;CAClF,MAAM,QAAQ;CACd,MAAM,UAAU,UAAU,SAAS,GAAG,CAAC,CAAC,cAAc;EACpD,MAAM,QAAQ;EACd,MAAM,SAAS,OAAO,OAAO;EAC7B,MAAM,MAAM;CACd,CAAC;CACD,MAAM,SAAS,IAAI,OAAO;AAC5B;AAEA,eAAe,UAAU,SAA0B,KAAiC;CAClF,IAAI;EACF,MAAM,QAAQ,IAAI,GAAG;CACvB,SAAS,OAAO;EACd,QAAQ,QAAQ,MAAM;GAAE,KAAK;GAAO,OAAO,IAAI;EAAM,GAAG,sBAAsB;CAChF;AACF;;AAGA,eAAe,OAAO,OAAiC;CACrD,IAAI,MAAM,SACR;CAEF,MAAM,EAAE,SAAS,YAAY,QAAQ,cAAoB;CACzD,MAAM,cAAoB;EACxB,QAAQ,IAAI;CACd;CACA,MAAM;AACR"}

package/dist/capture/db-queue/poll.d.mts

@@ -0,0 +1,8 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import "../../adapter/capture-queue.mjs";
+import "./types.mjs";
+/** Longest a nack may delay a retry; larger delays are clamped. */
+declare const MAX_NACK_DELAY_MS: number;
+export { MAX_NACK_DELAY_MS };
+//# sourceMappingURL=poll.d.mts.map