@keboola/api-client 27.0.0 → 31.0.0

package/dist/isPlainObject-BB3iy87C.cjs

@@ -0,0 +1,16 @@
+//#region src/utils/isPlainObject.ts
+/**
+* Narrows `unknown` to a string-keyed object — a non-null value of `typeof 'object'`
+* that is not an array. Note it does not distinguish class instances (e.g. `Date`) from
+* object literals; it only rules out `null`, arrays, and primitives.
+*/
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+Object.defineProperty(exports, "isPlainObject", {
+	enumerable: true,
+	get: function() {
+		return isPlainObject;
+	}
+});
+
+//# sourceMappingURL=isPlainObject-BB3iy87C.cjs.map

package/dist/isPlainObject-BB3iy87C.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject-BB3iy87C.cjs","names":[],"sources":["../src/utils/isPlainObject.ts"],"sourcesContent":["/**\n * Narrows `unknown` to a string-keyed object — a non-null value of `typeof 'object'`\n * that is not an array. Note it does not distinguish class instances (e.g. `Date`) from\n * object literals; it only rules out `null`, arrays, and primitives.\n */\nexport const isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n"],"mappings":";;;;;;AAKA,MAAa,iBAAiB,UAC5B,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK"}

package/dist/isPlainObject-LYW-03uB.js

@@ -0,0 +1,11 @@
+//#region src/utils/isPlainObject.ts
+/**
+* Narrows `unknown` to a string-keyed object — a non-null value of `typeof 'object'`
+* that is not an array. Note it does not distinguish class instances (e.g. `Date`) from
+* object literals; it only rules out `null`, arrays, and primitives.
+*/
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+export { isPlainObject as t };
+
+//# sourceMappingURL=isPlainObject-LYW-03uB.js.map

package/dist/isPlainObject-LYW-03uB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject-LYW-03uB.js","names":[],"sources":["../src/utils/isPlainObject.ts"],"sourcesContent":["/**\n * Narrows `unknown` to a string-keyed object — a non-null value of `typeof 'object'`\n * that is not an array. Note it does not distinguish class instances (e.g. `Date`) from\n * object literals; it only rules out `null`, arrays, and primitives.\n */\nexport const isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n"],"mappings":";;;;;;AAKA,MAAa,iBAAiB,UAC5B,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK"}

package/dist/jobStatus-DbMupQEK.js

@@ -0,0 +1,423 @@
+import { i as createStore, r as createEmitter } from "./createStore-BNiCRQXa.js";
+//#region src/utils/createAbortError.ts
+const createAbortError = (reason) => new DOMException(reason, "AbortError");
+//#endregion
+//#region src/utils/async/delay.ts
+const delay = (timeout, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) return reject(createAbortError(signal.reason));
+	const onAbort = () => {
+		clearTimeout(timeoutId);
+		reject(createAbortError(signal?.reason));
+	};
+	const timeoutId = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, timeout);
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+//#endregion
+//#region src/utils/async/lazy.ts
+/**
+* Computes `task` on first call and hands that one value to every later caller —
+* the async `Lazy<T>`. While the first run is in flight every call shares it; once
+* it resolves, every call — right after, or long after — replays the same promise.
+* (Contrast `dedupe`, which shares only an *in-flight* run and lets the next
+* trigger start a fresh one, success or not.)
+*
+* A rejection is *not* kept: the slot is cleared, so the next call starts a fresh
+* run. Lazy init over the network — a stack index, JWKS, feature flags — must not
+* be bricked forever by one transient failure. Callers that joined the failed run
+* all reject with its error; only a call made after it settles retries.
+*
+* @returns a getter; each call returns the promise of the computed value.
+* @throws The returned promise rejects with whatever `task` throws or rejects
+* with — the caller handles it (try/catch, or `.catch` on `void get()`).
+*/
+const lazy = (task) => {
+	let value = null;
+	const runTask = async () => await task();
+	return () => {
+		value ??= runTask().catch((error) => {
+			value = null;
+			throw error;
+		});
+		return value;
+	};
+};
+//#endregion
+//#region src/utils/async/result.ts
+const asError = (thrown) => thrown instanceof Error ? thrown : new Error(String(thrown), { cause: thrown });
+const tryCatch = (task) => {
+	try {
+		return {
+			success: true,
+			data: task()
+		};
+	} catch (thrown) {
+		return {
+			success: false,
+			error: asError(thrown)
+		};
+	}
+};
+const tryCatchAsync = async (task) => {
+	try {
+		return {
+			success: true,
+			data: await task()
+		};
+	} catch (thrown) {
+		return {
+			success: false,
+			error: asError(thrown)
+		};
+	}
+};
+const fromThrowable = (fn) => (...args) => tryCatch(() => fn(...args));
+const fromThrowableAsync = (fn) => (...args) => tryCatchAsync(() => fn(...args));
+const Result = {
+	tryCatch,
+	tryCatchAsync,
+	fromThrowable,
+	fromThrowableAsync
+};
+//#endregion
+//#region src/utils/async/poll/utils.ts
+/**
+* The longest delay a timer can hold: `setTimeout` takes a 32-bit signed number of milliseconds,
+* about 24.9 days.
+*
+* - Above it the delay wraps: Node warns and fires after 1 ms, so a long wait becomes a busy loop.
+* - It bounds a backoff curve and a poll's timeout alike, since both end up in a timer.
+*/
+const MAX_TIMER_DELAY = 2 ** 31 - 1;
+const clamp = (value, min, max = Infinity) => Math.min(Math.max(value, min), max);
+const finiteOr = (value, fallback) => Number.isFinite(value) ? value : fallback;
+/** A signal that never aborts, so an input nobody gave costs no branch of its own. */
+const neverAborts = () => new AbortController().signal;
+//#endregion
+//#region src/utils/async/poll/backoff.ts
+const MIN_STEP = 500;
+const MIN_FACTOR = 2;
+const MIN_INTERVAL = 500;
+const createBackoff = ({ jitter = "none", maxInterval: _maxInterval = MAX_TIMER_DELAY, random = Math.random, ...backoff }) => {
+	const backoffFn = (attempt) => {
+		if (backoff.type === "linear") return clamp(finiteOr(backoff.initialInterval, MIN_INTERVAL), MIN_INTERVAL) + clamp(finiteOr(backoff.step, MIN_STEP), MIN_STEP) * (attempt - 1);
+		if (backoff.type === "exponential") return clamp(finiteOr(backoff.initialInterval, MIN_INTERVAL), MIN_INTERVAL) * clamp(finiteOr(backoff.factor ?? MIN_FACTOR, MIN_FACTOR), MIN_FACTOR) ** (attempt - 1);
+		return clamp(finiteOr(backoff.interval, MIN_INTERVAL), MIN_INTERVAL);
+	};
+	const jitterFn = (delay) => {
+		if (jitter === "none") return delay;
+		if (jitter === "full") return delay * random();
+		return delay / 2 + delay / 2 * random();
+	};
+	const maxInterval = clamp(finiteOr(_maxInterval, MAX_TIMER_DELAY), MIN_INTERVAL, MAX_TIMER_DELAY);
+	return (_attempt) => {
+		const attempt = clamp(finiteOr(Math.trunc(_attempt), 1), 1);
+		const capped = Math.min(backoffFn(attempt), maxInterval);
+		return clamp(finiteOr(jitterFn(capped), MIN_INTERVAL), MIN_INTERVAL, maxInterval);
+	};
+};
+//#endregion
+//#region src/utils/async/poll/pollLoop.ts
+const pollResult = {
+	done: (data, context) => ({
+		state: "done",
+		data,
+		...context,
+		last: data
+	}),
+	errored: (error, context) => ({
+		state: "errored",
+		error,
+		...context
+	}),
+	exhausted: (context, error) => ({
+		state: "exhausted",
+		error,
+		...context
+	}),
+	timedOut: (context, error) => ({
+		state: "timedOut",
+		error,
+		...context
+	}),
+	aborted: (context, reason) => ({
+		state: "aborted",
+		reason,
+		...context
+	})
+};
+const pollLoop = async ({ pollKey, pollFn: _pollFn, until: _until, signal: callerSignal = neverAborts(), backoff: backoffDef = {
+	type: "constant",
+	interval: 3e3
+}, clock = {
+	wait: (ms, signal) => delay(ms, signal),
+	now: () => performance.now()
+}, isRetryable: _isRetryable = () => false, maxAttempts: _maxAttempts = Infinity, timeout: _timeout = Infinity }) => {
+	const requested = finiteOr(_timeout, Infinity);
+	const timeout = requested === Infinity ? Infinity : clamp(requested, 0, MAX_TIMER_DELAY);
+	const maxAttempts = Math.trunc(clamp(finiteOr(_maxAttempts, Infinity), 0));
+	const timeoutSignal = timeout === Infinity ? neverAborts() : AbortSignal.timeout(timeout);
+	const anySignal = AbortSignal.any([callerSignal, timeoutSignal]);
+	const anyAborted = Promise.withResolvers();
+	anySignal.addEventListener("abort", () => anyAborted.reject(anySignal.reason), { once: true });
+	anyAborted.promise.catch(() => void 0);
+	const backoffFn = createBackoff(backoffDef);
+	const startedAt = clock.now();
+	const until = Result.fromThrowable(_until);
+	const isRetryable = Result.fromThrowable(_isRetryable);
+	const key = pollKey ?? [];
+	const pollFn = ({ pollKey: key, attempt: at, elapsed }) => Result.tryCatchAsync(() => Promise.race([_pollFn({
+		pollKey: key,
+		attempt: at,
+		elapsed,
+		signal: anySignal
+	}), anyAborted.promise]));
+	const sleep = Result.fromThrowableAsync((ms) => clock.wait(ms, anySignal));
+	let attempt = 0;
+	let last = null;
+	let lastError;
+	const context = (at = clock.now() - startedAt) => ({
+		pollKey: key,
+		attempt,
+		elapsed: at,
+		last
+	});
+	if (attempt >= maxAttempts) return pollResult.exhausted(context());
+	while (true) {
+		const before = context();
+		if (timeoutSignal.aborted) return pollResult.timedOut(before, lastError);
+		if (callerSignal.aborted) return pollResult.aborted(before, callerSignal.reason);
+		attempt++;
+		const poll = await pollFn({
+			...before,
+			attempt
+		});
+		if (poll.success) last = poll.data;
+		else lastError = poll.error;
+		const after = context();
+		if (timeoutSignal.aborted) return pollResult.timedOut(after, lastError);
+		if (callerSignal.aborted) return pollResult.aborted(after, callerSignal.reason);
+		if (!poll.success) {
+			const canRetry = isRetryable(poll.error);
+			if (!canRetry.success) {
+				poll.error.cause ??= canRetry.error;
+				return pollResult.errored(poll.error, after);
+			}
+			if (!canRetry.data) return pollResult.errored(poll.error, after);
+		}
+		if (poll.success) {
+			const isDone = until({
+				...after,
+				data: poll.data
+			});
+			if (!isDone.success) return pollResult.errored(isDone.error, after);
+			if (isDone.data) return pollResult.done(poll.data, after);
+		}
+		if (attempt >= maxAttempts) return pollResult.exhausted(after, lastError);
+		const backoff = backoffFn(attempt);
+		if (after.elapsed + backoff >= timeout) return pollResult.timedOut(after, lastError);
+		const slept = await sleep(backoff);
+		if (!slept.success) {
+			const afterSleep = context();
+			if (timeoutSignal.aborted) return pollResult.timedOut(afterSleep, lastError);
+			if (callerSignal.aborted) return pollResult.aborted(afterSleep, callerSignal.reason);
+			return pollResult.errored(slept.error, afterSleep);
+		}
+	}
+};
+//#endregion
+//#region src/utils/async/poll/poll.ts
+const emitter = createEmitter();
+const failureOf = (result) => {
+	if ("error" in result && result.error) return result.error;
+	if (result.state === "aborted") {
+		if (result.reason instanceof Error) return result.reason;
+		return createAbortError(typeof result.reason === "string" ? result.reason : "The poll was stopped.");
+	}
+	return /* @__PURE__ */ new Error(`The poll ${result.state} after ${result.attempt} attempts.`);
+};
+const poller = ({ pollKey, signal, until, ...pollLoopOptions }) => {
+	const callerSignal = signal ?? neverAborts();
+	const pollerSignal = new AbortController();
+	const anySignal = AbortSignal.any([pollerSignal.signal, callerSignal]);
+	const snapshot = createStore({
+		pollKey: pollKey ?? [],
+		state: "idle",
+		attempt: 0,
+		elapsed: 0,
+		last: null
+	});
+	const updateSnapshot = (next) => snapshot.set({
+		...snapshot.get(),
+		...next
+	});
+	const handleUntil = (context) => {
+		updateSnapshot({
+			attempt: context.attempt,
+			elapsed: context.elapsed,
+			last: context.data
+		});
+		return until(context);
+	};
+	const start = lazy(async () => {
+		updateSnapshot({ state: "polling" });
+		const result = await pollLoop({
+			...pollLoopOptions,
+			pollKey,
+			until: handleUntil,
+			signal: anySignal
+		});
+		snapshot.set({
+			pollKey: result.pollKey,
+			state: result.state,
+			attempt: result.attempt,
+			elapsed: result.elapsed,
+			last: result.last
+		});
+		return result;
+	});
+	const stop = (reason) => pollerSignal.abort(reason);
+	const subscribe = (listener) => snapshot.subscribe(() => listener(snapshot.get()));
+	const debug = snapshot.get;
+	const unwrap = async (onFailure) => {
+		const result = await start();
+		if (result.state === "done") return result.data;
+		throw onFailure?.(result) ?? failureOf(result);
+	};
+	const controls = {
+		stop,
+		subscribe,
+		debug,
+		start
+	};
+	emitter.emit(controls);
+	return {
+		get state() {
+			return snapshot.get().state;
+		},
+		unwrap,
+		...controls
+	};
+};
+const poll = (options) => {
+	const p = poller(options);
+	return Object.assign(p.start(), {
+		unwrap: p.unwrap,
+		stop: p.stop,
+		subscribe: p.subscribe,
+		debug: p.debug
+	});
+};
+//#endregion
+//#region src/domain/jobStatus.ts
+const STORAGE = {
+	running: ["waiting", "processing"],
+	successful: ["success"],
+	failed: ["error"]
+};
+/**
+* `PlainJobInterface` in `job-queue-internal-api-php-client`.
+*
+* - `terminating` is running, not terminal: the job is still being killed and keeps reporting until
+*   `terminated`.
+* - `warning` is a success — the run produced its output and only added a non-fatal notice, which is
+*   why a flow keeps going past it. The backend declares no such split (`STATUSES_FINISHED` is its
+*   only grouping), so dividing it into success and failure is ours.
+*/
+const QUEUE = {
+	running: [
+		"created",
+		"waiting",
+		"processing",
+		"terminating"
+	],
+	successful: ["success", "warning"],
+	failed: [
+		"error",
+		"cancelled",
+		"terminated"
+	]
+};
+const QUERY = {
+	running: [
+		"created",
+		"enqueued",
+		"processing"
+	],
+	successful: ["completed"],
+	failed: ["failed", "canceled"]
+};
+/**
+* One service's view of its statuses: a predicate per question, with the data a level down.
+*
+* - `isSuccessful` / `isFailed` are `false` while the job is still running, so read them together
+*   with `isTerminal` where that distinction matters.
+* - `isKnown` narrows an untyped string — one read out of an MCP tool result or a URL, say. A status
+*   that arrived on a typed response needs no guard. Its `Set<string>` is what takes the wider type
+*   the caller has, so the guard needs no assertion of its own.
+* - `describe` answers every question about one status at once, for a caller that needs more than
+*   one of them.
+* - `statuses.terminal` is `successful` plus `failed` — the group a poll loop stops on.
+* - `named` is asserted, not proven: `Object.fromEntries` types its result as an index signature,
+*   and no expression convinces TypeScript that uppercasing every status produces exactly
+*   `StatusNames<Status>`. The alternative is writing all three maps out by hand, which is the
+*   duplication this file exists to avoid.
+*/
+const forService = (groups) => {
+	const all = [
+		...groups.running,
+		...groups.successful,
+		...groups.failed
+	];
+	const running = new Set(groups.running);
+	const successful = new Set(groups.successful);
+	const failed = new Set(groups.failed);
+	const terminal = /* @__PURE__ */ new Set([...groups.successful, ...groups.failed]);
+	const known = new Set(all);
+	return {
+		isRunning: (status) => running.has(status),
+		isTerminal: (status) => terminal.has(status),
+		isSuccessful: (status) => successful.has(status),
+		isFailed: (status) => failed.has(status),
+		isKnown: (value) => known.has(value),
+		describe: (status) => ({
+			isRunning: running.has(status),
+			isTerminal: terminal.has(status),
+			isSuccessful: successful.has(status),
+			isFailed: failed.has(status)
+		}),
+		statuses: {
+			running,
+			successful,
+			failed,
+			terminal
+		},
+		named: Object.fromEntries(all.map((status) => [status.toUpperCase(), status]))
+	};
+};
+/**
+* Job statuses per service: `jobStatus.queue.isFailed(status)` is the question about one job,
+* `jobStatus.queue.statuses.failed` the statuses behind it,
+* `jobStatus.queue.named.ERROR` one of them by name.
+*
+* One entry per service, never one over the union: the vocabularies overlap by label — `processing`
+* belongs to all three, `created` to queue and query — while which statuses exist and what each
+* implies differ per service. A shared entry would take another service's status and answer by its
+* rules.
+*
+* - `storage` and `queue` describe a job; `query` describes a query job, not its statements. A
+*   statement has its own state, including a terminal `notExecuted` with no job-level equivalent.
+* - Spread a group where an array is wanted — an API `status` filter, or a UI list that mixes job
+*   statuses with its own.
+*/
+const jobStatus = {
+	storage: forService(STORAGE),
+	queue: forService(QUEUE),
+	query: forService(QUERY)
+};
+//#endregion
+export { poller as a, Result as c, delay as d, createAbortError as f, poll as i, asError as l, emitter as n, clamp as o, failureOf as r, finiteOr as s, jobStatus as t, lazy as u };
+
+//# sourceMappingURL=jobStatus-DbMupQEK.js.map

package/dist/jobStatus-DbMupQEK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobStatus-DbMupQEK.js","names":[],"sources":["../src/utils/createAbortError.ts","../src/utils/async/delay.ts","../src/utils/async/lazy.ts","../src/utils/async/result.ts","../src/utils/async/poll/utils.ts","../src/utils/async/poll/backoff.ts","../src/utils/async/poll/pollLoop.ts","../src/utils/async/poll/poll.ts","../src/domain/jobStatus.ts"],"sourcesContent":["export const createAbortError = (reason?: string) => new DOMException(reason, 'AbortError');\n","import { createAbortError } from '../createAbortError';\n\nexport const delay = (timeout: number, signal?: AbortSignal) =>\n  new Promise<void>((resolve, reject) => {\n    if (signal?.aborted) return reject(createAbortError(signal.reason));\n\n    const onAbort = () => {\n      clearTimeout(timeoutId);\n      reject(createAbortError(signal?.reason));\n    };\n\n    // `once: true` only detaches the listener once the event fires, so the timeout path has to\n    // detach it explicitly — a caller reusing one signal across many delays (`poll` does) would\n    // otherwise pile up a listener per delay for as long as the signal is alive.\n    const timeoutId = setTimeout(() => {\n      signal?.removeEventListener('abort', onAbort);\n      resolve();\n    }, timeout);\n\n    signal?.addEventListener('abort', onAbort, { once: true });\n  });\n","import type { TaskFn } from './types';\n\n/**\n * Computes `task` on first call and hands that one value to every later caller —\n * the async `Lazy<T>`. While the first run is in flight every call shares it; once\n * it resolves, every call — right after, or long after — replays the same promise.\n * (Contrast `dedupe`, which shares only an *in-flight* run and lets the next\n * trigger start a fresh one, success or not.)\n *\n * A rejection is *not* kept: the slot is cleared, so the next call starts a fresh\n * run. Lazy init over the network — a stack index, JWKS, feature flags — must not\n * be bricked forever by one transient failure. Callers that joined the failed run\n * all reject with its error; only a call made after it settles retries.\n *\n * @returns a getter; each call returns the promise of the computed value.\n * @throws The returned promise rejects with whatever `task` throws or rejects\n * with — the caller handles it (try/catch, or `.catch` on `void get()`).\n */\nexport const lazy = <T>(task: TaskFn<T>): (() => Promise<Awaited<T>>) => {\n  let value: Promise<Awaited<T>> | null = null;\n\n  // async wrapper so a synchronous throw from `task` rejects rather than throws.\n  const runTask = async (): Promise<Awaited<T>> => await task();\n\n  return () => {\n    value ??= runTask().catch((error: unknown) => {\n      value = null;\n      throw error;\n    });\n    return value;\n  };\n};\n","export type Result<T, E extends Error = Error> =\n  | { success: true; data: T }\n  | { success: false; error: E };\n\nexport const asError = (thrown: unknown) =>\n  thrown instanceof Error ? thrown : new Error(String(thrown), { cause: thrown });\n\nconst tryCatch = <T>(task: () => T): Result<T> => {\n  try {\n    return { success: true, data: task() };\n  } catch (thrown) {\n    return { success: false, error: asError(thrown) };\n  }\n};\n\nconst tryCatchAsync = async <T>(task: () => T | PromiseLike<T>): Promise<Result<T>> => {\n  try {\n    return { success: true, data: await task() };\n  } catch (thrown) {\n    return { success: false, error: asError(thrown) };\n  }\n};\n\nconst fromThrowable =\n  <A extends unknown[], R>(fn: (...args: A) => R) =>\n  (...args: A): Result<R> =>\n    tryCatch(() => fn(...args));\n\nconst fromThrowableAsync =\n  <A extends unknown[], R>(fn: (...args: A) => R | PromiseLike<R>) =>\n  (...args: A): Promise<Result<R>> =>\n    tryCatchAsync(() => fn(...args));\n\nexport const Result = { tryCatch, tryCatchAsync, fromThrowable, fromThrowableAsync };\n","/**\n * The longest delay a timer can hold: `setTimeout` takes a 32-bit signed number of milliseconds,\n * about 24.9 days.\n *\n * - Above it the delay wraps: Node warns and fires after 1 ms, so a long wait becomes a busy loop.\n * - It bounds a backoff curve and a poll's timeout alike, since both end up in a timer.\n */\nexport const MAX_TIMER_DELAY = 2 ** 31 - 1;\n\nexport const clamp = (value: number, min: number, max = Infinity) =>\n  Math.min(Math.max(value, min), max);\n\nexport const finiteOr = (value: number, fallback: number) =>\n  Number.isFinite(value) ? value : fallback;\n\n/** A signal that never aborts, so an input nobody gave costs no branch of its own. */\nexport const neverAborts = () => new AbortController().signal;\n","import { clamp, finiteOr, MAX_TIMER_DELAY } from './utils';\n\nexport type Jitter =\n  | 'none' // delay\n  | 'full' // [0, delay)\n  | 'equal'; // [delay / 2, delay)\n\ntype Backoff =\n  | { type: 'constant'; interval: number } //   3000, 3000, 3000, ...\n  | { type: 'linear'; initialInterval: number; step: number } // 1000, 2000, 3000, …\n  | { type: 'exponential'; initialInterval: number; factor?: number }; // 1000, 2000, 4000, 8000, …\n\ntype RandomFn = () => number;\ntype JitterFn = (delay: number) => number;\ntype BackoffFn = (attempt: number) => number;\n\nexport type BackoffDef = {\n  jitter?: Jitter;\n  maxInterval?: number;\n  random?: RandomFn;\n} & Backoff;\n\nconst MIN_STEP = 500;\nconst MIN_FACTOR = 2;\nconst MIN_INTERVAL = 500;\n\nexport const createBackoff = ({\n  jitter = 'none',\n  maxInterval: _maxInterval = MAX_TIMER_DELAY,\n  random = Math.random,\n  ...backoff\n}: BackoffDef): BackoffFn => {\n  const backoffFn: BackoffFn = (attempt) => {\n    if (backoff.type === 'linear') {\n      const interval = clamp(finiteOr(backoff.initialInterval, MIN_INTERVAL), MIN_INTERVAL);\n      const step = clamp(finiteOr(backoff.step, MIN_STEP), MIN_STEP);\n\n      return interval + step * (attempt - 1);\n    }\n    if (backoff.type === 'exponential') {\n      const interval = clamp(finiteOr(backoff.initialInterval, MIN_INTERVAL), MIN_INTERVAL);\n      const factor = clamp(finiteOr(backoff.factor ?? MIN_FACTOR, MIN_FACTOR), MIN_FACTOR);\n\n      return interval * factor ** (attempt - 1);\n    }\n\n    return clamp(finiteOr(backoff.interval, MIN_INTERVAL), MIN_INTERVAL);\n  };\n\n  const jitterFn: JitterFn = (delay) => {\n    if (jitter === 'none') return delay;\n    if (jitter === 'full') return delay * random();\n    return delay / 2 + (delay / 2) * random(); // equal\n  };\n\n  const maxInterval = clamp(finiteOr(_maxInterval, MAX_TIMER_DELAY), MIN_INTERVAL, MAX_TIMER_DELAY);\n  return (_attempt) => {\n    const attempt = clamp(finiteOr(Math.trunc(_attempt), 1), 1);\n    const capped = Math.min(backoffFn(attempt), maxInterval);\n    // Floored after the jitter, not before: `full` jitter multiplies by a random fraction, so a floor\n    // applied to the curve alone leaves sub-millisecond gaps between attempts.\n    return clamp(finiteOr(jitterFn(capped), MIN_INTERVAL), MIN_INTERVAL, maxInterval);\n  };\n};\n","import { delay } from '../delay';\nimport { Result } from '../result';\n\nimport { type BackoffDef, createBackoff } from './backoff';\nimport { clamp, finiteOr, MAX_TIMER_DELAY, neverAborts } from './utils';\n\ntype Clock = {\n  wait: (ms: number, signal?: AbortSignal) => Promise<void>;\n  now: () => number;\n};\n\nexport type PollKey = readonly unknown[];\n\nexport type PollContext<K extends PollKey = PollKey> = {\n  pollKey: K;\n  attempt: number;\n  elapsed: number;\n};\n\n/** The context plus the answer it is about: what `until` decides on, and what an ending reports. */\nexport type PollTick<T, K extends PollKey = PollKey> = PollContext<K> & { last: T | null };\n\nexport type PollResultState = 'done' | 'timedOut' | 'exhausted' | 'aborted' | 'errored';\n\nexport type PollResult<T, K extends PollKey = PollKey> = PollTick<T, K> &\n  (\n    | { state: 'done'; data: T }\n    | { state: 'timedOut' | 'exhausted'; error?: Error }\n    | { state: 'aborted'; reason?: unknown }\n    | { state: 'errored'; error: Error }\n  );\n\nexport type PollOptions<T, K extends PollKey = PollKey> = {\n  pollKey?: K;\n  pollFn: (context: PollContext<K> & { signal: AbortSignal }) => Promise<T>;\n  until: (tick: PollTick<T, K> & { data: T }) => boolean;\n  signal?: AbortSignal;\n  backoff?: BackoffDef;\n  isRetryable?: (error: Error) => boolean;\n  maxAttempts?: number;\n  timeout?: number;\n  clock?: Clock;\n};\n\nconst pollResult = {\n  done: <T, K extends PollKey>(data: T, context: PollTick<T, K>): PollResult<T, K> => ({\n    state: 'done',\n    data,\n    ...context,\n    last: data,\n  }),\n  errored: <T, K extends PollKey>(error: Error, context: PollTick<T, K>): PollResult<T, K> => ({\n    state: 'errored',\n    error,\n    ...context,\n  }),\n  exhausted: <T, K extends PollKey>(context: PollTick<T, K>, error?: Error): PollResult<T, K> => ({\n    state: 'exhausted',\n    error,\n    ...context,\n  }),\n  timedOut: <T, K extends PollKey>(context: PollTick<T, K>, error?: Error): PollResult<T, K> => ({\n    state: 'timedOut',\n    error,\n    ...context,\n  }),\n  aborted: <T, K extends PollKey>(context: PollTick<T, K>, reason: unknown): PollResult<T, K> => ({\n    state: 'aborted',\n    reason,\n    ...context,\n  }),\n};\n\nexport const pollLoop = async <T, K extends PollKey = PollKey>({\n  pollKey,\n  pollFn: _pollFn,\n  until: _until,\n  signal: callerSignal = neverAborts(),\n  backoff: backoffDef = { type: 'constant', interval: 3000 },\n  clock = { wait: (ms, signal) => delay(ms, signal), now: () => performance.now() },\n  isRetryable: _isRetryable = () => false,\n  maxAttempts: _maxAttempts = Infinity,\n  timeout: _timeout = Infinity,\n}: PollOptions<T, K>): Promise<PollResult<T, K>> => {\n  // A deadline ends up in a timer, so a finite one is bounded by what a timer can hold. `Infinity`\n  // is answered before the clamp: it means no deadline, and clamping would make it the longest one.\n  const requested = finiteOr(_timeout, Infinity);\n  const timeout = requested === Infinity ? Infinity : clamp(requested, 0, MAX_TIMER_DELAY);\n  const maxAttempts = Math.trunc(clamp(finiteOr(_maxAttempts, Infinity), 0));\n\n  const timeoutSignal = timeout === Infinity ? neverAborts() : AbortSignal.timeout(timeout);\n  const anySignal = AbortSignal.any([callerSignal, timeoutSignal]);\n  const anyAborted = Promise.withResolvers<never>();\n\n  anySignal.addEventListener('abort', () => anyAborted.reject(anySignal.reason), {\n    once: true,\n  });\n  void anyAborted.promise.catch(() => undefined);\n\n  const backoffFn = createBackoff(backoffDef);\n  const startedAt = clock.now();\n\n  const until = Result.fromThrowable(_until);\n  const isRetryable = Result.fromThrowable(_isRetryable);\n  // A poll without a key has an empty one, and `K` is opaque in here — the one place the absent\n  // case is materialised is the one place it has to be asserted.\n  const key = pollKey ?? ([] as unknown as K);\n  // Only what the context declares: a request is not handed the tick's `last` as well.\n  const pollFn = ({ pollKey: key, attempt: at, elapsed }: PollContext<K>) =>\n    Result.tryCatchAsync(() =>\n      Promise.race([\n        _pollFn({ pollKey: key, attempt: at, elapsed, signal: anySignal }),\n        anyAborted.promise,\n      ]),\n    );\n  const sleep = Result.fromThrowableAsync((ms: number) => clock.wait(ms, anySignal));\n\n  let attempt = 0;\n  // What a retry swallowed: the poll carries it to whichever ending runs out first.\n  let last: T | null = null;\n  let lastError: Error | undefined;\n  const context = (at = clock.now() - startedAt): PollTick<T, K> => ({\n    pollKey: key,\n    attempt,\n    elapsed: at,\n    last,\n  });\n\n  if (attempt >= maxAttempts) return pollResult.exhausted<T, K>(context());\n\n  while (true) {\n    const before = context();\n    if (timeoutSignal.aborted) return pollResult.timedOut(before, lastError);\n    if (callerSignal.aborted) return pollResult.aborted(before, callerSignal.reason);\n\n    attempt++;\n    // The attempt it is, not the one before it — `before` was read to decide whether to make it.\n    const poll = await pollFn({ ...before, attempt });\n\n    // What the attempt produced, recorded before the tick that reports it: on any ending but `done`\n    // these two are the only account of what the poll saw, and reading them one attempt behind is\n    // reading the wrong answer.\n    if (poll.success) last = poll.data;\n    else lastError = poll.error;\n\n    const after = context();\n    if (timeoutSignal.aborted) return pollResult.timedOut(after, lastError);\n    if (callerSignal.aborted) return pollResult.aborted(after, callerSignal.reason);\n\n    if (!poll.success) {\n      const canRetry = isRetryable(poll.error);\n\n      // A predicate that throws cannot ask for a retry. The request's own failure stays the reported\n      // one — it is the type a caller's guards expect — and the predicate's rides along as its cause.\n      if (!canRetry.success) {\n        poll.error.cause ??= canRetry.error;\n        return pollResult.errored(poll.error, after);\n      }\n      if (!canRetry.data) return pollResult.errored(poll.error, after);\n    }\n\n    if (poll.success) {\n      const isDone = until({ ...after, data: poll.data });\n      if (!isDone.success) return pollResult.errored(isDone.error, after);\n      if (isDone.data) return pollResult.done(poll.data, after);\n    }\n\n    // exhausted\n    if (attempt >= maxAttempts) return pollResult.exhausted(after, lastError);\n\n    // sleep\n    const backoff = backoffFn(attempt);\n    if (after.elapsed + backoff >= timeout) return pollResult.timedOut(after, lastError);\n\n    const slept = await sleep(backoff);\n    if (!slept.success) {\n      const afterSleep = context();\n      if (timeoutSignal.aborted) return pollResult.timedOut(afterSleep, lastError);\n      if (callerSignal.aborted) return pollResult.aborted(afterSleep, callerSignal.reason);\n\n      return pollResult.errored(slept.error, afterSleep);\n    }\n  }\n};\n","import { createAbortError } from '../../createAbortError';\nimport { createEmitter, createStore } from '../../createStore';\nimport { lazy } from '../lazy';\n\nimport {\n  type PollKey,\n  pollLoop,\n  type PollOptions,\n  type PollResult,\n  type PollResultState,\n  type PollTick,\n} from './pollLoop';\nimport { neverAborts } from './utils';\n\nexport type PollState = 'idle' | 'polling' | PollResultState;\nexport type PollSnapshot = PollTick<unknown> & { state: PollState };\n\ntype OnFailure<T> = (result: PollResult<T>) => Error | undefined;\n\nexport type PollerStartFn<T> = () => Promise<PollResult<T>>;\nexport type PollerStopFn = (reason?: string) => void;\ntype PollerSubscribeFn = (listener: (snapshot: PollSnapshot) => void) => () => void;\ntype PollerDebugFn = () => PollSnapshot;\ntype PollerUnwrapFn<T> = (onFailure?: OnFailure<T>) => Promise<T>;\nexport type Poller<T> = {\n  readonly state: PollState;\n  start: PollerStartFn<T>;\n  unwrap: PollerUnwrapFn<T>;\n  stop: PollerStopFn;\n  subscribe: PollerSubscribeFn;\n  debug: PollerDebugFn;\n};\n\nexport type PollTask<T> = Promise<PollResult<T>> &\n  Pick<Poller<T>, 'unwrap' | 'stop' | 'subscribe' | 'debug'>;\n\nexport type ObservedPoller = Pick<Poller<unknown>, 'stop' | 'subscribe' | 'debug' | 'start'>;\n\nexport const emitter = createEmitter<ObservedPoller>();\n\nexport const failureOf = (result: PollResult<unknown>): Error => {\n  if ('error' in result && result.error) return result.error;\n\n  if (result.state === 'aborted') {\n    if (result.reason instanceof Error) return result.reason;\n\n    return createAbortError(\n      typeof result.reason === 'string' ? result.reason : 'The poll was stopped.',\n    );\n  }\n\n  return new Error(`The poll ${result.state} after ${result.attempt} attempts.`);\n};\n\nexport const poller = <T, K extends PollKey = PollKey>({\n  pollKey,\n  signal,\n  until,\n  ...pollLoopOptions\n}: PollOptions<T, K>): Poller<T> => {\n  const callerSignal = signal ?? neverAborts();\n  const pollerSignal = new AbortController();\n  const anySignal = AbortSignal.any([pollerSignal.signal, callerSignal]);\n\n  // snapshoting\n  const snapshot = createStore<PollSnapshot>({\n    pollKey: pollKey ?? [],\n    state: 'idle',\n    attempt: 0,\n    elapsed: 0,\n    last: null,\n  });\n  const updateSnapshot = (next: Partial<PollSnapshot>) =>\n    snapshot.set({ ...snapshot.get(), ...next });\n\n  const handleUntil = (context: PollTick<T, K> & { data: T }) => {\n    updateSnapshot({ attempt: context.attempt, elapsed: context.elapsed, last: context.data });\n    return until(context);\n  };\n\n  const start: PollerStartFn<T> = lazy(async () => {\n    updateSnapshot({ state: 'polling' });\n    const result = await pollLoop({\n      ...pollLoopOptions,\n      pollKey,\n      until: handleUntil,\n      signal: anySignal,\n    });\n    // The result knows what a tick cannot: attempts that failed, and the time the ending itself took.\n    snapshot.set({\n      pollKey: result.pollKey,\n      state: result.state,\n      attempt: result.attempt,\n      elapsed: result.elapsed,\n      last: result.last,\n    });\n    return result;\n  });\n\n  const stop: PollerStopFn = (reason) => pollerSignal.abort(reason);\n  const subscribe: PollerSubscribeFn = (listener) =>\n    snapshot.subscribe(() => listener(snapshot.get()));\n  const debug: PollerDebugFn = snapshot.get;\n\n  const unwrap: PollerUnwrapFn<T> = async (onFailure) => {\n    const result = await start();\n    if (result.state === 'done') return result.data;\n    throw onFailure?.(result) ?? failureOf(result);\n  };\n\n  const controls = {\n    stop,\n    subscribe,\n    debug,\n    start,\n  };\n\n  emitter.emit(controls);\n\n  return {\n    get state() {\n      return snapshot.get().state;\n    },\n    unwrap,\n    ...controls,\n  };\n};\n\nexport const poll = <T, K extends PollKey = PollKey>(options: PollOptions<T, K>): PollTask<T> => {\n  const p = poller(options);\n\n  return Object.assign(p.start(), {\n    unwrap: p.unwrap,\n    stop: p.stop,\n    subscribe: p.subscribe,\n    debug: p.debug,\n  });\n};\n","import type { QueryJobStatus } from '../clients/queryService/types';\nimport type { QueueJobStatus } from '../clients/queue/types';\nimport type { StorageJobStatus } from '../clients/storage/jobs/types';\n\n/**\n * How one service's status vocabulary splits by what the job is doing. Declared per service, then\n * indexed into sets by `forService`.\n *\n * - The three groups are disjoint and together cover the vocabulary. `terminal` is not declared: a\n *   job is terminal exactly when it has succeeded or failed.\n * - Annotating the constant is what validates its members: `QueueJobStatus` and `QueryJobStatus` are\n *   generated, so a spec that renames one fails the build here instead of silently dropping it from\n *   a group and leaving a poll loop to run to `maxAttempts`.\n */\ntype StatusGroups<Status extends string> = {\n  running: readonly Status[];\n  successful: readonly Status[];\n  failed: readonly Status[];\n};\n\n/**\n * A service's statuses as named constants — `SUCCESS: 'success'`.\n *\n * Keyed off the status type, so there is an entry per status and no more, and a spec that renames a\n * status renames the key with it.\n */\ntype StatusNames<Status extends string> = { [K in Status as Uppercase<K>]: K };\n\n// `StorageJobStatus` in `connection`, whose `isDoneStatus` is the `success`/`error` pair.\nconst STORAGE: StatusGroups<StorageJobStatus> = {\n  running: ['waiting', 'processing'],\n  successful: ['success'],\n  failed: ['error'],\n};\n\n/**\n * `PlainJobInterface` in `job-queue-internal-api-php-client`.\n *\n * - `terminating` is running, not terminal: the job is still being killed and keeps reporting until\n *   `terminated`.\n * - `warning` is a success — the run produced its output and only added a non-fatal notice, which is\n *   why a flow keeps going past it. The backend declares no such split (`STATUSES_FINISHED` is its\n *   only grouping), so dividing it into success and failure is ours.\n */\nconst QUEUE: StatusGroups<QueueJobStatus> = {\n  running: ['created', 'waiting', 'processing', 'terminating'],\n  successful: ['success', 'warning'],\n  failed: ['error', 'cancelled', 'terminated'],\n};\n\n// `JobState` in `go-monorepo` (`services/query/internal/repository/models`). `canceled` with one\n// `l` — queryService's spelling, unlike the other two services.\nconst QUERY: StatusGroups<QueryJobStatus> = {\n  running: ['created', 'enqueued', 'processing'],\n  successful: ['completed'],\n  failed: ['failed', 'canceled'],\n};\n\n/**\n * One service's view of its statuses: a predicate per question, with the data a level down.\n *\n * - `isSuccessful` / `isFailed` are `false` while the job is still running, so read them together\n *   with `isTerminal` where that distinction matters.\n * - `isKnown` narrows an untyped string — one read out of an MCP tool result or a URL, say. A status\n *   that arrived on a typed response needs no guard. Its `Set<string>` is what takes the wider type\n *   the caller has, so the guard needs no assertion of its own.\n * - `describe` answers every question about one status at once, for a caller that needs more than\n *   one of them.\n * - `statuses.terminal` is `successful` plus `failed` — the group a poll loop stops on.\n * - `named` is asserted, not proven: `Object.fromEntries` types its result as an index signature,\n *   and no expression convinces TypeScript that uppercasing every status produces exactly\n *   `StatusNames<Status>`. The alternative is writing all three maps out by hand, which is the\n *   duplication this file exists to avoid.\n */\nconst forService = <Status extends string>(groups: StatusGroups<Status>) => {\n  const all = [...groups.running, ...groups.successful, ...groups.failed];\n\n  const running: ReadonlySet<Status> = new Set(groups.running);\n  const successful: ReadonlySet<Status> = new Set(groups.successful);\n  const failed: ReadonlySet<Status> = new Set(groups.failed);\n  const terminal: ReadonlySet<Status> = new Set([...groups.successful, ...groups.failed]);\n  const known: ReadonlySet<string> = new Set<string>(all);\n\n  return {\n    isRunning: (status: Status) => running.has(status),\n    isTerminal: (status: Status) => terminal.has(status),\n    isSuccessful: (status: Status) => successful.has(status),\n    isFailed: (status: Status) => failed.has(status),\n    isKnown: (value: string): value is Status => known.has(value),\n    describe: (status: Status) => ({\n      isRunning: running.has(status),\n      isTerminal: terminal.has(status),\n      isSuccessful: successful.has(status),\n      isFailed: failed.has(status),\n    }),\n    statuses: { running, successful, failed, terminal },\n    named: Object.fromEntries(\n      all.map((status) => [status.toUpperCase(), status]),\n    ) as StatusNames<Status>,\n  };\n};\n\n/**\n * Job statuses per service: `jobStatus.queue.isFailed(status)` is the question about one job,\n * `jobStatus.queue.statuses.failed` the statuses behind it,\n * `jobStatus.queue.named.ERROR` one of them by name.\n *\n * One entry per service, never one over the union: the vocabularies overlap by label — `processing`\n * belongs to all three, `created` to queue and query — while which statuses exist and what each\n * implies differ per service. A shared entry would take another service's status and answer by its\n * rules.\n *\n * - `storage` and `queue` describe a job; `query` describes a query job, not its statements. A\n *   statement has its own state, including a terminal `notExecuted` with no job-level equivalent.\n * - Spread a group where an array is wanted — an API `status` filter, or a UI list that mixes job\n *   statuses with its own.\n */\nexport const jobStatus = {\n  storage: forService(STORAGE),\n  queue: forService(QUEUE),\n  query: forService(QUERY),\n};\n"],"mappings":"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"}