@ayepi/work 0.1.0 → 0.2.0

package/dist/index.js

@@ -87,6 +87,16 @@ const defaultCodec = {
 */
 /** A v4 UUID. Thin wrapper over `node:crypto` so callers don't import it directly. */
 const uuid = () => randomUUID();
+/** The active work-id generator (default {@link uuid}); swapped by {@link setIdGenerator}. */
+let idGenerator = uuid;
+/**
+* Override how work/group ids are generated process-wide — e.g. sortable or prefixed ids. Affects
+* **build-time** work ids (builders are minted outside a system) and any engine ids without their own
+* `generateId`. Pass nothing to reset to the default UUID generator.
+*/
+const setIdGenerator = (fn) => void (idGenerator = fn ?? uuid);
+/** Generate an id via the active generator. */
+const genId = () => idGenerator();
 /** Resolve after `ms` (an unref'd timer, so it never keeps the process alive). */
 function sleep(ms) {
 	return new Promise((resolve) => {
@@ -425,7 +435,7 @@ const rehydrate = (s) => ({
 });
 /** Build a {@link DEPENDENCY_TYPE} work item from a (re-usable) input — a fresh queue id, same key. */
 const buildDependency = (input) => ({
-	id: uuid(),
+	id: genId(),
 	type: DEPENDENCY_TYPE,
 	input
 });
@@ -435,7 +445,7 @@ const buildDependency = (input) => ({
 */
 function dependency(opts) {
 	return buildDependency({
-		key: uuid(),
+		key: genId(),
 		on: opts.on.map(toId),
 		queue: opts.queue.map(toSerialized),
 		config: opts.config ?? "all-success",
@@ -458,12 +468,9 @@ const dependencyHandler = async (input, ctx) => {
 	});
 	const freshById = new Map(unknownIds.map((id, i) => [id, fresh[i]]));
 	const states = input.on.map((id) => resolved[id] ? { status: resolved[id] } : freshById.get(id));
-	if (conditionMet(input.config, states)) {
-		if (await ctx.claim(`dep:${input.key}:fired`)) ctx.queue(input.queue.map(rehydrate));
-		return;
-	}
+	if (conditionMet(input.config, states)) return await ctx.claim(`dep:${input.key}:fired`) ? ctx.queue(input.queue.map(rehydrate)) : ctx.void();
 	if (input.deadline !== void 0 && Date.now() >= input.deadline) throw new Error(`dependency: timed out waiting for [${input.on.join(", ")}]`);
-	ctx.queue(buildDependency({
+	return ctx.queue(buildDependency({
 		...input,
 		resolved
 	}), { delay: input.poll });
@@ -610,6 +617,7 @@ const WORK_METRICS = {
 	retried: "work.retried",
 	deferred: "work.deferred",
 	rescheduled: "work.rescheduled",
+	expired: "work.expired",
 	active: "work.active",
 	pending: "work.pending",
 	running: "work.running",
@@ -642,6 +650,7 @@ const createWorkStats = (metrics = createMetrics$1()) => {
 			retried: metrics.counter(WORK_METRICS.retried, l, { description: "attempt-advancing retries" }),
 			deferred: metrics.counter(WORK_METRICS.deferred, l, { description: "handler/classifier reschedules" }),
 			rescheduled: metrics.counter(WORK_METRICS.rescheduled, l, { description: "early-arrival re-pushes" }),
+			expired: metrics.counter(WORK_METRICS.expired, l, { description: "items expired past their deadline" }),
 			active: metrics.gauge(WORK_METRICS.active, l, { description: "items in flight (pending + running)" }),
 			pending: metrics.gauge(WORK_METRICS.pending, l, { description: "items admitted, awaiting a doer slot" }),
 			running: metrics.gauge(WORK_METRICS.running, l, { description: "items executing" }),
@@ -737,6 +746,7 @@ const createWorkStats = (metrics = createMetrics$1()) => {
 			h.lastFailed.set(at);
 		},
 		retried: (type) => void handles(type).retried.inc(),
+		expired: (type) => void handles(type).expired.inc(),
 		deferred: (type, delayMs) => {
 			const h = handles(type);
 			h.deferred.inc();
@@ -756,23 +766,26 @@ const createWorkStats = (metrics = createMetrics$1()) => {
 *
 * Defining a work type with {@link defineWork} yields a **callable builder**: call it
 * with the work's exact input and you get a type-checked, queueable {@link Work} (with
-* a build-time id) that also carries its output type. {@link createWork} takes a
-* `const` tuple of builders and produces a {@link WorkSystem} whose `enqueue` is fully
-* checked — by instance (`enqueue(add({ a, b }))`) or by name (`enqueue('add', { a, b })`).
+* a build-time id). A handler **returns a {@link WorkResult}** — `ctx.result(value)`,
+* `ctx.queue(...)`, `ctx.void()`, or a `.next(...)` dependency chain — so each work carries
+* two inferred types: its *awaited-alone* result `S` and its *group* contribution `G`.
+* {@link createWork} takes a `const` tuple of builders and produces a {@link WorkSystem} whose
+* `enqueue` is fully checked — by instance or by name.
 *
-* The **group result type** is the union of every registered work's non-void output
-* ({@link GroupResult}). All durations are **milliseconds**.
+* `enqueue(root).group()` resolves to `root`'s `G` — a **precise union from the workflow
+* structure**, not the whole registry. All durations are **milliseconds**.
 *
 * @module
 */
 const build = (name, input) => ({
-	id: uuid(),
+	id: genId(),
 	type: name,
 	input
 });
 /**
-* Define a work type. Returns a {@link WorkBuilder} — a function that builds queueable
-* instances — typed by its input `I` and output `O`.
+* Define a work type. The handler **returns a {@link WorkResult}** — `ctx.result(value)`,
+* `ctx.queue(...)`, `ctx.void()`, or a `.next(...)` chain — and its `S`/`G` types are inferred
+* from that return: `S` is what `.result()` resolves to alone, `G` what it contributes to the group.
 */
 function defineWork(name, handler, opts = {}) {
 	return Object.assign((input) => build(name, input), {
@@ -785,10 +798,10 @@ function defineWork(name, handler, opts = {}) {
 	});
 }
 /**
-* Define a **batched** work type. Items still enqueue, retry, prioritize, and join
-* groups individually, but execute together via {@link BatchConfig.run} once `size`
-* accumulate or `maxWait` ms elapse — so each `.result()` resolves to its aligned
-* output. The per-type {@link WorkOptions.doer} governs how many *batches* run at once.
+* Define a **batched** work type. Items still enqueue, retry, prioritize, and join groups
+* individually, but execute together via {@link BatchConfig.run} once `size` accumulate or `maxWait`
+* ms elapse — so each `.result()` resolves to its aligned output `O` (which is also its group
+* contribution). The per-type {@link WorkOptions.doer} governs how many *batches* run at once.
 */
 function defineBatchWork(name, config) {
 	const { size, maxWait, run, ...options } = config;
@@ -797,7 +810,7 @@ function defineBatchWork(name, config) {
 		maxWait,
 		run
 	};
-	const handler = async (input) => (await run([input]))[0];
+	const handler = async (input, ctx) => ctx.result((await run([input]))[0]);
 	return Object.assign((input) => build(name, input), {
 		type: name,
 		def: {
@@ -858,6 +871,8 @@ const DEP_RETRY_ATTEMPTS = 1;
 const REDRIVE_DEFAULT = 10;
 const unref = (t) => void t.unref?.();
 const errString = (err) => err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+/** Brand stamped on a runtime `WorkResult` node — distinguishes a handler instruction from a raw value. */
+const WR_BRAND = Symbol.for("ayepi.work.result");
 /**
 * Create a work system. Zero-config (`createWork()`) uses the bundled in-memory backend
 * and an {@link unlimitedDoer}; pass `work: [...] as const` for a typed registry, a
@@ -880,6 +895,8 @@ function createWork(opts = {}) {
 	const logWith = opts.logWith ?? identityLogWith;
 	const now = opts.now ?? Date.now;
 	const random = opts.random ?? Math.random;
+	const newId = opts.generateId ?? genId;
+	const strictReturnDefault = opts.strictReturn ?? true;
 	const attemptsOf = (r) => r.attempts ?? getDefaultRetryOptions$1().attempts ?? 1;
 	const stats = createWorkStats(opts.metrics);
 	const k = (suffix) => prefix + suffix;
@@ -943,11 +960,13 @@ function createWork(opts = {}) {
 	const resolveOptions = (type, input, qOpts) => {
 		const tOpts = registry.get(type)?.def.options;
 		const computed = tOpts?.options?.(input) ?? {};
+		const timeout = qOpts?.timeout ?? computed.timeout ?? tOpts?.timeout;
 		return {
 			delay: qOpts?.delay ?? computed.delay ?? 0,
 			runAt: qOpts?.runAt ?? computed.runAt,
 			priority: qOpts?.priority ?? computed.priority ?? tOpts?.priority ?? 0,
 			group: qOpts?.group ?? computed.group ?? tOpts?.group,
+			deadline: qOpts?.deadline ?? computed.deadline ?? (timeout !== void 0 ? now() + timeout : void 0),
 			retry: {
 				...getDefaultRetryOptions$1(),
 				...opts.retry,
@@ -1009,16 +1028,56 @@ function createWork(opts = {}) {
 		});
 		maybeUnhandled(groupId);
 	};
-	const makeContext = (impl) => {
-		const queue = (works, options) => Array.isArray(works) ? works.map((w) => impl.enqueueOne(w, options)) : impl.enqueueOne(works, options);
+	const isWR = (x) => typeof x === "object" && x !== null && x[WR_BRAND] === true;
+	const toItems = (x) => Array.isArray(x) ? [...x] : [x];
+	const makeNode = (data) => {
+		const node = {
+			[WR_BRAND]: true,
+			data,
+			next(nextItems, condition = "all-success", options) {
+				if (data.kind !== "queue") throw new Error(".next() is only valid on ctx.queue(...)");
+				const q = toItems(nextItems);
+				data.chains.push({
+					on: data.frontier,
+					queue: q,
+					condition,
+					options
+				});
+				data.frontier = q;
+				return node;
+			}
+		};
+		return node;
+	};
+	/** Collect the Work ids to wait on within items (recursing into nested `queue` nodes). */
+	const workIdsOf = (items) => items.flatMap((it) => isWR(it) ? it.data.kind === "queue" ? workIdsOf(it.data.items) : [] : [it.id]);
+	const makeContext = (meta, created) => {
+		const reg = (n) => (created.add(n), n);
 		return {
-			id: impl.id,
-			groupId: impl.groupId,
-			attempt: impl.attempt,
-			queue,
-			setResult: impl.setResult,
-			states: impl.states,
-			claim: impl.claim
+			id: meta.id,
+			groupId: meta.groupId,
+			attempt: meta.attempt,
+			parent: meta.parent,
+			dependents: meta.dependents,
+			result: (value, options) => reg(makeNode({
+				kind: "result",
+				value,
+				final: !!options?.final,
+				append: options?.append
+			})),
+			queue: (items, options) => {
+				const arr = toItems(items);
+				return reg(makeNode({
+					kind: "queue",
+					items: arr,
+					options,
+					chains: [],
+					frontier: arr
+				}));
+			},
+			void: () => reg(makeNode({ kind: "void" })),
+			states: storeStates,
+			claim: storeClaim
 		};
 	};
 	const storeStates = (ids) => Promise.all(ids.map(readState));
@@ -1027,7 +1086,7 @@ function createWork(opts = {}) {
 	const pushEnvelope = (env, delay) => port(() => Promise.resolve(queueFor(env.type).push(JSON.stringify(env), { delay })).then(() => void 0));
 	/** Resolve when a deferred/scheduled item should next run (absolute epoch ms). */
 	const resolveRunAt = (when) => when.runAt ?? now() + (when.delay ?? 0);
-	const submitQueued = (id, type, input, groupId, ro) => {
+	const submitQueued = (id, type, input, groupId, ro, meta) => {
 		const queueAt = now();
 		const startAt = ro.runAt ?? queueAt + ro.delay;
 		return (async () => {
@@ -1053,7 +1112,10 @@ function createWork(opts = {}) {
 					attempt: 1,
 					priority: ro.priority,
 					group: ro.group,
-					retry: ro.retry
+					retry: ro.retry,
+					deadline: ro.deadline,
+					parent: meta?.parent,
+					dependents: meta?.dependents
 				}, Math.max(0, startAt - queueAt));
 			} catch (err) {
 				await undoHold(groupId);
@@ -1065,10 +1127,14 @@ function createWork(opts = {}) {
 				id,
 				type,
 				groupId,
+				parent: meta?.parent,
+				dependents: meta?.dependents,
 				at: queueAt
 			});
 		})();
 	};
+	/** Submit a built {@link Work} (used by the result-apply walk), carrying its parent/dependents metadata. */
+	const submitWork = (work, groupId, options, meta) => submitQueued(work.id, work.type, work.input, groupId, resolveOptions(work.type, work.input, options), meta);
 	/** Re-enter the queue for a retry: a fresh delivery with `attempt + 1` and a recomputed `startAt`. */
 	const rePush = async (env, delay) => {
 		const startAt = now() + delay;
@@ -1091,11 +1157,11 @@ function createWork(opts = {}) {
 	};
 	const enqueueImpl = (a, b, c) => {
 		const fromName = typeof a === "string";
-		const id = fromName ? uuid() : a.id;
+		const id = fromName ? newId() : a.id;
 		const type = fromName ? a : a.type;
 		const input = fromName ? b : a.input;
 		const qOpts = fromName ? c : b;
-		const groupId = uuid();
+		const groupId = newId();
 		const ro = resolveOptions(type, input, qOpts);
 		return makeHandle(id, type, groupId, ro.skipQueue ? runImmediate(id, type, input, groupId, ro) : submitQueued(id, type, input, groupId, ro));
 	};
@@ -1366,6 +1432,50 @@ function createWork(opts = {}) {
 			attempt: env.attempt,
 			error,
 			willRetry: false,
+			parent: env.parent,
+			dependents: env.dependents,
+			at
+		});
+		await settleGroup(env.groupId);
+	};
+	/** Whether an item is past its deadline (so it should expire rather than run or retry). */
+	const expired = (env) => env.deadline !== void 0 && now() > env.deadline;
+	/** Terminal expiry: like a dead-letter, but emits `'expired'` (the item didn't start+finish by its deadline). */
+	const expireItem = async (p, env, q) => {
+		const at = now();
+		const error = "deadline exceeded";
+		stats.expired(env.type);
+		await port(() => Promise.resolve(store.set(k(`item:${env.id}:error`), error, RESULT_TTL)));
+		await setState({
+			id: env.id,
+			type: env.type,
+			status: "dead",
+			attempt: env.attempt,
+			error,
+			queueAt: env.queueAt,
+			startAt: env.startAt,
+			endAt: at,
+			priority: env.priority,
+			group: env.group
+		}, env.groupId);
+		if (p && q) {
+			await Promise.resolve(q.deadLetter?.(p.body, error));
+			await port(() => Promise.resolve(q.ack(p)));
+		}
+		notify({
+			kind: "done",
+			id: env.id,
+			groupId: env.groupId,
+			error
+		});
+		emit({
+			kind: "expired",
+			id: env.id,
+			type: env.type,
+			groupId: env.groupId,
+			deadline: env.deadline,
+			parent: env.parent,
+			dependents: env.dependents,
 			at
 		});
 		await settleGroup(env.groupId);
@@ -1398,6 +1508,8 @@ function createWork(opts = {}) {
 			type: env.type,
 			groupId: env.groupId,
 			attempt: env.attempt,
+			parent: env.parent,
+			dependents: env.dependents,
 			at: runAt
 		});
 	};
@@ -1435,6 +1547,8 @@ function createWork(opts = {}) {
 			groupId: env.groupId,
 			attempt: env.attempt,
 			result: output,
+			parent: env.parent,
+			dependents: env.dependents,
 			at
 		});
 		await settleGroup(env.groupId);
@@ -1442,6 +1556,10 @@ function createWork(opts = {}) {
 	const finishFailure = async (p, env, runAt, err, q) => {
 		if (env.attempt < attemptsOf(env.retry)) {
 			const delay = backoff$1(env.attempt, env.retry, random);
+			if (env.deadline !== void 0 && now() + delay > env.deadline) {
+				await expireItem(p, env, q);
+				return;
+			}
 			stats.retried(env.type);
 			emit({
 				kind: "failed",
@@ -1451,6 +1569,8 @@ function createWork(opts = {}) {
 				attempt: env.attempt,
 				error: errString(err),
 				willRetry: true,
+				parent: env.parent,
+				dependents: env.dependents,
 				at: now()
 			});
 			if (p && q) await port(() => Promise.resolve(q.ack(p)));
@@ -1499,35 +1619,85 @@ function createWork(opts = {}) {
 		}
 		await finishFailure(p, env, runAt, err, q);
 	};
-	const queuedContext = (env, pending) => makeContext({
-		id: env.id,
-		groupId: env.groupId,
-		attempt: env.attempt,
-		enqueueOne: (work, options) => {
-			pending.push(submitQueued(work.id, work.type, work.input, env.groupId, resolveOptions(work.type, work.input, options)));
-			return work.id;
-		},
-		setResult: (r) => {
-			pending.push(port(() => Promise.resolve(store.set(k(`group:${env.groupId}:result`), globalCodec.stringify(r), RESULT_TTL)).then(() => void 0)));
-		},
-		states: storeStates,
-		claim: storeClaim
-	});
+	/** Write a group-result contribution: `final` locks it; `append` folds into the existing value (read-modify-write, best-effort under concurrency). */
+	const writeGroupResult = async (groupId, value, final, append) => {
+		const resultKey = k(`group:${groupId}:result`);
+		const finalKey = k(`group:${groupId}:final`);
+		if (await Promise.resolve(store.get(finalKey)) !== void 0) return;
+		let toWrite = value;
+		if (append) {
+			const ex = await Promise.resolve(store.get(resultKey));
+			toWrite = append(ex === void 0 ? void 0 : globalCodec.parse(ex));
+		}
+		await port(() => Promise.resolve(store.set(resultKey, globalCodec.stringify(toWrite), RESULT_TTL)).then(() => void 0));
+		if (final) await port(() => Promise.resolve(store.set(finalKey, "1", RESULT_TTL)).then(() => void 0));
+	};
+	/**
+	* Run the returned WorkResult tree: enqueue works, build native dependencies (`.next`), write group
+	* contributions. `assignDeps` (the `on` list when this is a fired dependency) tags non-dependency
+	* children's `dependents`.
+	*/
+	const applyNode = (node, env, pending, assignDeps) => {
+		const d = node.data;
+		if (d.kind === "void") return;
+		if (d.kind === "result") {
+			pending.push(writeGroupResult(env.groupId, d.value, d.final, d.append));
+			return;
+		}
+		for (const item of d.items) if (isWR(item)) applyNode(item, env, pending, assignDeps);
+		else pending.push(submitWork(item, env.groupId, d.options, {
+			parent: env.id,
+			dependents: item.type === "@work/dependency" ? void 0 : assignDeps
+		}));
+		for (const chain of d.chains) {
+			const dep = dependency({
+				on: workIdsOf(chain.on),
+				queue: chain.queue,
+				config: chain.condition
+			});
+			pending.push(submitWork(dep, env.groupId, chain.options, { parent: env.id }));
+		}
+	};
+	/** Strict-return: every created WorkResult must be reachable from the returned `root` (else it silently does nothing). */
+	const reachableCheck = (root, created) => {
+		const seen = /* @__PURE__ */ new Set();
+		const walk = (n) => {
+			if (seen.has(n)) return;
+			seen.add(n);
+			if (n.data.kind === "queue") {
+				for (const it of n.data.items) if (isWR(it)) walk(it);
+			}
+		};
+		walk(root);
+		for (const n of created) if (!seen.has(n)) throw new Error(`work "${root.data.kind}" created a ctx.queue()/result()/void() that was not returned (set strictReturn:false to allow detached instructions)`);
+	};
 	/**
 	* The task handed to a doer: run a single item (leased from queue `q`, or `skipQueue` with `p`/`q`
 	* null). `release` is the {@link claim} teardown — {@link scoped} runs it in `finally`, so the
-	* active-set entry + heartbeat are always cleaned up regardless of how the run ends.
+	* active-set entry + heartbeat are always cleaned up regardless of how the run ends. The handler
+	* returns a {@link WorkResult}; we then apply its tree (enqueue children, write group contributions).
 	*/
 	const execute = (p, env, input, def, q, release) => scoped(release, async () => {
 		const runAt = now();
 		markRunningSync(env, runAt);
 		const running = persistRunning(env, runAt).catch((err) => report(err, "commit"));
-		const pending = [];
-		const ctx = queuedContext(env, pending);
-		let output;
+		const created = /* @__PURE__ */ new Set();
+		const ctx = makeContext({
+			id: env.id,
+			groupId: env.groupId,
+			attempt: env.attempt,
+			parent: env.parent,
+			dependents: env.dependents
+		}, created);
+		let itemValue;
 		try {
-			output = await logWith(merge(opts.logContext?.(input, env.type), def.options.logContext?.(input)), () => Promise.resolve(def.handler(input, ctx)));
+			const ret = await logWith(merge(opts.logContext?.(input, env.type), def.options.logContext?.(input)), () => Promise.resolve(def.handler(input, ctx)));
+			if (!isWR(ret)) throw new Error(`work "${env.type}" handler must return a WorkResult — ctx.result(...), ctx.queue(...), or ctx.void()`);
+			if (def.options.strictReturn ?? strictReturnDefault) reachableCheck(ret, created);
+			const pending = [];
+			applyNode(ret, env, pending, env.type === "@work/dependency" ? input.on : void 0);
 			await Promise.all(pending);
+			itemValue = ret.data.kind === "result" ? ret.data.value : void 0;
 		} catch (err) {
 			await running;
 			await handleFailure(p, env, runAt, err, q);
@@ -1535,7 +1705,7 @@ function createWork(opts = {}) {
 		}
 		try {
 			await running;
-			await finishSuccess(p, env, runAt, output, q);
+			await finishSuccess(p, env, runAt, itemValue, q);
 		} catch (err) {
 			report(err, "commit");
 		}
@@ -1554,7 +1724,7 @@ function createWork(opts = {}) {
 			await Promise.all(items.map((it) => handleFailure(it.p, it.env, runAt, err, it.q)));
 			return;
 		}
-		await Promise.all(items.map((it, i) => Promise.resolve(finishSuccess(it.p, it.env, runAt, outputs[i], it.q)).catch((err) => report(err, "commit"))));
+		await Promise.all(items.map((it, i) => Promise.resolve(writeGroupResult(it.env.groupId, outputs[i], false)).then(() => finishSuccess(it.p, it.env, runAt, outputs[i], it.q)).catch((err) => report(err, "commit"))));
 	});
 	const batchers = /* @__PURE__ */ new Map();
 	const batcherFor = (type) => {
@@ -1607,6 +1777,10 @@ function createWork(opts = {}) {
 			await Promise.resolve(q.ack(p));
 			return false;
 		}
+		if (expired(env)) {
+			await expireItem(p, env, q);
+			return false;
+		}
 		const due = now();
 		if (env.startAt - due > SCHED_TOLERANCE) {
 			await reschedule(p, env, q, env.startAt);
@@ -1780,7 +1954,10 @@ function createWork(opts = {}) {
 			await sleep(pollInterval);
 		}
 	};
-	registry.set(DEPENDENCY_TYPE, defineWork(DEPENDENCY_TYPE, dependencyHandler, { retry: { attempts: DEP_RETRY_ATTEMPTS } }));
+	registry.set(DEPENDENCY_TYPE, defineWork(DEPENDENCY_TYPE, dependencyHandler, {
+		retry: { attempts: DEP_RETRY_ATTEMPTS },
+		strictReturn: false
+	}));
 	const start = () => {
 		if (running) return;
 		running = true;
@@ -1892,7 +2069,7 @@ function adaptiveDelay(opts = {}) {
 * ```ts
 * import { defineWork, createWork } from '@ayepi/work'
 *
-* const add = defineWork('add', (i: { a: number; b: number }) => i.a + i.b)
+* const add = defineWork('add', (i: { a: number; b: number }, ctx) => ctx.result(i.a + i.b))
 * const w = createWork({ work: [add] as const })
 *
 * const sum = await w.enqueue(add({ a: 1, b: 2 })).result() // 3, typed as number
@@ -1917,4 +2094,4 @@ const stop = () => instance.stop();
 /** Snapshot the default system's known work states. */
 const list = () => instance.list();
 //#endregion
-export { DEFAULT_BUCKETS, DEFAULT_RETRY_OPTIONS, DEPENDENCY_TYPE, RetryAbort, WORK_METRICS, WorkDelayError, adaptiveDelay, ageDoer, backoff, balancedDoer, conditionMet, createMetrics, createWork, defaultCodec, defineBatchWork, defineWork, dependency, enqueue, formatPrometheus, getDefaultRetryOptions, list, memoryBackend, memoryPubSub, memoryQueue, memoryStore, nextAfter, parseCron, priorityDoer, retry, schedule, setDefaultRetryOptions, start, stop, unlimitedDoer, work };
+export { DEFAULT_BUCKETS, DEFAULT_RETRY_OPTIONS, DEPENDENCY_TYPE, RetryAbort, WORK_METRICS, WorkDelayError, adaptiveDelay, ageDoer, backoff, balancedDoer, conditionMet, createMetrics, createWork, defaultCodec, defineBatchWork, defineWork, dependency, enqueue, formatPrometheus, getDefaultRetryOptions, list, memoryBackend, memoryPubSub, memoryQueue, memoryStore, nextAfter, parseCron, priorityDoer, retry, schedule, setDefaultRetryOptions, setIdGenerator, start, stop, unlimitedDoer, work };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ayepi/work",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Type-safe distributed work / job-queue + workflow engine for ayepi — pluggable queue/pubsub/kv ports, in-memory bundled, retries, dependencies, scheduling",
   "license": "MIT",
   "publishConfig": {
@@ -18,7 +18,8 @@
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "ayepi-*.md"
   ],
   "exports": {
     ".": {
@@ -37,14 +38,14 @@
     "node": ">=18"
   },
   "peerDependencies": {
-    "@ayepi/core": "^0.1.0"
+    "@ayepi/core": "^0.2.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^2.1.8",
     "publint": "^0.3.0",
     "tsdown": "^0.12.0",
     "vitest": "^2.1.8",
-    "@ayepi/core": "0.1.0"
+    "@ayepi/core": "0.2.0"
   },
   "keywords": [
     "ayepi",