@durable-effect/jobs 0.0.1-next.1

package/dist/definitions/index.js

@@ -0,0 +1,5 @@
+// packages/jobs/src/definitions/index.ts
+export { Continuous, } from "./continuous";
+export { Debounce, } from "./debounce";
+export { Task, } from "./task";
+//# sourceMappingURL=index.js.map

package/dist/definitions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/definitions/index.ts"],"names":[],"mappings":"AAAA,yCAAyC;AAEzC,OAAO,EACL,UAAU,GAGX,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,QAAQ,GAGT,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,IAAI,GAGL,MAAM,QAAQ,CAAC"}

package/dist/definitions/task.d.ts

@@ -0,0 +1,234 @@
+import type { Effect, Schema } from "effect";
+import type { UnregisteredTaskDefinition, TaskEventContext, TaskExecuteContext, TaskIdleContext, TaskErrorContext } from "../registry/types";
+/**
+ * Configuration for creating a task job definition.
+ *
+ * Task provides user-controlled durable state machines where:
+ * - Events update state and optionally schedule execution
+ * - Execute runs when alarm fires
+ * - User controls the full lifecycle via schedule/clear
+ *
+ * @typeParam S - State type (inferred from stateSchema)
+ * @typeParam E - Event type (inferred from eventSchema)
+ * @typeParam Err - Error type (inferred from handlers)
+ * @typeParam R - Effect requirements (inferred from handlers)
+ */
+export interface TaskMakeConfig<S, E, Err, R> {
+    /**
+     * Schema for validating and serializing state.
+     * State is persisted durably and survives restarts.
+     */
+    readonly stateSchema: Schema.Schema<S, any, never>;
+    /**
+     * Schema for validating incoming events.
+     * Events are validated before being passed to onEvent.
+     */
+    readonly eventSchema: Schema.Schema<E, any, never>;
+    /**
+     * Handler called for each incoming event.
+     *
+     * The event is passed as the first parameter (not on ctx) to make it
+     * clear that it's a direct value, not an Effect that needs yielding.
+     *
+     * Responsibilities:
+     * - Update state based on the event (via ctx.setState or ctx.updateState)
+     * - Schedule execution if needed (via ctx.schedule)
+     * - Optionally clear the task if complete (via ctx.clear)
+     *
+     * @param event - The incoming event (already validated against eventSchema)
+     * @param ctx - Context for state access, scheduling, and metadata
+     *
+     * @example
+     * ```ts
+     * onEvent: (event, ctx) => Effect.gen(function* () {
+     *   // event is a direct value - no yield needed!
+     *   console.log("Received:", event);
+     *
+     *   // Initialize state on first event
+     *   if (ctx.state === null) {
+     *     yield* ctx.setState({ items: [event], createdAt: Date.now() });
+     *   } else {
+     *     // Update state based on event
+     *     yield* ctx.updateState(s => ({
+     *       ...s,
+     *       items: [...s.items, event]
+     *     }));
+     *   }
+     *
+     *   // Schedule processing in 5 seconds
+     *   yield* ctx.schedule(Duration.seconds(5));
+     * })
+     * ```
+     */
+    onEvent(event: E, ctx: TaskEventContext<S>): Effect.Effect<void, Err, R>;
+    /**
+     * Handler called when the scheduled alarm fires.
+     *
+     * Responsibilities:
+     * - Process the current state
+     * - Schedule next execution if needed
+     * - Clear the task when work is complete
+     *
+     * @example
+     * ```ts
+     * execute: (ctx) => Effect.gen(function* () {
+     *   const state = yield* ctx.state;
+     *   if (state === null) return;
+     *
+     *   // Process items
+     *   yield* processItems(state.items);
+     *
+     *   // Clear when done
+     *   yield* ctx.clear();
+     * })
+     * ```
+     */
+    execute(ctx: TaskExecuteContext<S>): Effect.Effect<void, Err, R>;
+    /**
+     * Optional handler called when either `onEvent` or `execute` completes
+     * and no alarm is scheduled.
+     *
+     * Use this to:
+     * - Schedule delayed cleanup
+     * - Log idle state
+     * - Trigger maintenance tasks
+     *
+     * @example
+     * ```ts
+     * onIdle: (ctx) => Effect.gen(function* () {
+     *   // Schedule cleanup in 1 hour if nothing happens
+     *   yield* ctx.schedule(Duration.hours(1));
+     * })
+     * ```
+     */
+    readonly onIdle?: (ctx: TaskIdleContext<S>) => Effect.Effect<void, never, R>;
+    /**
+     * Optional error handler for onEvent/execute failures.
+     *
+     * Use this to:
+     * - Log errors
+     * - Update state to track failures
+     * - Schedule retries
+     * - Clear the task on fatal errors
+     *
+     * If not provided, errors are logged and the task continues.
+     *
+     * @example
+     * ```ts
+     * onError: (error, ctx) => Effect.gen(function* () {
+     *   yield* Effect.logError("Task failed", error);
+     *
+     *   // Track error in state
+     *   yield* ctx.updateState(s => ({
+     *     ...s,
+     *     errorCount: (s.errorCount ?? 0) + 1
+     *   }));
+     *
+     *   // Retry in 30 seconds
+     *   yield* ctx.schedule(Duration.seconds(30));
+     * })
+     * ```
+     */
+    readonly onError?: (error: Err, ctx: TaskErrorContext<S>) => Effect.Effect<void, never, R>;
+}
+/**
+ * Namespace for creating task job definitions.
+ *
+ * Task is a user-controlled durable state machine that provides:
+ * - Event-driven state updates
+ * - Scheduled execution via alarms
+ * - Full lifecycle control (schedule, cancel, clear)
+ *
+ * @example
+ * ```ts
+ * import { Task } from "@durable-effect/jobs";
+ * import { Schema, Effect, Duration } from "effect";
+ *
+ * // Order processing task
+ * const orderProcessor = Task.make({
+ *   stateSchema: Schema.Struct({
+ *     orderId: Schema.String,
+ *     status: Schema.Literal("pending", "processing", "shipped", "delivered"),
+ *     lastUpdated: Schema.Number,
+ *   }),
+ *
+ *   eventSchema: Schema.Union(
+ *     Schema.Struct({ _tag: Schema.Literal("OrderPlaced"), orderId: Schema.String }),
+ *     Schema.Struct({ _tag: Schema.Literal("PaymentReceived") }),
+ *     Schema.Struct({ _tag: Schema.Literal("Shipped"), trackingNumber: Schema.String }),
+ *   ),
+ *
+ *   // event is passed as first parameter - clear it's a direct value!
+ *   onEvent: (event, ctx) => Effect.gen(function* () {
+ *     switch (event._tag) {
+ *       case "OrderPlaced":
+ *         yield* ctx.setState({
+ *           orderId: event.orderId,
+ *           status: "pending",
+ *           lastUpdated: Date.now(),
+ *         });
+ *         // Check payment status in 5 minutes
+ *         yield* ctx.schedule(Duration.minutes(5));
+ *         break;
+ *
+ *       case "PaymentReceived":
+ *         yield* ctx.updateState(s => ({ ...s, status: "processing", lastUpdated: Date.now() }));
+ *         break;
+ *
+ *       case "Shipped":
+ *         yield* ctx.updateState(s => ({ ...s, status: "shipped", lastUpdated: Date.now() }));
+ *         // Check delivery in 24 hours
+ *         yield* ctx.schedule(Duration.hours(24));
+ *         break;
+ *     }
+ *   }),
+ *
+ *   execute: (ctx) => Effect.gen(function* () {
+ *     const state = yield* ctx.state;
+ *     if (state === null) return;
+ *
+ *     if (state.status === "shipped") {
+ *       // Check if delivered
+ *       const delivered = yield* checkDeliveryStatus(state.orderId);
+ *       if (delivered) {
+ *         yield* ctx.updateState(s => ({ ...s, status: "delivered", lastUpdated: Date.now() }));
+ *         yield* ctx.clear(); // Order complete
+ *       } else {
+ *         yield* ctx.schedule(Duration.hours(24)); // Check again tomorrow
+ *       }
+ *     }
+ *   }),
+ * });
+ *
+ * // Register with createDurableJobs - name comes from key
+ * const { Jobs, client } = createDurableJobs({
+ *   jobs: { orderProcessor },
+ *   binding: env.JOBS,
+ * });
+ *
+ * // Send events
+ * await Effect.runPromise(
+ *   client.task("orderProcessor").send({
+ *     id: "order-123",
+ *     event: { _tag: "OrderPlaced", orderId: "order-123" }
+ *   })
+ * );
+ * ```
+ */
+export declare const Task: {
+    /**
+     * Create a task job definition.
+     *
+     * The name is NOT provided here - it comes from the key when you
+     * register the job via createDurableJobs().
+     *
+     * @param config - Configuration for the task
+     * @returns An UnregisteredTaskDefinition that can be registered
+     */
+    readonly make: <S, E, Err = never, R = never>(config: TaskMakeConfig<S, E, Err, R>) => UnregisteredTaskDefinition<S, E, Err, R>;
+};
+/**
+ * Type alias for the Task namespace.
+ */
+export type TaskNamespace = typeof Task;
+//# sourceMappingURL=task.d.ts.map

package/dist/definitions/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/definitions/task.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EACV,0BAA0B,EAC1B,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAM3B;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IAEnD;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IAEzE;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IAEjE;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CACjB,KAAK,EAAE,GAAG,EACV,GAAG,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACrB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;OAQG;oBACI,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,kBACjB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,KACnC,0BAA0B,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;CASnC,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,IAAI,CAAC"}

package/dist/definitions/task.js

@@ -0,0 +1,106 @@
+// packages/jobs/src/definitions/task.ts
+/**
+ * Namespace for creating task job definitions.
+ *
+ * Task is a user-controlled durable state machine that provides:
+ * - Event-driven state updates
+ * - Scheduled execution via alarms
+ * - Full lifecycle control (schedule, cancel, clear)
+ *
+ * @example
+ * ```ts
+ * import { Task } from "@durable-effect/jobs";
+ * import { Schema, Effect, Duration } from "effect";
+ *
+ * // Order processing task
+ * const orderProcessor = Task.make({
+ *   stateSchema: Schema.Struct({
+ *     orderId: Schema.String,
+ *     status: Schema.Literal("pending", "processing", "shipped", "delivered"),
+ *     lastUpdated: Schema.Number,
+ *   }),
+ *
+ *   eventSchema: Schema.Union(
+ *     Schema.Struct({ _tag: Schema.Literal("OrderPlaced"), orderId: Schema.String }),
+ *     Schema.Struct({ _tag: Schema.Literal("PaymentReceived") }),
+ *     Schema.Struct({ _tag: Schema.Literal("Shipped"), trackingNumber: Schema.String }),
+ *   ),
+ *
+ *   // event is passed as first parameter - clear it's a direct value!
+ *   onEvent: (event, ctx) => Effect.gen(function* () {
+ *     switch (event._tag) {
+ *       case "OrderPlaced":
+ *         yield* ctx.setState({
+ *           orderId: event.orderId,
+ *           status: "pending",
+ *           lastUpdated: Date.now(),
+ *         });
+ *         // Check payment status in 5 minutes
+ *         yield* ctx.schedule(Duration.minutes(5));
+ *         break;
+ *
+ *       case "PaymentReceived":
+ *         yield* ctx.updateState(s => ({ ...s, status: "processing", lastUpdated: Date.now() }));
+ *         break;
+ *
+ *       case "Shipped":
+ *         yield* ctx.updateState(s => ({ ...s, status: "shipped", lastUpdated: Date.now() }));
+ *         // Check delivery in 24 hours
+ *         yield* ctx.schedule(Duration.hours(24));
+ *         break;
+ *     }
+ *   }),
+ *
+ *   execute: (ctx) => Effect.gen(function* () {
+ *     const state = yield* ctx.state;
+ *     if (state === null) return;
+ *
+ *     if (state.status === "shipped") {
+ *       // Check if delivered
+ *       const delivered = yield* checkDeliveryStatus(state.orderId);
+ *       if (delivered) {
+ *         yield* ctx.updateState(s => ({ ...s, status: "delivered", lastUpdated: Date.now() }));
+ *         yield* ctx.clear(); // Order complete
+ *       } else {
+ *         yield* ctx.schedule(Duration.hours(24)); // Check again tomorrow
+ *       }
+ *     }
+ *   }),
+ * });
+ *
+ * // Register with createDurableJobs - name comes from key
+ * const { Jobs, client } = createDurableJobs({
+ *   jobs: { orderProcessor },
+ *   binding: env.JOBS,
+ * });
+ *
+ * // Send events
+ * await Effect.runPromise(
+ *   client.task("orderProcessor").send({
+ *     id: "order-123",
+ *     event: { _tag: "OrderPlaced", orderId: "order-123" }
+ *   })
+ * );
+ * ```
+ */
+export const Task = {
+    /**
+     * Create a task job definition.
+     *
+     * The name is NOT provided here - it comes from the key when you
+     * register the job via createDurableJobs().
+     *
+     * @param config - Configuration for the task
+     * @returns An UnregisteredTaskDefinition that can be registered
+     */
+    make: (config) => ({
+        _tag: "TaskDefinition",
+        stateSchema: config.stateSchema,
+        eventSchema: config.eventSchema,
+        onEvent: config.onEvent,
+        execute: config.execute,
+        onIdle: config.onIdle,
+        onError: config.onError,
+    }),
+};
+//# sourceMappingURL=task.js.map

package/dist/definitions/task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../../src/definitions/task.ts"],"names":[],"mappings":"AAAA,wCAAwC;AA2JxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB;;;;;;;;OAQG;IACH,IAAI,EAAE,CACJ,MAAoC,EACM,EAAE,CAAC,CAAC;QAC9C,IAAI,EAAE,gBAAgB;QACtB,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,OAAO,EAAE,MAAM,CAAC,OAAO;KACxB,CAAC;CACM,CAAC"}

package/dist/engine/engine.d.ts

@@ -0,0 +1,60 @@
+import { DurableObject } from "cloudflare:workers";
+import type { JobRequest, JobResponse } from "../runtime/types";
+import type { DurableJobsEngineInterface, JobsEngineConfig } from "./types";
+/**
+ * The Durable Object class for jobs.
+ *
+ * This is a THIN SHELL that:
+ * 1. Creates the runtime in constructor
+ * 2. Delegates `call()` to `runtime.handle()`
+ * 3. Delegates `alarm()` to `runtime.handleAlarm()`
+ * 4. Flushes events via `ctx.waitUntil()`
+ *
+ * The engine knows NOTHING about job types. It just:
+ * - Creates the runtime
+ * - Delegates to runtime.handle() and runtime.handleAlarm()
+ * - Flushes events
+ *
+ * @example
+ * ```ts
+ * // In your worker's wrangler.toml:
+ * // [[durable_objects.bindings]]
+ * // name = "JOBS"
+ * // class_name = "DurableJobsEngine"
+ *
+ * // The engine is created via createDurableJobs():
+ * const { Jobs } = createDurableJobs({
+ *   jobs: { tokenRefresher, webhookDebounce, emailWorkerPool },
+ * });
+ *
+ * export { Jobs };
+ * ```
+ */
+export declare class DurableJobsEngine extends DurableObject implements DurableJobsEngineInterface {
+    #private;
+    /**
+     * Create a new jobs engine instance.
+     *
+     * @param state - Durable Object state (provides storage + alarm)
+     * @param env - Environment with config injected
+     */
+    constructor(state: DurableObjectState, env: JobsEngineConfig);
+    /**
+     * Handle a job request.
+     *
+     * ONE generic RPC method - NOT one per job operation.
+     * The DO doesn't know about job types.
+     *
+     * @param request - The typed request from the client
+     * @returns The typed response
+     */
+    call(request: JobRequest): Promise<JobResponse>;
+    /**
+     * Handle an alarm.
+     *
+     * The runtime reads metadata to determine job type,
+     * then delegates to the appropriate handler.
+     */
+    alarm(): Promise<void>;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/engine/engine.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,0BAA0B,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAM5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,iBACX,SAAQ,aACR,YAAW,0BAA0B;;IAOrC;;;;;OAKG;gBACS,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,gBAAgB;IAe5D;;;;;;;;OAQG;IACG,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC;IAUrD;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAO7B"}

package/dist/engine/engine.js

@@ -0,0 +1,89 @@
+// packages/jobs/src/engine/engine.ts
+import { DurableObject } from "cloudflare:workers";
+import { createJobsRuntime } from "../runtime/runtime";
+// =============================================================================
+// Durable Jobs Engine
+// =============================================================================
+/**
+ * The Durable Object class for jobs.
+ *
+ * This is a THIN SHELL that:
+ * 1. Creates the runtime in constructor
+ * 2. Delegates `call()` to `runtime.handle()`
+ * 3. Delegates `alarm()` to `runtime.handleAlarm()`
+ * 4. Flushes events via `ctx.waitUntil()`
+ *
+ * The engine knows NOTHING about job types. It just:
+ * - Creates the runtime
+ * - Delegates to runtime.handle() and runtime.handleAlarm()
+ * - Flushes events
+ *
+ * @example
+ * ```ts
+ * // In your worker's wrangler.toml:
+ * // [[durable_objects.bindings]]
+ * // name = "JOBS"
+ * // class_name = "DurableJobsEngine"
+ *
+ * // The engine is created via createDurableJobs():
+ * const { Jobs } = createDurableJobs({
+ *   jobs: { tokenRefresher, webhookDebounce, emailWorkerPool },
+ * });
+ *
+ * export { Jobs };
+ * ```
+ */
+export class DurableJobsEngine extends DurableObject {
+    /**
+     * The runtime that handles all job operations.
+     */
+    #runtime;
+    /**
+     * Create a new jobs engine instance.
+     *
+     * @param state - Durable Object state (provides storage + alarm)
+     * @param env - Environment with config injected
+     */
+    constructor(state, env) {
+        super(state, env);
+        state.storage.deleteAll;
+        if (!env.__JOB_REGISTRY__) {
+            throw new Error("DurableJobsEngine requires __JOB_REGISTRY__ in env");
+        }
+        // Create the runtime with DO state and registry
+        // The runtime handles all Effect complexity
+        this.#runtime = createJobsRuntime({
+            doState: state,
+            registry: env.__JOB_REGISTRY__,
+        });
+    }
+    /**
+     * Handle a job request.
+     *
+     * ONE generic RPC method - NOT one per job operation.
+     * The DO doesn't know about job types.
+     *
+     * @param request - The typed request from the client
+     * @returns The typed response
+     */
+    async call(request) {
+        // Delegate to runtime
+        const result = await this.#runtime.handle(request);
+        // Fire-and-forget event flushing - don't block response
+        this.ctx.waitUntil(this.#runtime.flush());
+        return result;
+    }
+    /**
+     * Handle an alarm.
+     *
+     * The runtime reads metadata to determine job type,
+     * then delegates to the appropriate handler.
+     */
+    async alarm() {
+        // Delegate to runtime
+        await this.#runtime.handleAlarm();
+        // Fire-and-forget event flushing
+        this.ctx.waitUntil(this.#runtime.flush());
+    }
+}
+//# sourceMappingURL=engine.js.map

package/dist/engine/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../src/engine/engine.ts"],"names":[],"mappings":"AAAA,qCAAqC;AAErC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAoB,MAAM,oBAAoB,CAAC;AAIzE,gFAAgF;AAChF,sBAAsB;AACtB,gFAAgF;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO,iBACX,SAAQ,aAAa;IAGrB;;OAEG;IACM,QAAQ,CAAc;IAE/B;;;;;OAKG;IACH,YAAY,KAAyB,EAAE,GAAqB;QAC1D,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAClB,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC;QACxB,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QAED,gDAAgD;QAChD,4CAA4C;QAC5C,IAAI,CAAC,QAAQ,GAAG,iBAAiB,CAAC;YAChC,OAAO,EAAE,KAAK;YACd,QAAQ,EAAE,GAAG,CAAC,gBAAgB;SAC/B,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,IAAI,CAAC,OAAmB;QAC5B,sBAAsB;QACtB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAEnD,wDAAwD;QACxD,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;QAE1C,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK;QACT,sBAAsB;QACtB,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAElC,iCAAiC;QACjC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5C,CAAC;CACF"}

package/dist/engine/index.d.ts

@@ -0,0 +1,3 @@
+export { DurableJobsEngine } from "./engine";
+export type { DurableJobsEngineInterface, JobsEngineConfig, JobsEnv, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/engine/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,YAAY,EACV,0BAA0B,EAC1B,gBAAgB,EAChB,OAAO,GACR,MAAM,SAAS,CAAC"}

package/dist/engine/index.js

@@ -0,0 +1,3 @@
+// packages/jobs/src/engine/index.ts
+export { DurableJobsEngine } from "./engine";
+//# sourceMappingURL=index.js.map

package/dist/engine/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/engine/index.ts"],"names":[],"mappings":"AAAA,oCAAoC;AAEpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC"}

package/dist/engine/types.d.ts

@@ -0,0 +1,53 @@
+import type { JobRequest, JobResponse } from "../runtime/types";
+import type { RuntimeJobRegistry } from "../registry/typed";
+/**
+ * Configuration for the jobs engine.
+ *
+ * This is passed to the engine via the Cloudflare environment binding.
+ */
+export interface JobsEngineConfig {
+    /**
+     * The job registry containing all registered jobs.
+     */
+    readonly __JOB_REGISTRY__: RuntimeJobRegistry;
+}
+/**
+ * The Durable Object interface for the jobs engine.
+ *
+ * This is a thin shell that delegates all operations to the runtime.
+ * It has ONE generic RPC method `call()` and `alarm()` - nothing else.
+ */
+export interface DurableJobsEngineInterface {
+    /**
+     * Handle a job request.
+     *
+     * This is the ONLY RPC method for jobs. The client sends typed
+     * requests and receives typed responses. The engine doesn't know
+     * about specific job operations - it just delegates to the runtime.
+     *
+     * @param request - The job request to handle
+     * @returns The response from the job handler
+     */
+    call(request: JobRequest): Promise<JobResponse>;
+    /**
+     * Handle an alarm.
+     *
+     * The alarm handler reads metadata to determine which job type
+     * owns this instance, then delegates to the appropriate handler.
+     */
+    alarm(): Promise<void>;
+}
+/**
+ * Type helper for Cloudflare worker environment with jobs binding.
+ *
+ * @example
+ * ```ts
+ * interface Env extends JobsEnv<"JOBS"> {
+ *   // Other bindings...
+ * }
+ * ```
+ */
+export type JobsEnv<BindingName extends string = "JOBS"> = {
+    [K in BindingName]: DurableObjectNamespace;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/engine/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/engine/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAM5D;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,kBAAkB,CAAC;CAC/C;AAMD;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;;OASG;IACH,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAEhD;;;;;OAKG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAMD;;;;;;;;;GASG;AACH,MAAM,MAAM,OAAO,CAAC,WAAW,SAAS,MAAM,GAAG,MAAM,IAAI;KACxD,CAAC,IAAI,WAAW,GAAG,sBAAsB;CAC3C,CAAC"}

package/dist/engine/types.js

@@ -0,0 +1,3 @@
+// packages/jobs/src/engine/types.ts
+export {};
+//# sourceMappingURL=types.js.map

package/dist/engine/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/engine/types.ts"],"names":[],"mappings":"AAAA,oCAAoC"}