@warlock.js/core 5.30.0 → 5.32.0

package/esm/use-cases/index.mjs

@@ -5,4 +5,4 @@ import { runPipeline } from "./use-case-pipeline.mjs";
 import { $registerUseCase, $unregisterUseCase, addUseCaseHistory, getUseCase, getUseCaseHistory, getUseCases, increaseUseCaseFailedCalls, increaseUseCaseSuccessCalls } from "./use-cases-registry.mjs";
 import { useCase } from "./use-case.mjs";
 
-export {  };
+export { $registerUseCase, $unregisterUseCase, BadSchemaUseCaseError, addUseCaseHistory, broadcastUseCaseResult, fireLifecycleEvent, getUseCase, getUseCaseHistory, getUseCases, globalEventsCallbacksMap, globalUseCasesEvents, increaseUseCaseFailedCalls, increaseUseCaseSuccessCalls, runPipeline, useCase };

package/esm/use-cases/types.d.mts

@@ -1,14 +1,13 @@
 import { BenchmarkOptions } from "../benchmark/types.mjs";
 import { Infer, ObjectValidator } from "@warlock.js/seal";
 import { RetryOptions } from "@mongez/reinforcements";
-
 //#region ../../packages/core/src/use-cases/types.d.ts
 /**
  * Shared context object passed through the entire use case pipeline.
  * Contains the optional schema and can be enriched by guards/middleware
  * with arbitrary data (e.g., currentUser, permissions, request metadata).
  */
-type UseCaseContext = {
+export type UseCaseContext = {
   schema?: ObjectValidator;
 } & Record<string, any>;
 /**
@@ -30,7 +29,7 @@ type UseCaseContext = {
  * @template Input - The shape of the use case input data
  * @template Ctx - The shape of the shared context
  */
-type UseCaseGuard<Input, Ctx extends UseCaseContext = UseCaseContext> = (data: Readonly<Input>, ctx: Ctx) => void | Promise<void>;
+export type UseCaseGuard<Input, Ctx extends UseCaseContext = UseCaseContext> = (data: Readonly<Input>, ctx: Ctx) => void | Promise<void>;
 /**
  * Before middleware that runs **after** schema validation.
  *
@@ -47,7 +46,7 @@ type UseCaseGuard<Input, Ctx extends UseCaseContext = UseCaseContext> = (data: R
  * @template Input - The shape of the use case input data
  * @template Ctx - The shape of the shared context
  */
-type UseCaseBeforeMiddleware<Input, Ctx extends UseCaseContext = UseCaseContext> = (data: Input, ctx: Ctx) => Input | Promise<Input>;
+export type UseCaseBeforeMiddleware<Input, Ctx extends UseCaseContext = UseCaseContext> = (data: Input, ctx: Ctx) => Input | Promise<Input>;
 /**
  * After middleware that runs **after** the handler succeeds.
  *
@@ -65,17 +64,23 @@ type UseCaseBeforeMiddleware<Input, Ctx extends UseCaseContext = UseCaseContext>
  * @template Output - The shape of the use case output data
  * @template Ctx - The shape of the shared context
  */
-type UseCaseAfterMiddleware<Output, Ctx extends UseCaseContext = UseCaseContext> = (output: Output, ctx: Ctx) => void | Promise<void>;
+export type UseCaseAfterMiddleware<Output, Ctx extends UseCaseContext = UseCaseContext> = (output: Output, ctx: Ctx) => void | Promise<void>;
 /**
  * Context passed to `onExecuting` lifecycle event callbacks.
  * Fired at the start of each use case execution, before guards run.
  */
-type UseCaseOnExecutingContext = {
-  /** The shared pipeline context */ctx: UseCaseContext; /** Unique execution ID */
-  id: string; /** Use case name */
-  name: string; /** Raw input data */
-  data: any; /** Schema validator (if defined) */
-  schema?: ObjectValidator; /** Timestamp when execution started */
+export type UseCaseOnExecutingContext = {
+  /** The shared pipeline context */
+  ctx: UseCaseContext;
+  /** Unique execution ID */
+  id: string;
+  /** Use case name */
+  name: string;
+  /** Raw input data */
+  data: any;
+  /** Schema validator (if defined) */
+  schema?: ObjectValidator;
+  /** Timestamp when execution started */
   startedAt: Date;
 };
 /**
@@ -84,11 +89,16 @@ type UseCaseOnExecutingContext = {
  * An envelope (not the bare payload) so consumers get a correlation `id` for
  * tracing/idempotency under at-least-once delivery.
  */
-type UseCaseBroadcastEvent = {
-  /** Use case name */useCase: string; /** Channel/event name — defaults to the use case name */
-  event: string; /** Execution id (correlation / idempotency) */
-  id: string; /** Emission timestamp */
-  at: Date; /** The output as-is, or the projected shape from `broadcast.output` */
+export type UseCaseBroadcastEvent = {
+  /** Use case name */
+  useCase: string;
+  /** Channel/event name — defaults to the use case name */
+  event: string;
+  /** Execution id (correlation / idempotency) */
+  id: string;
+  /** Emission timestamp */
+  at: Date;
+  /** The output as-is, or the projected shape from `broadcast.output` */
   payload: unknown;
 };
 /**
@@ -104,7 +114,7 @@ type UseCaseBroadcastEvent = {
  * broadcast: { enabled: true, channels: [heraldBroadcast({ broker: "default" })] }
  * ```
  */
-interface UseCaseBroadcastChannel {
+export interface UseCaseBroadcastChannel {
   broadcast(event: UseCaseBroadcastEvent): void | Promise<void>;
 }
 /**
@@ -113,8 +123,10 @@ interface UseCaseBroadcastChannel {
  *
  * @template Output - The shape of the handler's return value
  */
-type UseCaseBroadcastOption<Output> = boolean | {
-  /** Channel/event name; defaults to the use case name */event?: string; /** Project the payload before broadcasting (e.g. strip sensitive fields) */
+export type UseCaseBroadcastOption<Output> = boolean | {
+  /** Channel/event name; defaults to the use case name */
+  event?: string;
+  /** Project the payload before broadcasting (e.g. strip sensitive fields) */
   output?: (output: Output, result: UseCaseResult<Output>) => unknown;
 };
 /**
@@ -143,16 +155,26 @@ type UseCaseBroadcastOption<Output> = boolean | {
  * @template Input - The shape of the input data (before transformation)
  * @template Ctx - The shape of the shared context
  */
-type UseCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseContext> = {
-  /** Unique use case identifier, used for registration, logging, and cache keys */name: string; /** Human-readable description, surfaced in the registry and observability */
-  description?: string; /** Core business logic handler. Receives validated + transformed data and context */
-  handler: (data: Input, ctx: Ctx) => Promise<Output>; /** Optional schema validator (from @warlock.js/seal). Runs after guards */
-  schema?: ObjectValidator; /** Guards to run before validation. Sequential, can enrich ctx, cannot mutate data */
-  guards?: UseCaseGuard<Input, Ctx>[]; /** Before middleware to run after validation. Sequential, can transform data */
-  before?: UseCaseBeforeMiddleware<Input, Ctx>[]; /** After middleware to run on success. Fire-and-forget, errors are logged not thrown */
-  after?: UseCaseAfterMiddleware<Output, Ctx>[]; /** Lifecycle callback: fires when execution starts (before guards) */
-  onExecuting?: (ctx: UseCaseOnExecutingContext) => void; /** Lifecycle callback: fires on successful completion with full result snapshot */
-  onCompleted?: (result: UseCaseResult<Output>) => void; /** Lifecycle callback: fires on error with error details and execution context */
+export type UseCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseContext> = {
+  /** Unique use case identifier, used for registration, logging, and cache keys */
+  name: string;
+  /** Human-readable description, surfaced in the registry and observability */
+  description?: string;
+  /** Core business logic handler. Receives validated + transformed data and context */
+  handler: (data: Input, ctx: Ctx) => Promise<Output>;
+  /** Optional schema validator (from @warlock.js/seal). Runs after guards */
+  schema?: ObjectValidator;
+  /** Guards to run before validation. Sequential, can enrich ctx, cannot mutate data */
+  guards?: UseCaseGuard<Input, Ctx>[];
+  /** Before middleware to run after validation. Sequential, can transform data */
+  before?: UseCaseBeforeMiddleware<Input, Ctx>[];
+  /** After middleware to run on success. Fire-and-forget, errors are logged not thrown */
+  after?: UseCaseAfterMiddleware<Output, Ctx>[];
+  /** Lifecycle callback: fires when execution starts (before guards) */
+  onExecuting?: (ctx: UseCaseOnExecutingContext) => void;
+  /** Lifecycle callback: fires on successful completion with full result snapshot */
+  onCompleted?: (result: UseCaseResult<Output>) => void;
+  /** Lifecycle callback: fires on error with error details and execution context */
   onError?: (ctx: UseCaseErrorResult) => void;
   /**
    * Retry configuration (from `@mongez/reinforcements`). When set, the **handler**
@@ -178,7 +200,7 @@ type UseCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseCont
  * @template Schema - The schema validator the input is inferred from
  * @template Ctx - The shape of the shared context
  */
-type UseCaseWithSchema<Output, Schema extends ObjectValidator, Ctx extends UseCaseContext = UseCaseContext> = Omit<UseCase<Output, Infer<Schema>, Ctx>, "schema"> & {
+export type UseCaseWithSchema<Output, Schema extends ObjectValidator, Ctx extends UseCaseContext = UseCaseContext> = Omit<UseCase<Output, Infer<Schema>, Ctx>, "schema"> & {
   schema: Schema;
 };
 /**
@@ -188,17 +210,21 @@ type UseCaseWithSchema<Output, Schema extends ObjectValidator, Ctx extends UseCa
  * @template Output - The shape of the handler's return value
  * @template Input - The shape of the input data
  */
-type UseCaseHandler<Output, Input> = ((data: Input, options?: UseCaseRuntimeOptions<Output>) => Promise<Output>) & {
+export type UseCaseHandler<Output, Input> = ((data: Input, options?: UseCaseRuntimeOptions<Output>) => Promise<Output>) & {
   $cleanup: () => void;
 };
 /**
  * A registered use case with call tracking metadata.
  * Created internally when a use case is registered via `useCase()`.
  */
-type RegisteredUseCase<Output = any, Input = any> = UseCase<Output, Input> & {
-  /** Execution call counters */calls: {
-    /** Number of successful executions */success: number; /** Number of failed executions */
-    failed: number; /** Total executions (success + failed) */
+export type RegisteredUseCase<Output = any, Input = any> = UseCase<Output, Input> & {
+  /** Execution call counters */
+  calls: {
+    /** Number of successful executions */
+    success: number;
+    /** Number of failed executions */
+    failed: number;
+    /** Total executions (success + failed) */
     total: number;
   };
 };
@@ -217,19 +243,25 @@ type RegisteredUseCase<Output = any, Input = any> = UseCase<Output, Input> & {
  *
  * @template Output - The shape of the use case output data
  */
-type UseCaseRuntimeOptions<Output = any> = {
-  /** Override the auto-generated execution ID */id?: string; /** Provide a pre-populated context object */
-  ctx?: UseCaseContext; /** Invocation-level lifecycle callback: fires first, before use case and global */
-  onExecuting?: (ctx: UseCaseOnExecutingContext) => void; /** Invocation-level lifecycle callback: fires first on success */
-  onCompleted?: (result: UseCaseResult<Output>) => void; /** Invocation-level lifecycle callback: fires first on error */
+export type UseCaseRuntimeOptions<Output = any> = {
+  /** Override the auto-generated execution ID */
+  id?: string;
+  /** Provide a pre-populated context object */
+  ctx?: UseCaseContext;
+  /** Invocation-level lifecycle callback: fires first, before use case and global */
+  onExecuting?: (ctx: UseCaseOnExecutingContext) => void;
+  /** Invocation-level lifecycle callback: fires first on success */
+  onCompleted?: (result: UseCaseResult<Output>) => void;
+  /** Invocation-level lifecycle callback: fires first on error */
   onError?: (ctx: UseCaseErrorResult) => void;
 };
 /**
  * Error result snapshot, emitted via `onError` lifecycle callbacks.
  * Contains all fields from `UseCaseResult` except `output`, plus the thrown error.
  */
-type UseCaseErrorResult = Omit<UseCaseResult, "output"> & {
-  /** The error that caused the failure */error: Error;
+export type UseCaseErrorResult = Omit<UseCaseResult, "output"> & {
+  /** The error that caused the failure */
+  error: Error;
 };
 /**
  * Success result snapshot, emitted via `onCompleted` lifecycle callbacks
@@ -237,21 +269,35 @@ type UseCaseErrorResult = Omit<UseCaseResult, "output"> & {
  *
  * @template Output - The shape of the handler's return value
  */
-type UseCaseResult<Output = any> = {
-  /** Handler return value (undefined if execution failed) */output?: Output; /** The pipeline context at time of completion */
-  ctx: UseCaseContext; /** Timestamp when execution started */
-  startedAt: Date; /** Timestamp when execution ended */
-  endedAt: Date; /** Unique execution ID */
-  id: string; /** Use case name */
-  name: string; /** Success or failed call count at time of completion (matches the outcome) */
-  calls: number; /** Retry state (present only if retry was configured) */
+export type UseCaseResult<Output = any> = {
+  /** Handler return value (undefined if execution failed) */
+  output?: Output;
+  /** The pipeline context at time of completion */
+  ctx: UseCaseContext;
+  /** Timestamp when execution started */
+  startedAt: Date;
+  /** Timestamp when execution ended */
+  endedAt: Date;
+  /** Unique execution ID */
+  id: string;
+  /** Use case name */
+  name: string;
+  /** Success or failed call count at time of completion (matches the outcome) */
+  calls: number;
+  /** Retry state (present only if retry was configured) */
   retries?: {
-    /** Total allowed attempts (initial try + retries) */attempts: number; /** Delay between attempts in ms */
-    delay?: number; /** Actual retry attempts performed (0 = succeeded on first try) */
+    /** Total allowed attempts (initial try + retries) */
+    attempts: number;
+    /** Delay between attempts in ms */
+    delay?: number;
+    /** Actual retry attempts performed (0 = succeeded on first try) */
     currentRetry: number;
-  }; /** Benchmark result (present only if benchmark was enabled) */
+  };
+  /** Benchmark result (present only if benchmark was enabled) */
   benchmarkResult?: {
-    /** Execution time in milliseconds */latency: number; /** Performance classification */
+    /** Execution time in milliseconds */
+    latency: number;
+    /** Performance classification */
     state: "poor" | "good" | "excellent";
   };
 };
@@ -259,7 +305,7 @@ type UseCaseResult<Output = any> = {
  * Internal registry of global lifecycle event callback arrays.
  * Used by `globalUseCasesEvents` to manage subscriptions.
  */
-type UseCaseEventsCallbacksMap = {
+export type UseCaseEventsCallbacksMap = {
   onExecuting: ((ctx: UseCaseOnExecutingContext) => void)[];
   onCompleted: ((result: UseCaseResult<any>) => void)[];
   onError: ((ctx: UseCaseErrorResult) => void)[];
@@ -279,7 +325,7 @@ type UseCaseEventsCallbacksMap = {
  * } satisfies UseCaseConfigurations;
  * ```
  */
-type UseCaseConfigurations = {
+export type UseCaseConfigurations = {
   /**
    * Default retry for all use cases (from `@mongez/reinforcements`).
    * When set, every use case retries its handler unless it overrides `retry`.
@@ -289,18 +335,25 @@ type UseCaseConfigurations = {
    * Default benchmark setting for all use cases.
    * For standalone benchmark usage, use `config.get("benchmark")` instead.
    */
-  benchmark?: boolean | BenchmarkOptions; /** Broadcast transport — registered channels plus a global kill-switch */
+  benchmark?: boolean | BenchmarkOptions;
+  /** Broadcast transport — registered channels plus a global kill-switch */
   broadcast?: {
-    /** Global on/off — `false` disables broadcasting for every use case */enabled?: boolean; /** Channels every broadcast fans out to */
+    /** Global on/off — `false` disables broadcasting for every use case */
+    enabled?: boolean;
+    /** Channels every broadcast fans out to */
     channels?: UseCaseBroadcastChannel[];
-  }; /** Per-step debug logging through `@warlock.js/logger` (default: false) */
-  log?: boolean; /** Execution history cache settings */
+  };
+  /** Per-step debug logging through `@warlock.js/logger` (default: false) */
+  log?: boolean;
+  /** Execution history cache settings */
   history?: {
-    /** Enable/disable history storage (default: true) */enabled?: boolean; /** Cache TTL in seconds (default: 3600). `false` uses the cache driver default */
-    ttl?: number | false; /** Max history entries kept per use case before oldest are evicted (default: 100) */
+    /** Enable/disable history storage (default: true) */
+    enabled?: boolean;
+    /** Cache TTL in seconds (default: 3600). `false` uses the cache driver default */
+    ttl?: number | false;
+    /** Max history entries kept per use case before oldest are evicted (default: 100) */
     maxEntries?: number;
   };
 };
 //#endregion
-export { RegisteredUseCase, UseCase, UseCaseAfterMiddleware, UseCaseBeforeMiddleware, UseCaseBroadcastChannel, UseCaseBroadcastEvent, UseCaseBroadcastOption, UseCaseConfigurations, UseCaseContext, UseCaseErrorResult, UseCaseEventsCallbacksMap, UseCaseGuard, UseCaseHandler, UseCaseOnExecutingContext, UseCaseResult, UseCaseRuntimeOptions, UseCaseWithSchema };
 //# sourceMappingURL=types.d.mts.map

package/esm/use-cases/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/types.ts"],"mappings":"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"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/types.ts"],"mappings":";;;;;;;;;YASY;EACV,SAAS;IACP;;;;;;;;;;;;;;;;;;;;YAqBQ,aAAa,OAAO,YAAY,iBAAiB,mBAC3D,MAAM,SAAS,QACf,KAAK,eACK;;;;;;;;;;;;;;;;;YAkBA,wBAAwB,OAAO,YAAY,iBAAiB,mBACtE,MAAM,OACN,KAAK,QACF,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;YAmBT,uBAAuB,QAAQ,YAAY,iBAAiB,mBACtE,QAAQ,QACR,KAAK,eACK;;;;;YAMA;;EAEV,KAAK;;EAEL;;EAEA;;EAEA;;EAEA,SAAS;;EAET,WAAW;;;;;;;;YASD;;EAEV;;EAEA;;EAEA;;EAEA,IAAI;;EAEJ;;;;;;;;;;;;;;;iBAgBe;EACf,UAAU,OAAO,+BAA+B;;;;;;;;YAStC,uBAAuB;;EAI7B;;EAEA,UAAU,QAAQ,QAAQ,QAAQ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA6B1C,QAAQ,cAAc,aAAa,YAAY,iBAAiB;;EAE1E;;EAEA;;EAEA,UAAU,MAAM,OAAO,KAAK,QAAQ,QAAQ;;EAE5C,SAAS;;EAET,SAAS,aAAa,OAAO;;EAE7B,SAAS,wBAAwB,OAAO;;EAExC,QAAQ,uBAAuB,QAAQ;;EAEvC,eAAe,KAAK;;EAEpB,eAAe,QAAQ,cAAc;;EAErC,WAAW,KAAK;;;;;EAKhB,QAAQ;;;;;EAKR,sBAAsB;;;;;EAKtB,YAAY,uBAAuB;;;;;;;;;;YAWzB,kBACV,QACA,eAAe,iBACf,YAAY,iBAAiB,kBAC3B,KAAK,QAAQ,QAAQ,MAAM,SAAS;EACtC,QAAQ;;;;;;;;;YAUE,eAAe,QAAQ,WACjC,MAAM,OACN,UAAU,sBAAsB,YAC7B,QAAQ;EACX;;;;;;YAOU,kBAAkB,cAAc,eAAe,QAAQ,QAAQ;;EAEzE;;IAEE;;IAEA;;IAEA;;;;;;;;;;;;;;;;;;YAmBQ,sBAAsB;;EAEhC;;EAEA,MAAM;;EAEN,eAAe,KAAK;;EAEpB,eAAe,QAAQ,cAAc;;EAErC,WAAW,KAAK;;;;;;YAON,qBAAqB,KAAK;;EAEpC,OAAO;;;;;;;;YASG,cAAc;;EAExB,SAAS;;EAET,KAAK;;EAEL,WAAW;;EAEX,SAAS;;EAET;;EAEA;;EAEA;;EAEA;;IAEE;;IAEA;;IAEA;;;EAGF;;IAEE;;IAEA;;;;;;;YAQQ;EACV,eAAe,KAAK;EACpB,eAAe,QAAQ;EACvB,WAAW,KAAK;;;;;;;;;;;;;;;;;YAkBN;;;;;EAKV,QAAQ;;;;;EAKR,sBAAsB;;EAEtB;;IAEE;;IAEA,WAAW;;;EAGb;;EAEA;;IAEE;;IAEA;;IAEA"}

package/esm/use-cases/use-case-broadcast.d.mts

@@ -1,5 +1,4 @@
 import { UseCaseBroadcastOption, UseCaseConfigurations, UseCaseResult } from "./types.mjs";
-
 //#region ../../packages/core/src/use-cases/use-case-broadcast.d.ts
 /**
  * Broadcast a successful use-case result through the globally-configured channels.
@@ -11,7 +10,7 @@ import { UseCaseBroadcastOption, UseCaseConfigurations, UseCaseResult } from "./
  * @example
  * await broadcastUseCaseResult({ name, id, output, result, broadcast, config });
  */
-declare function broadcastUseCaseResult<Output>(params: {
+export declare function broadcastUseCaseResult<Output>(params: {
   name: string;
   id: string;
   output: Output;
@@ -20,5 +19,4 @@ declare function broadcastUseCaseResult<Output>(params: {
   config?: UseCaseConfigurations["broadcast"];
 }): Promise<void>;
 //#endregion
-export { broadcastUseCaseResult };
 //# sourceMappingURL=use-case-broadcast.d.mts.map

package/esm/use-cases/use-case-broadcast.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-broadcast.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case-broadcast.ts"],"mappings":";;;;;AAkBA;;;;;;;;iBAAsB,sBAAA,SAA+B,MAAA;EACnD,IAAA;EACA,EAAA;EACA,MAAA,EAAQ,MAAA;EACR,MAAA,EAAQ,aAAA,CAAc,MAAA;EACtB,SAAA,GAAY,sBAAA,CAAuB,MAAA;EACnC,MAAA,GAAS,qBAAA;AAAA,IACP,OAAA"}
+{"version":3,"file":"use-case-broadcast.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case-broadcast.ts"],"mappings":";;;;;;;;;;;;wBAkBsB,uBAAuB,QAAQ;EACnD;EACA;EACA,QAAQ;EACR,QAAQ,cAAc;EACtB,YAAY,uBAAuB;EACnC,SAAS;IACP"}

package/esm/use-cases/use-case-events.d.mts

@@ -1,10 +1,9 @@
 import { UseCaseErrorResult, UseCaseEventsCallbacksMap, UseCaseOnExecutingContext, UseCaseResult } from "./types.mjs";
-
 //#region ../../packages/core/src/use-cases/use-case-events.d.ts
 /**
  * Global event callbacks — shared across all use case instances.
  */
-declare const globalEventsCallbacksMap: UseCaseEventsCallbacksMap;
+export declare const globalEventsCallbacksMap: UseCaseEventsCallbacksMap;
 /**
  * Subscribe to lifecycle events fired by any use case.
  *
@@ -12,7 +11,7 @@ declare const globalEventsCallbacksMap: UseCaseEventsCallbacksMap;
  * globalUseCasesEvents.onCompleted((result) => metrics.track(result.name, result.benchmarkResult));
  * globalUseCasesEvents.onError((ctx) => logger.error(ctx.name, ctx.error));
  */
-declare const globalUseCasesEvents: {
+export declare const globalUseCasesEvents: {
   onExecuting(callback: (ctx: UseCaseOnExecutingContext) => void): {
     unsubscribe: () => void;
   };
@@ -30,11 +29,10 @@ declare const globalUseCasesEvents: {
  * observer can't stall the others, and a throwing one can't break the pipeline (e.g.
  * a successful use case must not fail because a metrics/broadcast observer threw).
  */
-declare function fireLifecycleEvent<EventCtx>(ctx: EventCtx, observers: {
+export declare function fireLifecycleEvent<EventCtx>(ctx: EventCtx, observers: {
   invocation?: ((ctx: EventCtx) => void | Promise<void>)[];
   useCase?: ((ctx: EventCtx) => void | Promise<void>)[];
   global?: ((ctx: EventCtx) => void | Promise<void>)[];
 }): Promise<void>;
 //#endregion
-export { fireLifecycleEvent, globalEventsCallbacksMap, globalUseCasesEvents };
 //# sourceMappingURL=use-case-events.d.mts.map

package/esm/use-cases/use-case-events.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-events.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case-events.ts"],"mappings":";;;;;AAWA;cAAa,wBAAA,EAA0B,yBAItC;;;AAAA;AASD;;;;cAAa,oBAAA;yBACY,GAAA,EAAK,yBAAA;;;sBASV,QAAA,GAAa,MAAA,EAAQ,aAAA,CAAc,MAAA;;;qBASlC,GAAA,EAAK,kBAAA;;;;;;;;;;;iBAkBJ,kBAAA,WACpB,GAAA,EAAK,QAAA,EACL,SAAA;EACE,UAAA,KAAe,GAAA,EAAK,QAAA,YAAoB,OAAA;EACxC,OAAA,KAAY,GAAA,EAAK,QAAA,YAAoB,OAAA;EACrC,MAAA,KAAW,GAAA,EAAK,QAAA,YAAoB,OAAA;AAAA,IACrC,OAAA"}
+{"version":3,"file":"use-case-events.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case-events.ts"],"mappings":";;;;;qBAWa,0BAA0B;;;;;;;;qBAa1B;EACX,YAAW,WAAY,KAAK;IAGxB;;EAMJ,YAAY,QAAM,WAAa,QAAQ,cAAc;IAGjD;;EAMJ,QAAO,WAAY,KAAK;IAGpB;;;;;;;;;;wBAegB,mBAAmB,UACvC,KAAK,UACL;EACE,eAAe,KAAK,oBAAoB;EACxC,YAAY,KAAK,oBAAoB;EACrC,WAAW,KAAK,oBAAoB;IACrC"}

package/esm/use-cases/use-case-pipeline.d.mts

@@ -1,8 +1,7 @@
 import { UseCaseBeforeMiddleware, UseCaseContext, UseCaseGuard, UseCaseOnExecutingContext } from "./types.mjs";
 import { ObjectValidator } from "@warlock.js/seal";
-
 //#region ../../packages/core/src/use-cases/use-case-pipeline.d.ts
-type PipelineOptions<Input> = {
+export type PipelineOptions<Input> = {
   name: string;
   id: string;
   data: Input;
@@ -10,8 +9,10 @@ type PipelineOptions<Input> = {
   startedAt: Date;
   schema?: ObjectValidator;
   guards?: UseCaseGuard<Input>[];
-  before?: UseCaseBeforeMiddleware<Input>[]; /** Invocation-level onExecuting override */
-  onExecuting?: (ctx: UseCaseOnExecutingContext) => void; /** Use-case-level onExecuting */
+  before?: UseCaseBeforeMiddleware<Input>[];
+  /** Invocation-level onExecuting override */
+  onExecuting?: (ctx: UseCaseOnExecutingContext) => void;
+  /** Use-case-level onExecuting */
   ucOnExecuting?: (ctx: UseCaseOnExecutingContext) => void;
 };
 /**
@@ -27,7 +28,6 @@ type PipelineOptions<Input> = {
  * @example
  * const data = await runPipeline({ name, id, data, ctx, startedAt, schema, guards, before });
  */
-declare function runPipeline<Input>(opts: PipelineOptions<Input>): Promise<Input>;
+export declare function runPipeline<Input>(opts: PipelineOptions<Input>): Promise<Input>;
 //#endregion
-export { PipelineOptions, runPipeline };
 //# sourceMappingURL=use-case-pipeline.d.mts.map

package/esm/use-cases/use-case-pipeline.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-pipeline.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case-pipeline.ts"],"mappings":";;;;KAWY,eAAA;EACV,IAAA;EACA,EAAA;EACA,IAAA,EAAM,KAAA;EACN,GAAA,EAAK,cAAA;EACL,SAAA,EAAW,IAAA;EACX,MAAA,GAAS,eAAA;EACT,MAAA,GAAS,YAAA,CAAa,KAAA;EACtB,MAAA,GAAS,uBAAA,CAAwB,KAAA,KADX;EAGtB,WAAA,IAAe,GAAA,EAAK,yBAAA,WAFa;EAIjC,aAAA,IAAiB,GAAA,EAAK,yBAAA;AAAA;;;;;;;;;;;;;;iBAgBF,WAAA,QAAmB,IAAA,EAAM,eAAA,CAAgB,KAAA,IAAS,OAAA,CAAQ,KAAA"}
+{"version":3,"file":"use-case-pipeline.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case-pipeline.ts"],"mappings":";;;YAWY,gBAAgB;EAC1B;EACA;EACA,MAAM;EACN,KAAK;EACL,WAAW;EACX,SAAS;EACT,SAAS,aAAa;EACtB,SAAS,wBAAwB;;EAEjC,eAAe,KAAK;;EAEpB,iBAAiB,KAAK;;;;;;;;;;;;;;;wBAgBF,YAAY,OAAO,MAAM,gBAAgB,SAAS,QAAQ"}

package/esm/use-cases/use-case.d.mts

@@ -1,6 +1,5 @@
 import { UseCase, UseCaseContext, UseCaseHandler, UseCaseWithSchema } from "./types.mjs";
 import { Infer, ObjectValidator } from "@warlock.js/seal";
-
 //#region ../../packages/core/src/use-cases/use-case.d.ts
 /**
  * Defines and registers a use case.
@@ -28,8 +27,7 @@ import { Infer, ObjectValidator } from "@warlock.js/seal";
  * // In a controller:
  * const output = await createOrderUseCase({ ...validated, user_id: req.user.id });
  */
-declare function useCase<Output, Schema extends ObjectValidator, Ctx extends UseCaseContext = UseCaseContext>(options: UseCaseWithSchema<Output, Schema, Ctx>): UseCaseHandler<Output, Infer<Schema>>;
-declare function useCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseContext>(options: UseCase<Output, Input, Ctx>): UseCaseHandler<Output, Input>;
+export declare function useCase<Output, Schema extends ObjectValidator, Ctx extends UseCaseContext = UseCaseContext>(options: UseCaseWithSchema<Output, Schema, Ctx>): UseCaseHandler<Output, Infer<Schema>>;
+export declare function useCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseContext>(options: UseCase<Output, Input, Ctx>): UseCaseHandler<Output, Input>;
 //#endregion
-export { useCase };
 //# sourceMappingURL=use-case.d.mts.map

package/esm/use-cases/use-case.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case.ts"],"mappings":";;;;;;AAwDA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,OAAA,wBAEC,eAAA,cACH,cAAA,GAAiB,cAAA,EAC7B,OAAA,EAAS,iBAAA,CAAkB,MAAA,EAAQ,MAAA,EAAQ,GAAA,IAAO,cAAA,CAAe,MAAA,EAAQ,KAAA,CAAM,MAAA;AAAA,iBACjE,OAAA,wCAA+C,cAAA,GAAiB,cAAA,EAC9E,OAAA,EAAS,OAAA,CAAQ,MAAA,EAAQ,KAAA,EAAO,GAAA,IAC/B,cAAA,CAAe,MAAA,EAAQ,KAAA"}
+{"version":3,"file":"use-case.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwDgB,QACd,QACA,eAAe,iBACf,YAAY,iBAAiB,gBAC7B,SAAS,kBAAkB,QAAQ,QAAQ,OAAO,eAAe,QAAQ,MAAM;wBACjE,QAAQ,cAAc,aAAa,YAAY,iBAAiB,gBAC9E,SAAS,QAAQ,QAAQ,OAAO,OAC/B,eAAe,QAAQ"}

package/esm/use-cases/use-case.errors.d.mts

@@ -1,10 +1,8 @@
 import { HttpError } from "../http/errors/errors.mjs";
 import { ValidationResult } from "@warlock.js/seal";
-
 //#region ../../packages/core/src/use-cases/use-case.errors.d.ts
-declare class BadSchemaUseCaseError extends HttpError {
+export declare class BadSchemaUseCaseError extends HttpError {
   constructor(result: ValidationResult);
 }
 //#endregion
-export { BadSchemaUseCaseError };
 //# sourceMappingURL=use-case.errors.d.mts.map

package/esm/use-cases/use-case.errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case.errors.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case.errors.ts"],"mappings":";;;;cAGa,qBAAA,SAA8B,SAAS;cAC/B,MAAA,EAAQ,gBAAA;AAAA"}
+{"version":3,"file":"use-case.errors.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-case.errors.ts"],"mappings":";;;qBAGa,8BAA8B;EACzC,YAAmB,QAAQ"}

package/esm/use-cases/use-cases-registry.d.mts

@@ -1,10 +1,9 @@
 import { RegisteredUseCase, UseCaseResult } from "./types.mjs";
-
 //#region ../../packages/core/src/use-cases/use-cases-registry.d.ts
 /**
  * Register a use case
  */
-declare function $registerUseCase<Output, Input>(name: string, useCase: RegisteredUseCase<Output, Input>): void;
+export declare function $registerUseCase<Output, Input>(name: string, useCase: RegisteredUseCase<Output, Input>): void;
 /**
  * Unregister a use case.
  *
@@ -12,7 +11,7 @@ declare function $registerUseCase<Output, Input>(name: string, useCase: Register
  * async cache removal is fire-and-forget with a `.catch` guard — a rejecting cache
  * driver must never turn cleanup into an unhandled rejection.
  */
-declare function $unregisterUseCase(name: string): void;
+export declare function $unregisterUseCase(name: string): void;
 /**
  * Get a use case.
  *
@@ -20,30 +19,29 @@ declare function $unregisterUseCase(name: string): void;
  * the registry actually stores — so consumers can read call stats without an
  * ad-hoc cast.
  */
-declare function getUseCase<Output, Input>(name: string): RegisteredUseCase<Output, Input> | undefined;
+export declare function getUseCase<Output, Input>(name: string): RegisteredUseCase<Output, Input> | undefined;
 /**
  * Get all use cases
  */
-declare function getUseCases(): Map<string, RegisteredUseCase>;
+export declare function getUseCases(): Map<string, RegisteredUseCase>;
 /**
  * Increase use case success calls
  */
-declare function increaseUseCaseSuccessCalls(name: string): number;
+export declare function increaseUseCaseSuccessCalls(name: string): number;
 /**
  * Increase use case failed calls
  */
-declare function increaseUseCaseFailedCalls(name: string): number;
+export declare function increaseUseCaseFailedCalls(name: string): number;
 /**
  * Get use case history from cache.
  *
  * Prunes ids whose entries have expired so the list can't accumulate dead refs.
  */
-declare function getUseCaseHistory(name: string): Promise<UseCaseResult<any>[]>;
+export declare function getUseCaseHistory(name: string): Promise<UseCaseResult<any>[]>;
 /**
  * Add use case history to cache, capping the per-use-case list so it can't grow
  * unbounded — oldest entries (and their ids) are evicted past MAX_HISTORY_ENTRIES.
  */
-declare function addUseCaseHistory(name: string, result: UseCaseResult<any>): Promise<void>;
+export declare function addUseCaseHistory(name: string, result: UseCaseResult<any>): Promise<void>;
 //#endregion
-export { $registerUseCase, $unregisterUseCase, addUseCaseHistory, getUseCase, getUseCaseHistory, getUseCases, increaseUseCaseFailedCalls, increaseUseCaseSuccessCalls };
 //# sourceMappingURL=use-cases-registry.d.mts.map

package/esm/use-cases/use-cases-registry.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-cases-registry.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-cases-registry.ts"],"mappings":";;;;;AAaA;iBAAgB,gBAAA,gBACd,IAAA,UACA,OAAA,EAAS,iBAAA,CAAkB,MAAA,EAAQ,KAAA;;;;;;;;iBAgBrB,kBAAA,CAAmB,IAAY;;;;;;;AAhBJ;iBA+B3B,UAAA,gBAA0B,IAAA,WACJ,iBAAA,CAAkB,MAAA,EAAQ,KAAA;;;;iBAMhD,WAAA,IAAW,GAAA,SAAA,iBAAA;AAP3B;;;AAAA,iBAcgB,2BAAA,CAA4B,IAAY;;;;iBAexC,0BAAA,CAA2B,IAAY;;;;;;iBA2BjC,iBAAA,CAAkB,IAAA,WAAe,OAAO,CAAC,aAAA;;AAvDM;AAMrE;;iBA+EsB,iBAAA,CAAkB,IAAA,UAAc,MAAA,EAAQ,aAAA,QAAkB,OAAA"}
+{"version":3,"file":"use-cases-registry.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-cases-registry.ts"],"mappings":";;;;;wBAagB,iBAAiB,QAAQ,OACvC,cACA,SAAS,kBAAkB,QAAQ;;;;;;;;wBAgBrB,mBAAmB;;;;;;;;wBAenB,WAAW,QAAQ,OAAO,eACJ,kBAAkB,QAAQ;;;;wBAMhD,eAAW,YAAA;;;;wBAOX,4BAA4B;;;;wBAe5B,2BAA2B;;;;;;wBA2BrB,kBAAkB,eAAe,QAAQ;;;;;wBA8BzC,kBAAkB,cAAc,QAAQ,qBAAkB"}

package/esm/use-cases/use-cases-registry.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-cases-registry.mjs","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-cases-registry.ts"],"sourcesContent":["import { cache } from \"@warlock.js/cache\";\nimport { log } from \"@warlock.js/logger\";\nimport { config } from \"../config\";\nimport { type RegisteredUseCase, type UseCaseConfigurations, type UseCaseResult } from \"./types\";\n\n/**\n * Store registered use cases\n */\nconst useCaseRegister = new Map<string, RegisteredUseCase>();\n\n/**\n * Register a use case\n */\nexport function $registerUseCase<Output, Input>(\n  name: string,\n  useCase: RegisteredUseCase<Output, Input>,\n) {\n  if (useCaseRegister.has(name) && process.env.NODE_ENV !== \"production\") {\n    log.warn(\"use-cases\", \"registering\", `Use case \"${name}\" is already registered. Overwriting.`);\n  }\n\n  useCaseRegister.set(name, useCase);\n}\n\n/**\n * Unregister a use case.\n *\n * Dropping the history namespace is best-effort: `$cleanup` is synchronous, so the\n * async cache removal is fire-and-forget with a `.catch` guard — a rejecting cache\n * driver must never turn cleanup into an unhandled rejection.\n */\nexport function $unregisterUseCase(name: string) {\n  useCaseRegister.delete(name);\n\n  Promise.resolve(cache.removeNamespace(`use-case:history:${name}`)).catch((error) => {\n    log.error(\"use-cases\", name, \"history namespace removal failed\", { error });\n  });\n}\n\n/**\n * Get a use case.\n *\n * Returns the `RegisteredUseCase` shape — including the runtime `calls` counters\n * the registry actually stores — so consumers can read call stats without an\n * ad-hoc cast.\n */\nexport function getUseCase<Output, Input>(name: string) {\n  return useCaseRegister.get(name) as RegisteredUseCase<Output, Input> | undefined;\n}\n\n/**\n * Get all use cases\n */\nexport function getUseCases() {\n  return useCaseRegister;\n}\n\n/**\n * Increase use case success calls\n */\nexport function increaseUseCaseSuccessCalls(name: string): number {\n  const useCase = useCaseRegister.get(name);\n  if (useCase) {\n    useCase.calls.success++;\n    useCase.calls.total++;\n\n    return useCase.calls.success;\n  }\n\n  return 0;\n}\n\n/**\n * Increase use case failed calls\n */\nexport function increaseUseCaseFailedCalls(name: string): number {\n  const useCase = useCaseRegister.get(name);\n  if (useCase) {\n    useCase.calls.failed++;\n    useCase.calls.total++;\n\n    return useCase.calls.failed;\n  }\n\n  return 0;\n}\n\n/**\n * Resolve the history cache TTL (seconds) from config.\n * `false` means \"use the cache driver's default\", represented as `undefined`.\n */\nfunction resolveHistoryTtl(useCaseConfig?: UseCaseConfigurations): number | undefined {\n  const ttlConfig = useCaseConfig?.history?.ttl ?? 3600; // 1 hour default\n\n  return ttlConfig === false ? undefined : ttlConfig;\n}\n\n/**\n * Get use case history from cache.\n *\n * Prunes ids whose entries have expired so the list can't accumulate dead refs.\n */\nexport async function getUseCaseHistory(name: string): Promise<UseCaseResult<any>[]> {\n  const listKey = `use-case:history:${name}:list`;\n  const ids = (await cache.get<string[]>(listKey)) || [];\n\n  const entries = await Promise.all(\n    ids.map(async (id: string) => ({\n      id,\n      result: await cache.get<UseCaseResult<any>>(`use-case:history:${name}:${id}`),\n    })),\n  );\n\n  const liveEntries = entries.filter((entry) => Boolean(entry.result));\n\n  if (liveEntries.length !== ids.length) {\n    const useCaseConfig = config.get<UseCaseConfigurations>(\"use-cases\");\n\n    await cache.set(\n      listKey,\n      liveEntries.map((entry) => entry.id),\n      resolveHistoryTtl(useCaseConfig),\n    );\n  }\n\n  return liveEntries.map((entry) => entry.result) as UseCaseResult<any>[];\n}\n\n/**\n * Add use case history to cache, capping the per-use-case list so it can't grow\n * unbounded — oldest entries (and their ids) are evicted past MAX_HISTORY_ENTRIES.\n */\nexport async function addUseCaseHistory(name: string, result: UseCaseResult<any>) {\n  const useCaseConfig = config.get<UseCaseConfigurations>(\"use-cases\");\n\n  // On by default outside production; opt in to production with `history.enabled: true`.\n  const enabled = useCaseConfig?.history?.enabled ?? process.env.NODE_ENV !== \"production\";\n\n  if (!enabled) return;\n\n  const previous = historyWrites.get(name) ?? Promise.resolve();\n  const current = previous.catch(() => undefined).then(() => writeHistory(name, result));\n\n  historyWrites.set(name, current);\n\n  try {\n    await current;\n  } finally {\n    if (historyWrites.get(name) === current) {\n      historyWrites.delete(name);\n    }\n  }\n}\n\n/**\n * Per-use-case write chain so the list read-modify-write never interleaves\n * within a process (keeps the cap enforced under concurrency).\n */\nconst historyWrites = new Map<string, Promise<unknown>>();\n\nasync function writeHistory(name: string, result: UseCaseResult<any>) {\n  const useCaseConfig = config.get<UseCaseConfigurations>(\"use-cases\");\n  const ttl = resolveHistoryTtl(useCaseConfig);\n  const maxEntries = useCaseConfig?.history?.maxEntries ?? 100;\n  const key = `use-case:history:${name}:${result.id}`;\n  const listKey = `use-case:history:${name}:list`;\n\n  // Store a projection only: `output` and `ctx` (tokens, payloads) never reach the cache.\n  const projection = { ...result, output: undefined, ctx: undefined } as unknown as UseCaseResult<any>;\n\n  await cache.set(key, projection, ttl);\n\n  const list = (await cache.get<string[]>(listKey)) || [];\n\n  list.push(result.id);\n\n  while (list.length > maxEntries) {\n    const evictedId = list.shift();\n\n    if (evictedId) {\n      await cache.remove(`use-case:history:${name}:${evictedId}`);\n    }\n  }\n\n  await cache.set(listKey, list, ttl);\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-cases-registry.mjs","names":[],"sources":["../../../../../../../../packages/core/src/use-cases/use-cases-registry.ts"],"sourcesContent":["import { cache } from \"@warlock.js/cache\";\nimport { log } from \"@warlock.js/logger\";\nimport { config } from \"../config\";\nimport { type RegisteredUseCase, type UseCaseConfigurations, type UseCaseResult } from \"./types\";\n\n/**\n * Store registered use cases\n */\nconst useCaseRegister = new Map<string, RegisteredUseCase>();\n\n/**\n * Register a use case\n */\nexport function $registerUseCase<Output, Input>(\n  name: string,\n  useCase: RegisteredUseCase<Output, Input>,\n) {\n  if (useCaseRegister.has(name) && process.env.NODE_ENV !== \"production\") {\n    log.warn(\"use-cases\", \"registering\", `Use case \"${name}\" is already registered. Overwriting.`);\n  }\n\n  useCaseRegister.set(name, useCase);\n}\n\n/**\n * Unregister a use case.\n *\n * Dropping the history namespace is best-effort: `$cleanup` is synchronous, so the\n * async cache removal is fire-and-forget with a `.catch` guard — a rejecting cache\n * driver must never turn cleanup into an unhandled rejection.\n */\nexport function $unregisterUseCase(name: string) {\n  useCaseRegister.delete(name);\n\n  Promise.resolve(cache.removeNamespace(`use-case:history:${name}`)).catch((error) => {\n    log.error(\"use-cases\", name, \"history namespace removal failed\", { error });\n  });\n}\n\n/**\n * Get a use case.\n *\n * Returns the `RegisteredUseCase` shape — including the runtime `calls` counters\n * the registry actually stores — so consumers can read call stats without an\n * ad-hoc cast.\n */\nexport function getUseCase<Output, Input>(name: string) {\n  return useCaseRegister.get(name) as RegisteredUseCase<Output, Input> | undefined;\n}\n\n/**\n * Get all use cases\n */\nexport function getUseCases() {\n  return useCaseRegister;\n}\n\n/**\n * Increase use case success calls\n */\nexport function increaseUseCaseSuccessCalls(name: string): number {\n  const useCase = useCaseRegister.get(name);\n  if (useCase) {\n    useCase.calls.success++;\n    useCase.calls.total++;\n\n    return useCase.calls.success;\n  }\n\n  return 0;\n}\n\n/**\n * Increase use case failed calls\n */\nexport function increaseUseCaseFailedCalls(name: string): number {\n  const useCase = useCaseRegister.get(name);\n  if (useCase) {\n    useCase.calls.failed++;\n    useCase.calls.total++;\n\n    return useCase.calls.failed;\n  }\n\n  return 0;\n}\n\n/**\n * Resolve the history cache TTL (seconds) from config.\n * `false` means \"use the cache driver's default\", represented as `undefined`.\n */\nfunction resolveHistoryTtl(useCaseConfig?: UseCaseConfigurations): number | undefined {\n  const ttlConfig = useCaseConfig?.history?.ttl ?? 3600; // 1 hour default\n\n  return ttlConfig === false ? undefined : ttlConfig;\n}\n\n/**\n * Get use case history from cache.\n *\n * Prunes ids whose entries have expired so the list can't accumulate dead refs.\n */\nexport async function getUseCaseHistory(name: string): Promise<UseCaseResult<any>[]> {\n  const listKey = `use-case:history:${name}:list`;\n  const ids = (await cache.get<string[]>(listKey)) || [];\n\n  const entries = await Promise.all(\n    ids.map(async (id: string) => ({\n      id,\n      result: await cache.get<UseCaseResult<any>>(`use-case:history:${name}:${id}`),\n    })),\n  );\n\n  const liveEntries = entries.filter((entry) => Boolean(entry.result));\n\n  if (liveEntries.length !== ids.length) {\n    const useCaseConfig = config.get<UseCaseConfigurations>(\"use-cases\");\n\n    await cache.set(\n      listKey,\n      liveEntries.map((entry) => entry.id),\n      resolveHistoryTtl(useCaseConfig),\n    );\n  }\n\n  return liveEntries.map((entry) => entry.result) as UseCaseResult<any>[];\n}\n\n/**\n * Add use case history to cache, capping the per-use-case list so it can't grow\n * unbounded — oldest entries (and their ids) are evicted past MAX_HISTORY_ENTRIES.\n */\nexport async function addUseCaseHistory(name: string, result: UseCaseResult<any>) {\n  const useCaseConfig = config.get<UseCaseConfigurations>(\"use-cases\");\n\n  // On by default outside production; opt in to production with `history.enabled: true`.\n  const enabled = useCaseConfig?.history?.enabled ?? process.env.NODE_ENV !== \"production\";\n\n  if (!enabled) return;\n\n  const previous = historyWrites.get(name) ?? Promise.resolve();\n  const current = previous.catch(() => undefined).then(() => writeHistory(name, result));\n\n  historyWrites.set(name, current);\n\n  try {\n    await current;\n  } finally {\n    if (historyWrites.get(name) === current) {\n      historyWrites.delete(name);\n    }\n  }\n}\n\n/**\n * Per-use-case write chain so the list read-modify-write never interleaves\n * within a process (keeps the cap enforced under concurrency).\n */\nconst historyWrites = new Map<string, Promise<unknown>>();\n\nasync function writeHistory(name: string, result: UseCaseResult<any>) {\n  const useCaseConfig = config.get<UseCaseConfigurations>(\"use-cases\");\n  const ttl = resolveHistoryTtl(useCaseConfig);\n  const maxEntries = useCaseConfig?.history?.maxEntries ?? 100;\n  const key = `use-case:history:${name}:${result.id}`;\n  const listKey = `use-case:history:${name}:list`;\n\n  // Store a projection only: `output` and `ctx` (tokens, payloads) never reach the cache.\n  const projection = {\n    ...result,\n    output: undefined,\n    ctx: undefined,\n  } as unknown as UseCaseResult<any>;\n\n  await cache.set(key, projection, ttl);\n\n  const list = (await cache.get<string[]>(listKey)) || [];\n\n  list.push(result.id);\n\n  while (list.length > maxEntries) {\n    const evictedId = list.shift();\n\n    if (evictedId) {\n      await cache.remove(`use-case:history:${name}:${evictedId}`);\n    }\n  }\n\n  await cache.set(listKey, list, ttl);\n}\n"],"mappings":"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"}

package/esm/utils/app-log.d.mts

@@ -1,5 +1,5 @@
 //#region ../../packages/core/src/utils/app-log.d.ts
-declare const appLog: {
+export declare const appLog: {
   info: (module: string, message: string) => import("@warlock.js/logger").Logger;
   error: (module: string, message: string) => import("@warlock.js/logger").Logger;
   warn: (module: string, message: string) => import("@warlock.js/logger").Logger;
@@ -7,5 +7,4 @@ declare const appLog: {
   success: (module: string, message: string) => import("@warlock.js/logger").Logger;
 };
 //#endregion
-export { appLog };
 //# sourceMappingURL=app-log.d.mts.map

package/esm/utils/app-log.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"app-log.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/app-log.ts"],"mappings":";cAEa,MAAA;yBACU,OAAA,0CAAiB,MAAA;0BAChB,OAAA,0CAAiB,MAAA;yBAClB,OAAA,0CAAiB,MAAA;0BAChB,OAAA,0CAAiB,MAAA;4BACf,OAAA,0CAAiB,MAAA;AAAA"}
+{"version":3,"file":"app-log.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/app-log.ts"],"mappings":";qBAEa;EACX,OAAI,gBAAiB,iDAAiB;EACtC,QAAK,gBAAiB,iDAAiB;EACvC,OAAI,gBAAiB,iDAAiB;EACtC,QAAK,gBAAiB,iDAAiB;EACvC,UAAO,gBAAiB,iDAAiB"}