alepha 0.21.2 → 0.23.0

package/dist/background/index.d.ts

@@ -0,0 +1,95 @@
+import { Alepha } from "alepha";
+
+//#region ../../src/background/providers/BackgroundTaskProvider.d.ts
+/**
+ * Runs fire-and-forget work that should outlive the request that scheduled it
+ * (sending a welcome email, an audit write, a webhook) without blocking the
+ * response.
+ *
+ * On a long-lived runtime (Node, Vercel) the event loop keeps the promise
+ * alive, so the only job here is to detach the task from the caller and never
+ * leak an unhandled rejection. On serverless/edge runtimes that freeze the
+ * isolate once the response is returned (Cloudflare Workers) the
+ * {@link WorkerdBackgroundTaskProvider} variant additionally wraps the task in
+ * `executionCtx.waitUntil` — call sites stay platform-agnostic and only ever
+ * call {@link defer}.
+ *
+ * In-flight tasks are tracked and awaited on shutdown (`flush`), so graceful
+ * stop, `run({ once })`, and unit tests don't silently drop work.
+ */
+declare class BackgroundTaskProvider {
+  protected readonly alepha: Alepha;
+  protected readonly log: import("alepha/logger").Logger;
+  /** In-flight deferred tasks, awaited on stop. */
+  protected readonly pending: Set<Promise<void>>;
+  /**
+   * Schedule `task` to run in the background. Returns immediately — the task is
+   * detached onto a microtask, so the caller (e.g. an HTTP handler) is never
+   * blocked and a synchronous throw inside `task` can't escape into it. Errors
+   * are caught and logged.
+   */
+  defer(task: () => unknown | Promise<unknown>): void;
+  /**
+   * Hook for platform variants to keep the runtime alive until `promise`
+   * settles. No-op on long-lived runtimes (the event loop already does). The
+   * Cloudflare variant overrides this with `executionCtx.waitUntil`.
+   */
+  protected keepAlive(_promise: Promise<void>): void;
+  /**
+   * Await all in-flight tasks (best-effort). Called on `stop` so shutdown and
+   * tests don't drop deferred work.
+   */
+  flush(): Promise<void>;
+  protected readonly onStop: import("alepha").HookPrimitive<"stop">;
+}
+//#endregion
+//#region ../../src/background/providers/WorkerdBackgroundTaskProvider.d.ts
+/**
+ * Cloudflare Workers variant of {@link BackgroundTaskProvider}.
+ *
+ * Cloudflare freezes the isolate once the response is returned, so a plain
+ * fire-and-forget promise would be killed mid-flight. The platform exposes a
+ * per-request `executionCtx.waitUntil(promise)` that keeps the isolate alive
+ * until `promise` settles; the request entry point (generated by the Cloudflare
+ * build) stashes it in the Alepha store under `cloudflare.waitUntil`.
+ *
+ * This is the ONE place that reads that key — call sites use
+ * {@link BackgroundTaskProvider.defer} and stay platform-agnostic.
+ *
+ * `waitUntil` is request-scoped, so `defer()` must be called within the
+ * request's async context (which is where background work is scheduled). Outside
+ * a request (e.g. a cron tick) the key is absent and we fall back to the base
+ * fire-and-track behaviour.
+ */
+declare class WorkerdBackgroundTaskProvider extends BackgroundTaskProvider {
+  protected keepAlive(promise: Promise<void>): void;
+}
+//#endregion
+//#region ../../src/background/index.d.ts
+/**
+ * Fire-and-forget background work that should outlive the request that
+ * scheduled it, without blocking the response.
+ *
+ * Inject {@link BackgroundTaskProvider} and call `defer(() => …)`:
+ *
+ * ```ts
+ * protected readonly background = $inject(BackgroundTaskProvider);
+ *
+ * createUser = $action({ handler: async ({ body }) => {
+ *   const user = await this.users.create(body);
+ *   this.background.defer(() => this.email.send(welcome(user))); // don't block
+ *   return user;
+ * }});
+ * ```
+ *
+ * On Node/Vercel the event loop keeps the task alive. On Cloudflare Workers the
+ * `workerd` build swaps in {@link WorkerdBackgroundTaskProvider}, which wraps
+ * the task in `executionCtx.waitUntil` so the isolate isn't frozen at response
+ * time — the call site is identical either way.
+ *
+ * @module alepha.background
+ */
+declare const AlephaBackground: import("alepha").Service<import("alepha").Module>;
+//#endregion
+export { AlephaBackground, BackgroundTaskProvider, WorkerdBackgroundTaskProvider };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/background/providers/BackgroundTaskProvider.ts","../../src/background/providers/WorkerdBackgroundTaskProvider.ts","../../src/background/index.ts"],"mappings":";;;;;AAmBA;;;;;;;;;;;;;;cAAa,sBAAA;EAAA,mBACQ,MAAA,EAAM,MAAA;EAAA,mBACN,GAAA,0BAAG,MAAA;EAGI;EAAA,mBAAP,OAAA,EAAO,GAAA,CAAA,OAAA;EAQS;;;;;;EAA5B,KAAA,CAAM,IAAA,kBAAsB,OAAA;EAiChB;;;AAAM;;EAAN,UAVT,SAAA,CAAU,QAAA,EAAU,OAAA;;ACpChC;;;ED0Ce,KAAA,IAAS,OAAA;EAAA,mBAIH,MAAA,mBAAM,aAAA;AAAA;;;;;AA9C3B;;;;;;;;;;;;;;;cCAa,6BAAA,SAAsC,sBAAsB;EAAA,UACpD,SAAA,CAAU,OAAA,EAAS,OAAA;AAAA;;;;ADDxC;;;;;;;;;;;;;;;;;;;;;;cEca,gBAAA,mBAAgB,OAAA,kBAAA,MAAA"}

package/dist/background/index.js

@@ -0,0 +1,121 @@
+import { $hook, $inject, $module, Alepha } from "alepha";
+import { $logger } from "alepha/logger";
+//#region ../../src/background/providers/BackgroundTaskProvider.ts
+/**
+* Runs fire-and-forget work that should outlive the request that scheduled it
+* (sending a welcome email, an audit write, a webhook) without blocking the
+* response.
+*
+* On a long-lived runtime (Node, Vercel) the event loop keeps the promise
+* alive, so the only job here is to detach the task from the caller and never
+* leak an unhandled rejection. On serverless/edge runtimes that freeze the
+* isolate once the response is returned (Cloudflare Workers) the
+* {@link WorkerdBackgroundTaskProvider} variant additionally wraps the task in
+* `executionCtx.waitUntil` — call sites stay platform-agnostic and only ever
+* call {@link defer}.
+*
+* In-flight tasks are tracked and awaited on shutdown (`flush`), so graceful
+* stop, `run({ once })`, and unit tests don't silently drop work.
+*/
+var BackgroundTaskProvider = class {
+	alepha = $inject(Alepha);
+	log = $logger();
+	/** In-flight deferred tasks, awaited on stop. */
+	pending = /* @__PURE__ */ new Set();
+	/**
+	* Schedule `task` to run in the background. Returns immediately — the task is
+	* detached onto a microtask, so the caller (e.g. an HTTP handler) is never
+	* blocked and a synchronous throw inside `task` can't escape into it. Errors
+	* are caught and logged.
+	*/
+	defer(task) {
+		const promise = Promise.resolve().then(task).then(() => void 0, (error) => {
+			this.log.warn("Background task failed", error);
+		});
+		this.pending.add(promise);
+		promise.finally(() => {
+			this.pending.delete(promise);
+		});
+		this.keepAlive(promise);
+	}
+	/**
+	* Hook for platform variants to keep the runtime alive until `promise`
+	* settles. No-op on long-lived runtimes (the event loop already does). The
+	* Cloudflare variant overrides this with `executionCtx.waitUntil`.
+	*/
+	keepAlive(_promise) {}
+	/**
+	* Await all in-flight tasks (best-effort). Called on `stop` so shutdown and
+	* tests don't drop deferred work.
+	*/
+	async flush() {
+		await Promise.allSettled([...this.pending]);
+	}
+	onStop = $hook({
+		on: "stop",
+		handler: () => this.flush()
+	});
+};
+//#endregion
+//#region ../../src/background/providers/WorkerdBackgroundTaskProvider.ts
+/**
+* Cloudflare Workers variant of {@link BackgroundTaskProvider}.
+*
+* Cloudflare freezes the isolate once the response is returned, so a plain
+* fire-and-forget promise would be killed mid-flight. The platform exposes a
+* per-request `executionCtx.waitUntil(promise)` that keeps the isolate alive
+* until `promise` settles; the request entry point (generated by the Cloudflare
+* build) stashes it in the Alepha store under `cloudflare.waitUntil`.
+*
+* This is the ONE place that reads that key — call sites use
+* {@link BackgroundTaskProvider.defer} and stay platform-agnostic.
+*
+* `waitUntil` is request-scoped, so `defer()` must be called within the
+* request's async context (which is where background work is scheduled). Outside
+* a request (e.g. a cron tick) the key is absent and we fall back to the base
+* fire-and-track behaviour.
+*/
+var WorkerdBackgroundTaskProvider = class extends BackgroundTaskProvider {
+	keepAlive(promise) {
+		const waitUntil = this.alepha.store.get("cloudflare.waitUntil");
+		if (typeof waitUntil !== "function") return;
+		try {
+			waitUntil(promise);
+		} catch (error) {
+			this.log.debug("waitUntil rejected — falling back to fire-and-track", error);
+		}
+	}
+};
+//#endregion
+//#region ../../src/background/index.ts
+/**
+* Fire-and-forget background work that should outlive the request that
+* scheduled it, without blocking the response.
+*
+* Inject {@link BackgroundTaskProvider} and call `defer(() => …)`:
+*
+* ```ts
+* protected readonly background = $inject(BackgroundTaskProvider);
+*
+* createUser = $action({ handler: async ({ body }) => {
+*   const user = await this.users.create(body);
+*   this.background.defer(() => this.email.send(welcome(user))); // don't block
+*   return user;
+* }});
+* ```
+*
+* On Node/Vercel the event loop keeps the task alive. On Cloudflare Workers the
+* `workerd` build swaps in {@link WorkerdBackgroundTaskProvider}, which wraps
+* the task in `executionCtx.waitUntil` so the isolate isn't frozen at response
+* time — the call site is identical either way.
+*
+* @module alepha.background
+*/
+const AlephaBackground = $module({
+	name: "alepha.background",
+	services: [BackgroundTaskProvider]
+});
+//#endregion
+export { AlephaBackground, BackgroundTaskProvider, WorkerdBackgroundTaskProvider };
+
+//# sourceMappingURL=index.js.map

package/dist/background/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/background/providers/BackgroundTaskProvider.ts","../../src/background/providers/WorkerdBackgroundTaskProvider.ts","../../src/background/index.ts"],"sourcesContent":["import { $hook, $inject, Alepha } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\n\n/**\n * Runs fire-and-forget work that should outlive the request that scheduled it\n * (sending a welcome email, an audit write, a webhook) without blocking the\n * response.\n *\n * On a long-lived runtime (Node, Vercel) the event loop keeps the promise\n * alive, so the only job here is to detach the task from the caller and never\n * leak an unhandled rejection. On serverless/edge runtimes that freeze the\n * isolate once the response is returned (Cloudflare Workers) the\n * {@link WorkerdBackgroundTaskProvider} variant additionally wraps the task in\n * `executionCtx.waitUntil` — call sites stay platform-agnostic and only ever\n * call {@link defer}.\n *\n * In-flight tasks are tracked and awaited on shutdown (`flush`), so graceful\n * stop, `run({ once })`, and unit tests don't silently drop work.\n */\nexport class BackgroundTaskProvider {\n  protected readonly alepha = $inject(Alepha);\n  protected readonly log = $logger();\n\n  /** In-flight deferred tasks, awaited on stop. */\n  protected readonly pending = new Set<Promise<void>>();\n\n  /**\n   * Schedule `task` to run in the background. Returns immediately — the task is\n   * detached onto a microtask, so the caller (e.g. an HTTP handler) is never\n   * blocked and a synchronous throw inside `task` can't escape into it. Errors\n   * are caught and logged.\n   */\n  public defer(task: () => unknown | Promise<unknown>): void {\n    const promise = Promise.resolve()\n      .then(task)\n      .then(\n        () => undefined,\n        (error: unknown) => {\n          this.log.warn(\"Background task failed\", error as Error);\n        },\n      );\n\n    this.pending.add(promise);\n    void promise.finally(() => {\n      this.pending.delete(promise);\n    });\n\n    this.keepAlive(promise);\n  }\n\n  /**\n   * Hook for platform variants to keep the runtime alive until `promise`\n   * settles. No-op on long-lived runtimes (the event loop already does). The\n   * Cloudflare variant overrides this with `executionCtx.waitUntil`.\n   */\n  protected keepAlive(_promise: Promise<void>): void {}\n\n  /**\n   * Await all in-flight tasks (best-effort). Called on `stop` so shutdown and\n   * tests don't drop deferred work.\n   */\n  public async flush(): Promise<void> {\n    await Promise.allSettled([...this.pending]);\n  }\n\n  protected readonly onStop = $hook({\n    on: \"stop\",\n    handler: () => this.flush(),\n  });\n}\n","import { BackgroundTaskProvider } from \"./BackgroundTaskProvider.ts\";\n\n/**\n * Cloudflare Workers variant of {@link BackgroundTaskProvider}.\n *\n * Cloudflare freezes the isolate once the response is returned, so a plain\n * fire-and-forget promise would be killed mid-flight. The platform exposes a\n * per-request `executionCtx.waitUntil(promise)` that keeps the isolate alive\n * until `promise` settles; the request entry point (generated by the Cloudflare\n * build) stashes it in the Alepha store under `cloudflare.waitUntil`.\n *\n * This is the ONE place that reads that key — call sites use\n * {@link BackgroundTaskProvider.defer} and stay platform-agnostic.\n *\n * `waitUntil` is request-scoped, so `defer()` must be called within the\n * request's async context (which is where background work is scheduled). Outside\n * a request (e.g. a cron tick) the key is absent and we fall back to the base\n * fire-and-track behaviour.\n */\nexport class WorkerdBackgroundTaskProvider extends BackgroundTaskProvider {\n  protected override keepAlive(promise: Promise<void>): void {\n    const waitUntil = this.alepha.store.get(\"cloudflare.waitUntil\") as\n      | ((p: Promise<unknown>) => void)\n      | undefined;\n\n    if (typeof waitUntil !== \"function\") {\n      // No request-scoped execution context (cron / outside a request). The\n      // base tracking + a long-lived isolate keep the promise alive.\n      return;\n    }\n\n    try {\n      waitUntil(promise);\n    } catch (error) {\n      // The runtime rejects waitUntil if called outside a request scope; the\n      // promise still runs, just without the isolate-alive guarantee.\n      this.log.debug(\n        \"waitUntil rejected — falling back to fire-and-track\",\n        error as Error,\n      );\n    }\n  }\n}\n","import { $module } from \"alepha\";\nimport { BackgroundTaskProvider } from \"./providers/BackgroundTaskProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/BackgroundTaskProvider.ts\";\nexport * from \"./providers/WorkerdBackgroundTaskProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Fire-and-forget background work that should outlive the request that\n * scheduled it, without blocking the response.\n *\n * Inject {@link BackgroundTaskProvider} and call `defer(() => …)`:\n *\n * ```ts\n * protected readonly background = $inject(BackgroundTaskProvider);\n *\n * createUser = $action({ handler: async ({ body }) => {\n *   const user = await this.users.create(body);\n *   this.background.defer(() => this.email.send(welcome(user))); // don't block\n *   return user;\n * }});\n * ```\n *\n * On Node/Vercel the event loop keeps the task alive. On Cloudflare Workers the\n * `workerd` build swaps in {@link WorkerdBackgroundTaskProvider}, which wraps\n * the task in `executionCtx.waitUntil` so the isolate isn't frozen at response\n * time — the call site is identical either way.\n *\n * @module alepha.background\n */\nexport const AlephaBackground = $module({\n  name: \"alepha.background\",\n  services: [BackgroundTaskProvider],\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,IAAa,yBAAb,MAAoC;CAClC,SAA4B,QAAQ,MAAM;CAC1C,MAAyB,QAAQ;;CAGjC,0BAA6B,IAAI,IAAmB;;;;;;;CAQpD,MAAa,MAA8C;EACzD,MAAM,UAAU,QAAQ,QAAQ,EAC7B,KAAK,IAAI,EACT,WACO,KAAA,IACL,UAAmB;GAClB,KAAK,IAAI,KAAK,0BAA0B,KAAc;EACxD,CACF;EAEF,KAAK,QAAQ,IAAI,OAAO;EACxB,QAAa,cAAc;GACzB,KAAK,QAAQ,OAAO,OAAO;EAC7B,CAAC;EAED,KAAK,UAAU,OAAO;CACxB;;;;;;CAOA,UAAoB,UAA+B,CAAC;;;;;CAMpD,MAAa,QAAuB;EAClC,MAAM,QAAQ,WAAW,CAAC,GAAG,KAAK,OAAO,CAAC;CAC5C;CAEA,SAA4B,MAAM;EAChC,IAAI;EACJ,eAAe,KAAK,MAAM;CAC5B,CAAC;AACH;;;;;;;;;;;;;;;;;;;;AClDA,IAAa,gCAAb,cAAmD,uBAAuB;CACxE,UAA6B,SAA8B;EACzD,MAAM,YAAY,KAAK,OAAO,MAAM,IAAI,sBAAsB;EAI9D,IAAI,OAAO,cAAc,YAGvB;EAGF,IAAI;GACF,UAAU,OAAO;EACnB,SAAS,OAAO;GAGd,KAAK,IAAI,MACP,uDACA,KACF;EACF;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;ACTA,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,UAAU,CAAC,sBAAsB;AACnC,CAAC"}

package/dist/background/index.workerd.js

@@ -0,0 +1,110 @@
+import { $hook, $inject, $module, Alepha } from "alepha";
+import { $logger } from "alepha/logger";
+//#region ../../src/background/providers/BackgroundTaskProvider.ts
+/**
+* Runs fire-and-forget work that should outlive the request that scheduled it
+* (sending a welcome email, an audit write, a webhook) without blocking the
+* response.
+*
+* On a long-lived runtime (Node, Vercel) the event loop keeps the promise
+* alive, so the only job here is to detach the task from the caller and never
+* leak an unhandled rejection. On serverless/edge runtimes that freeze the
+* isolate once the response is returned (Cloudflare Workers) the
+* {@link WorkerdBackgroundTaskProvider} variant additionally wraps the task in
+* `executionCtx.waitUntil` — call sites stay platform-agnostic and only ever
+* call {@link defer}.
+*
+* In-flight tasks are tracked and awaited on shutdown (`flush`), so graceful
+* stop, `run({ once })`, and unit tests don't silently drop work.
+*/
+var BackgroundTaskProvider = class {
+	alepha = $inject(Alepha);
+	log = $logger();
+	/** In-flight deferred tasks, awaited on stop. */
+	pending = /* @__PURE__ */ new Set();
+	/**
+	* Schedule `task` to run in the background. Returns immediately — the task is
+	* detached onto a microtask, so the caller (e.g. an HTTP handler) is never
+	* blocked and a synchronous throw inside `task` can't escape into it. Errors
+	* are caught and logged.
+	*/
+	defer(task) {
+		const promise = Promise.resolve().then(task).then(() => void 0, (error) => {
+			this.log.warn("Background task failed", error);
+		});
+		this.pending.add(promise);
+		promise.finally(() => {
+			this.pending.delete(promise);
+		});
+		this.keepAlive(promise);
+	}
+	/**
+	* Hook for platform variants to keep the runtime alive until `promise`
+	* settles. No-op on long-lived runtimes (the event loop already does). The
+	* Cloudflare variant overrides this with `executionCtx.waitUntil`.
+	*/
+	keepAlive(_promise) {}
+	/**
+	* Await all in-flight tasks (best-effort). Called on `stop` so shutdown and
+	* tests don't drop deferred work.
+	*/
+	async flush() {
+		await Promise.allSettled([...this.pending]);
+	}
+	onStop = $hook({
+		on: "stop",
+		handler: () => this.flush()
+	});
+};
+//#endregion
+//#region ../../src/background/providers/WorkerdBackgroundTaskProvider.ts
+/**
+* Cloudflare Workers variant of {@link BackgroundTaskProvider}.
+*
+* Cloudflare freezes the isolate once the response is returned, so a plain
+* fire-and-forget promise would be killed mid-flight. The platform exposes a
+* per-request `executionCtx.waitUntil(promise)` that keeps the isolate alive
+* until `promise` settles; the request entry point (generated by the Cloudflare
+* build) stashes it in the Alepha store under `cloudflare.waitUntil`.
+*
+* This is the ONE place that reads that key — call sites use
+* {@link BackgroundTaskProvider.defer} and stay platform-agnostic.
+*
+* `waitUntil` is request-scoped, so `defer()` must be called within the
+* request's async context (which is where background work is scheduled). Outside
+* a request (e.g. a cron tick) the key is absent and we fall back to the base
+* fire-and-track behaviour.
+*/
+var WorkerdBackgroundTaskProvider = class extends BackgroundTaskProvider {
+	keepAlive(promise) {
+		const waitUntil = this.alepha.store.get("cloudflare.waitUntil");
+		if (typeof waitUntil !== "function") return;
+		try {
+			waitUntil(promise);
+		} catch (error) {
+			this.log.debug("waitUntil rejected — falling back to fire-and-track", error);
+		}
+	}
+};
+//#endregion
+//#region ../../src/background/index.workerd.ts
+/**
+* Cloudflare Workers build of {@link AlephaBackground}: swaps
+* {@link BackgroundTaskProvider} for {@link WorkerdBackgroundTaskProvider},
+* which keeps the isolate alive past the response via `executionCtx.waitUntil`.
+*
+* @module alepha.background
+*/
+const AlephaBackground = $module({
+	name: "alepha.background",
+	services: [BackgroundTaskProvider],
+	variants: [WorkerdBackgroundTaskProvider],
+	register: (alepha) => alepha.with({
+		provide: BackgroundTaskProvider,
+		use: WorkerdBackgroundTaskProvider
+	})
+});
+//#endregion
+export { AlephaBackground, BackgroundTaskProvider, WorkerdBackgroundTaskProvider };
+
+//# sourceMappingURL=index.workerd.js.map

package/dist/background/index.workerd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.workerd.js","names":[],"sources":["../../src/background/providers/BackgroundTaskProvider.ts","../../src/background/providers/WorkerdBackgroundTaskProvider.ts","../../src/background/index.workerd.ts"],"sourcesContent":["import { $hook, $inject, Alepha } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\n\n/**\n * Runs fire-and-forget work that should outlive the request that scheduled it\n * (sending a welcome email, an audit write, a webhook) without blocking the\n * response.\n *\n * On a long-lived runtime (Node, Vercel) the event loop keeps the promise\n * alive, so the only job here is to detach the task from the caller and never\n * leak an unhandled rejection. On serverless/edge runtimes that freeze the\n * isolate once the response is returned (Cloudflare Workers) the\n * {@link WorkerdBackgroundTaskProvider} variant additionally wraps the task in\n * `executionCtx.waitUntil` — call sites stay platform-agnostic and only ever\n * call {@link defer}.\n *\n * In-flight tasks are tracked and awaited on shutdown (`flush`), so graceful\n * stop, `run({ once })`, and unit tests don't silently drop work.\n */\nexport class BackgroundTaskProvider {\n  protected readonly alepha = $inject(Alepha);\n  protected readonly log = $logger();\n\n  /** In-flight deferred tasks, awaited on stop. */\n  protected readonly pending = new Set<Promise<void>>();\n\n  /**\n   * Schedule `task` to run in the background. Returns immediately — the task is\n   * detached onto a microtask, so the caller (e.g. an HTTP handler) is never\n   * blocked and a synchronous throw inside `task` can't escape into it. Errors\n   * are caught and logged.\n   */\n  public defer(task: () => unknown | Promise<unknown>): void {\n    const promise = Promise.resolve()\n      .then(task)\n      .then(\n        () => undefined,\n        (error: unknown) => {\n          this.log.warn(\"Background task failed\", error as Error);\n        },\n      );\n\n    this.pending.add(promise);\n    void promise.finally(() => {\n      this.pending.delete(promise);\n    });\n\n    this.keepAlive(promise);\n  }\n\n  /**\n   * Hook for platform variants to keep the runtime alive until `promise`\n   * settles. No-op on long-lived runtimes (the event loop already does). The\n   * Cloudflare variant overrides this with `executionCtx.waitUntil`.\n   */\n  protected keepAlive(_promise: Promise<void>): void {}\n\n  /**\n   * Await all in-flight tasks (best-effort). Called on `stop` so shutdown and\n   * tests don't drop deferred work.\n   */\n  public async flush(): Promise<void> {\n    await Promise.allSettled([...this.pending]);\n  }\n\n  protected readonly onStop = $hook({\n    on: \"stop\",\n    handler: () => this.flush(),\n  });\n}\n","import { BackgroundTaskProvider } from \"./BackgroundTaskProvider.ts\";\n\n/**\n * Cloudflare Workers variant of {@link BackgroundTaskProvider}.\n *\n * Cloudflare freezes the isolate once the response is returned, so a plain\n * fire-and-forget promise would be killed mid-flight. The platform exposes a\n * per-request `executionCtx.waitUntil(promise)` that keeps the isolate alive\n * until `promise` settles; the request entry point (generated by the Cloudflare\n * build) stashes it in the Alepha store under `cloudflare.waitUntil`.\n *\n * This is the ONE place that reads that key — call sites use\n * {@link BackgroundTaskProvider.defer} and stay platform-agnostic.\n *\n * `waitUntil` is request-scoped, so `defer()` must be called within the\n * request's async context (which is where background work is scheduled). Outside\n * a request (e.g. a cron tick) the key is absent and we fall back to the base\n * fire-and-track behaviour.\n */\nexport class WorkerdBackgroundTaskProvider extends BackgroundTaskProvider {\n  protected override keepAlive(promise: Promise<void>): void {\n    const waitUntil = this.alepha.store.get(\"cloudflare.waitUntil\") as\n      | ((p: Promise<unknown>) => void)\n      | undefined;\n\n    if (typeof waitUntil !== \"function\") {\n      // No request-scoped execution context (cron / outside a request). The\n      // base tracking + a long-lived isolate keep the promise alive.\n      return;\n    }\n\n    try {\n      waitUntil(promise);\n    } catch (error) {\n      // The runtime rejects waitUntil if called outside a request scope; the\n      // promise still runs, just without the isolate-alive guarantee.\n      this.log.debug(\n        \"waitUntil rejected — falling back to fire-and-track\",\n        error as Error,\n      );\n    }\n  }\n}\n","import { $module } from \"alepha\";\nimport { BackgroundTaskProvider } from \"./providers/BackgroundTaskProvider.ts\";\nimport { WorkerdBackgroundTaskProvider } from \"./providers/WorkerdBackgroundTaskProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/BackgroundTaskProvider.ts\";\nexport * from \"./providers/WorkerdBackgroundTaskProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Cloudflare Workers build of {@link AlephaBackground}: swaps\n * {@link BackgroundTaskProvider} for {@link WorkerdBackgroundTaskProvider},\n * which keeps the isolate alive past the response via `executionCtx.waitUntil`.\n *\n * @module alepha.background\n */\nexport const AlephaBackground = $module({\n  name: \"alepha.background\",\n  services: [BackgroundTaskProvider],\n  variants: [WorkerdBackgroundTaskProvider],\n  register: (alepha) =>\n    alepha.with({\n      provide: BackgroundTaskProvider,\n      use: WorkerdBackgroundTaskProvider,\n    }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,IAAa,yBAAb,MAAoC;CAClC,SAA4B,QAAQ,MAAM;CAC1C,MAAyB,QAAQ;;CAGjC,0BAA6B,IAAI,IAAmB;;;;;;;CAQpD,MAAa,MAA8C;EACzD,MAAM,UAAU,QAAQ,QAAQ,EAC7B,KAAK,IAAI,EACT,WACO,KAAA,IACL,UAAmB;GAClB,KAAK,IAAI,KAAK,0BAA0B,KAAc;EACxD,CACF;EAEF,KAAK,QAAQ,IAAI,OAAO;EACxB,QAAa,cAAc;GACzB,KAAK,QAAQ,OAAO,OAAO;EAC7B,CAAC;EAED,KAAK,UAAU,OAAO;CACxB;;;;;;CAOA,UAAoB,UAA+B,CAAC;;;;;CAMpD,MAAa,QAAuB;EAClC,MAAM,QAAQ,WAAW,CAAC,GAAG,KAAK,OAAO,CAAC;CAC5C;CAEA,SAA4B,MAAM;EAChC,IAAI;EACJ,eAAe,KAAK,MAAM;CAC5B,CAAC;AACH;;;;;;;;;;;;;;;;;;;;AClDA,IAAa,gCAAb,cAAmD,uBAAuB;CACxE,UAA6B,SAA8B;EACzD,MAAM,YAAY,KAAK,OAAO,MAAM,IAAI,sBAAsB;EAI9D,IAAI,OAAO,cAAc,YAGvB;EAGF,IAAI;GACF,UAAU,OAAO;EACnB,SAAS,OAAO;GAGd,KAAK,IAAI,MACP,uDACA,KACF;EACF;CACF;AACF;;;;;;;;;;ACxBA,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,UAAU,CAAC,sBAAsB;CACjC,UAAU,CAAC,6BAA6B;CACxC,WAAW,WACT,OAAO,KAAK;EACV,SAAS;EACT,KAAK;CACP,CAAC;AACL,CAAC"}

package/dist/batch/index.d.ts

@@ -1,8 +1,6 @@
-import * as _$alepha from "alepha";
 import { Alepha, KIND, Primitive, Static, TSchema } from "alepha";
 import { CryptoProvider } from "alepha/crypto";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
-import * as _$alepha_logger0 from "alepha/logger";
 import { RetryBackoffOptions, RetryPrimitiveOptions, RetryProvider } from "alepha/retry";
 
 //#region ../../src/batch/providers/BatchProvider.d.ts
@@ -110,7 +108,7 @@ interface BatchContext<TItem, TResponse> {
  * Provides methods to manage batches of items with automatic flushing based on size or time.
  */
 declare class BatchProvider {
-  protected readonly log: _$alepha_logger0.Logger;
+  protected readonly log: import("alepha/logger").Logger;
   protected readonly dateTime: DateTimeProvider;
   protected readonly retryProvider: RetryProvider;
   protected readonly crypto: CryptoProvider;
@@ -125,7 +123,7 @@ declare class BatchProvider {
   /**
    * Shutdown hook - flushes all batch contexts on application stop.
    */
-  protected readonly onStop: _$alepha.HookPrimitive<"stop">;
+  protected readonly onStop: import("alepha").HookPrimitive<"stop">;
   /**
    * Get the effective maxSize for a context.
    */
@@ -287,7 +285,7 @@ declare class BatchPrimitive<TItem extends TSchema, TResponse = any> extends Pri
    * @returns The number of items cleared
    */
   clearCompleted(status?: "completed" | "failed"): number;
-  protected readonly onReady: _$alepha.HookPrimitive<"ready">;
+  protected readonly onReady: import("alepha").HookPrimitive<"ready">;
 }
 //#endregion
 //#region ../../src/batch/index.d.ts
@@ -302,7 +300,7 @@ declare class BatchPrimitive<TItem extends TSchema, TResponse = any> extends Pri
  *
  * @module alepha.batch
  */
-declare const AlephaBatch: _$alepha.Service<_$alepha.Module>;
+declare const AlephaBatch: import("alepha").Service<import("alepha").Module>;
 //#endregion
-export { $batch, AlephaBatch, BatchContext, type BatchItemState, type BatchItemStatus, BatchOptions, BatchPrimitive, BatchPrimitiveOptions, BatchProvider, PartitionState };
+export { $batch, AlephaBatch, BatchContext, BatchItemState, BatchItemStatus, BatchOptions, BatchPrimitive, BatchPrimitiveOptions, BatchProvider, PartitionState };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/batch/providers/BatchProvider.ts","../../src/batch/primitives/$batch.ts","../../src/batch/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/batch/providers/BatchProvider.ts","../../src/batch/primitives/$batch.ts","../../src/batch/index.ts"],"mappings":"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"}

package/dist/batch/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/batch/providers/BatchProvider.ts","../../src/batch/primitives/$batch.ts","../../src/batch/index.ts"],"sourcesContent":["import { $hook, $inject, type Alepha, AlephaError } from \"alepha\";\nimport { CryptoProvider } from \"alepha/crypto\";\nimport { DateTimeProvider, type DurationLike } from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport { type RetryBackoffOptions, RetryProvider } from \"alepha/retry\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface BatchOptions<TItem, TResponse = any> {\n  /**\n   * The batch processing handler function that processes arrays of validated items.\n   */\n  handler: (items: TItem[]) => TResponse;\n\n  /**\n   * Maximum number of items to collect before automatically flushing the batch.\n   *\n   * @default 10\n   */\n  maxSize?: number;\n\n  /**\n   * Maximum number of items that can be queued in a single partition.\n   * If exceeded, push() will throw an error.\n   */\n  maxQueueSize?: number;\n\n  /**\n   * Maximum time to wait before flushing a batch, even if it hasn't reached maxSize.\n   *\n   * @default [1, \"second\"]\n   */\n  maxDuration?: DurationLike;\n\n  /**\n   * Function to determine partition keys for grouping items into separate batches.\n   */\n  partitionBy?: (item: TItem) => string;\n\n  /**\n   * Maximum number of batch handlers that can execute simultaneously.\n   *\n   * @default 1\n   */\n  concurrency?: number;\n\n  /**\n   * Retry configuration for failed batch processing operations.\n   */\n  retry?: {\n    /**\n     * The maximum number of attempts.\n     *\n     * @default 3\n     */\n    max?: number;\n\n    /**\n     * The backoff strategy for delays between retries.\n     * Can be a fixed number (in ms) or a configuration object for exponential backoff.\n     *\n     * @default { initial: 200, factor: 2, jitter: true }\n     */\n    backoff?: number | RetryBackoffOptions;\n\n    /**\n     * An overall time limit for all retry attempts combined.\n     *\n     * e.g., `[5, 'seconds']`\n     */\n    maxDuration?: DurationLike;\n\n    /**\n     * A function that determines if a retry should be attempted based on the error.\n     *\n     * @default (error) => true (retries on any error)\n     */\n    when?: (error: Error) => boolean;\n\n    /**\n     * A custom callback for when a retry attempt fails.\n     * This is called before the delay.\n     */\n    onError?: (error: Error, attempt: number) => void;\n  };\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport type BatchItemStatus = \"pending\" | \"processing\" | \"completed\" | \"failed\";\n\nexport interface BatchItemState<TItem, TResponse> {\n  id: string;\n  item: TItem;\n  partitionKey: string;\n  status: BatchItemStatus;\n  result?: TResponse;\n  error?: Error;\n  promise?: Promise<TResponse>;\n  resolve?: (value: TResponse) => void;\n  reject?: (error: Error) => void;\n}\n\nexport interface PartitionState {\n  itemIds: string[];\n  timeout?: { clear: () => void };\n  flushing: boolean;\n}\n\n/**\n * Context object that holds all state for a batch processor instance.\n */\nexport interface BatchContext<TItem, TResponse> {\n  options: BatchOptions<TItem, TResponse>;\n  itemStates: Map<string, BatchItemState<TItem, TResponse>>;\n  partitions: Map<string, PartitionState>;\n  activeHandlers: PromiseWithResolvers<void>[];\n  isShuttingDown: boolean;\n  isReady: boolean;\n  alepha: Alepha;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Service for batch processing operations.\n * Provides methods to manage batches of items with automatic flushing based on size or time.\n */\nexport class BatchProvider {\n  protected readonly log = $logger();\n  protected readonly dateTime = $inject(DateTimeProvider);\n  protected readonly retryProvider = $inject(RetryProvider);\n  protected readonly crypto = $inject(CryptoProvider);\n\n  /**\n   * All active batch contexts managed by this provider.\n   */\n  protected readonly contexts = new Set<BatchContext<any, any>>();\n\n  /**\n   * Creates a new batch context with the given options.\n   */\n  createContext<TItem, TResponse>(\n    alepha: Alepha,\n    options: BatchOptions<TItem, TResponse>,\n  ): BatchContext<TItem, TResponse> {\n    const context: BatchContext<TItem, TResponse> = {\n      options,\n      itemStates: new Map(),\n      partitions: new Map(),\n      activeHandlers: [],\n      isShuttingDown: false,\n      isReady: false,\n      alepha,\n    };\n    this.contexts.add(context);\n    return context;\n  }\n\n  /**\n   * Shutdown hook - flushes all batch contexts on application stop.\n   */\n  protected readonly onStop = $hook({\n    on: \"stop\",\n    priority: \"first\",\n    handler: async () => {\n      if (this.contexts.size === 0) {\n        return;\n      }\n      this.log.debug(`Shutting down ${this.contexts.size} batch context(s)...`);\n      const promises: Promise<void>[] = [];\n      for (const context of this.contexts) {\n        promises.push(this.shutdown(context));\n      }\n      await Promise.all(promises);\n      this.log.debug(\"All batch contexts shut down\");\n    },\n  });\n\n  /**\n   * Get the effective maxSize for a context.\n   */\n  protected getMaxSize<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): number {\n    return context.options.maxSize ?? 10;\n  }\n\n  /**\n   * Get the effective concurrency for a context.\n   */\n  protected getConcurrency<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): number {\n    return context.options.concurrency ?? 1;\n  }\n\n  /**\n   * Get the effective maxDuration for a context.\n   */\n  protected getMaxDuration<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): DurationLike {\n    return context.options.maxDuration ?? [1, \"second\"];\n  }\n\n  /**\n   * Pushes an item into the batch and returns immediately with a unique ID.\n   * The item will be processed asynchronously with other items when the batch is flushed.\n   * Use wait(id) to get the processing result.\n   *\n   * @throws Error if maxQueueSize is exceeded\n   */\n  push<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    item: TItem,\n  ): string {\n    // 1. Generate unique ID\n    const id = this.crypto.randomUUID();\n\n    // 2. Determine the partition key (with error handling)\n    let partitionKey: string;\n    try {\n      partitionKey = context.options.partitionBy\n        ? context.options.partitionBy(item)\n        : \"default\";\n    } catch (error) {\n      this.log.warn(\n        \"partitionBy function threw an error, using 'default' partition\",\n        { error },\n      );\n      partitionKey = \"default\";\n    }\n\n    // 3. Create item state\n    const itemState: BatchItemState<TItem, TResponse> = {\n      id,\n      item,\n      partitionKey,\n      status: \"pending\",\n    };\n\n    // CAUTION: Do not log.debug/info here as it may cause infinite loops if logging is batched\n\n    context.itemStates.set(id, itemState);\n\n    // 4. Get or create the partition state\n    if (!context.partitions.has(partitionKey)) {\n      context.partitions.set(partitionKey, {\n        itemIds: [],\n        flushing: false,\n      });\n    }\n    const partition = context.partitions.get(partitionKey)!;\n\n    // 5. Check maxQueueSize before adding\n    if (\n      context.options.maxQueueSize !== undefined &&\n      partition.itemIds.length >= context.options.maxQueueSize\n    ) {\n      throw new AlephaError(\n        `Batch queue size exceeded for partition '${partitionKey}' (max: ${context.options.maxQueueSize})`,\n      );\n    }\n\n    // 6. Add item ID to partition\n    partition.itemIds.push(id);\n\n    const maxSize = this.getMaxSize(context);\n    const maxDuration = this.getMaxDuration(context);\n\n    // 7. Only start processing if the app is ready (after \"ready\" hook)\n    // During startup, items are just buffered in memory\n    if (context.isReady) {\n      // Check if the batch is full\n      if (partition.itemIds.length >= maxSize) {\n        this.log.trace(\n          `Batch partition '${partitionKey}' is full, flushing...`,\n        );\n        this.flushPartition(context, partitionKey).catch((error) =>\n          this.log.error(\n            `Failed to flush batch partition '${partitionKey}' on max size`,\n            error,\n          ),\n        );\n      } else if (!partition.timeout && !partition.flushing) {\n        // 8. Start the timeout if it's not already running for this partition and not currently flushing\n        partition.timeout = this.dateTime.createTimeout(() => {\n          this.log.trace(\n            `Batch partition '${partitionKey}' timed out, flushing...`,\n          );\n          this.flushPartition(context, partitionKey).catch((error) =>\n            this.log.error(\n              `Failed to flush batch partition '${partitionKey}' on timeout`,\n              error,\n            ),\n          );\n        }, maxDuration);\n      }\n    } else {\n      // Not ready yet - just buffer items, no size checks or timeouts\n      this.log.trace(\n        `Buffering item in partition '${partitionKey}' (app not ready yet, ${partition.itemIds.length} items buffered)`,\n      );\n    }\n\n    // 9. Return ID immediately\n    return id;\n  }\n\n  /**\n   * Wait for a specific item to be processed and get its result.\n   * @param id The item ID returned from push()\n   * @returns The processing result\n   * @throws If the item doesn't exist or processing failed\n   */\n  async wait<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    id: string,\n  ): Promise<TResponse> {\n    const itemState = context.itemStates.get(id);\n    if (!itemState) {\n      throw new AlephaError(`Item with id '${id}' not found`);\n    }\n\n    // If already completed or failed, return immediately\n    if (itemState.status === \"completed\") {\n      return itemState.result!;\n    }\n    if (itemState.status === \"failed\") {\n      throw itemState.error!;\n    }\n\n    // Create promise on-demand if not already created\n    if (!itemState.promise) {\n      itemState.promise = new Promise<TResponse>((resolve, reject) => {\n        itemState.resolve = resolve;\n        itemState.reject = reject;\n      });\n    }\n\n    return itemState.promise;\n  }\n\n  /**\n   * Get the current status of an item.\n   * @param id The item ID returned from push()\n   * @returns Status information or undefined if item doesn't exist\n   */\n  status<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    id: string,\n  ):\n    | { status: \"pending\" | \"processing\" }\n    | { status: \"completed\"; result: TResponse }\n    | { status: \"failed\"; error: Error }\n    | undefined {\n    const itemState = context.itemStates.get(id);\n    if (!itemState) {\n      return undefined;\n    }\n\n    if (itemState.status === \"completed\") {\n      return { status: \"completed\", result: itemState.result! };\n    }\n    if (itemState.status === \"failed\") {\n      return { status: \"failed\", error: itemState.error! };\n    }\n    return { status: itemState.status };\n  }\n\n  /**\n   * Clears completed and failed items from the context to free memory.\n   * Returns the number of items cleared.\n   *\n   * @param context The batch context\n   * @param status Optional: only clear items with this specific status ('completed' or 'failed')\n   * @returns The number of items cleared\n   */\n  clearCompleted<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    status?: \"completed\" | \"failed\",\n  ): number {\n    let count = 0;\n    for (const [id, state] of context.itemStates) {\n      if (status) {\n        if (state.status === status) {\n          context.itemStates.delete(id);\n          count++;\n        }\n      } else if (state.status === \"completed\" || state.status === \"failed\") {\n        context.itemStates.delete(id);\n        count++;\n      }\n    }\n    return count;\n  }\n\n  /**\n   * Flush all partitions or a specific partition.\n   */\n  async flush<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    partitionKey?: string,\n  ): Promise<void> {\n    const promises: Promise<void>[] = [];\n    if (partitionKey) {\n      if (context.partitions.has(partitionKey)) {\n        promises.push(this.flushPartition(context, partitionKey));\n      }\n    } else {\n      for (const key of context.partitions.keys()) {\n        promises.push(this.flushPartition(context, key));\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  /**\n   * Flush a specific partition.\n   */\n  protected async flushPartition<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    partitionKey: string,\n    limit?: number,\n  ): Promise<void> {\n    const partition = context.partitions.get(partitionKey);\n    if (!partition || partition.itemIds.length === 0) {\n      context.partitions.delete(partitionKey);\n      return;\n    }\n\n    // Clear the timeout and grab the item IDs (up to limit if specified)\n    partition.timeout?.clear();\n    partition.timeout = undefined;\n    const itemsToTake =\n      limit !== undefined\n        ? Math.min(limit, partition.itemIds.length)\n        : partition.itemIds.length;\n    const itemIdsToProcess = partition.itemIds.splice(0, itemsToTake);\n\n    // Mark partition as flushing to prevent race conditions\n    partition.flushing = true;\n\n    // Get the items and mark them as processing\n    const itemsToProcess: TItem[] = [];\n    for (const id of itemIdsToProcess) {\n      const itemState = context.itemStates.get(id);\n      if (itemState) {\n        itemState.status = \"processing\";\n        itemsToProcess.push(itemState.item);\n      }\n    }\n\n    const concurrency = this.getConcurrency(context);\n    const maxDuration = this.getMaxDuration(context);\n\n    // Wait until there's a free slot (if at concurrency limit)\n    while (context.activeHandlers.length >= concurrency) {\n      this.log.trace(\n        `Batch handler is at concurrency limit, waiting for a slot...`,\n      );\n      // Wait for any single handler to complete, not all of them\n      await Promise.race(context.activeHandlers.map((it) => it.promise));\n    }\n\n    const promise = Promise.withResolvers<void>();\n    context.activeHandlers.push(promise);\n    let result: any;\n    try {\n      result = await context.alepha.context.run(() =>\n        // during shutdown, call handler directly to avoid retry cancellation\n        context.isShuttingDown\n          ? context.options.handler(itemsToProcess)\n          : this.retryProvider.retry(\n              {\n                ...context.options.retry,\n                handler: context.options.handler,\n              },\n              itemsToProcess,\n            ),\n      );\n\n      // Mark all items as completed and resolve their promises\n      for (const id of itemIdsToProcess) {\n        const itemState = context.itemStates.get(id);\n        if (itemState) {\n          itemState.status = \"completed\";\n          itemState.result = result;\n          // Only resolve if someone is waiting\n          itemState.resolve?.(result);\n        }\n      }\n    } catch (error) {\n      this.log.error(`Batch handler failed`, error);\n\n      // Mark all items as failed and reject their promises\n      for (const id of itemIdsToProcess) {\n        const itemState = context.itemStates.get(id);\n        if (itemState) {\n          itemState.status = \"failed\";\n          itemState.error = error as Error;\n          // Only reject if someone is waiting (promise was created)\n          itemState.reject?.(error as Error);\n        }\n      }\n    } finally {\n      promise.resolve();\n      context.activeHandlers = context.activeHandlers.filter(\n        (it) => it !== promise,\n      );\n\n      // Only delete partition if no new items arrived during processing\n      const currentPartition = context.partitions.get(partitionKey);\n      if (currentPartition?.flushing && currentPartition.itemIds.length === 0) {\n        context.partitions.delete(partitionKey);\n      } else if (currentPartition) {\n        // Reset flushing flag if partition still exists with items\n        currentPartition.flushing = false;\n\n        // Restart timeout for items that arrived during flush\n        if (currentPartition.itemIds.length > 0 && !currentPartition.timeout) {\n          currentPartition.timeout = this.dateTime.createTimeout(() => {\n            this.log.trace(\n              `Batch partition '${partitionKey}' timed out, flushing...`,\n            );\n            this.flushPartition(context, partitionKey).catch((error) =>\n              this.log.error(\n                `Failed to flush batch partition '${partitionKey}' on timeout`,\n                error,\n              ),\n            );\n          }, maxDuration);\n        }\n      }\n    }\n  }\n\n  /**\n   * Mark the context as ready and start processing buffered items.\n   * Called after the \"ready\" hook.\n   */\n  async markReady<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): Promise<void> {\n    this.log.debug(\n      \"Batch processor is now ready, starting to process buffered items...\",\n    );\n    context.isReady = true;\n    await this.startProcessing(context);\n  }\n\n  /**\n   * Mark the context as shutting down and flush all remaining items.\n   */\n  async shutdown<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): Promise<void> {\n    this.log.debug(\"Flushing all remaining batch partitions on shutdown...\");\n    context.isShuttingDown = true;\n    await this.flush(context);\n    this.log.debug(\"All batch partitions flushed\");\n  }\n\n  /**\n   * Called after the \"ready\" hook to start processing buffered items that were\n   * pushed during startup. This checks all partitions and starts timeouts/flushes\n   * for items that were accumulated before the app was ready.\n   */\n  protected async startProcessing<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): Promise<void> {\n    const maxSize = this.getMaxSize(context);\n    const maxDuration = this.getMaxDuration(context);\n\n    for (const [partitionKey, partition] of context.partitions.entries()) {\n      if (partition.itemIds.length === 0) {\n        continue;\n      }\n\n      this.log.trace(\n        `Starting processing for partition '${partitionKey}' with ${partition.itemIds.length} buffered items`,\n      );\n\n      // Flush batches of maxSize while we have items >= maxSize\n      while (partition.itemIds.length >= maxSize) {\n        this.log.trace(\n          `Partition '${partitionKey}' has ${partition.itemIds.length} items, flushing batch of ${maxSize}...`,\n        );\n        await this.flushPartition(context, partitionKey, maxSize);\n      }\n\n      // After flushing full batches, start timeout for any remaining items\n      if (\n        partition.itemIds.length > 0 &&\n        !partition.timeout &&\n        !partition.flushing\n      ) {\n        this.log.trace(\n          `Starting timeout for partition '${partitionKey}' with ${partition.itemIds.length} remaining items`,\n        );\n        partition.timeout = this.dateTime.createTimeout(() => {\n          this.log.trace(\n            `Batch partition '${partitionKey}' timed out, flushing...`,\n          );\n          this.flushPartition(context, partitionKey).catch((error) =>\n            this.log.error(\n              `Failed to flush partition '${partitionKey}' on timeout after startup`,\n              error,\n            ),\n          );\n        }, maxDuration);\n      }\n    }\n  }\n}\n","import {\n  $hook,\n  $inject,\n  createPrimitive,\n  KIND,\n  Primitive,\n  type Static,\n  type TSchema,\n} from \"alepha\";\nimport type { DurationLike } from \"alepha/datetime\";\nimport type { RetryPrimitiveOptions } from \"alepha/retry\";\nimport {\n  type BatchContext,\n  type BatchItemState,\n  type BatchItemStatus,\n  BatchProvider,\n} from \"../providers/BatchProvider.ts\";\n\n/**\n * Creates a batch processing primitive for efficient grouping and processing of multiple operations.\n */\nexport const $batch = <TItem extends TSchema, TResponse>(\n  options: BatchPrimitiveOptions<TItem, TResponse>,\n): BatchPrimitive<TItem, TResponse> =>\n  createPrimitive(BatchPrimitive<TItem, TResponse>, options);\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface BatchPrimitiveOptions<TItem extends TSchema, TResponse = any> {\n  /**\n   * TypeBox schema for validating each item added to the batch.\n   */\n  schema: TItem;\n\n  /**\n   * The batch processing handler function that processes arrays of validated items.\n   */\n  handler: (items: Static<TItem>[]) => TResponse;\n\n  /**\n   * Maximum number of items to collect before automatically flushing the batch.\n   */\n  maxSize?: number;\n\n  /**\n   * Maximum number of items that can be queued in a single partition.\n   * If exceeded, push() will throw an error.\n   */\n  maxQueueSize?: number;\n\n  /**\n   * Maximum time to wait before flushing a batch, even if it hasn't reached maxSize.\n   */\n  maxDuration?: DurationLike;\n\n  /**\n   * Function to determine partition keys for grouping items into separate batches.\n   */\n  partitionBy?: (item: Static<TItem>) => string;\n\n  /**\n   * Maximum number of batch handlers that can execute simultaneously.\n   */\n  concurrency?: number;\n\n  /**\n   * Retry configuration for failed batch processing operations.\n   */\n  retry?: Omit<RetryPrimitiveOptions<() => Array<Static<TItem>>>, \"handler\">;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport type { BatchItemState, BatchItemStatus };\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class BatchPrimitive<\n  TItem extends TSchema,\n  TResponse = any,\n> extends Primitive<BatchPrimitiveOptions<TItem, TResponse>> {\n  protected readonly batchProvider = $inject(BatchProvider);\n  protected readonly context: BatchContext<Static<TItem>, TResponse>;\n\n  constructor(\n    ...args: ConstructorParameters<\n      typeof Primitive<BatchPrimitiveOptions<TItem, TResponse>>\n    >\n  ) {\n    super(...args);\n    this.context = this.batchProvider.createContext(this.alepha, {\n      handler: this.options.handler,\n      maxSize: this.options.maxSize,\n      maxQueueSize: this.options.maxQueueSize,\n      maxDuration: this.options.maxDuration,\n      partitionBy: this.options.partitionBy,\n      concurrency: this.options.concurrency,\n      retry: this.options.retry,\n    });\n  }\n\n  /**\n   * Pushes an item into the batch and returns immediately with a unique ID.\n   * The item will be processed asynchronously with other items when the batch is flushed.\n   * Use wait(id) to get the processing result.\n   */\n  public async push(item: Static<TItem>): Promise<string> {\n    // Validate the item against the schema\n    const validatedItem = this.alepha.codec.validate(this.options.schema, item);\n    return this.batchProvider.push(this.context, validatedItem);\n  }\n\n  /**\n   * Wait for a specific item to be processed and get its result.\n   * @param id The item ID returned from push()\n   * @returns The processing result\n   * @throws If the item doesn't exist or processing failed\n   */\n  public async wait(id: string): Promise<TResponse> {\n    return this.batchProvider.wait(this.context, id);\n  }\n\n  /**\n   * Get the current status of an item.\n   * @param id The item ID returned from push()\n   * @returns Status information or undefined if item doesn't exist\n   */\n  public status(\n    id: string,\n  ):\n    | { status: \"pending\" | \"processing\" }\n    | { status: \"completed\"; result: TResponse }\n    | { status: \"failed\"; error: Error }\n    | undefined {\n    return this.batchProvider.status(this.context, id);\n  }\n\n  /**\n   * Flush all partitions or a specific partition.\n   */\n  public async flush(partitionKey?: string): Promise<void> {\n    return this.batchProvider.flush(this.context, partitionKey);\n  }\n\n  /**\n   * Clears completed and failed items from memory.\n   * Call this periodically in long-running applications to prevent memory leaks.\n   *\n   * @param status Optional: only clear items with this specific status ('completed' or 'failed')\n   * @returns The number of items cleared\n   */\n  public clearCompleted(status?: \"completed\" | \"failed\"): number {\n    return this.batchProvider.clearCompleted(this.context, status);\n  }\n\n  protected readonly onReady = $hook({\n    on: \"ready\",\n    handler: async () => {\n      await this.batchProvider.markReady(this.context);\n    },\n  });\n}\n\n$batch[KIND] = BatchPrimitive;\n","import { $module } from \"alepha\";\nimport { $batch } from \"./primitives/$batch.ts\";\nimport { BatchProvider } from \"./providers/BatchProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./primitives/$batch.ts\";\nexport * from \"./providers/BatchProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Batch accumulation and processing.\n *\n * **Features:**\n * - Batch accumulator with handler\n * - Configurable batch size\n * - Time-based triggers\n * - Status tracking\n *\n * @module alepha.batch\n */\nexport const AlephaBatch = $module({\n  name: \"alepha.batch\",\n  primitives: [$batch],\n  services: [BatchProvider],\n});\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/batch/providers/BatchProvider.ts","../../src/batch/primitives/$batch.ts","../../src/batch/index.ts"],"sourcesContent":["import { $hook, $inject, type Alepha, AlephaError } from \"alepha\";\nimport { CryptoProvider } from \"alepha/crypto\";\nimport { DateTimeProvider, type DurationLike } from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport { type RetryBackoffOptions, RetryProvider } from \"alepha/retry\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface BatchOptions<TItem, TResponse = any> {\n  /**\n   * The batch processing handler function that processes arrays of validated items.\n   */\n  handler: (items: TItem[]) => TResponse;\n\n  /**\n   * Maximum number of items to collect before automatically flushing the batch.\n   *\n   * @default 10\n   */\n  maxSize?: number;\n\n  /**\n   * Maximum number of items that can be queued in a single partition.\n   * If exceeded, push() will throw an error.\n   */\n  maxQueueSize?: number;\n\n  /**\n   * Maximum time to wait before flushing a batch, even if it hasn't reached maxSize.\n   *\n   * @default [1, \"second\"]\n   */\n  maxDuration?: DurationLike;\n\n  /**\n   * Function to determine partition keys for grouping items into separate batches.\n   */\n  partitionBy?: (item: TItem) => string;\n\n  /**\n   * Maximum number of batch handlers that can execute simultaneously.\n   *\n   * @default 1\n   */\n  concurrency?: number;\n\n  /**\n   * Retry configuration for failed batch processing operations.\n   */\n  retry?: {\n    /**\n     * The maximum number of attempts.\n     *\n     * @default 3\n     */\n    max?: number;\n\n    /**\n     * The backoff strategy for delays between retries.\n     * Can be a fixed number (in ms) or a configuration object for exponential backoff.\n     *\n     * @default { initial: 200, factor: 2, jitter: true }\n     */\n    backoff?: number | RetryBackoffOptions;\n\n    /**\n     * An overall time limit for all retry attempts combined.\n     *\n     * e.g., `[5, 'seconds']`\n     */\n    maxDuration?: DurationLike;\n\n    /**\n     * A function that determines if a retry should be attempted based on the error.\n     *\n     * @default (error) => true (retries on any error)\n     */\n    when?: (error: Error) => boolean;\n\n    /**\n     * A custom callback for when a retry attempt fails.\n     * This is called before the delay.\n     */\n    onError?: (error: Error, attempt: number) => void;\n  };\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport type BatchItemStatus = \"pending\" | \"processing\" | \"completed\" | \"failed\";\n\nexport interface BatchItemState<TItem, TResponse> {\n  id: string;\n  item: TItem;\n  partitionKey: string;\n  status: BatchItemStatus;\n  result?: TResponse;\n  error?: Error;\n  promise?: Promise<TResponse>;\n  resolve?: (value: TResponse) => void;\n  reject?: (error: Error) => void;\n}\n\nexport interface PartitionState {\n  itemIds: string[];\n  timeout?: { clear: () => void };\n  flushing: boolean;\n}\n\n/**\n * Context object that holds all state for a batch processor instance.\n */\nexport interface BatchContext<TItem, TResponse> {\n  options: BatchOptions<TItem, TResponse>;\n  itemStates: Map<string, BatchItemState<TItem, TResponse>>;\n  partitions: Map<string, PartitionState>;\n  activeHandlers: PromiseWithResolvers<void>[];\n  isShuttingDown: boolean;\n  isReady: boolean;\n  alepha: Alepha;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Service for batch processing operations.\n * Provides methods to manage batches of items with automatic flushing based on size or time.\n */\nexport class BatchProvider {\n  protected readonly log = $logger();\n  protected readonly dateTime = $inject(DateTimeProvider);\n  protected readonly retryProvider = $inject(RetryProvider);\n  protected readonly crypto = $inject(CryptoProvider);\n\n  /**\n   * All active batch contexts managed by this provider.\n   */\n  protected readonly contexts = new Set<BatchContext<any, any>>();\n\n  /**\n   * Creates a new batch context with the given options.\n   */\n  createContext<TItem, TResponse>(\n    alepha: Alepha,\n    options: BatchOptions<TItem, TResponse>,\n  ): BatchContext<TItem, TResponse> {\n    const context: BatchContext<TItem, TResponse> = {\n      options,\n      itemStates: new Map(),\n      partitions: new Map(),\n      activeHandlers: [],\n      isShuttingDown: false,\n      isReady: false,\n      alepha,\n    };\n    this.contexts.add(context);\n    return context;\n  }\n\n  /**\n   * Shutdown hook - flushes all batch contexts on application stop.\n   */\n  protected readonly onStop = $hook({\n    on: \"stop\",\n    priority: \"first\",\n    handler: async () => {\n      if (this.contexts.size === 0) {\n        return;\n      }\n      this.log.debug(`Shutting down ${this.contexts.size} batch context(s)...`);\n      const promises: Promise<void>[] = [];\n      for (const context of this.contexts) {\n        promises.push(this.shutdown(context));\n      }\n      await Promise.all(promises);\n      this.log.debug(\"All batch contexts shut down\");\n    },\n  });\n\n  /**\n   * Get the effective maxSize for a context.\n   */\n  protected getMaxSize<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): number {\n    return context.options.maxSize ?? 10;\n  }\n\n  /**\n   * Get the effective concurrency for a context.\n   */\n  protected getConcurrency<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): number {\n    return context.options.concurrency ?? 1;\n  }\n\n  /**\n   * Get the effective maxDuration for a context.\n   */\n  protected getMaxDuration<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): DurationLike {\n    return context.options.maxDuration ?? [1, \"second\"];\n  }\n\n  /**\n   * Pushes an item into the batch and returns immediately with a unique ID.\n   * The item will be processed asynchronously with other items when the batch is flushed.\n   * Use wait(id) to get the processing result.\n   *\n   * @throws Error if maxQueueSize is exceeded\n   */\n  push<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    item: TItem,\n  ): string {\n    // 1. Generate unique ID\n    const id = this.crypto.randomUUID();\n\n    // 2. Determine the partition key (with error handling)\n    let partitionKey: string;\n    try {\n      partitionKey = context.options.partitionBy\n        ? context.options.partitionBy(item)\n        : \"default\";\n    } catch (error) {\n      this.log.warn(\n        \"partitionBy function threw an error, using 'default' partition\",\n        { error },\n      );\n      partitionKey = \"default\";\n    }\n\n    // 3. Create item state\n    const itemState: BatchItemState<TItem, TResponse> = {\n      id,\n      item,\n      partitionKey,\n      status: \"pending\",\n    };\n\n    // CAUTION: Do not log.debug/info here as it may cause infinite loops if logging is batched\n\n    context.itemStates.set(id, itemState);\n\n    // 4. Get or create the partition state\n    if (!context.partitions.has(partitionKey)) {\n      context.partitions.set(partitionKey, {\n        itemIds: [],\n        flushing: false,\n      });\n    }\n    const partition = context.partitions.get(partitionKey)!;\n\n    // 5. Check maxQueueSize before adding\n    if (\n      context.options.maxQueueSize !== undefined &&\n      partition.itemIds.length >= context.options.maxQueueSize\n    ) {\n      throw new AlephaError(\n        `Batch queue size exceeded for partition '${partitionKey}' (max: ${context.options.maxQueueSize})`,\n      );\n    }\n\n    // 6. Add item ID to partition\n    partition.itemIds.push(id);\n\n    const maxSize = this.getMaxSize(context);\n    const maxDuration = this.getMaxDuration(context);\n\n    // 7. Only start processing if the app is ready (after \"ready\" hook)\n    // During startup, items are just buffered in memory\n    if (context.isReady) {\n      // Check if the batch is full\n      if (partition.itemIds.length >= maxSize) {\n        this.log.trace(\n          `Batch partition '${partitionKey}' is full, flushing...`,\n        );\n        this.flushPartition(context, partitionKey).catch((error) =>\n          this.log.error(\n            `Failed to flush batch partition '${partitionKey}' on max size`,\n            error,\n          ),\n        );\n      } else if (!partition.timeout && !partition.flushing) {\n        // 8. Start the timeout if it's not already running for this partition and not currently flushing\n        partition.timeout = this.dateTime.createTimeout(() => {\n          this.log.trace(\n            `Batch partition '${partitionKey}' timed out, flushing...`,\n          );\n          this.flushPartition(context, partitionKey).catch((error) =>\n            this.log.error(\n              `Failed to flush batch partition '${partitionKey}' on timeout`,\n              error,\n            ),\n          );\n        }, maxDuration);\n      }\n    } else {\n      // Not ready yet - just buffer items, no size checks or timeouts\n      this.log.trace(\n        `Buffering item in partition '${partitionKey}' (app not ready yet, ${partition.itemIds.length} items buffered)`,\n      );\n    }\n\n    // 9. Return ID immediately\n    return id;\n  }\n\n  /**\n   * Wait for a specific item to be processed and get its result.\n   * @param id The item ID returned from push()\n   * @returns The processing result\n   * @throws If the item doesn't exist or processing failed\n   */\n  async wait<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    id: string,\n  ): Promise<TResponse> {\n    const itemState = context.itemStates.get(id);\n    if (!itemState) {\n      throw new AlephaError(`Item with id '${id}' not found`);\n    }\n\n    // If already completed or failed, return immediately\n    if (itemState.status === \"completed\") {\n      return itemState.result!;\n    }\n    if (itemState.status === \"failed\") {\n      throw itemState.error!;\n    }\n\n    // Create promise on-demand if not already created\n    if (!itemState.promise) {\n      itemState.promise = new Promise<TResponse>((resolve, reject) => {\n        itemState.resolve = resolve;\n        itemState.reject = reject;\n      });\n    }\n\n    return itemState.promise;\n  }\n\n  /**\n   * Get the current status of an item.\n   * @param id The item ID returned from push()\n   * @returns Status information or undefined if item doesn't exist\n   */\n  status<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    id: string,\n  ):\n    | { status: \"pending\" | \"processing\" }\n    | { status: \"completed\"; result: TResponse }\n    | { status: \"failed\"; error: Error }\n    | undefined {\n    const itemState = context.itemStates.get(id);\n    if (!itemState) {\n      return undefined;\n    }\n\n    if (itemState.status === \"completed\") {\n      return { status: \"completed\", result: itemState.result! };\n    }\n    if (itemState.status === \"failed\") {\n      return { status: \"failed\", error: itemState.error! };\n    }\n    return { status: itemState.status };\n  }\n\n  /**\n   * Clears completed and failed items from the context to free memory.\n   * Returns the number of items cleared.\n   *\n   * @param context The batch context\n   * @param status Optional: only clear items with this specific status ('completed' or 'failed')\n   * @returns The number of items cleared\n   */\n  clearCompleted<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    status?: \"completed\" | \"failed\",\n  ): number {\n    let count = 0;\n    for (const [id, state] of context.itemStates) {\n      if (status) {\n        if (state.status === status) {\n          context.itemStates.delete(id);\n          count++;\n        }\n      } else if (state.status === \"completed\" || state.status === \"failed\") {\n        context.itemStates.delete(id);\n        count++;\n      }\n    }\n    return count;\n  }\n\n  /**\n   * Flush all partitions or a specific partition.\n   */\n  async flush<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    partitionKey?: string,\n  ): Promise<void> {\n    const promises: Promise<void>[] = [];\n    if (partitionKey) {\n      if (context.partitions.has(partitionKey)) {\n        promises.push(this.flushPartition(context, partitionKey));\n      }\n    } else {\n      for (const key of context.partitions.keys()) {\n        promises.push(this.flushPartition(context, key));\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  /**\n   * Flush a specific partition.\n   */\n  protected async flushPartition<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n    partitionKey: string,\n    limit?: number,\n  ): Promise<void> {\n    const partition = context.partitions.get(partitionKey);\n    if (!partition || partition.itemIds.length === 0) {\n      context.partitions.delete(partitionKey);\n      return;\n    }\n\n    // Clear the timeout and grab the item IDs (up to limit if specified)\n    partition.timeout?.clear();\n    partition.timeout = undefined;\n    const itemsToTake =\n      limit !== undefined\n        ? Math.min(limit, partition.itemIds.length)\n        : partition.itemIds.length;\n    const itemIdsToProcess = partition.itemIds.splice(0, itemsToTake);\n\n    // Mark partition as flushing to prevent race conditions\n    partition.flushing = true;\n\n    // Get the items and mark them as processing\n    const itemsToProcess: TItem[] = [];\n    for (const id of itemIdsToProcess) {\n      const itemState = context.itemStates.get(id);\n      if (itemState) {\n        itemState.status = \"processing\";\n        itemsToProcess.push(itemState.item);\n      }\n    }\n\n    const concurrency = this.getConcurrency(context);\n    const maxDuration = this.getMaxDuration(context);\n\n    // Wait until there's a free slot (if at concurrency limit)\n    while (context.activeHandlers.length >= concurrency) {\n      this.log.trace(\n        `Batch handler is at concurrency limit, waiting for a slot...`,\n      );\n      // Wait for any single handler to complete, not all of them\n      await Promise.race(context.activeHandlers.map((it) => it.promise));\n    }\n\n    const promise = Promise.withResolvers<void>();\n    context.activeHandlers.push(promise);\n    let result: any;\n    try {\n      result = await context.alepha.context.run(() =>\n        // during shutdown, call handler directly to avoid retry cancellation\n        context.isShuttingDown\n          ? context.options.handler(itemsToProcess)\n          : this.retryProvider.retry(\n              {\n                ...context.options.retry,\n                handler: context.options.handler,\n              },\n              itemsToProcess,\n            ),\n      );\n\n      // Mark all items as completed and resolve their promises\n      for (const id of itemIdsToProcess) {\n        const itemState = context.itemStates.get(id);\n        if (itemState) {\n          itemState.status = \"completed\";\n          itemState.result = result;\n          // Only resolve if someone is waiting\n          itemState.resolve?.(result);\n        }\n      }\n    } catch (error) {\n      this.log.error(`Batch handler failed`, error);\n\n      // Mark all items as failed and reject their promises\n      for (const id of itemIdsToProcess) {\n        const itemState = context.itemStates.get(id);\n        if (itemState) {\n          itemState.status = \"failed\";\n          itemState.error = error as Error;\n          // Only reject if someone is waiting (promise was created)\n          itemState.reject?.(error as Error);\n        }\n      }\n    } finally {\n      promise.resolve();\n      context.activeHandlers = context.activeHandlers.filter(\n        (it) => it !== promise,\n      );\n\n      // Only delete partition if no new items arrived during processing\n      const currentPartition = context.partitions.get(partitionKey);\n      if (currentPartition?.flushing && currentPartition.itemIds.length === 0) {\n        context.partitions.delete(partitionKey);\n      } else if (currentPartition) {\n        // Reset flushing flag if partition still exists with items\n        currentPartition.flushing = false;\n\n        // Restart timeout for items that arrived during flush\n        if (currentPartition.itemIds.length > 0 && !currentPartition.timeout) {\n          currentPartition.timeout = this.dateTime.createTimeout(() => {\n            this.log.trace(\n              `Batch partition '${partitionKey}' timed out, flushing...`,\n            );\n            this.flushPartition(context, partitionKey).catch((error) =>\n              this.log.error(\n                `Failed to flush batch partition '${partitionKey}' on timeout`,\n                error,\n              ),\n            );\n          }, maxDuration);\n        }\n      }\n    }\n  }\n\n  /**\n   * Mark the context as ready and start processing buffered items.\n   * Called after the \"ready\" hook.\n   */\n  async markReady<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): Promise<void> {\n    this.log.debug(\n      \"Batch processor is now ready, starting to process buffered items...\",\n    );\n    context.isReady = true;\n    await this.startProcessing(context);\n  }\n\n  /**\n   * Mark the context as shutting down and flush all remaining items.\n   */\n  async shutdown<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): Promise<void> {\n    this.log.debug(\"Flushing all remaining batch partitions on shutdown...\");\n    context.isShuttingDown = true;\n    await this.flush(context);\n    this.log.debug(\"All batch partitions flushed\");\n  }\n\n  /**\n   * Called after the \"ready\" hook to start processing buffered items that were\n   * pushed during startup. This checks all partitions and starts timeouts/flushes\n   * for items that were accumulated before the app was ready.\n   */\n  protected async startProcessing<TItem, TResponse>(\n    context: BatchContext<TItem, TResponse>,\n  ): Promise<void> {\n    const maxSize = this.getMaxSize(context);\n    const maxDuration = this.getMaxDuration(context);\n\n    for (const [partitionKey, partition] of context.partitions.entries()) {\n      if (partition.itemIds.length === 0) {\n        continue;\n      }\n\n      this.log.trace(\n        `Starting processing for partition '${partitionKey}' with ${partition.itemIds.length} buffered items`,\n      );\n\n      // Flush batches of maxSize while we have items >= maxSize\n      while (partition.itemIds.length >= maxSize) {\n        this.log.trace(\n          `Partition '${partitionKey}' has ${partition.itemIds.length} items, flushing batch of ${maxSize}...`,\n        );\n        await this.flushPartition(context, partitionKey, maxSize);\n      }\n\n      // After flushing full batches, start timeout for any remaining items\n      if (\n        partition.itemIds.length > 0 &&\n        !partition.timeout &&\n        !partition.flushing\n      ) {\n        this.log.trace(\n          `Starting timeout for partition '${partitionKey}' with ${partition.itemIds.length} remaining items`,\n        );\n        partition.timeout = this.dateTime.createTimeout(() => {\n          this.log.trace(\n            `Batch partition '${partitionKey}' timed out, flushing...`,\n          );\n          this.flushPartition(context, partitionKey).catch((error) =>\n            this.log.error(\n              `Failed to flush partition '${partitionKey}' on timeout after startup`,\n              error,\n            ),\n          );\n        }, maxDuration);\n      }\n    }\n  }\n}\n","import {\n  $hook,\n  $inject,\n  createPrimitive,\n  KIND,\n  Primitive,\n  type Static,\n  type TSchema,\n} from \"alepha\";\nimport type { DurationLike } from \"alepha/datetime\";\nimport type { RetryPrimitiveOptions } from \"alepha/retry\";\nimport {\n  type BatchContext,\n  type BatchItemState,\n  type BatchItemStatus,\n  BatchProvider,\n} from \"../providers/BatchProvider.ts\";\n\n/**\n * Creates a batch processing primitive for efficient grouping and processing of multiple operations.\n */\nexport const $batch = <TItem extends TSchema, TResponse>(\n  options: BatchPrimitiveOptions<TItem, TResponse>,\n): BatchPrimitive<TItem, TResponse> =>\n  createPrimitive(BatchPrimitive<TItem, TResponse>, options);\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface BatchPrimitiveOptions<TItem extends TSchema, TResponse = any> {\n  /**\n   * TypeBox schema for validating each item added to the batch.\n   */\n  schema: TItem;\n\n  /**\n   * The batch processing handler function that processes arrays of validated items.\n   */\n  handler: (items: Static<TItem>[]) => TResponse;\n\n  /**\n   * Maximum number of items to collect before automatically flushing the batch.\n   */\n  maxSize?: number;\n\n  /**\n   * Maximum number of items that can be queued in a single partition.\n   * If exceeded, push() will throw an error.\n   */\n  maxQueueSize?: number;\n\n  /**\n   * Maximum time to wait before flushing a batch, even if it hasn't reached maxSize.\n   */\n  maxDuration?: DurationLike;\n\n  /**\n   * Function to determine partition keys for grouping items into separate batches.\n   */\n  partitionBy?: (item: Static<TItem>) => string;\n\n  /**\n   * Maximum number of batch handlers that can execute simultaneously.\n   */\n  concurrency?: number;\n\n  /**\n   * Retry configuration for failed batch processing operations.\n   */\n  retry?: Omit<RetryPrimitiveOptions<() => Array<Static<TItem>>>, \"handler\">;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport type { BatchItemState, BatchItemStatus };\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class BatchPrimitive<\n  TItem extends TSchema,\n  TResponse = any,\n> extends Primitive<BatchPrimitiveOptions<TItem, TResponse>> {\n  protected readonly batchProvider = $inject(BatchProvider);\n  protected readonly context: BatchContext<Static<TItem>, TResponse>;\n\n  constructor(\n    ...args: ConstructorParameters<\n      typeof Primitive<BatchPrimitiveOptions<TItem, TResponse>>\n    >\n  ) {\n    super(...args);\n    this.context = this.batchProvider.createContext(this.alepha, {\n      handler: this.options.handler,\n      maxSize: this.options.maxSize,\n      maxQueueSize: this.options.maxQueueSize,\n      maxDuration: this.options.maxDuration,\n      partitionBy: this.options.partitionBy,\n      concurrency: this.options.concurrency,\n      retry: this.options.retry,\n    });\n  }\n\n  /**\n   * Pushes an item into the batch and returns immediately with a unique ID.\n   * The item will be processed asynchronously with other items when the batch is flushed.\n   * Use wait(id) to get the processing result.\n   */\n  public async push(item: Static<TItem>): Promise<string> {\n    // Validate the item against the schema\n    const validatedItem = this.alepha.codec.validate(this.options.schema, item);\n    return this.batchProvider.push(this.context, validatedItem);\n  }\n\n  /**\n   * Wait for a specific item to be processed and get its result.\n   * @param id The item ID returned from push()\n   * @returns The processing result\n   * @throws If the item doesn't exist or processing failed\n   */\n  public async wait(id: string): Promise<TResponse> {\n    return this.batchProvider.wait(this.context, id);\n  }\n\n  /**\n   * Get the current status of an item.\n   * @param id The item ID returned from push()\n   * @returns Status information or undefined if item doesn't exist\n   */\n  public status(\n    id: string,\n  ):\n    | { status: \"pending\" | \"processing\" }\n    | { status: \"completed\"; result: TResponse }\n    | { status: \"failed\"; error: Error }\n    | undefined {\n    return this.batchProvider.status(this.context, id);\n  }\n\n  /**\n   * Flush all partitions or a specific partition.\n   */\n  public async flush(partitionKey?: string): Promise<void> {\n    return this.batchProvider.flush(this.context, partitionKey);\n  }\n\n  /**\n   * Clears completed and failed items from memory.\n   * Call this periodically in long-running applications to prevent memory leaks.\n   *\n   * @param status Optional: only clear items with this specific status ('completed' or 'failed')\n   * @returns The number of items cleared\n   */\n  public clearCompleted(status?: \"completed\" | \"failed\"): number {\n    return this.batchProvider.clearCompleted(this.context, status);\n  }\n\n  protected readonly onReady = $hook({\n    on: \"ready\",\n    handler: async () => {\n      await this.batchProvider.markReady(this.context);\n    },\n  });\n}\n\n$batch[KIND] = BatchPrimitive;\n","import { $module } from \"alepha\";\nimport { $batch } from \"./primitives/$batch.ts\";\nimport { BatchProvider } from \"./providers/BatchProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./primitives/$batch.ts\";\nexport * from \"./providers/BatchProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Batch accumulation and processing.\n *\n * **Features:**\n * - Batch accumulator with handler\n * - Configurable batch size\n * - Time-based triggers\n * - Status tracking\n *\n * @module alepha.batch\n */\nexport const AlephaBatch = $module({\n  name: \"alepha.batch\",\n  primitives: [$batch],\n  services: [BatchProvider],\n});\n"],"mappings":"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"}

package/dist/bin/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/bin/index.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { Alepha, run } from \"alepha\";\nimport { AlephaCli, version } from \"alepha/cli\";\n\nconst alepha = Alepha.create({\n  env: {\n    APP_NAME: \"CLI\",\n    CLI_NAME: \"alepha\",\n    CLI_DESCRIPTION: `Alepha CLI v${version} - Create and manage Alepha projects.`,\n    LOG_FORMAT: (process.env.LOG_FORMAT ?? \"raw\") as any,\n    LOG_LEVEL: process.env.LOG_LEVEL ?? \"alepha.core:warn,info\",\n  },\n});\n\nalepha.with(AlephaCli);\n\nrun(alepha);\n"],"mappings":";;;;AAIA,MAAM,SAAS,OAAO,OAAO,EAC3B,KAAK;CACH,UAAU;CACV,UAAU;CACV,iBAAiB,eAAe,QAAQ;CACxC,YAAa,QAAQ,IAAI,cAAc;CACvC,WAAW,QAAQ,IAAI,aAAa;CACrC,EACF,CAAC;AAEF,OAAO,KAAK,UAAU;AAEtB,IAAI,OAAO"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/bin/index.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { Alepha, run } from \"alepha\";\nimport { AlephaCli, version } from \"alepha/cli\";\n\nconst alepha = Alepha.create({\n  env: {\n    APP_NAME: \"CLI\",\n    CLI_NAME: \"alepha\",\n    CLI_DESCRIPTION: `Alepha CLI v${version} - Create and manage Alepha projects.`,\n    LOG_FORMAT: (process.env.LOG_FORMAT ?? \"raw\") as any,\n    LOG_LEVEL: process.env.LOG_LEVEL ?? \"alepha.core:warn,info\",\n  },\n});\n\nalepha.with(AlephaCli);\n\nrun(alepha);\n"],"mappings":";;;;AAIA,MAAM,SAAS,OAAO,OAAO,EAC3B,KAAK;CACH,UAAU;CACV,UAAU;CACV,iBAAiB,eAAe,QAAQ;CACxC,YAAa,QAAQ,IAAI,cAAc;CACvC,WAAW,QAAQ,IAAI,aAAa;AACtC,EACF,CAAC;AAED,OAAO,KAAK,SAAS;AAErB,IAAI,MAAM"}