flowli 0.2.1

package/dist/bun-redis.d.ts

@@ -0,0 +1 @@
+export { type BunRedisDriverOptions, type BunRedisLikeClient, bunRedisDriver, } from "./drivers/bun-redis.js";

package/dist/bun-redis.js

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

package/dist/core/define-jobs.d.ts

@@ -0,0 +1,8 @@
+import type { DefineJobsFactoryOptions, DefineJobsOptions, EnsureJobContexts, FlowliContextRecord, FlowliRuntime, FlowliRuntimeInternals, JobsRecord } from "./types.js";
+type DefineJobsFunction = {
+    <const TJobs extends JobsRecord, TContext extends FlowliContextRecord>(options: DefineJobsFactoryOptions<TJobs, TContext>): FlowliRuntime<TJobs, TContext>;
+    withContext<TContext extends FlowliContextRecord>(): <const TJobs extends JobsRecord>(options: DefineJobsOptions<EnsureJobContexts<TJobs, TContext>, TContext>) => FlowliRuntime<EnsureJobContexts<TJobs, TContext>, TContext>;
+};
+export declare const defineJobs: DefineJobsFunction;
+export declare function getFlowliRuntimeInternals<TJobs extends JobsRecord, TContext extends FlowliContextRecord>(runtime: FlowliRuntime<TJobs, TContext>): FlowliRuntimeInternals<TJobs, TContext>;
+export {};

package/dist/core/define-jobs.js

@@ -0,0 +1,47 @@
+import { createJobSurface } from "../runtime/create-job-surface.js";
+import { normalizeJobs } from "../runtime/normalize-jobs.js";
+import { createContextResolver } from "../runtime/resolve-context.js";
+import { createContextualJobFactory } from "./job.js";
+import { FLOWLI_RUNTIME_SYMBOL as runtimeSymbol } from "./types.js";
+function defineJobsFromFactory(options) {
+    const resolvedJobs = options.jobs({
+        job: createContextualJobFactory(),
+    });
+    return buildRuntime(resolvedJobs, options.context, options.driver, options.defaults);
+}
+function defineJobsFromObject(options) {
+    return buildRuntime(options.jobs, options.context, options.driver, options.defaults);
+}
+function buildRuntime(jobs, context, driver, defaultsInput) {
+    const normalized = normalizeJobs(jobs);
+    const defaults = {
+        maxAttempts: defaultsInput?.maxAttempts ?? 1,
+        ...(defaultsInput?.backoff ? { backoff: defaultsInput.backoff } : {}),
+    };
+    const internals = {
+        jobs: normalized.jobs,
+        jobsByName: normalized.jobsByName,
+        context: createContextResolver(context),
+        ...(driver ? { driver } : {}),
+        defaults,
+    };
+    const runtime = {};
+    for (const [exportName, definition] of Object.entries(normalized.jobs)) {
+        runtime[exportName] = createJobSurface(definition, internals);
+    }
+    Object.defineProperty(runtime, runtimeSymbol, {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value: internals,
+    });
+    return runtime;
+}
+export const defineJobs = Object.assign(defineJobsFromFactory, {
+    withContext() {
+        return (options) => defineJobsFromObject(options);
+    },
+});
+export function getFlowliRuntimeInternals(runtime) {
+    return runtime[runtimeSymbol];
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,21 @@
+import type { StandardSchemaIssue } from "./types.js";
+export declare class FlowliError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class FlowliDefinitionError extends FlowliError {
+    constructor(message: string);
+}
+export declare class FlowliValidationError extends FlowliError {
+    readonly issues: ReadonlyArray<StandardSchemaIssue>;
+    constructor(message: string, issues: ReadonlyArray<StandardSchemaIssue>);
+}
+export declare class FlowliStrategyError extends FlowliError {
+    constructor(message: string);
+}
+export declare class FlowliDriverError extends FlowliError {
+    constructor(message: string);
+}
+export declare class FlowliSchedulingError extends FlowliError {
+    constructor(message: string);
+}

package/dist/core/errors.js

@@ -0,0 +1,35 @@
+export class FlowliError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = new.target.name;
+        this.code = code;
+    }
+}
+export class FlowliDefinitionError extends FlowliError {
+    constructor(message) {
+        super("FLOWLI_DEFINITION_ERROR", message);
+    }
+}
+export class FlowliValidationError extends FlowliError {
+    issues;
+    constructor(message, issues) {
+        super("FLOWLI_VALIDATION_ERROR", message);
+        this.issues = issues;
+    }
+}
+export class FlowliStrategyError extends FlowliError {
+    constructor(message) {
+        super("FLOWLI_STRATEGY_ERROR", message);
+    }
+}
+export class FlowliDriverError extends FlowliError {
+    constructor(message) {
+        super("FLOWLI_DRIVER_ERROR", message);
+    }
+}
+export class FlowliSchedulingError extends FlowliError {
+    constructor(message) {
+        super("FLOWLI_SCHEDULING_ERROR", message);
+    }
+}

package/dist/core/job.d.ts

@@ -0,0 +1,9 @@
+import type { FlowliContextRecord, JobDefinition, JobOptions, StandardSchemaV1 } from "./types.js";
+type JobFactory = {
+    <TInputSchema extends StandardSchemaV1<any, any>, TMetaSchema extends StandardSchemaV1<any, any> | undefined, TResult>(name: string, options: JobOptions<TInputSchema, TMetaSchema, FlowliContextRecord, TResult>): JobDefinition<TInputSchema, TMetaSchema, FlowliContextRecord, TResult>;
+    withContext<TContext extends FlowliContextRecord>(): <TInputSchema extends StandardSchemaV1<any, any>, TMetaSchema extends StandardSchemaV1<any, any> | undefined, TResult>(name: string, options: JobOptions<TInputSchema, TMetaSchema, TContext, TResult>) => JobDefinition<TInputSchema, TMetaSchema, TContext, TResult>;
+};
+export type ContextualJobFactory<TContext extends FlowliContextRecord> = <TInputSchema extends StandardSchemaV1<any, any>, TMetaSchema extends StandardSchemaV1<any, any> | undefined, TResult>(name: string, options: JobOptions<TInputSchema, TMetaSchema, TContext, TResult>) => JobDefinition<TInputSchema, TMetaSchema, TContext, TResult>;
+export declare const job: JobFactory;
+export declare function createContextualJobFactory<TContext extends FlowliContextRecord>(): ContextualJobFactory<TContext>;
+export {};

package/dist/core/job.js

@@ -0,0 +1,20 @@
+function createJob(name, options) {
+    return {
+        __flowli: "job",
+        name,
+        input: options.input,
+        handler: options.handler,
+        ...(options.meta ? { meta: options.meta } : {}),
+        ...(options.defaults ? { defaults: options.defaults } : {}),
+        ...(options.description ? { description: options.description } : {}),
+        ...(options.tags ? { tags: options.tags } : {}),
+    };
+}
+export const job = Object.assign(createJob, {
+    withContext() {
+        return (name, options) => createJob(name, options);
+    },
+});
+export function createContextualJobFactory() {
+    return job.withContext();
+}

package/dist/core/types.d.ts

@@ -0,0 +1,175 @@
+export interface StandardSchemaIssue {
+    message: string;
+    path?: ReadonlyArray<unknown>;
+}
+export interface StandardSchemaSuccess<TValue> {
+    readonly value: TValue;
+}
+export interface StandardSchemaFailure {
+    readonly issues: ReadonlyArray<StandardSchemaIssue>;
+}
+export type StandardSchemaResult<TValue> = StandardSchemaSuccess<TValue> | StandardSchemaFailure;
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": {
+        readonly version: number;
+        readonly vendor?: string;
+        readonly validate: (...args: any[]) => unknown | Promise<unknown>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+}
+export type InferInput<TSchema extends StandardSchemaV1<any, any>> = TSchema extends StandardSchemaV1<infer TInput, any> ? TInput : never;
+export type InferOutput<TSchema extends StandardSchemaV1<any, any>> = TSchema extends StandardSchemaV1<any, infer TOutput> ? TOutput : never;
+export interface FlowliContextRecord {
+    readonly [key: PropertyKey]: unknown;
+}
+export type FlowliContextResolver<TContext extends FlowliContextRecord> = TContext | (() => TContext | Promise<TContext>);
+export type ResolveContext<TResolver> = TResolver extends () => infer TResult ? Awaited<TResult> : TResolver extends FlowliContextRecord ? TResolver : never;
+export interface JobDefaults {
+    readonly maxAttempts?: number;
+    readonly backoff?: BackoffOptions;
+}
+export interface BackoffOptions {
+    readonly type: "fixed" | "exponential";
+    readonly delayMs: number;
+}
+export interface FlowliInvocationOptions<TMeta> {
+    readonly meta?: TMeta;
+}
+export interface PersistedInvocationOptions<TMeta> extends FlowliInvocationOptions<TMeta>, JobDefaults {
+}
+export interface ScheduleInvocation<TInput, TMeta> {
+    readonly key?: string;
+    readonly cron: string;
+    readonly input: TInput;
+    readonly meta?: TMeta;
+}
+export type DelayValue = number | `${number}${"ms" | "s" | "m" | "h" | "d"}`;
+export interface JobReceipt {
+    readonly id: string;
+    readonly name: string;
+    readonly state: JobState;
+    readonly scheduledFor: number;
+    readonly attemptsMade: number;
+}
+export interface ScheduleReceipt {
+    readonly key: string;
+    readonly name: string;
+    readonly cron: string;
+    readonly nextRunAt: number;
+}
+export type JobState = "queued" | "active" | "completed" | "failed" | "scheduled";
+export interface JobHandlerArgs<TInput, TContext, TMeta> {
+    readonly input: TInput;
+    readonly ctx: TContext;
+    readonly meta: TMeta | undefined;
+}
+export interface JobDefinition<TInputSchema extends StandardSchemaV1<any, any>, TMetaSchema extends StandardSchemaV1<any, any> | undefined, TContext extends FlowliContextRecord, TResult> {
+    readonly __flowli: "job";
+    readonly name: string;
+    readonly input: TInputSchema;
+    readonly meta?: TMetaSchema;
+    readonly handler: (args: JobHandlerArgs<InferOutput<TInputSchema>, TContext, TMetaSchema extends StandardSchemaV1<any, any> ? InferOutput<TMetaSchema> : undefined>) => TResult | Promise<TResult>;
+    readonly defaults?: JobDefaults;
+    readonly description?: string;
+    readonly tags?: ReadonlyArray<string>;
+}
+export interface JobOptions<TInputSchema extends StandardSchemaV1<any, any>, TMetaSchema extends StandardSchemaV1<any, any> | undefined, TContext extends FlowliContextRecord, TResult> {
+    readonly input: TInputSchema;
+    readonly meta?: TMetaSchema;
+    readonly handler: JobDefinition<TInputSchema, TMetaSchema, TContext, TResult>["handler"];
+    readonly defaults?: JobDefaults;
+    readonly description?: string;
+    readonly tags?: ReadonlyArray<string>;
+}
+export type AnyJobDefinition = JobDefinition<StandardSchemaV1<any, any>, StandardSchemaV1<any, any> | undefined, any, unknown>;
+export type JobsRecord = {
+    readonly [key: string]: AnyJobDefinition;
+};
+export type JobInput<TJob extends AnyJobDefinition> = InferOutput<TJob["input"]>;
+export type JobMeta<TJob extends AnyJobDefinition> = NonNullable<TJob["meta"]> extends StandardSchemaV1<any, any> ? InferOutput<NonNullable<TJob["meta"]>> : undefined;
+export type JobResult<TJob extends AnyJobDefinition> = Awaited<ReturnType<TJob["handler"]>>;
+export interface FlowliDriver {
+    readonly kind: string;
+    enqueue(record: PersistedJobRecord): Promise<JobReceipt>;
+    registerSchedule(record: ScheduleRecord): Promise<ScheduleReceipt>;
+    recoverExpiredLeases(now: number): Promise<number>;
+    acquireNextReady(now: number, leaseMs: number): Promise<AcquiredJobRecord | null>;
+    renewLease(jobId: string, token: string, leaseMs: number): Promise<boolean>;
+    markCompleted(acquired: AcquiredJobRecord, finishedAt: number): Promise<void>;
+    markFailed(acquired: AcquiredJobRecord, finishedAt: number, error: PersistedJobError): Promise<"failed" | "retrying">;
+    materializeDueSchedules(now: number, leaseMs: number): Promise<number>;
+}
+export interface DefineJobsOptions<TJobs extends JobsRecord, TContext extends FlowliContextRecord> {
+    readonly jobs: TJobs;
+    readonly context: FlowliContextResolver<TContext>;
+    readonly driver?: FlowliDriver;
+    readonly defaults?: JobDefaults;
+}
+export interface DefineJobsBuilder<TContext extends FlowliContextRecord> {
+    readonly job: <TInputSchema extends StandardSchemaV1<any, any>, TMetaSchema extends StandardSchemaV1<any, any> | undefined, TResult>(name: string, options: JobOptions<TInputSchema, TMetaSchema, TContext, TResult>) => JobDefinition<TInputSchema, TMetaSchema, TContext, TResult>;
+}
+export interface DefineJobsFactoryOptions<TJobs extends JobsRecord, TContext extends FlowliContextRecord> {
+    readonly jobs: (builder: DefineJobsBuilder<TContext>) => TJobs;
+    readonly context: FlowliContextResolver<TContext>;
+    readonly driver?: FlowliDriver;
+    readonly defaults?: JobDefaults;
+}
+export type EnsureJobContexts<TJobs extends JobsRecord, TContext extends FlowliContextRecord> = {
+    readonly [TKey in keyof TJobs]: TJobs[TKey] extends JobDefinition<StandardSchemaV1<any, any>, StandardSchemaV1<any, any> | undefined, infer TJobContext, unknown> ? TContext extends TJobContext ? TJobs[TKey] : never : never;
+};
+export interface FlowliJobSurface<TJob extends AnyJobDefinition> {
+    run(input: JobInput<TJob>, options?: FlowliInvocationOptions<JobMeta<TJob>>): Promise<JobResult<TJob>>;
+    enqueue(input: JobInput<TJob>, options?: PersistedInvocationOptions<JobMeta<TJob>>): Promise<JobReceipt>;
+    delay(delay: DelayValue, input: JobInput<TJob>, options?: PersistedInvocationOptions<JobMeta<TJob>>): Promise<JobReceipt>;
+    schedule(invocation: ScheduleInvocation<JobInput<TJob>, JobMeta<TJob>>): Promise<ScheduleReceipt>;
+}
+export type FlowliRuntime<TJobs extends JobsRecord, TContext extends FlowliContextRecord> = {
+    readonly [TKey in keyof TJobs]: FlowliJobSurface<TJobs[TKey]>;
+} & {
+    readonly [FLOWLI_RUNTIME_SYMBOL]: FlowliRuntimeInternals<TJobs, TContext>;
+};
+export interface FlowliRuntimeInternals<TJobs extends JobsRecord, TContext extends FlowliContextRecord> {
+    readonly jobs: TJobs;
+    readonly jobsByName: Map<string, AnyJobDefinition>;
+    readonly context: () => Promise<TContext>;
+    readonly driver?: FlowliDriver;
+    readonly defaults: JobDefaults;
+}
+export declare const FLOWLI_RUNTIME_SYMBOL: unique symbol;
+export interface PersistedJobError {
+    readonly code: string;
+    readonly message: string;
+}
+export interface PersistedJobRecord {
+    readonly id: string;
+    readonly name: string;
+    readonly input: unknown;
+    readonly meta?: unknown;
+    readonly state: JobState;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly scheduledFor: number;
+    readonly attemptsMade: number;
+    readonly maxAttempts: number;
+    readonly backoff?: BackoffOptions;
+    readonly lastError?: PersistedJobError;
+}
+export interface AcquiredJobRecord {
+    readonly token: string;
+    readonly record: PersistedJobRecord;
+}
+export interface ScheduleRecord {
+    readonly key: string;
+    readonly name: string;
+    readonly cron: string;
+    readonly input: unknown;
+    readonly meta?: unknown;
+    readonly maxAttempts: number;
+    readonly backoff?: BackoffOptions;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly nextRunAt: number;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export const FLOWLI_RUNTIME_SYMBOL = Symbol.for("flowli.runtime");

package/dist/driver/duration.d.ts

@@ -0,0 +1,2 @@
+import type { DelayValue } from "../core/types.js";
+export declare function parseDelay(delay: DelayValue): number;

package/dist/driver/duration.js

@@ -0,0 +1,23 @@
+import { FlowliStrategyError } from "../core/errors.js";
+const DURATION_UNITS = {
+    ms: 1,
+    s: 1_000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+};
+export function parseDelay(delay) {
+    if (typeof delay === "number") {
+        if (!Number.isFinite(delay) || delay < 0) {
+            throw new FlowliStrategyError("Delay must be a non-negative finite number.");
+        }
+        return delay;
+    }
+    const match = /^(\d+)(ms|s|m|h|d)$/.exec(delay);
+    if (!match) {
+        throw new FlowliStrategyError(`Invalid delay value "${delay}". Expected a number or a duration string like "5m".`);
+    }
+    const value = Number(match[1]);
+    const unit = match[2];
+    return value * DURATION_UNITS[unit];
+}

package/dist/driver/encoding.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeJson(value: unknown): string;
+export declare function decodeJson<TValue>(value: string | null): TValue | null;

package/dist/driver/encoding.js

@@ -0,0 +1,9 @@
+export function encodeJson(value) {
+    return JSON.stringify(value);
+}
+export function decodeJson(value) {
+    if (value === null) {
+        return null;
+    }
+    return JSON.parse(value);
+}

package/dist/driver/keys.d.ts

@@ -0,0 +1,15 @@
+export interface FlowliRedisKeyOptions {
+    readonly prefix?: string;
+}
+export interface FlowliRedisKeys {
+    readonly job: (id: string) => string;
+    readonly pending: string;
+    readonly active: string;
+    readonly completed: string;
+    readonly failed: string;
+    readonly schedule: (key: string) => string;
+    readonly schedulesDue: string;
+    readonly lease: (id: string) => string;
+    readonly scheduleLease: (key: string) => string;
+}
+export declare function createRedisKeys(options?: FlowliRedisKeyOptions): FlowliRedisKeys;

package/dist/driver/keys.js

@@ -0,0 +1,14 @@
+export function createRedisKeys(options = {}) {
+    const base = `flowli:${options.prefix ?? "default"}`;
+    return {
+        job: (id) => `${base}:job:${id}`,
+        pending: `${base}:queue:pending`,
+        active: `${base}:queue:active`,
+        completed: `${base}:queue:completed`,
+        failed: `${base}:queue:failed`,
+        schedule: (key) => `${base}:schedule:${key}`,
+        schedulesDue: `${base}:schedule:due`,
+        lease: (id) => `${base}:lease:${id}`,
+        scheduleLease: (key) => `${base}:lease:schedule:${key}`,
+    };
+}

package/dist/driver/records.d.ts

@@ -0,0 +1,25 @@
+import type { BackoffOptions, JobReceipt, PersistedJobError, PersistedJobRecord, ScheduleReceipt, ScheduleRecord } from "../core/types.js";
+export declare function createPersistedJobRecord(options: {
+    id: string;
+    name: string;
+    input: unknown;
+    meta?: unknown;
+    scheduledFor: number;
+    maxAttempts: number;
+    backoff?: BackoffOptions;
+    now: number;
+}): PersistedJobRecord;
+export declare function createJobReceipt(record: PersistedJobRecord): JobReceipt;
+export declare function createScheduleRecord(options: {
+    key: string;
+    name: string;
+    cron: string;
+    input: unknown;
+    meta?: unknown;
+    maxAttempts: number;
+    backoff?: BackoffOptions;
+    nextRunAt: number;
+    now: number;
+}): ScheduleRecord;
+export declare function createScheduleReceipt(record: ScheduleRecord): ScheduleReceipt;
+export declare function createPersistedJobError(error: unknown): PersistedJobError;

package/dist/driver/records.js

@@ -0,0 +1,61 @@
+export function createPersistedJobRecord(options) {
+    return {
+        id: options.id,
+        name: options.name,
+        input: options.input,
+        state: "queued",
+        createdAt: options.now,
+        updatedAt: options.now,
+        scheduledFor: options.scheduledFor,
+        attemptsMade: 0,
+        maxAttempts: options.maxAttempts,
+        ...(options.meta !== undefined ? { meta: options.meta } : {}),
+        ...(options.backoff ? { backoff: options.backoff } : {}),
+    };
+}
+export function createJobReceipt(record) {
+    return {
+        id: record.id,
+        name: record.name,
+        state: record.state,
+        scheduledFor: record.scheduledFor,
+        attemptsMade: record.attemptsMade,
+    };
+}
+export function createScheduleRecord(options) {
+    return {
+        key: options.key,
+        name: options.name,
+        cron: options.cron,
+        input: options.input,
+        maxAttempts: options.maxAttempts,
+        createdAt: options.now,
+        updatedAt: options.now,
+        nextRunAt: options.nextRunAt,
+        ...(options.meta !== undefined ? { meta: options.meta } : {}),
+        ...(options.backoff ? { backoff: options.backoff } : {}),
+    };
+}
+export function createScheduleReceipt(record) {
+    return {
+        key: record.key,
+        name: record.name,
+        cron: record.cron,
+        nextRunAt: record.nextRunAt,
+    };
+}
+export function createPersistedJobError(error) {
+    if (error instanceof Error) {
+        const code = "code" in error && typeof error.code === "string"
+            ? error.code
+            : "FLOWLI_HANDLER_ERROR";
+        return {
+            code,
+            message: error.message,
+        };
+    }
+    return {
+        code: "FLOWLI_HANDLER_ERROR",
+        message: typeof error === "string" ? error : "Unknown handler error",
+    };
+}

package/dist/driver/scheduling.d.ts

@@ -0,0 +1,6 @@
+export declare function validateCron(cron: string): void;
+export declare function getNextCronRun(cron: string, from: number): number;
+export declare function deriveScheduleKey(name: string, cron: string, input: unknown): string;
+export declare function createJobId(): string;
+export declare function createLeaseToken(): string;
+export declare function stableStringify(value: unknown): string;

package/dist/driver/scheduling.js

@@ -0,0 +1,127 @@
+import { createHash, randomUUID } from "node:crypto";
+import { FlowliSchedulingError } from "../core/errors.js";
+const FIELD_RANGES = [
+    { min: 0, max: 59 },
+    { min: 0, max: 23 },
+    { min: 1, max: 31 },
+    { min: 1, max: 12 },
+    { min: 0, max: 6 },
+];
+export function validateCron(cron) {
+    parseCron(cron);
+}
+export function getNextCronRun(cron, from) {
+    const parsed = parseCron(cron);
+    const candidate = new Date(from);
+    candidate.setUTCSeconds(0, 0);
+    candidate.setUTCMinutes(candidate.getUTCMinutes() + 1);
+    for (let offset = 0; offset < 366 * 24 * 60; offset += 1) {
+        if (parsed.minute.has(candidate.getUTCMinutes()) &&
+            parsed.hour.has(candidate.getUTCHours()) &&
+            parsed.dayOfMonth.has(candidate.getUTCDate()) &&
+            parsed.month.has(candidate.getUTCMonth() + 1) &&
+            parsed.dayOfWeek.has(candidate.getUTCDay())) {
+            return candidate.getTime();
+        }
+        candidate.setUTCMinutes(candidate.getUTCMinutes() + 1);
+    }
+    throw new FlowliSchedulingError(`Unable to resolve next UTC execution time for cron "${cron}".`);
+}
+export function deriveScheduleKey(name, cron, input) {
+    const hash = createHash("sha256");
+    hash.update(stableStringify({
+        name,
+        cron,
+        input,
+    }));
+    return `schedule_${hash.digest("hex").slice(0, 16)}`;
+}
+export function createJobId() {
+    return randomUUID();
+}
+export function createLeaseToken() {
+    return randomUUID();
+}
+export function stableStringify(value) {
+    return JSON.stringify(normalizeValue(value));
+}
+function normalizeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeValue(item));
+    }
+    if (value && typeof value === "object" && value.constructor === Object) {
+        return Object.keys(value)
+            .sort()
+            .reduce((result, key) => {
+            result[key] = normalizeValue(value[key]);
+            return result;
+        }, {});
+    }
+    return value;
+}
+function parseCron(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new FlowliSchedulingError(`Invalid cron "${cron}". Expected exactly five UTC fields.`);
+    }
+    return {
+        minute: parseField(parts[0], FIELD_RANGES[0].min, FIELD_RANGES[0].max),
+        hour: parseField(parts[1], FIELD_RANGES[1].min, FIELD_RANGES[1].max),
+        dayOfMonth: parseField(parts[2], FIELD_RANGES[2].min, FIELD_RANGES[2].max),
+        month: parseField(parts[3], FIELD_RANGES[3].min, FIELD_RANGES[3].max),
+        dayOfWeek: parseField(parts[4], FIELD_RANGES[4].min, FIELD_RANGES[4].max),
+    };
+}
+function parseField(field, min, max) {
+    if (field === "*") {
+        return createRange(min, max);
+    }
+    const values = new Set();
+    for (const segment of field.split(",")) {
+        if (/^\d+$/.test(segment)) {
+            const value = Number(segment);
+            assertRange(value, min, max, field);
+            values.add(value);
+            continue;
+        }
+        const stepMatch = /^\*\/(\d+)$/.exec(segment);
+        if (stepMatch) {
+            const step = Number(stepMatch[1]);
+            if (step <= 0) {
+                throw new FlowliSchedulingError(`Invalid cron step "${segment}".`);
+            }
+            for (let value = min; value <= max; value += step) {
+                values.add(value);
+            }
+            continue;
+        }
+        const rangeMatch = /^(\d+)-(\d+)$/.exec(segment);
+        if (rangeMatch) {
+            const start = Number(rangeMatch[1]);
+            const end = Number(rangeMatch[2]);
+            assertRange(start, min, max, field);
+            assertRange(end, min, max, field);
+            if (start > end) {
+                throw new FlowliSchedulingError(`Invalid cron range "${segment}".`);
+            }
+            for (let value = start; value <= end; value += 1) {
+                values.add(value);
+            }
+            continue;
+        }
+        throw new FlowliSchedulingError(`Unsupported cron field "${segment}".`);
+    }
+    return values;
+}
+function createRange(min, max) {
+    const values = new Set();
+    for (let value = min; value <= max; value += 1) {
+        values.add(value);
+    }
+    return values;
+}
+function assertRange(value, min, max, field) {
+    if (value < min || value > max) {
+        throw new FlowliSchedulingError(`Value ${value} is out of range for cron field "${field}".`);
+    }
+}

package/dist/drivers/bun-redis.d.ts

@@ -0,0 +1,24 @@
+import type { FlowliDriver } from "../core/types.js";
+import { type RedisCommandAdapter } from "./shared.js";
+export interface BunRedisLikeClient {
+    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, options?: {
+        limit?: {
+            offset: number;
+            count: number;
+        };
+    }): Promise<string[]>;
+}
+export interface BunRedisDriverOptions {
+    readonly client: BunRedisLikeClient;
+    readonly prefix?: string;
+}
+export declare function bunRedisDriver(options: BunRedisDriverOptions): FlowliDriver;
+export declare function createBunRedisAdapter(client: BunRedisLikeClient): RedisCommandAdapter;