flowli 0.2.1

package/dist/drivers/bun-redis.js

@@ -0,0 +1,21 @@
+import { createRedisDriver } from "./shared.js";
+export function bunRedisDriver(options) {
+    return createRedisDriver({
+        kind: "bun-redis",
+        ...(options.prefix ? { prefix: options.prefix } : {}),
+        commands: createBunRedisAdapter(options.client),
+    });
+}
+export function createBunRedisAdapter(client) {
+    return {
+        get: (key) => client.get(key),
+        set: (key, value, options) => client.set(key, value, {
+            ...(options?.nx ? { nx: options.nx } : {}),
+            ...(options?.px !== undefined ? { px: options.px } : {}),
+        }),
+        del: (key) => client.del(key),
+        zadd: (key, score, member) => client.zadd(key, score, member),
+        zrem: (key, member) => client.zrem(key, member),
+        zrangebyscore: (key, min, max, limit) => client.zrangebyscore(key, min, max, limit ? { limit } : undefined),
+    };
+}

package/dist/drivers/ioredis.d.ts

@@ -0,0 +1,16 @@
+import type { FlowliDriver } from "../core/types.js";
+import { type RedisCommandAdapter } from "./shared.js";
+export interface IoredisLikeClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, modeOrOptions?: "PX" | "NX" | undefined, ttlOrMode?: number | "NX" | "PX", maybeMode?: "NX" | "PX"): Promise<"OK" | null>;
+    del(key: string): Promise<number>;
+    zadd(key: string, score: number, member: string): Promise<number>;
+    zrem(key: string, member: string): Promise<number>;
+    zrangebyscore(key: string, min: number | string, max: number | string, limitToken?: "LIMIT", offset?: number, count?: number): Promise<string[]>;
+}
+export interface IoredisDriverOptions {
+    readonly client: IoredisLikeClient;
+    readonly prefix?: string;
+}
+export declare function ioredisDriver(options: IoredisDriverOptions): FlowliDriver;
+export declare function createIoredisAdapter(client: IoredisLikeClient): RedisCommandAdapter;

package/dist/drivers/ioredis.js

@@ -0,0 +1,31 @@
+import { createRedisDriver } from "./shared.js";
+export function ioredisDriver(options) {
+    return createRedisDriver({
+        kind: "ioredis",
+        ...(options.prefix ? { prefix: options.prefix } : {}),
+        commands: createIoredisAdapter(options.client),
+    });
+}
+export function createIoredisAdapter(client) {
+    return {
+        get: (key) => client.get(key),
+        async set(key, value, options) {
+            if (options?.nx && options?.px !== undefined) {
+                return client.set(key, value, "PX", options.px, "NX");
+            }
+            if (options?.nx) {
+                return client.set(key, value, "NX");
+            }
+            if (options?.px !== undefined) {
+                return client.set(key, value, "PX", options.px);
+            }
+            return client.set(key, value);
+        },
+        del: (key) => client.del(key),
+        zadd: (key, score, member) => client.zadd(key, score, member),
+        zrem: (key, member) => client.zrem(key, member),
+        zrangebyscore: (key, min, max, limit) => limit
+            ? client.zrangebyscore(key, min, max, "LIMIT", limit.offset, limit.count)
+            : client.zrangebyscore(key, min, max),
+    };
+}

package/dist/drivers/redis.d.ts

@@ -0,0 +1,27 @@
+import type { FlowliDriver } from "../core/types.js";
+import { type RedisCommandAdapter } from "./shared.js";
+export interface NodeRedisLikeClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        NX?: boolean;
+        PX?: number;
+    }): Promise<string | null>;
+    del(key: string): Promise<number>;
+    zAdd(key: string, members: ReadonlyArray<{
+        score: number;
+        value: string;
+    }>): Promise<number>;
+    zRem(key: string, member: string): Promise<number>;
+    zRangeByScore(key: string, min: number, max: number, options?: {
+        LIMIT?: {
+            offset: number;
+            count: number;
+        };
+    }): Promise<string[]>;
+}
+export interface RedisDriverOptions {
+    readonly client: NodeRedisLikeClient;
+    readonly prefix?: string;
+}
+export declare function redisDriver(options: RedisDriverOptions): FlowliDriver;
+export declare function createNodeRedisAdapter(client: NodeRedisLikeClient): RedisCommandAdapter;

package/dist/drivers/redis.js

@@ -0,0 +1,23 @@
+import { createRedisDriver } from "./shared.js";
+export function redisDriver(options) {
+    return createRedisDriver({
+        kind: "redis",
+        ...(options.prefix ? { prefix: options.prefix } : {}),
+        commands: createNodeRedisAdapter(options.client),
+    });
+}
+export function createNodeRedisAdapter(client) {
+    return {
+        get: (key) => client.get(key),
+        set: (key, value, options) => client
+            .set(key, value, {
+            ...(options?.nx ? { NX: options.nx } : {}),
+            ...(options?.px !== undefined ? { PX: options.px } : {}),
+        })
+            .then((result) => (result === null ? null : "OK")),
+        del: (key) => client.del(key),
+        zadd: (key, score, member) => client.zAdd(key, [{ score, value: member }]),
+        zrem: (key, member) => client.zRem(key, member),
+        zrangebyscore: (key, min, max, limit) => client.zRangeByScore(key, min, max, limit ? { LIMIT: limit } : undefined),
+    };
+}

package/dist/drivers/shared.d.ts

@@ -0,0 +1,21 @@
+import type { FlowliDriver } from "../core/types.js";
+import { type FlowliRedisKeyOptions } from "../driver/keys.js";
+export interface RedisCommandAdapter {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        nx?: boolean;
+        px?: number;
+    }): Promise<"OK" | null>;
+    del(key: string): Promise<number>;
+    zadd(key: string, score: number, member: string): Promise<number>;
+    zrem(key: string, member: string): Promise<number>;
+    zrangebyscore(key: string, min: number, max: number, limit?: {
+        offset: number;
+        count: number;
+    }): Promise<string[]>;
+}
+export interface SharedRedisDriverOptions extends FlowliRedisKeyOptions {
+    readonly kind: string;
+    readonly commands: RedisCommandAdapter;
+}
+export declare function createRedisDriver(options: SharedRedisDriverOptions): FlowliDriver;

package/dist/drivers/shared.js

@@ -0,0 +1,172 @@
+import { decodeJson, encodeJson } from "../driver/encoding.js";
+import { createRedisKeys } from "../driver/keys.js";
+import { createJobReceipt, createPersistedJobRecord, createScheduleReceipt, } from "../driver/records.js";
+import { createJobId, createLeaseToken, getNextCronRun, } from "../driver/scheduling.js";
+export function createRedisDriver(options) {
+    const keys = createRedisKeys(options.prefix ? { prefix: options.prefix } : undefined);
+    const commands = options.commands;
+    return {
+        kind: options.kind,
+        async enqueue(record) {
+            await writeJob(record);
+            await commands.zadd(keys.pending, record.scheduledFor, record.id);
+            return createJobReceipt(record);
+        },
+        async registerSchedule(record) {
+            await commands.set(keys.schedule(record.key), encodeJson(record));
+            await commands.zadd(keys.schedulesDue, record.nextRunAt, record.key);
+            return createScheduleReceipt(record);
+        },
+        async acquireNextReady(now, leaseMs) {
+            const candidates = await commands.zrangebyscore(keys.pending, Number.NEGATIVE_INFINITY, now, {
+                offset: 0,
+                count: 25,
+            });
+            for (const jobId of candidates) {
+                const token = createLeaseToken();
+                const locked = await commands.set(keys.lease(jobId), token, {
+                    nx: true,
+                    px: leaseMs,
+                });
+                if (!locked) {
+                    continue;
+                }
+                const removed = await commands.zrem(keys.pending, jobId);
+                if (removed === 0) {
+                    await commands.del(keys.lease(jobId));
+                    continue;
+                }
+                const record = await readJob(jobId);
+                if (!record) {
+                    await commands.del(keys.lease(jobId));
+                    continue;
+                }
+                const acquiredRecord = {
+                    ...record,
+                    state: "active",
+                    attemptsMade: record.attemptsMade + 1,
+                    updatedAt: now,
+                };
+                await writeJob(acquiredRecord);
+                await commands.zadd(keys.active, now, jobId);
+                return {
+                    token,
+                    record: acquiredRecord,
+                };
+            }
+            return null;
+        },
+        async renewLease(jobId, token, leaseMs) {
+            const current = await commands.get(keys.lease(jobId));
+            if (current !== token) {
+                return false;
+            }
+            const updated = await commands.set(keys.lease(jobId), token, {
+                px: leaseMs,
+            });
+            return updated === "OK";
+        },
+        async markCompleted(acquired, finishedAt) {
+            const completedRecord = {
+                ...acquired.record,
+                state: "completed",
+                updatedAt: finishedAt,
+            };
+            await writeJob(completedRecord);
+            await commands.zrem(keys.active, completedRecord.id);
+            await commands.zadd(keys.completed, finishedAt, completedRecord.id);
+            await commands.del(keys.lease(completedRecord.id));
+        },
+        async markFailed(acquired, finishedAt, error) {
+            const shouldRetry = acquired.record.attemptsMade < acquired.record.maxAttempts;
+            const retryAt = shouldRetry
+                ? finishedAt + computeBackoff(acquired.record, finishedAt)
+                : finishedAt;
+            const nextRecord = {
+                ...acquired.record,
+                state: shouldRetry ? "queued" : "failed",
+                scheduledFor: retryAt,
+                updatedAt: finishedAt,
+                lastError: error,
+            };
+            await writeJob(nextRecord);
+            await commands.zrem(keys.active, nextRecord.id);
+            if (shouldRetry) {
+                await commands.zadd(keys.pending, retryAt, nextRecord.id);
+            }
+            else {
+                await commands.zadd(keys.failed, finishedAt, nextRecord.id);
+            }
+            await commands.del(keys.lease(nextRecord.id));
+            return shouldRetry ? "retrying" : "failed";
+        },
+        async materializeDueSchedules(now, leaseMs) {
+            const dueKeys = await commands.zrangebyscore(keys.schedulesDue, Number.NEGATIVE_INFINITY, now, { offset: 0, count: 100 });
+            let created = 0;
+            for (const scheduleKey of dueKeys) {
+                const token = createLeaseToken();
+                const locked = await commands.set(keys.scheduleLease(scheduleKey), token, {
+                    nx: true,
+                    px: leaseMs,
+                });
+                if (!locked) {
+                    continue;
+                }
+                const schedule = await readSchedule(scheduleKey);
+                if (!schedule) {
+                    await commands.zrem(keys.schedulesDue, scheduleKey);
+                    await commands.del(keys.scheduleLease(scheduleKey));
+                    continue;
+                }
+                if (schedule.nextRunAt > now) {
+                    await commands.del(keys.scheduleLease(scheduleKey));
+                    continue;
+                }
+                const jobRecord = createPersistedJobRecord({
+                    id: createJobId(),
+                    name: schedule.name,
+                    input: schedule.input,
+                    meta: schedule.meta,
+                    scheduledFor: now,
+                    maxAttempts: schedule.maxAttempts,
+                    ...(schedule.backoff ? { backoff: schedule.backoff } : {}),
+                    now,
+                });
+                await writeJob(jobRecord);
+                await commands.zadd(keys.pending, now, jobRecord.id);
+                created += 1;
+                const nextRunAt = getNextCronRun(schedule.cron, now);
+                const nextSchedule = {
+                    ...schedule,
+                    nextRunAt,
+                    updatedAt: now,
+                };
+                await commands.set(keys.schedule(schedule.key), encodeJson(nextSchedule));
+                await commands.zrem(keys.schedulesDue, scheduleKey);
+                await commands.zadd(keys.schedulesDue, nextRunAt, scheduleKey);
+                await commands.del(keys.scheduleLease(scheduleKey));
+            }
+            return created;
+        },
+    };
+    async function writeJob(record) {
+        await commands.set(keys.job(record.id), encodeJson(record));
+    }
+    async function readJob(jobId) {
+        return decodeJson(await commands.get(keys.job(jobId)));
+    }
+    async function readSchedule(key) {
+        return decodeJson(await commands.get(keys.schedule(key)));
+    }
+}
+function computeBackoff(record, finishedAt) {
+    void finishedAt;
+    if (!record.backoff) {
+        return 0;
+    }
+    if (record.backoff.type === "fixed") {
+        return record.backoff.delayMs;
+    }
+    const exponent = Math.max(record.attemptsMade - 1, 0);
+    return record.backoff.delayMs * Math.max(1, 2 ** exponent);
+}

package/dist/hono.d.ts

@@ -0,0 +1 @@
+export { type HonoFlowliVariables, type HonoJobsOptions, type HonoLikeContext, type HonoLikeNext, honoJobs, } from "./integrations/hono.js";

package/dist/hono.js

@@ -0,0 +1,3 @@
+export {
+  honoJobs
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { defineJobs } from "./core/define-jobs.js";
+export { FlowliDefinitionError, FlowliDriverError, FlowliError, FlowliSchedulingError, FlowliStrategyError, FlowliValidationError, } from "./core/errors.js";
+export { createContextualJobFactory, job } from "./core/job.js";
+export type { BackoffOptions, DefineJobsBuilder, DelayValue, FlowliContextRecord, FlowliContextResolver, FlowliDriver, FlowliInvocationOptions, FlowliJobSurface, FlowliRuntime, JobDefaults, JobDefinition, JobHandlerArgs, JobReceipt, ScheduleInvocation, ScheduleReceipt, StandardSchemaIssue, StandardSchemaV1, } from "./core/types.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+export {
+  job,
+  defineJobs,
+  createContextualJobFactory,
+  FlowliValidationError,
+  FlowliStrategyError,
+  FlowliSchedulingError,
+  FlowliError,
+  FlowliDriverError,
+  FlowliDefinitionError
+};

package/dist/integrations/hono.d.ts

@@ -0,0 +1,10 @@
+import type { FlowliContextRecord, FlowliRuntime, JobsRecord } from "../core/types.js";
+export interface HonoLikeContext {
+    set(key: string, value: unknown): void;
+}
+export type HonoLikeNext = () => Promise<unknown>;
+export interface HonoJobsOptions<TKey extends string = "flowli"> {
+    readonly key?: TKey;
+}
+export type HonoFlowliVariables<TFlowli, TKey extends string = "flowli"> = Record<TKey, TFlowli>;
+export declare function honoJobs<TJobs extends JobsRecord, TContext extends FlowliContextRecord, TKey extends string = "flowli">(flowli: FlowliRuntime<TJobs, TContext>, options?: HonoJobsOptions<TKey>): (context: HonoLikeContext, next: HonoLikeNext) => Promise<void>;

package/dist/integrations/hono.js

@@ -0,0 +1,7 @@
+export function honoJobs(flowli, options = {}) {
+    const key = options.key ?? "flowli";
+    return async (context, next) => {
+        context.set(key, flowli);
+        await next();
+    };
+}

package/dist/integrations/next.d.ts

@@ -0,0 +1,18 @@
+import type { FlowliContextRecord, FlowliRuntime, JobsRecord } from "../core/types.js";
+export type NextRouteParams = Record<string, string | ReadonlyArray<string> | undefined>;
+export interface NextRouteContext<TParams extends NextRouteParams = NextRouteParams> {
+    readonly params?: TParams | Promise<TParams>;
+}
+export interface NextRouteHandlerArgs<TFlowli, TParams extends NextRouteParams = NextRouteParams, TRequest extends Request = Request> {
+    readonly request: TRequest;
+    readonly context: NextRouteContext<TParams>;
+    readonly params: TParams | undefined;
+    readonly flowli: TFlowli;
+}
+export type NextRouteHandler<TFlowli, TParams extends NextRouteParams = NextRouteParams, TRequest extends Request = Request, TResult = Response> = (args: NextRouteHandlerArgs<TFlowli, TParams, TRequest>) => TResult | Promise<TResult>;
+export interface NextActionTools<TFlowli> {
+    readonly flowli: TFlowli;
+}
+export type NextActionHandler<TFlowli, TArgs extends ReadonlyArray<unknown>, TResult> = (tools: NextActionTools<TFlowli>, ...args: TArgs) => TResult | Promise<TResult>;
+export declare function nextRoute<TJobs extends JobsRecord, TContext extends FlowliContextRecord, TParams extends NextRouteParams = NextRouteParams, TRequest extends Request = Request, TResult = Response>(flowli: FlowliRuntime<TJobs, TContext>, handler: NextRouteHandler<FlowliRuntime<TJobs, TContext>, TParams, TRequest, TResult>): (request: TRequest, context?: NextRouteContext<TParams>) => Promise<Awaited<TResult>>;
+export declare function nextAction<TJobs extends JobsRecord, TContext extends FlowliContextRecord, TArgs extends ReadonlyArray<unknown>, TResult>(flowli: FlowliRuntime<TJobs, TContext>, handler: NextActionHandler<FlowliRuntime<TJobs, TContext>, TArgs, TResult>): (...args: TArgs) => Promise<Awaited<TResult>>;

package/dist/integrations/tanstack-start.d.ts

@@ -0,0 +1,20 @@
+import type { FlowliContextRecord, FlowliRuntime, JobsRecord } from "../core/types.js";
+export type TanStackStartRouteParams = Record<string, string | ReadonlyArray<string> | undefined>;
+export interface TanStackStartRouteContext {
+    readonly [key: PropertyKey]: unknown;
+}
+export interface TanStackStartRouteHandlerArgs<TFlowli, TParams extends TanStackStartRouteParams = TanStackStartRouteParams, TContext extends TanStackStartRouteContext = TanStackStartRouteContext, TRequest extends Request = Request> {
+    readonly request: TRequest;
+    readonly params: TParams;
+    readonly context: TContext;
+    readonly flowli: TFlowli;
+}
+export type TanStackStartRouteHandler<TFlowli, TParams extends TanStackStartRouteParams = TanStackStartRouteParams, TContext extends TanStackStartRouteContext = TanStackStartRouteContext, TRequest extends Request = Request, TResult = Response> = (args: TanStackStartRouteHandlerArgs<TFlowli, TParams, TContext, TRequest>) => TResult | Promise<TResult>;
+export interface TanStackStartServerFnTools<TFlowli> {
+    readonly flowli: TFlowli;
+}
+type StripFlowli<TArgs extends object> = Omit<TArgs, keyof TanStackStartServerFnTools<unknown>>;
+export type TanStackStartServerFnHandler<TFlowli, TArgs extends TanStackStartServerFnTools<TFlowli>, TResult> = (args: TArgs) => TResult | Promise<TResult>;
+export declare function tanstackStartRoute<TJobs extends JobsRecord, TContext extends FlowliContextRecord, TParams extends TanStackStartRouteParams = TanStackStartRouteParams, TRouteContext extends TanStackStartRouteContext = TanStackStartRouteContext, TRequest extends Request = Request, TResult = Response>(flowli: FlowliRuntime<TJobs, TContext>, handler: TanStackStartRouteHandler<FlowliRuntime<TJobs, TContext>, TParams, TRouteContext, TRequest, TResult>): (args: Omit<TanStackStartRouteHandlerArgs<FlowliRuntime<TJobs, TContext>, TParams, TRouteContext, TRequest>, "flowli">) => Promise<Awaited<TResult>>;
+export declare function tanstackStartServerFn<TJobs extends JobsRecord, TContext extends FlowliContextRecord, TArgs extends TanStackStartServerFnTools<FlowliRuntime<TJobs, TContext>>, TResult>(flowli: FlowliRuntime<TJobs, TContext>, handler: TanStackStartServerFnHandler<FlowliRuntime<TJobs, TContext>, TArgs, TResult>): (args: StripFlowli<TArgs>) => Promise<Awaited<TResult>>;
+export {};

package/dist/ioredis.d.ts

@@ -0,0 +1 @@
+export { type IoredisDriverOptions, type IoredisLikeClient, ioredisDriver, } from "./drivers/ioredis.js";

package/dist/ioredis.js

@@ -0,0 +1,3 @@
+export {
+  ioredisDriver
+};

package/dist/next.d.ts

@@ -0,0 +1 @@
+export { type NextActionHandler, type NextActionTools, type NextRouteContext, type NextRouteHandler, type NextRouteHandlerArgs, type NextRouteParams, nextAction, nextRoute, } from "./integrations/next.js";

package/dist/next.js

@@ -0,0 +1,4 @@
+export {
+  nextRoute,
+  nextAction
+};

package/dist/redis.d.ts

@@ -0,0 +1 @@
+export { type NodeRedisLikeClient, type RedisDriverOptions, redisDriver, } from "./drivers/redis.js";

package/dist/redis.js

@@ -0,0 +1,3 @@
+export {
+  redisDriver
+};

package/dist/runner/create-runner.d.ts

@@ -0,0 +1,3 @@
+import type { FlowliContextRecord, JobsRecord } from "../core/types.js";
+import type { FlowliRunner, RunnerOptions } from "./types.js";
+export declare function createRunner<TJobs extends JobsRecord, TContext extends FlowliContextRecord>(options: RunnerOptions<TJobs, TContext>): FlowliRunner;

package/dist/runner/create-runner.js

@@ -0,0 +1,104 @@
+import { getFlowliRuntimeInternals } from "../core/define-jobs.js";
+import { FlowliDriverError, FlowliStrategyError } from "../core/errors.js";
+import { createPersistedJobError } from "../driver/records.js";
+import { invokeHandler } from "../runtime/invoke-handler.js";
+import { validateWithSchema } from "../runtime/validate.js";
+export function createRunner(options) {
+    const internals = getFlowliRuntimeInternals(options.flowli);
+    if (!internals.driver) {
+        throw new FlowliDriverError("createRunner() requires a Flowli runtime with a configured driver.");
+    }
+    const driver = internals.driver;
+    const concurrency = Math.max(options.concurrency ?? 1, 1);
+    const pollIntervalMs = Math.max(options.pollIntervalMs ?? 1_000, 10);
+    const leaseMs = Math.max(options.leaseMs ?? 30_000, 1_000);
+    const maxJobsPerTick = Math.max(options.maxJobsPerTick ?? concurrency, 1);
+    let running = false;
+    let timer;
+    let ticking = false;
+    return {
+        get running() {
+            return running;
+        },
+        async runOnce() {
+            if (ticking) {
+                return 0;
+            }
+            ticking = true;
+            try {
+                await driver.materializeDueSchedules(Date.now(), leaseMs);
+                let processed = 0;
+                while (processed < maxJobsPerTick) {
+                    const batch = await Promise.all(Array.from({ length: Math.min(concurrency, maxJobsPerTick - processed) }, () => processNext()));
+                    const completed = batch.reduce((count, value) => count + value, 0);
+                    processed += completed;
+                    if (completed === 0) {
+                        break;
+                    }
+                }
+                return processed;
+            }
+            finally {
+                ticking = false;
+            }
+        },
+        async start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            const loop = async () => {
+                if (!running) {
+                    return;
+                }
+                await this.runOnce();
+                timer = setTimeout(loop, pollIntervalMs);
+            };
+            await loop();
+        },
+        async stop() {
+            running = false;
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+    };
+    async function processNext() {
+        const acquired = await driver.acquireNextReady(Date.now(), leaseMs);
+        if (!acquired) {
+            return 0;
+        }
+        const job = internals.jobsByName.get(acquired.record.name);
+        if (!job) {
+            throw new FlowliStrategyError(`No registered job named "${acquired.record.name}" found for runner execution.`);
+        }
+        const heartbeat = setInterval(() => {
+            void driver.renewLease(acquired.record.id, acquired.token, leaseMs);
+        }, Math.max(Math.floor(leaseMs / 2), 250));
+        try {
+            await options.hooks?.onJobStarted?.(acquired.record.id, acquired.record.name);
+            await executePersistedJob(job, options.flowli, acquired.record.input, acquired.record.meta);
+            clearInterval(heartbeat);
+            await driver.markCompleted(acquired, Date.now());
+            await options.hooks?.onJobCompleted?.(acquired.record.id, acquired.record.name);
+            return 1;
+        }
+        catch (error) {
+            clearInterval(heartbeat);
+            const serialized = createPersistedJobError(error);
+            await driver.markFailed(acquired, Date.now(), serialized);
+            await options.hooks?.onJobFailed?.(acquired.record.id, acquired.record.name, serialized);
+            return 1;
+        }
+    }
+}
+async function executePersistedJob(job, flowli, input, meta) {
+    const internals = getFlowliRuntimeInternals(flowli);
+    const validatedInput = await validateWithSchema(job.input, input, `${job.name} input`);
+    const validatedMeta = job.meta
+        ? await validateWithSchema(job.meta, meta, `${job.name} meta`)
+        : undefined;
+    const context = await internals.context();
+    await invokeHandler(job, validatedInput, context, validatedMeta);
+}

package/dist/runner/types.d.ts

@@ -0,0 +1,20 @@
+import type { FlowliContextRecord, FlowliRuntime, JobsRecord, PersistedJobError } from "../core/types.js";
+export interface RunnerHooks {
+    readonly onJobStarted?: (jobId: string, jobName: string) => void | Promise<void>;
+    readonly onJobCompleted?: (jobId: string, jobName: string) => void | Promise<void>;
+    readonly onJobFailed?: (jobId: string, jobName: string, error: PersistedJobError) => void | Promise<void>;
+}
+export interface RunnerOptions<TJobs extends JobsRecord, TContext extends FlowliContextRecord> {
+    readonly flowli: FlowliRuntime<TJobs, TContext>;
+    readonly concurrency?: number;
+    readonly pollIntervalMs?: number;
+    readonly leaseMs?: number;
+    readonly maxJobsPerTick?: number;
+    readonly hooks?: RunnerHooks;
+}
+export interface FlowliRunner {
+    readonly running: boolean;
+    runOnce(): Promise<number>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/runner/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runner.d.ts

@@ -0,0 +1,2 @@
+export { createRunner } from "./runner/create-runner.js";
+export type { FlowliRunner, RunnerHooks, RunnerOptions, } from "./runner/types.js";

package/dist/runner.js

@@ -0,0 +1,3 @@
+export {
+  createRunner
+};

package/dist/runtime/create-job-surface.d.ts

@@ -0,0 +1,2 @@
+import type { AnyJobDefinition, FlowliContextRecord, FlowliJobSurface, FlowliRuntimeInternals } from "../core/types.js";
+export declare function createJobSurface<TJob extends AnyJobDefinition, TContext extends FlowliContextRecord>(job: TJob, internals: FlowliRuntimeInternals<Record<string, TJob>, TContext>): FlowliJobSurface<TJob>;

package/dist/runtime/create-job-surface.js

@@ -0,0 +1,24 @@
+import { delayStrategy } from "../strategies/delay.js";
+import { enqueueStrategy } from "../strategies/enqueue.js";
+import { runStrategy } from "../strategies/run.js";
+import { scheduleStrategy } from "../strategies/schedule.js";
+export function createJobSurface(job, internals) {
+    const defaults = mergeDefaults(internals.defaults, job.defaults);
+    return {
+        run: (input, options) => runStrategy(job, internals, defaults, input, options?.meta),
+        enqueue: (input, options) => enqueueStrategy(job, internals, defaults, Date.now(), input, options),
+        delay: (delay, input, options) => delayStrategy(job, internals, defaults, Date.now(), delay, input, options),
+        schedule: (invocation) => scheduleStrategy(job, internals, defaults, Date.now(), invocation),
+    };
+}
+function mergeDefaults(globalDefaults, jobDefaults) {
+    return {
+        ...(jobDefaults?.maxAttempts !== undefined ||
+            globalDefaults.maxAttempts !== undefined
+            ? { maxAttempts: jobDefaults?.maxAttempts ?? globalDefaults.maxAttempts }
+            : {}),
+        ...((jobDefaults?.backoff ?? globalDefaults.backoff)
+            ? { backoff: jobDefaults?.backoff ?? globalDefaults.backoff }
+            : {}),
+    };
+}

package/dist/runtime/invoke-handler.d.ts

@@ -0,0 +1,2 @@
+import type { AnyJobDefinition, FlowliContextRecord, JobMeta, JobResult } from "../core/types.js";
+export declare function invokeHandler<TJob extends AnyJobDefinition, TContext extends FlowliContextRecord>(job: TJob, input: unknown, context: TContext, meta: JobMeta<TJob>): Promise<JobResult<TJob>>;

package/dist/runtime/invoke-handler.js

@@ -0,0 +1,7 @@
+export async function invokeHandler(job, input, context, meta) {
+    return (await job.handler({
+        input: input,
+        ctx: context,
+        meta,
+    }));
+}

package/dist/runtime/normalize-jobs.d.ts

@@ -0,0 +1,5 @@
+import type { AnyJobDefinition, JobsRecord } from "../core/types.js";
+export declare function normalizeJobs<TJobs extends JobsRecord>(jobs: TJobs): {
+    readonly jobs: TJobs;
+    readonly jobsByName: Map<string, AnyJobDefinition>;
+};

package/dist/runtime/normalize-jobs.js

@@ -0,0 +1,14 @@
+import { FlowliDefinitionError } from "../core/errors.js";
+export function normalizeJobs(jobs) {
+    const jobsByName = new Map();
+    for (const [exportName, definition] of Object.entries(jobs)) {
+        if (!definition || definition.__flowli !== "job") {
+            throw new FlowliDefinitionError(`Expected "${exportName}" to be a Flowli job definition.`);
+        }
+        if (jobsByName.has(definition.name)) {
+            throw new FlowliDefinitionError(`Duplicate job name "${definition.name}" found in registry.`);
+        }
+        jobsByName.set(definition.name, definition);
+    }
+    return { jobs, jobsByName };
+}

package/dist/runtime/resolve-context.d.ts

@@ -0,0 +1,2 @@
+import type { FlowliContextRecord, FlowliContextResolver } from "../core/types.js";
+export declare function createContextResolver<TContext extends FlowliContextRecord>(context: FlowliContextResolver<TContext>): () => Promise<TContext>;