@storyshelf/core 0.6.2 → 0.7.0

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

@@ -0,0 +1,132 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { attemptRowId, isTerminalJob } from "../../models/capture-job.mjs";
+import { toDatabaseJob } from "./codec.mjs";
+import { isoAt } from "./clock.mjs";
+//#region src/capture/db-queue/claim.ts
+/**
+* The claim algorithm of the database queue. A poll probes for the oldest candidate row (a queued
+* job whose `visibleAt` passed, or a running attempt whose lease ran out), then claims the job's
+* next attempt by inserting its row: the unique key lets exactly one instance win. The winner
+* retires the expired attempt it replaced and marks the job row running.
+*/
+/** Candidates tried per poll when other instances win the race for them. */
+const MAX_CLAIM_TRIES = 3;
+/** Error recorded on a job whose last allowed attempt lost its lease. */
+const LEASE_EXHAUSTED_ERROR = "lease expired on the final attempt";
+/** Probe once and claim the job found; on a lost race, try the next candidate (a few times). */
+async function claimNext(rt) {
+	for (let tries = 0; tries < MAX_CLAIM_TRIES; tries += 1) {
+		const candidate = await rt.model.nextCandidate(rt.kinds, isoAt(rt));
+		if (candidate === null) return null;
+		const job = await claimCandidate(rt, candidate);
+		if (job !== null) return job;
+	}
+	return null;
+}
+/** Claim the job behind a candidate row; null when it is gone, over, exhausted or lost to a race. */
+async function claimCandidate(rt, candidate) {
+	if (candidate.entry === "job" && candidate.status !== "queued") {
+		await rt.model.clearVisibility(candidate.id, isoAt(rt));
+		return null;
+	}
+	const stale = candidate.entry === "attempt" ? candidate : null;
+	const job = stale === null ? candidate : await rt.model.get(candidate.jobId);
+	if (job === null || isTerminalJob(job) || stale !== null && stale.attempt < job.attempt) {
+		await retire(rt, stale);
+		return null;
+	}
+	return await claimNextAttempt(rt, job, stale);
+}
+/** Claim the attempt after the last one made, or fail the job when none is left. */
+async function claimNextAttempt(rt, job, stale) {
+	const made = Math.max(job.attempt, stale?.attempt ?? 0);
+	if (made >= job.maxAttempts) {
+		await exhaust(rt, job, stale);
+		return null;
+	}
+	return await claimAttempt(rt, job, made + 1, stale);
+}
+async function claimAttempt(rt, job, attempt, stale) {
+	const leaseUntil = isoAt(rt, rt.leaseMs);
+	if (!await rt.model.claim({
+		job,
+		attempt,
+		owner: rt.owner,
+		leaseUntil
+	}, isoAt(rt))) return stale === null ? await afterLostRace(rt, job, attempt) : null;
+	const fresh = await rt.model.get(job.jobId);
+	if (fresh === null || isTerminalJob(fresh)) {
+		await rt.model.finishAttempt(attemptRowId(job.jobId, attempt), "expired", isoAt(rt));
+		return null;
+	}
+	return await takeOver(rt, fresh, attempt, stale);
+}
+/**
+* Another instance holds attempt `attempt` of a job whose row still reads queued. Usually that
+* winner is about to mark the job running. If it died before doing so, its attempt's lease decides:
+* once expired, the attempt is claimed like any expired one; until then the job row is moved
+* behind that lease, so it does not sit at the head of the queue losing every claim. Only
+* `visibleAt` is written, never the status, so a winner that finished meanwhile keeps its outcome.
+*/
+async function afterLostRace(rt, job, attempt) {
+	const id = attemptRowId(job.jobId, attempt);
+	const expired = await rt.model.expiredAttempt(id, isoAt(rt));
+	if (expired !== null) return await claimCandidate(rt, expired);
+	await deferBehind(rt, job, await rt.model.get(id));
+	return null;
+}
+async function deferBehind(rt, job, holder) {
+	const current = await rt.model.get(job.jobId);
+	if (holder?.visibleAt && current?.status === "queued" && current.attempt === job.attempt) await rt.model.defer(job.jobId, holder.visibleAt, isoAt(rt));
+}
+/** The claim won: retire the attempt it replaced and record the new one on the job row. */
+async function takeOver(rt, job, attempt, stale) {
+	await retire(rt, stale);
+	await rt.model.markRunning(job.jobId, attempt, isoAt(rt));
+	rt.logger?.debug({
+		jobId: job.jobId,
+		attempt
+	}, "job claimed");
+	return toDatabaseJob(job, attempt, rt.leaseMs);
+}
+/** Mark an expired attempt row `expired`: it leaves the poll's range, and its holder sees `lost`. */
+async function retire(rt, stale) {
+	if (stale !== null) await rt.model.finishAttempt(stale.id, "expired", isoAt(rt));
+}
+/**
+* The final attempt lost its lease: the job fails (one limit covers failed attempts and lost
+* leases). Idempotent, so two instances finding the same row write the same outcome. If the late
+* holder finished after all, its `done` wins.
+*/
+async function exhaust(rt, job, stale) {
+	const now = isoAt(rt);
+	if (stale !== null && (await rt.model.get(stale.id))?.status === "done") {
+		await rt.model.finishJob(job.jobId, "done", now);
+		return;
+	}
+	await retire(rt, stale);
+	await rt.model.finishJob(job.jobId, "failed", now, LEASE_EXHAUSTED_ERROR);
+	rt.logger?.warn({
+		jobId: job.jobId,
+		attempts: job.attempt
+	}, "job failed: lease exhausted");
+	await reportExhausted(rt, job);
+}
+/** Tell the host a job ended without any holder to record it; its failure never blocks the poll. */
+async function reportExhausted(rt, job) {
+	if (rt.onExhausted === void 0) return;
+	try {
+		await rt.onExhausted(toDatabaseJob(job, job.attempt, rt.leaseMs), LEASE_EXHAUSTED_ERROR);
+	} catch (error) {
+		rt.logger?.error({
+			err: error,
+			jobId: job.jobId
+		}, "exhausted-job hook failed");
+	}
+}
+//#endregion
+export { LEASE_EXHAUSTED_ERROR, claimCandidate, claimNext };
+
+//# sourceMappingURL=claim.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claim.mjs","names":[],"sources":["../../../src/capture/db-queue/claim.ts"],"sourcesContent":["/**\n * The claim algorithm of the database queue. A poll probes for the oldest candidate row (a queued\n * job whose `visibleAt` passed, or a running attempt whose lease ran out), then claims the job's\n * next attempt by inserting its row: the unique key lets exactly one instance win. The winner\n * retires the expired attempt it replaced and marks the job row running.\n */\nimport { attemptRowId, isTerminalJob } from \"../../models/capture-job.ts\";\nimport type { CaptureJobRow } from \"../../schema/capture-job.ts\";\nimport { isoAt } from \"./clock.ts\";\nimport { toDatabaseJob } from \"./codec.ts\";\nimport type { DatabaseJob, QueueRuntime } from \"./types.ts\";\n\n/** Candidates tried per poll when other instances win the race for them. */\nconst MAX_CLAIM_TRIES = 3;\n\n/** Error recorded on a job whose last allowed attempt lost its lease. */\nexport const LEASE_EXHAUSTED_ERROR = \"lease expired on the final attempt\";\n\n/** Probe once and claim the job found; on a lost race, try the next candidate (a few times). */\nexport async function claimNext(rt: QueueRuntime): Promise<DatabaseJob | null> {\n  for (let tries = 0; tries < MAX_CLAIM_TRIES; tries += 1) {\n    // oxlint-disable-next-line no-await-in-loop -- one candidate at a time, in order\n    const candidate = await rt.model.nextCandidate(rt.kinds, isoAt(rt));\n    if (candidate === null) {\n      return null;\n    }\n    // oxlint-disable-next-line no-await-in-loop -- see above\n    const job = await claimCandidate(rt, candidate);\n    if (job !== null) {\n      return job;\n    }\n  }\n  return null;\n}\n\n/** Claim the job behind a candidate row; null when it is gone, over, exhausted or lost to a race. */\nexport async function claimCandidate(\n  rt: QueueRuntime,\n  candidate: CaptureJobRow,\n): Promise<DatabaseJob | null> {\n  if (candidate.entry === \"job\" && candidate.status !== \"queued\") {\n    // A running job row put back in range by a late deferral (see `deferBehind`): not claimable.\n    await rt.model.clearVisibility(candidate.id, isoAt(rt));\n    return null;\n  }\n  const stale = candidate.entry === \"attempt\" ? candidate : null;\n  const job = stale === null ? candidate : await rt.model.get(candidate.jobId);\n  if (job === null || isTerminalJob(job) || (stale !== null && stale.attempt < job.attempt)) {\n    // Nothing left to claim: the expired attempt is just cleaned out of the poll's range.\n    await retire(rt, stale);\n    return null;\n  }\n  return await claimNextAttempt(rt, job, stale);\n}\n\n/** Claim the attempt after the last one made, or fail the job when none is left. */\nasync function claimNextAttempt(\n  rt: QueueRuntime,\n  job: CaptureJobRow,\n  stale: CaptureJobRow | null,\n): Promise<DatabaseJob | null> {\n  // An attempt row ahead of its job row belongs to a claimer that died before marking the job.\n  const made = Math.max(job.attempt, stale?.attempt ?? 0);\n  if (made >= job.maxAttempts) {\n    await exhaust(rt, job, stale);\n    return null;\n  }\n  return await claimAttempt(rt, job, made + 1, stale);\n}\n\nasync function claimAttempt(\n  rt: QueueRuntime,\n  job: CaptureJobRow,\n  attempt: number,\n  stale: CaptureJobRow | null,\n): Promise<DatabaseJob | null> {\n  const leaseUntil = isoAt(rt, rt.leaseMs);\n  const won = await rt.model.claim({ job, attempt, owner: rt.owner, leaseUntil }, isoAt(rt));\n  if (!won) {\n    return stale === null ? await afterLostRace(rt, job, attempt) : null;\n  }\n  const fresh = await rt.model.get(job.jobId);\n  if (fresh === null || isTerminalJob(fresh)) {\n    // Cancelled (or finished by a late holder) between the probe and the insert.\n    await rt.model.finishAttempt(attemptRowId(job.jobId, attempt), \"expired\", isoAt(rt));\n    return null;\n  }\n  return await takeOver(rt, fresh, attempt, stale);\n}\n\n/**\n * Another instance holds attempt `attempt` of a job whose row still reads queued. Usually that\n * winner is about to mark the job running. If it died before doing so, its attempt's lease decides:\n * once expired, the attempt is claimed like any expired one; until then the job row is moved\n * behind that lease, so it does not sit at the head of the queue losing every claim. Only\n * `visibleAt` is written, never the status, so a winner that finished meanwhile keeps its outcome.\n */\nasync function afterLostRace(\n  rt: QueueRuntime,\n  job: CaptureJobRow,\n  attempt: number,\n): Promise<DatabaseJob | null> {\n  const id = attemptRowId(job.jobId, attempt);\n  const expired = await rt.model.expiredAttempt(id, isoAt(rt));\n  if (expired !== null) {\n    return await claimCandidate(rt, expired);\n  }\n  await deferBehind(rt, job, await rt.model.get(id));\n  return null;\n}\n\nasync function deferBehind(\n  rt: QueueRuntime,\n  job: CaptureJobRow,\n  holder: CaptureJobRow | null,\n): Promise<void> {\n  const current = await rt.model.get(job.jobId);\n  if (holder?.visibleAt && current?.status === \"queued\" && current.attempt === job.attempt) {\n    await rt.model.defer(job.jobId, holder.visibleAt, isoAt(rt));\n  }\n}\n\n/** The claim won: retire the attempt it replaced and record the new one on the job row. */\nasync function takeOver(\n  rt: QueueRuntime,\n  job: CaptureJobRow,\n  attempt: number,\n  stale: CaptureJobRow | null,\n): Promise<DatabaseJob> {\n  await retire(rt, stale);\n  await rt.model.markRunning(job.jobId, attempt, isoAt(rt));\n  rt.logger?.debug({ jobId: job.jobId, attempt }, \"job claimed\");\n  return toDatabaseJob(job, attempt, rt.leaseMs);\n}\n\n/** Mark an expired attempt row `expired`: it leaves the poll's range, and its holder sees `lost`. */\nasync function retire(rt: QueueRuntime, stale: CaptureJobRow | null): Promise<void> {\n  if (stale !== null) {\n    await rt.model.finishAttempt(stale.id, \"expired\", isoAt(rt));\n  }\n}\n\n/**\n * The final attempt lost its lease: the job fails (one limit covers failed attempts and lost\n * leases). Idempotent, so two instances finding the same row write the same outcome. If the late\n * holder finished after all, its `done` wins.\n */\nasync function exhaust(\n  rt: QueueRuntime,\n  job: CaptureJobRow,\n  stale: CaptureJobRow | null,\n): Promise<void> {\n  const now = isoAt(rt);\n  if (stale !== null && (await rt.model.get(stale.id))?.status === \"done\") {\n    await rt.model.finishJob(job.jobId, \"done\", now);\n    return;\n  }\n  await retire(rt, stale);\n  await rt.model.finishJob(job.jobId, \"failed\", now, LEASE_EXHAUSTED_ERROR);\n  rt.logger?.warn({ jobId: job.jobId, attempts: job.attempt }, \"job failed: lease exhausted\");\n  await reportExhausted(rt, job);\n}\n\n/** Tell the host a job ended without any holder to record it; its failure never blocks the poll. */\nasync function reportExhausted(rt: QueueRuntime, job: CaptureJobRow): Promise<void> {\n  if (rt.onExhausted === undefined) {\n    return;\n  }\n  try {\n    await rt.onExhausted(toDatabaseJob(job, job.attempt, rt.leaseMs), LEASE_EXHAUSTED_ERROR);\n  } catch (error) {\n    rt.logger?.error({ err: error, jobId: job.jobId }, \"exhausted-job hook failed\");\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,12 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/capture/db-queue/clock.ts
+/** ISO-8601 time `plusMs` from now on the queue's clock. */
+function isoAt(rt, plusMs = 0) {
+	return new Date(rt.now() + plusMs).toISOString();
+}
+//#endregion
+export { isoAt };
+
+//# sourceMappingURL=clock.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clock.mjs","names":[],"sources":["../../../src/capture/db-queue/clock.ts"],"sourcesContent":["/** Time of the database queue: every timestamp it writes or compares comes from the runtime clock. */\nimport type { QueueRuntime } from \"./types.ts\";\n\n/** ISO-8601 time `plusMs` from now on the queue's clock. */\nexport function isoAt(rt: Pick<QueueRuntime, \"now\">, plusMs = 0): string {\n  return new Date(rt.now() + plusMs).toISOString();\n}\n"],"mappings":";;;;;AAIA,SAAgB,MAAM,IAA+B,SAAS,GAAW;CACvE,OAAO,IAAI,KAAK,GAAG,IAAI,IAAI,MAAM,CAAC,CAAC,YAAY;AACjD"}

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

@@ -0,0 +1,76 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { attemptRowId } from "../../models/capture-job.mjs";
+//#region src/capture/db-queue/codec.ts
+/** Serialize the request id, trace context and kind-specific fields of a job; null when empty. */
+function encodePayload(job) {
+	const stored = {};
+	if (job.reqId !== void 0) stored.reqId = job.reqId;
+	if (job.traceparent !== void 0) stored.traceparent = job.traceparent;
+	if (job.data !== void 0 && Object.keys(job.data).length > 0) stored.data = job.data;
+	return Object.keys(stored).length === 0 ? null : JSON.stringify(stored);
+}
+/** Parse a stored payload. A malformed one (a poison row) decodes as empty rather than throwing. */
+function decodePayload(raw) {
+	if (raw === null || raw === "") return {};
+	try {
+		const parsed = JSON.parse(raw);
+		return isRecord(parsed) ? pickPayload(parsed) : {};
+	} catch {
+		return {};
+	}
+}
+/** The job handed to a consumer for attempt `attempt` of a job row. */
+function toDatabaseJob(row, attempt, leaseMs) {
+	const payload = decodePayload(row.payload);
+	return withOptional({
+		buildId: row.buildId ?? "",
+		jobId: row.jobId,
+		kind: row.kind,
+		attempt,
+		attempts: attempt - 1,
+		maxAttempts: row.maxAttempts,
+		receipt: attemptRowId(row.jobId, attempt),
+		leaseMs,
+		data: payload.data ?? {}
+	}, row, payload);
+}
+/** The queue-view entry of a job row. */
+function toQueueEntry(row) {
+	const entry = {
+		buildId: row.buildId ?? "",
+		status: entryStatus(row.status),
+		queuedAt: row.createdAt
+	};
+	if (row.shardId !== null) entry.shard = row.shardId;
+	if (row.startedAt !== null) entry.startedAt = row.startedAt;
+	if (row.finishedAt !== null) entry.finishedAt = row.finishedAt;
+	if (row.error !== null) entry.error = row.error;
+	return entry;
+}
+function withOptional(job, row, payload) {
+	if (row.shardId !== null) job.shard = row.shardId;
+	if (payload.reqId !== void 0) job.reqId = payload.reqId;
+	if (payload.traceparent !== void 0) job.traceparent = payload.traceparent;
+	return job;
+}
+function entryStatus(status) {
+	if (status === "done") return "completed";
+	if (status === "expired") return "failed";
+	return status;
+}
+function pickPayload(parsed) {
+	const stored = {};
+	if (typeof parsed["reqId"] === "string") stored.reqId = parsed["reqId"];
+	if (typeof parsed["traceparent"] === "string") stored.traceparent = parsed["traceparent"];
+	if (isRecord(parsed["data"])) stored.data = parsed["data"];
+	return stored;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { decodePayload, encodePayload, toDatabaseJob, toQueueEntry };
+
+//# sourceMappingURL=codec.mjs.map

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,20 @@
+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";
+//#region src/capture/db-queue/index.d.ts
+/** 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;
+//#endregion
+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";
+//#region 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.7.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,
+		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;
+}
+//#endregion
+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    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;CAYxF,OAAO,UAAU;EATf,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,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,36 @@
+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";
+//#region src/capture/db-queue/keeper.d.ts
+/** 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;
+//#endregion
+export { JobLeaseKeeper, LeaseEnd, LeaseKeeperOptions, RENEW_THROTTLE_MS, keepJobLease };
+//# sourceMappingURL=keeper.d.mts.map

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

@@ -0,0 +1,92 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { REAL_TIMERS, repeatEvery } from "./timers.mjs";
+import "./cadence.mjs";
+//#region 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));
+}
+//#endregion
+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,46 @@
+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";
+//#region 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;
+	}
+}
+//#endregion
+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,36 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region 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)
+				};
+			}
+		}
+	};
+}
+//#endregion
+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"}