@orchestr-sh/orchestr 1.10.0 → 1.11.0

package/dist/Facades/Config.d.cts

@@ -0,0 +1,20 @@
+import { Config as Config$1 } from "../Foundation/Config/Config.cjs";
+import { Facade } from "../Support/Facade.cjs";
+
+//#region src/Facades/Config.d.ts
+/**
+ * Config Facade - Static access to configuration
+ * Illuminate\Support\Facades\Config
+ *
+ * @example
+ * Config.get('app.name')
+ * Config.set('app.debug', true)
+ * Config.has('database.connections.mysql')
+ */
+declare class ConfigFacade extends Facade {
+  protected static getFacadeAccessor(): string;
+}
+declare const Config: typeof ConfigFacade & Config$1;
+//#endregion
+export { Config };
+//# sourceMappingURL=Config.d.cts.map

package/dist/Facades/Config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.cts","names":[],"sources":["../../src/Facades/Config.ts"],"mappings":";;;;;;AAC0C;;;;;AAkB1C;;cAPM,YAAA,SAAqB,MAAA;EAAA,iBACR,iBAAA,CAAA;AAAA;AAAA,cAMN,MAAA,SAAgC,YAAA,GAAe,QAAA"}

package/dist/Facades/Config.d.mts

@@ -0,0 +1,20 @@
+import { Config as Config$1 } from "../Foundation/Config/Config.mjs";
+import { Facade } from "../Support/Facade.mjs";
+
+//#region src/Facades/Config.d.ts
+/**
+ * Config Facade - Static access to configuration
+ * Illuminate\Support\Facades\Config
+ *
+ * @example
+ * Config.get('app.name')
+ * Config.set('app.debug', true)
+ * Config.has('database.connections.mysql')
+ */
+declare class ConfigFacade extends Facade {
+  protected static getFacadeAccessor(): string;
+}
+declare const Config: typeof ConfigFacade & Config$1;
+//#endregion
+export { Config };
+//# sourceMappingURL=Config.d.mts.map

package/dist/Facades/Config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.mts","names":[],"sources":["../../src/Facades/Config.ts"],"mappings":";;;;;;AAC0C;;;;;AAkB1C;;cAPM,YAAA,SAAqB,MAAA;EAAA,iBACR,iBAAA,CAAA;AAAA;AAAA,cAMN,MAAA,SAAgC,YAAA,GAAe,QAAA"}

package/dist/Facades/Config.mjs

@@ -0,0 +1,2 @@
+import{Facade as e}from"../Support/Facade.mjs";const t=class extends e{static getFacadeAccessor(){return`config`}};export{t as Config};
+//# sourceMappingURL=Config.mjs.map

package/dist/Facades/Config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.mjs","names":[],"sources":["../../src/Facades/Config.ts"],"sourcesContent":["import type { Config as ConfigClass } from '@/Foundation/Config/Config';\nimport { Facade } from '@/Support/Facade';\n\n/**\n * Config Facade - Static access to configuration\n * Illuminate\\Support\\Facades\\Config\n *\n * @example\n * Config.get('app.name')\n * Config.set('app.debug', true)\n * Config.has('database.connections.mysql')\n */\nclass ConfigFacade extends Facade {\n  protected static getFacadeAccessor(): string {\n    return 'config';\n  }\n}\n\n// Export facade with proper typing\nexport const Config = ConfigFacade as typeof ConfigFacade & ConfigClass;\n"],"mappings":"+CAmBA,MAAa,EAPb,cAA2B,CAAO,CAChC,OAAiB,mBAA4B,CAC3C,MAAO"}

package/dist/Facades/DB.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);const e=require(`../Support/Facade.cjs`);var t=class extends e.Facade{static getFacadeAccessor(){return`db`}};const n=new Proxy(t,{get(e,t){let n=e.getFacadeRoot();if(!n)throw Error(`DB Facade: Database manager not found in container. Did you register DatabaseServiceProvider?`);if(n&&typeof n[t]==`function`)return(...e)=>n[t](...e);if(n&&t in n)return n[t];if(t===`table`)return e=>n.connection().table(e);let r=n.connection();return r&&typeof r[t]==`function`?(...e)=>r[t](...e):r?.[t]}});exports.DB=n;

package/dist/Facades/DB.d.cts

@@ -0,0 +1,10 @@
+//#region src/Facades/DB.d.ts
+/**
+ * DB Facade
+ *
+ * Provides static access to the DatabaseManager
+ */
+declare const DB: any;
+//#endregion
+export { DB };
+//# sourceMappingURL=DB.d.cts.map

package/dist/Facades/DB.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DB.d.cts","names":[],"sources":["../../src/Facades/DB.ts"],"mappings":";;AAgBA;;;;cAAa,EAAA"}

package/dist/Facades/DB.d.mts

@@ -0,0 +1,10 @@
+//#region src/Facades/DB.d.ts
+/**
+ * DB Facade
+ *
+ * Provides static access to the DatabaseManager
+ */
+declare const DB: any;
+//#endregion
+export { DB };
+//# sourceMappingURL=DB.d.mts.map

package/dist/Facades/DB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DB.d.mts","names":[],"sources":["../../src/Facades/DB.ts"],"mappings":";;AAgBA;;;;cAAa,EAAA"}

package/dist/Facades/DB.mjs

@@ -0,0 +1,2 @@
+import{Facade as e}from"../Support/Facade.mjs";const t=new Proxy(class extends e{static getFacadeAccessor(){return`db`}},{get(e,t){let n=e.getFacadeRoot();if(!n)throw Error(`DB Facade: Database manager not found in container. Did you register DatabaseServiceProvider?`);if(n&&typeof n[t]==`function`)return(...e)=>n[t](...e);if(n&&t in n)return n[t];if(t===`table`)return e=>n.connection().table(e);let r=n.connection();return r&&typeof r[t]==`function`?(...e)=>r[t](...e):r?.[t]}});export{t as DB};
+//# sourceMappingURL=DB.mjs.map

package/dist/Facades/DB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DB.mjs","names":[],"sources":["../../src/Facades/DB.ts"],"sourcesContent":["/**\n * DB Facade\n *\n * Provides static access to the DatabaseManager\n */\n\nimport { DatabaseManager } from '@/Database/DatabaseManager';\nimport { Facade } from '@/Support/Facade';\n\nclass DBFacade extends Facade {\n  protected static getFacadeAccessor(): string {\n    return 'db';\n  }\n}\n\n// Create proxy for static method access\nexport const DB = new Proxy(DBFacade, {\n  get(target: any, prop: string) {\n    // Get the resolved instance from the container\n    const root = target.getFacadeRoot() as DatabaseManager;\n\n    if (!root) {\n      throw new Error('DB Facade: Database manager not found in container. Did you register DatabaseServiceProvider?');\n    }\n\n    // If accessing a method/property on DatabaseManager\n    if (root && typeof (root as any)[prop] === 'function') {\n      return (...args: any[]) => (root as any)[prop](...args);\n    }\n\n    if (root && prop in root) {\n      return (root as any)[prop];\n    }\n\n    // Default table() shortcut - get connection and call table()\n    if (prop === 'table') {\n      return (tableName: string) => root.connection().table(tableName);\n    }\n\n    // Proxy other methods to the default connection\n    const connection = root.connection();\n\n    if (connection && typeof (connection as any)[prop] === 'function') {\n      return (...args: any[]) => (connection as any)[prop](...args);\n    }\n\n    return (connection as any)?.[prop];\n  },\n});\n"],"mappings":"+CAgBA,MAAa,EAAK,IAAI,MAPtB,cAAuB,CAAO,CAC5B,OAAiB,mBAA4B,CAC3C,MAAO,OAK2B,CACpC,IAAI,EAAa,EAAc,CAE7B,IAAM,EAAO,EAAO,eAAe,CAEnC,GAAI,CAAC,EACH,MAAU,MAAM,gGAAgG,CAIlH,GAAI,GAAQ,OAAQ,EAAa,IAAU,WACzC,OAAQ,GAAG,IAAiB,EAAa,GAAM,GAAG,EAAK,CAGzD,GAAI,GAAQ,KAAQ,EAClB,OAAQ,EAAa,GAIvB,GAAI,IAAS,QACX,MAAQ,IAAsB,EAAK,YAAY,CAAC,MAAM,EAAU,CAIlE,IAAM,EAAa,EAAK,YAAY,CAMpC,OAJI,GAAc,OAAQ,EAAmB,IAAU,YAC7C,GAAG,IAAiB,EAAmB,GAAM,GAAG,EAAK,CAGvD,IAAqB,IAEhC,CAAC"}

package/dist/Facades/Event.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);const e=require(`../Support/Facade.cjs`),t=require(`../Support/Testing/Fakes/EventFake.cjs`);var n=class extends e.Facade{static getFacadeAccessor(){return`events`}static fake(e){let n=this.getFacadeApplication(),r=new t.EventFake(n);if(e&&e.length>0){let t=e.map(e=>typeof e==`string`?e:e.name);r.setFakedEvents(t);try{let e=n.make(`events`);r.setOriginalDispatcher(e)}catch{}}return n.instance(`events`,r),this.clearResolvedInstance(`events`),r}static fakeExcept(e){let n=this.getFacadeApplication(),r=new t.EventFake(n),i=e.map(e=>typeof e==`string`?e:e.name);r.setExceptedEvents(i);try{let e=n.make(`events`);r.setOriginalDispatcher(e)}catch{}return n.instance(`events`,r),this.clearResolvedInstance(`events`),r}static async fakeFor(e){let t=this.getFacadeApplication(),n=t.bound(`events`),r;if(n)try{r=t.make(`events`)}catch{}let i=this.fake();try{return[await e(i),i]}finally{if(r)t.instance(`events`,r);else{let{Dispatcher:e}=await Promise.resolve().then(()=>require(`../Events/Dispatcher.cjs`));t.singleton(`events`,t=>new e(t))}this.clearResolvedInstance(`events`)}}static assertDispatched(e,t){this.getFakeInstance().assertDispatched(e,t)}static assertNotDispatched(e,t){this.getFakeInstance().assertNotDispatched(e,t)}static assertDispatchedTimes(e,t){this.getFakeInstance().assertDispatchedTimes(e,t)}static assertNothingDispatched(){this.getFakeInstance().assertNothingDispatched()}static assertListening(e,t){this.getFakeInstance().assertListening(e,t)}static getFakeInstance(){let e=this.getFacadeApplication().make(`events`);if(!(e instanceof t.EventFake))throw Error(`Event facade is not faked. Call Event.fake() before making assertions.`);return e}static isFaked(){try{return this.getFacadeApplication().make(`events`)instanceof t.EventFake}catch{return!1}}};const r=new Proxy(n,{get(e,t){if(t in e){let n=e[t];return typeof n==`function`?n.bind(e):n}try{let n=e.getFacadeRoot();if(n&&t in n){let e=n[t];return typeof e==`function`?(...t)=>e.apply(n,t):e}}catch{}}});exports.Event=r;

package/dist/Facades/Event.d.cts

@@ -0,0 +1,200 @@
+import { Facade } from "../Support/Facade.cjs";
+import { Event as Event$1 } from "../Events/Event.cjs";
+import { EventListener } from "../Events/types.cjs";
+import { Dispatcher } from "../Events/Dispatcher.cjs";
+import { EventFake } from "../Support/Testing/Fakes/EventFake.cjs";
+
+//#region src/Facades/Event.d.ts
+/**
+ * Event Facade
+ *
+ * Provides static access to the event dispatcher for listening to and dispatching events.
+ * Includes testing utilities for faking events in tests.
+ *
+ * @example
+ * ```typescript
+ * // Listen to events
+ * Event.listen(UserRegistered, SendWelcomeEmail);
+ * Event.listen('user.*', (event) => console.log(event));
+ *
+ * // Dispatch events
+ * Event.dispatch(new UserRegistered(user));
+ * Event.dispatch('user.registered', [user]);
+ *
+ * // Dispatch until first non-null response
+ * const result = Event.until(new ValidateUser(user));
+ *
+ * // Testing - Fake all events
+ * Event.fake();
+ * // Your code that dispatches events
+ * Event.assertDispatched(UserRegistered);
+ * Event.assertDispatchedTimes(UserRegistered, 2);
+ *
+ * // Fake specific events
+ * Event.fake([UserRegistered, OrderPlaced]);
+ *
+ * // Fake all except specific events
+ * Event.fakeExcept([UserDeleted]);
+ * ```
+ */
+declare class EventFacadeClass extends Facade {
+  protected static getFacadeAccessor(): string;
+  /**
+   * Fake events for testing
+   *
+   * Replaces the real event dispatcher with a fake that records all
+   * dispatched events instead of calling listeners. Returns the fake
+   * instance for making assertions.
+   *
+   * @param events - Optional array of events to fake (fakes all if not provided)
+   * @returns EventFake instance for assertions
+   *
+   * @example
+   * ```typescript
+   * // Fake all events
+   * const fake = Event.fake();
+   * // Your code
+   * fake.assertDispatched(UserRegistered);
+   *
+   * // Fake specific events only
+   * Event.fake([UserRegistered, OrderPlaced]);
+   * ```
+   */
+  static fake(events?: (string | (new (...args: any[]) => Event$1))[]): EventFake;
+  /**
+   * Fake all events except the specified ones
+   *
+   * All events will be faked except those in the provided array,
+   * which will dispatch normally.
+   *
+   * @param events - Events that should NOT be faked
+   * @returns EventFake instance for assertions
+   *
+   * @example
+   * ```typescript
+   * // Fake all events except UserDeleted
+   * Event.fakeExcept([UserDeleted]);
+   * // UserDeleted will dispatch normally, all others will be faked
+   * ```
+   */
+  static fakeExcept(events: (string | (new (...args: any[]) => Event$1))[]): EventFake;
+  /**
+   * Fake events only for the duration of a callback
+   *
+   * Temporarily replaces the event dispatcher with a fake, executes
+   * the callback, then restores the original dispatcher. Useful for
+   * scoping fakes to specific test blocks.
+   *
+   * @param callback - Function to execute with faked events
+   * @returns Result of the callback and the fake instance
+   *
+   * @example
+   * ```typescript
+   * const [result, fake] = await Event.fakeFor(async () => {
+   *   await someService.createUser();
+   *   return 'done';
+   * });
+   *
+   * fake.assertDispatched(UserRegistered);
+   * expect(result).toBe('done');
+   * ```
+   */
+  static fakeFor<T>(callback: (fake: EventFake) => T | Promise<T>): Promise<[T, EventFake]>;
+  /**
+   * Assert that an event was dispatched
+   *
+   * Can only be called after Event.fake() has been called.
+   *
+   * @param event - The event name or class
+   * @param callback - Optional callback to filter events
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * // Your code
+   * Event.assertDispatched(UserRegistered);
+   * Event.assertDispatched(UserRegistered, (event) => event.user.email === 'test@example.com');
+   * ```
+   */
+  static assertDispatched(event: string | (new (...args: any[]) => Event$1), callback?: (event: Event$1) => boolean): void;
+  /**
+   * Assert that an event was NOT dispatched
+   *
+   * Can only be called after Event.fake() has been called.
+   *
+   * @param event - The event name or class
+   * @param callback - Optional callback to filter events
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * // Your code
+   * Event.assertNotDispatched(UserDeleted);
+   * ```
+   */
+  static assertNotDispatched(event: string | (new (...args: any[]) => Event$1), callback?: (event: Event$1) => boolean): void;
+  /**
+   * Assert that an event was dispatched a specific number of times
+   *
+   * Can only be called after Event.fake() has been called.
+   *
+   * @param event - The event name or class
+   * @param times - Expected number of dispatches
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * // Your code
+   * Event.assertDispatchedTimes(UserRegistered, 3);
+   * ```
+   */
+  static assertDispatchedTimes(event: string | (new (...args: any[]) => Event$1), times: number): void;
+  /**
+   * Assert that no events were dispatched
+   *
+   * Can only be called after Event.fake() has been called.
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * // Your code that shouldn't dispatch events
+   * Event.assertNothingDispatched();
+   * ```
+   */
+  static assertNothingDispatched(): void;
+  /**
+   * Assert that a listener is registered for an event
+   *
+   * @param event - The event name or class
+   * @param listener - Optional specific listener to check for
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * Event.listen(UserRegistered, SendWelcomeEmail);
+   * Event.assertListening(UserRegistered);
+   * Event.assertListening(UserRegistered, SendWelcomeEmail);
+   * ```
+   */
+  static assertListening(event: string | (new (...args: any[]) => Event$1), listener?: string | EventListener): void;
+  /**
+   * Get the fake instance
+   *
+   * @returns The EventFake instance
+   * @throws Error if Event.fake() hasn't been called
+   */
+  protected static getFakeInstance(): EventFake;
+  /**
+   * Check if the event dispatcher is currently faked
+   *
+   * @returns true if using EventFake
+   */
+  static isFaked(): boolean;
+}
+/**
+ * Export facade with Proxy for static method calls
+ */
+declare const Event: typeof EventFacadeClass & Dispatcher;
+//#endregion
+export { Event };
+//# sourceMappingURL=Event.d.cts.map

package/dist/Facades/Event.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.d.cts","names":[],"sources":["../../src/Facades/Event.ts"],"mappings":";;;;;;;;;AAI8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCxD,gBAAA,SAAyB,MAAA;EAAA,iBACZ,iBAAA,CAAA;EAiEV;;;;;;;;;;;;;;;;;;;;;EAAA,OAzCA,IAAA,CAAK,MAAA,sBAA4B,IAAA,YAAgB,OAAA,OAAiB,SAAA;EAwIvE;;;;;;;;;;;;;;;;EAAA,OA/FK,UAAA,CAAW,MAAA,qBAA2B,IAAA,YAAgB,OAAA,OAAiB,SAAA;EAgL5E;;;;;;;;AA2CJ;;;;;;;;;;;;;EA3CI,OArIW,OAAA,GAAA,CAAW,QAAA,GAAW,IAAA,EAAM,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAAK,OAAA,EAAS,CAAA,EAAG,SAAA;;;;;;;;;;;;;;;;;SAkD7E,gBAAA,CACL,KAAA,oBAAyB,IAAA,YAAgB,OAAA,GACzC,QAAA,IAAY,KAAA,EAAO,OAAA;;;;;;;;;;;;;;;;SAqBd,mBAAA,CACL,KAAA,oBAAyB,IAAA,YAAgB,OAAA,GACzC,QAAA,IAAY,KAAA,EAAO,OAAA;;;;;;;;;;;;;;;;SAqBd,qBAAA,CAAsB,KAAA,oBAAyB,IAAA,YAAgB,OAAA,GAAa,KAAA;;;;;;;;;;;;;SAiB5E,uBAAA,CAAA;;;;;;;;;;;;;;;SAmBA,eAAA,CACL,KAAA,oBAAyB,IAAA,YAAgB,OAAA,GACzC,QAAA,YAAoB,aAAA;;;;;;;mBAYL,eAAA,CAAA,GAAmB,SAAA;;;;;;SAgB7B,OAAA,CAAA;AAAA;;;;cAcI,KAAA,SA2BW,gBAAA,GAAmB,UAAA"}

package/dist/Facades/Event.d.mts

@@ -0,0 +1,200 @@
+import { Facade } from "../Support/Facade.mjs";
+import { Event as Event$1 } from "../Events/Event.mjs";
+import { EventListener } from "../Events/types.mjs";
+import { Dispatcher } from "../Events/Dispatcher.mjs";
+import { EventFake } from "../Support/Testing/Fakes/EventFake.mjs";
+
+//#region src/Facades/Event.d.ts
+/**
+ * Event Facade
+ *
+ * Provides static access to the event dispatcher for listening to and dispatching events.
+ * Includes testing utilities for faking events in tests.
+ *
+ * @example
+ * ```typescript
+ * // Listen to events
+ * Event.listen(UserRegistered, SendWelcomeEmail);
+ * Event.listen('user.*', (event) => console.log(event));
+ *
+ * // Dispatch events
+ * Event.dispatch(new UserRegistered(user));
+ * Event.dispatch('user.registered', [user]);
+ *
+ * // Dispatch until first non-null response
+ * const result = Event.until(new ValidateUser(user));
+ *
+ * // Testing - Fake all events
+ * Event.fake();
+ * // Your code that dispatches events
+ * Event.assertDispatched(UserRegistered);
+ * Event.assertDispatchedTimes(UserRegistered, 2);
+ *
+ * // Fake specific events
+ * Event.fake([UserRegistered, OrderPlaced]);
+ *
+ * // Fake all except specific events
+ * Event.fakeExcept([UserDeleted]);
+ * ```
+ */
+declare class EventFacadeClass extends Facade {
+  protected static getFacadeAccessor(): string;
+  /**
+   * Fake events for testing
+   *
+   * Replaces the real event dispatcher with a fake that records all
+   * dispatched events instead of calling listeners. Returns the fake
+   * instance for making assertions.
+   *
+   * @param events - Optional array of events to fake (fakes all if not provided)
+   * @returns EventFake instance for assertions
+   *
+   * @example
+   * ```typescript
+   * // Fake all events
+   * const fake = Event.fake();
+   * // Your code
+   * fake.assertDispatched(UserRegistered);
+   *
+   * // Fake specific events only
+   * Event.fake([UserRegistered, OrderPlaced]);
+   * ```
+   */
+  static fake(events?: (string | (new (...args: any[]) => Event$1))[]): EventFake;
+  /**
+   * Fake all events except the specified ones
+   *
+   * All events will be faked except those in the provided array,
+   * which will dispatch normally.
+   *
+   * @param events - Events that should NOT be faked
+   * @returns EventFake instance for assertions
+   *
+   * @example
+   * ```typescript
+   * // Fake all events except UserDeleted
+   * Event.fakeExcept([UserDeleted]);
+   * // UserDeleted will dispatch normally, all others will be faked
+   * ```
+   */
+  static fakeExcept(events: (string | (new (...args: any[]) => Event$1))[]): EventFake;
+  /**
+   * Fake events only for the duration of a callback
+   *
+   * Temporarily replaces the event dispatcher with a fake, executes
+   * the callback, then restores the original dispatcher. Useful for
+   * scoping fakes to specific test blocks.
+   *
+   * @param callback - Function to execute with faked events
+   * @returns Result of the callback and the fake instance
+   *
+   * @example
+   * ```typescript
+   * const [result, fake] = await Event.fakeFor(async () => {
+   *   await someService.createUser();
+   *   return 'done';
+   * });
+   *
+   * fake.assertDispatched(UserRegistered);
+   * expect(result).toBe('done');
+   * ```
+   */
+  static fakeFor<T>(callback: (fake: EventFake) => T | Promise<T>): Promise<[T, EventFake]>;
+  /**
+   * Assert that an event was dispatched
+   *
+   * Can only be called after Event.fake() has been called.
+   *
+   * @param event - The event name or class
+   * @param callback - Optional callback to filter events
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * // Your code
+   * Event.assertDispatched(UserRegistered);
+   * Event.assertDispatched(UserRegistered, (event) => event.user.email === 'test@example.com');
+   * ```
+   */
+  static assertDispatched(event: string | (new (...args: any[]) => Event$1), callback?: (event: Event$1) => boolean): void;
+  /**
+   * Assert that an event was NOT dispatched
+   *
+   * Can only be called after Event.fake() has been called.
+   *
+   * @param event - The event name or class
+   * @param callback - Optional callback to filter events
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * // Your code
+   * Event.assertNotDispatched(UserDeleted);
+   * ```
+   */
+  static assertNotDispatched(event: string | (new (...args: any[]) => Event$1), callback?: (event: Event$1) => boolean): void;
+  /**
+   * Assert that an event was dispatched a specific number of times
+   *
+   * Can only be called after Event.fake() has been called.
+   *
+   * @param event - The event name or class
+   * @param times - Expected number of dispatches
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * // Your code
+   * Event.assertDispatchedTimes(UserRegistered, 3);
+   * ```
+   */
+  static assertDispatchedTimes(event: string | (new (...args: any[]) => Event$1), times: number): void;
+  /**
+   * Assert that no events were dispatched
+   *
+   * Can only be called after Event.fake() has been called.
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * // Your code that shouldn't dispatch events
+   * Event.assertNothingDispatched();
+   * ```
+   */
+  static assertNothingDispatched(): void;
+  /**
+   * Assert that a listener is registered for an event
+   *
+   * @param event - The event name or class
+   * @param listener - Optional specific listener to check for
+   *
+   * @example
+   * ```typescript
+   * Event.fake();
+   * Event.listen(UserRegistered, SendWelcomeEmail);
+   * Event.assertListening(UserRegistered);
+   * Event.assertListening(UserRegistered, SendWelcomeEmail);
+   * ```
+   */
+  static assertListening(event: string | (new (...args: any[]) => Event$1), listener?: string | EventListener): void;
+  /**
+   * Get the fake instance
+   *
+   * @returns The EventFake instance
+   * @throws Error if Event.fake() hasn't been called
+   */
+  protected static getFakeInstance(): EventFake;
+  /**
+   * Check if the event dispatcher is currently faked
+   *
+   * @returns true if using EventFake
+   */
+  static isFaked(): boolean;
+}
+/**
+ * Export facade with Proxy for static method calls
+ */
+declare const Event: typeof EventFacadeClass & Dispatcher;
+//#endregion
+export { Event };
+//# sourceMappingURL=Event.d.mts.map

package/dist/Facades/Event.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.d.mts","names":[],"sources":["../../src/Facades/Event.ts"],"mappings":";;;;;;;;;AAI8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCxD,gBAAA,SAAyB,MAAA;EAAA,iBACZ,iBAAA,CAAA;EAiEV;;;;;;;;;;;;;;;;;;;;;EAAA,OAzCA,IAAA,CAAK,MAAA,sBAA4B,IAAA,YAAgB,OAAA,OAAiB,SAAA;EAwIvE;;;;;;;;;;;;;;;;EAAA,OA/FK,UAAA,CAAW,MAAA,qBAA2B,IAAA,YAAgB,OAAA,OAAiB,SAAA;EAgL5E;;;;;;;;AA2CJ;;;;;;;;;;;;;EA3CI,OArIW,OAAA,GAAA,CAAW,QAAA,GAAW,IAAA,EAAM,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAAK,OAAA,EAAS,CAAA,EAAG,SAAA;;;;;;;;;;;;;;;;;SAkD7E,gBAAA,CACL,KAAA,oBAAyB,IAAA,YAAgB,OAAA,GACzC,QAAA,IAAY,KAAA,EAAO,OAAA;;;;;;;;;;;;;;;;SAqBd,mBAAA,CACL,KAAA,oBAAyB,IAAA,YAAgB,OAAA,GACzC,QAAA,IAAY,KAAA,EAAO,OAAA;;;;;;;;;;;;;;;;SAqBd,qBAAA,CAAsB,KAAA,oBAAyB,IAAA,YAAgB,OAAA,GAAa,KAAA;;;;;;;;;;;;;SAiB5E,uBAAA,CAAA;;;;;;;;;;;;;;;SAmBA,eAAA,CACL,KAAA,oBAAyB,IAAA,YAAgB,OAAA,GACzC,QAAA,YAAoB,aAAA;;;;;;;mBAYL,eAAA,CAAA,GAAmB,SAAA;;;;;;SAgB7B,OAAA,CAAA;AAAA;;;;cAcI,KAAA,SA2BW,gBAAA,GAAmB,UAAA"}

package/dist/Facades/Event.mjs

@@ -0,0 +1,2 @@
+import{Facade as e}from"../Support/Facade.mjs";import{EventFake as t}from"../Support/Testing/Fakes/EventFake.mjs";const n=new Proxy(class extends e{static getFacadeAccessor(){return`events`}static fake(e){let n=this.getFacadeApplication(),r=new t(n);if(e&&e.length>0){let t=e.map(e=>typeof e==`string`?e:e.name);r.setFakedEvents(t);try{let e=n.make(`events`);r.setOriginalDispatcher(e)}catch{}}return n.instance(`events`,r),this.clearResolvedInstance(`events`),r}static fakeExcept(e){let n=this.getFacadeApplication(),r=new t(n),i=e.map(e=>typeof e==`string`?e:e.name);r.setExceptedEvents(i);try{let e=n.make(`events`);r.setOriginalDispatcher(e)}catch{}return n.instance(`events`,r),this.clearResolvedInstance(`events`),r}static async fakeFor(e){let t=this.getFacadeApplication(),n=t.bound(`events`),r;if(n)try{r=t.make(`events`)}catch{}let i=this.fake();try{return[await e(i),i]}finally{if(r)t.instance(`events`,r);else{let{Dispatcher:e}=await import(`../Events/Dispatcher.mjs`);t.singleton(`events`,t=>new e(t))}this.clearResolvedInstance(`events`)}}static assertDispatched(e,t){this.getFakeInstance().assertDispatched(e,t)}static assertNotDispatched(e,t){this.getFakeInstance().assertNotDispatched(e,t)}static assertDispatchedTimes(e,t){this.getFakeInstance().assertDispatchedTimes(e,t)}static assertNothingDispatched(){this.getFakeInstance().assertNothingDispatched()}static assertListening(e,t){this.getFakeInstance().assertListening(e,t)}static getFakeInstance(){let e=this.getFacadeApplication().make(`events`);if(!(e instanceof t))throw Error(`Event facade is not faked. Call Event.fake() before making assertions.`);return e}static isFaked(){try{return this.getFacadeApplication().make(`events`)instanceof t}catch{return!1}}},{get(e,t){if(t in e){let n=e[t];return typeof n==`function`?n.bind(e):n}try{let n=e.getFacadeRoot();if(n&&t in n){let e=n[t];return typeof e==`function`?(...t)=>e.apply(n,t):e}}catch{}}});export{n as Event};
+//# sourceMappingURL=Event.mjs.map

package/dist/Facades/Event.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.mjs","names":[],"sources":["../../src/Facades/Event.ts"],"sourcesContent":["import type { Dispatcher } from '@/Events/Dispatcher';\nimport type { Event as EventClass } from '@/Events/Event';\nimport type { EventListener } from '@/Events/types';\nimport { Facade } from '@/Support/Facade';\nimport { EventFake } from '@/Support/Testing/Fakes/EventFake';\n\n/**\n * Event Facade\n *\n * Provides static access to the event dispatcher for listening to and dispatching events.\n * Includes testing utilities for faking events in tests.\n *\n * @example\n * ```typescript\n * // Listen to events\n * Event.listen(UserRegistered, SendWelcomeEmail);\n * Event.listen('user.*', (event) => console.log(event));\n *\n * // Dispatch events\n * Event.dispatch(new UserRegistered(user));\n * Event.dispatch('user.registered', [user]);\n *\n * // Dispatch until first non-null response\n * const result = Event.until(new ValidateUser(user));\n *\n * // Testing - Fake all events\n * Event.fake();\n * // Your code that dispatches events\n * Event.assertDispatched(UserRegistered);\n * Event.assertDispatchedTimes(UserRegistered, 2);\n *\n * // Fake specific events\n * Event.fake([UserRegistered, OrderPlaced]);\n *\n * // Fake all except specific events\n * Event.fakeExcept([UserDeleted]);\n * ```\n */\nclass EventFacadeClass extends Facade {\n  protected static getFacadeAccessor(): string {\n    return 'events';\n  }\n  /**\n   * Fake events for testing\n   *\n   * Replaces the real event dispatcher with a fake that records all\n   * dispatched events instead of calling listeners. Returns the fake\n   * instance for making assertions.\n   *\n   * @param events - Optional array of events to fake (fakes all if not provided)\n   * @returns EventFake instance for assertions\n   *\n   * @example\n   * ```typescript\n   * // Fake all events\n   * const fake = Event.fake();\n   * // Your code\n   * fake.assertDispatched(UserRegistered);\n   *\n   * // Fake specific events only\n   * Event.fake([UserRegistered, OrderPlaced]);\n   * ```\n   */\n  static fake(events?: (string | (new (...args: any[]) => EventClass))[]): EventFake {\n    const app = this.getFacadeApplication();\n    const fake = new EventFake(app);\n\n    if (events && events.length > 0) {\n      // Create selective fake that only intercepts specified events\n      const eventNames = events.map((e) => (typeof e === 'string' ? e : e.name));\n      fake.setFakedEvents(eventNames);\n\n      // Store original dispatcher for pass-through\n      try {\n        const originalDispatcher = app.make<Dispatcher>('events');\n        fake.setOriginalDispatcher(originalDispatcher);\n      } catch (error) {\n        // Dispatcher not registered yet, that's okay\n      }\n    }\n\n    // Replace the events binding with the fake\n    app.instance('events', fake);\n    this.clearResolvedInstance('events');\n\n    return fake;\n  }\n\n  /**\n   * Fake all events except the specified ones\n   *\n   * All events will be faked except those in the provided array,\n   * which will dispatch normally.\n   *\n   * @param events - Events that should NOT be faked\n   * @returns EventFake instance for assertions\n   *\n   * @example\n   * ```typescript\n   * // Fake all events except UserDeleted\n   * Event.fakeExcept([UserDeleted]);\n   * // UserDeleted will dispatch normally, all others will be faked\n   * ```\n   */\n  static fakeExcept(events: (string | (new (...args: any[]) => EventClass))[]): EventFake {\n    const app = this.getFacadeApplication();\n    const fake = new EventFake(app);\n\n    const eventNames = events.map((e) => (typeof e === 'string' ? e : e.name));\n    fake.setExceptedEvents(eventNames);\n\n    // Store original dispatcher for pass-through\n    try {\n      const originalDispatcher = app.make<Dispatcher>('events');\n      fake.setOriginalDispatcher(originalDispatcher);\n    } catch (error) {\n      // Dispatcher not registered yet, that's okay\n    }\n\n    // Replace the events binding with the fake\n    app.instance('events', fake);\n    this.clearResolvedInstance('events');\n\n    return fake;\n  }\n\n  /**\n   * Fake events only for the duration of a callback\n   *\n   * Temporarily replaces the event dispatcher with a fake, executes\n   * the callback, then restores the original dispatcher. Useful for\n   * scoping fakes to specific test blocks.\n   *\n   * @param callback - Function to execute with faked events\n   * @returns Result of the callback and the fake instance\n   *\n   * @example\n   * ```typescript\n   * const [result, fake] = await Event.fakeFor(async () => {\n   *   await someService.createUser();\n   *   return 'done';\n   * });\n   *\n   * fake.assertDispatched(UserRegistered);\n   * expect(result).toBe('done');\n   * ```\n   */\n  static async fakeFor<T>(callback: (fake: EventFake) => T | Promise<T>): Promise<[T, EventFake]> {\n    const app = this.getFacadeApplication();\n\n    // Store the original binding\n    const originalBinding = app.bound('events');\n    let originalDispatcher: Dispatcher | undefined;\n\n    if (originalBinding) {\n      try {\n        originalDispatcher = app.make<Dispatcher>('events');\n      } catch (error) {\n        // Ignore if can't resolve\n      }\n    }\n\n    // Create and install fake\n    const fake = this.fake();\n\n    try {\n      const result = await callback(fake);\n      return [result, fake];\n    } finally {\n      // Restore original dispatcher\n      if (originalDispatcher) {\n        app.instance('events', originalDispatcher);\n      } else {\n        // Re-register the singleton binding\n        const { Dispatcher } = await import('@/Events/Dispatcher');\n        app.singleton('events', (container: any) => new Dispatcher(container));\n      }\n      this.clearResolvedInstance('events');\n    }\n  }\n\n  /**\n   * Assert that an event was dispatched\n   *\n   * Can only be called after Event.fake() has been called.\n   *\n   * @param event - The event name or class\n   * @param callback - Optional callback to filter events\n   *\n   * @example\n   * ```typescript\n   * Event.fake();\n   * // Your code\n   * Event.assertDispatched(UserRegistered);\n   * Event.assertDispatched(UserRegistered, (event) => event.user.email === 'test@example.com');\n   * ```\n   */\n  static assertDispatched(\n    event: string | (new (...args: any[]) => EventClass),\n    callback?: (event: EventClass) => boolean\n  ): void {\n    const fake = this.getFakeInstance();\n    fake.assertDispatched(event, callback);\n  }\n\n  /**\n   * Assert that an event was NOT dispatched\n   *\n   * Can only be called after Event.fake() has been called.\n   *\n   * @param event - The event name or class\n   * @param callback - Optional callback to filter events\n   *\n   * @example\n   * ```typescript\n   * Event.fake();\n   * // Your code\n   * Event.assertNotDispatched(UserDeleted);\n   * ```\n   */\n  static assertNotDispatched(\n    event: string | (new (...args: any[]) => EventClass),\n    callback?: (event: EventClass) => boolean\n  ): void {\n    const fake = this.getFakeInstance();\n    fake.assertNotDispatched(event, callback);\n  }\n\n  /**\n   * Assert that an event was dispatched a specific number of times\n   *\n   * Can only be called after Event.fake() has been called.\n   *\n   * @param event - The event name or class\n   * @param times - Expected number of dispatches\n   *\n   * @example\n   * ```typescript\n   * Event.fake();\n   * // Your code\n   * Event.assertDispatchedTimes(UserRegistered, 3);\n   * ```\n   */\n  static assertDispatchedTimes(event: string | (new (...args: any[]) => EventClass), times: number): void {\n    const fake = this.getFakeInstance();\n    fake.assertDispatchedTimes(event, times);\n  }\n\n  /**\n   * Assert that no events were dispatched\n   *\n   * Can only be called after Event.fake() has been called.\n   *\n   * @example\n   * ```typescript\n   * Event.fake();\n   * // Your code that shouldn't dispatch events\n   * Event.assertNothingDispatched();\n   * ```\n   */\n  static assertNothingDispatched(): void {\n    const fake = this.getFakeInstance();\n    fake.assertNothingDispatched();\n  }\n\n  /**\n   * Assert that a listener is registered for an event\n   *\n   * @param event - The event name or class\n   * @param listener - Optional specific listener to check for\n   *\n   * @example\n   * ```typescript\n   * Event.fake();\n   * Event.listen(UserRegistered, SendWelcomeEmail);\n   * Event.assertListening(UserRegistered);\n   * Event.assertListening(UserRegistered, SendWelcomeEmail);\n   * ```\n   */\n  static assertListening(\n    event: string | (new (...args: any[]) => EventClass),\n    listener?: string | EventListener\n  ): void {\n    const fake = this.getFakeInstance();\n    fake.assertListening(event, listener);\n  }\n\n  /**\n   * Get the fake instance\n   *\n   * @returns The EventFake instance\n   * @throws Error if Event.fake() hasn't been called\n   */\n  protected static getFakeInstance(): EventFake {\n    const app = this.getFacadeApplication();\n    const instance = app.make<EventFake>('events');\n\n    if (!(instance instanceof EventFake)) {\n      throw new Error('Event facade is not faked. Call Event.fake() before making assertions.');\n    }\n\n    return instance;\n  }\n\n  /**\n   * Check if the event dispatcher is currently faked\n   *\n   * @returns true if using EventFake\n   */\n  static isFaked(): boolean {\n    try {\n      const app = this.getFacadeApplication();\n      const instance = app.make('events');\n      return instance instanceof EventFake;\n    } catch (error) {\n      return false;\n    }\n  }\n}\n\n/**\n * Export facade with Proxy for static method calls\n */\nexport const Event = new Proxy(EventFacadeClass, {\n  get(target, prop) {\n    // First check if it's a static method on the facade class itself\n    if (prop in target) {\n      const value = (target as any)[prop];\n      if (typeof value === 'function') {\n        return value.bind(target);\n      }\n      return value;\n    }\n\n    // Then try to get from the facade root (the actual Dispatcher instance)\n    try {\n      const root = (target as any).getFacadeRoot();\n      if (root && prop in root) {\n        const value = root[prop];\n        if (typeof value === 'function') {\n          return (...args: any[]) => value.apply(root, args);\n        }\n        return value;\n      }\n    } catch (error) {\n      // Facade root not available yet, that's okay\n    }\n\n    return undefined;\n  },\n}) as unknown as typeof EventFacadeClass & Dispatcher;\n\n/**\n * Re-export EventFake for direct use\n */\nexport { EventFake };\n"],"mappings":"kHAmUA,MAAa,EAAQ,IAAI,MA7RzB,cAA+B,CAAO,CACpC,OAAiB,mBAA4B,CAC3C,MAAO,SAuBT,OAAO,KAAK,EAAuE,CACjF,IAAM,EAAM,KAAK,sBAAsB,CACjC,EAAO,IAAI,EAAU,EAAI,CAE/B,GAAI,GAAU,EAAO,OAAS,EAAG,CAE/B,IAAM,EAAa,EAAO,IAAK,GAAO,OAAO,GAAM,SAAW,EAAI,EAAE,KAAM,CAC1E,EAAK,eAAe,EAAW,CAG/B,GAAI,CACF,IAAM,EAAqB,EAAI,KAAiB,SAAS,CACzD,EAAK,sBAAsB,EAAmB,MAChC,GASlB,OAHA,EAAI,SAAS,SAAU,EAAK,CAC5B,KAAK,sBAAsB,SAAS,CAE7B,EAmBT,OAAO,WAAW,EAAsE,CACtF,IAAM,EAAM,KAAK,sBAAsB,CACjC,EAAO,IAAI,EAAU,EAAI,CAEzB,EAAa,EAAO,IAAK,GAAO,OAAO,GAAM,SAAW,EAAI,EAAE,KAAM,CAC1E,EAAK,kBAAkB,EAAW,CAGlC,GAAI,CACF,IAAM,EAAqB,EAAI,KAAiB,SAAS,CACzD,EAAK,sBAAsB,EAAmB,MAChC,EAQhB,OAHA,EAAI,SAAS,SAAU,EAAK,CAC5B,KAAK,sBAAsB,SAAS,CAE7B,EAwBT,aAAa,QAAW,EAAwE,CAC9F,IAAM,EAAM,KAAK,sBAAsB,CAGjC,EAAkB,EAAI,MAAM,SAAS,CACvC,EAEJ,GAAI,EACF,GAAI,CACF,EAAqB,EAAI,KAAiB,SAAS,MACrC,EAMlB,IAAM,EAAO,KAAK,MAAM,CAExB,GAAI,CAEF,MAAO,CADQ,MAAM,EAAS,EAAK,CACnB,EAAK,QACb,CAER,GAAI,EACF,EAAI,SAAS,SAAU,EAAmB,KACrC,CAEL,GAAM,CAAE,cAAe,MAAM,OAAO,4BACpC,EAAI,UAAU,SAAW,GAAmB,IAAI,EAAW,EAAU,CAAC,CAExE,KAAK,sBAAsB,SAAS,EAoBxC,OAAO,iBACL,EACA,EACM,CACO,KAAK,iBAAiB,CAC9B,iBAAiB,EAAO,EAAS,CAkBxC,OAAO,oBACL,EACA,EACM,CACO,KAAK,iBAAiB,CAC9B,oBAAoB,EAAO,EAAS,CAkB3C,OAAO,sBAAsB,EAAsD,EAAqB,CACzF,KAAK,iBAAiB,CAC9B,sBAAsB,EAAO,EAAM,CAe1C,OAAO,yBAAgC,CACxB,KAAK,iBAAiB,CAC9B,yBAAyB,CAiBhC,OAAO,gBACL,EACA,EACM,CACO,KAAK,iBAAiB,CAC9B,gBAAgB,EAAO,EAAS,CASvC,OAAiB,iBAA6B,CAE5C,IAAM,EADM,KAAK,sBAAsB,CAClB,KAAgB,SAAS,CAE9C,GAAI,EAAE,aAAoB,GACxB,MAAU,MAAM,yEAAyE,CAG3F,OAAO,EAQT,OAAO,SAAmB,CACxB,GAAI,CAGF,OAFY,KAAK,sBAAsB,CAClB,KAAK,SAAS,WACR,OACb,CACd,MAAO,MAQoC,CAC/C,IAAI,EAAQ,EAAM,CAEhB,GAAI,KAAQ,EAAQ,CAClB,IAAM,EAAS,EAAe,GAI9B,OAHI,OAAO,GAAU,WACZ,EAAM,KAAK,EAAO,CAEpB,EAIT,GAAI,CACF,IAAM,EAAQ,EAAe,eAAe,CAC5C,GAAI,GAAQ,KAAQ,EAAM,CACxB,IAAM,EAAQ,EAAK,GAInB,OAHI,OAAO,GAAU,YACX,GAAG,IAAgB,EAAM,MAAM,EAAM,EAAK,CAE7C,QAEK,IAMnB,CAAC"}

package/dist/Facades/Queue.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);const e=require(`../Support/Facade.cjs`);var t=class extends e.Facade{static getFacadeAccessor(){return`queue`}};const n=new Proxy(t,{get(e,t){if(t in e){let n=e[t];return typeof n==`function`?n.bind(e):n}try{let n=e.getFacadeRoot();if(n&&t in n){let e=n[t];return typeof e==`function`?(...t)=>e.apply(n,t):e}}catch{}}});exports.Queue=n;

package/dist/Facades/Queue.d.cts

@@ -0,0 +1,11 @@
+import { Facade } from "../Support/Facade.cjs";
+import { QueueManager } from "../Queue/QueueManager.cjs";
+
+//#region src/Facades/Queue.d.ts
+declare class QueueFacadeClass extends Facade {
+  protected static getFacadeAccessor(): string;
+}
+declare const Queue: typeof QueueFacadeClass & QueueManager;
+//#endregion
+export { Queue };
+//# sourceMappingURL=Queue.d.cts.map

package/dist/Facades/Queue.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Queue.d.cts","names":[],"sources":["../../src/Facades/Queue.ts"],"mappings":";;;;cAsCM,gBAAA,SAAyB,MAAA;EAAA,iBACZ,iBAAA,CAAA;AAAA;AAAA,cAKN,KAAA,SA2BW,gBAAA,GAAmB,YAAA"}

package/dist/Facades/Queue.d.mts

@@ -0,0 +1,11 @@
+import { Facade } from "../Support/Facade.mjs";
+import { QueueManager } from "../Queue/QueueManager.mjs";
+
+//#region src/Facades/Queue.d.ts
+declare class QueueFacadeClass extends Facade {
+  protected static getFacadeAccessor(): string;
+}
+declare const Queue: typeof QueueFacadeClass & QueueManager;
+//#endregion
+export { Queue };
+//# sourceMappingURL=Queue.d.mts.map

package/dist/Facades/Queue.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Queue.d.mts","names":[],"sources":["../../src/Facades/Queue.ts"],"mappings":";;;;cAsCM,gBAAA,SAAyB,MAAA;EAAA,iBACZ,iBAAA,CAAA;AAAA;AAAA,cAKN,KAAA,SA2BW,gBAAA,GAAmB,YAAA"}

package/dist/Facades/Queue.mjs

@@ -0,0 +1,2 @@
+import{Facade as e}from"../Support/Facade.mjs";const t=new Proxy(class extends e{static getFacadeAccessor(){return`queue`}},{get(e,t){if(t in e){let n=e[t];return typeof n==`function`?n.bind(e):n}try{let n=e.getFacadeRoot();if(n&&t in n){let e=n[t];return typeof e==`function`?(...t)=>e.apply(n,t):e}}catch{}}});export{t as Queue};
+//# sourceMappingURL=Queue.mjs.map

package/dist/Facades/Queue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Queue.mjs","names":[],"sources":["../../src/Facades/Queue.ts"],"sourcesContent":["/**\n * Queue Facade\n *\n * Provides static access to the queue manager for dispatching\n * and managing queued jobs.\n *\n * @example\n * ```typescript\n * // Push a job onto the queue\n * await Queue.push(new ProcessPodcast(podcastId));\n *\n * // Push onto a specific queue\n * await Queue.pushOn('high-priority', new ProcessPodcast(podcastId));\n *\n * // Push with a delay\n * await Queue.later(60, new ProcessPodcast(podcastId));\n *\n * // Get queue size\n * const size = await Queue.size();\n *\n * // Event hooks\n * Queue.before((connectionName, job) => {\n *   console.log('Processing:', job.displayName());\n * });\n *\n * Queue.after((connectionName, job) => {\n *   console.log('Processed:', job.displayName());\n * });\n *\n * Queue.failing((connectionName, job, error) => {\n *   console.error('Failed:', job.displayName(), error);\n * });\n * ```\n */\n\nimport type { QueueManager } from '@/Queue/QueueManager';\nimport { Facade } from '@/Support/Facade';\n\nclass QueueFacadeClass extends Facade {\n  protected static getFacadeAccessor(): string {\n    return 'queue';\n  }\n}\n\nexport const Queue = new Proxy(QueueFacadeClass, {\n  get(target, prop) {\n    // First check if it's a static method on the facade class itself\n    if (prop in target) {\n      const value = (target as any)[prop];\n      if (typeof value === 'function') {\n        return value.bind(target);\n      }\n      return value;\n    }\n\n    // Then try to get from the facade root (the QueueManager instance)\n    try {\n      const root = (target as any).getFacadeRoot() as QueueManager;\n      if (root && prop in root) {\n        const value = (root as any)[prop];\n        if (typeof value === 'function') {\n          return (...args: any[]) => value.apply(root, args);\n        }\n        return value;\n      }\n    } catch (error) {\n      // Facade root not available yet\n    }\n\n    return undefined;\n  },\n}) as unknown as typeof QueueFacadeClass & QueueManager;\n"],"mappings":"+CA4CA,MAAa,EAAQ,IAAI,MANzB,cAA+B,CAAO,CACpC,OAAiB,mBAA4B,CAC3C,MAAO,UAIsC,CAC/C,IAAI,EAAQ,EAAM,CAEhB,GAAI,KAAQ,EAAQ,CAClB,IAAM,EAAS,EAAe,GAI9B,OAHI,OAAO,GAAU,WACZ,EAAM,KAAK,EAAO,CAEpB,EAIT,GAAI,CACF,IAAM,EAAQ,EAAe,eAAe,CAC5C,GAAI,GAAQ,KAAQ,EAAM,CACxB,IAAM,EAAS,EAAa,GAI5B,OAHI,OAAO,GAAU,YACX,GAAG,IAAgB,EAAM,MAAM,EAAM,EAAK,CAE7C,QAEK,IAMnB,CAAC"}

package/dist/Facades/Route.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);const e=require(`../Support/Facade.cjs`);var t=class extends e.Facade{static getFacadeAccessor(){return`router`}static get;static post;static put;static patch;static delete;static any;static match;static group};const n=new Proxy(t,{get(e,t){try{let n=e.getFacadeRoot();if(n&&t in n){let e=n[t];return typeof e==`function`?(...t)=>e.apply(n,t):e}}catch{}if(typeof t==`string`&&t in e){let n=e[t];return typeof n==`function`?n.bind(e):n}}});exports.Route=n;

package/dist/Facades/Route.d.cts

@@ -0,0 +1,23 @@
+import { Router } from "../Routing/Router.cjs";
+import { Facade } from "../Support/Facade.cjs";
+
+//#region src/Facades/Route.d.ts
+/**
+ * Route Facade - Static access to the Router
+ * Usage: Route.get('/path', handler)
+ */
+declare class RouteFacade extends Facade {
+  protected static getFacadeAccessor(): string;
+  static get: Router['get'];
+  static post: Router['post'];
+  static put: Router['put'];
+  static patch: Router['patch'];
+  static delete: Router['delete'];
+  static any: Router['any'];
+  static match: Router['match'];
+  static group: Router['group'];
+}
+declare const Route: typeof RouteFacade & Omit<Router, "app">;
+//#endregion
+export { Route };
+//# sourceMappingURL=Route.d.cts.map

package/dist/Facades/Route.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Route.d.cts","names":[],"sources":["../../src/Facades/Route.ts"],"mappings":";;;;;;AAC0C;;cAMpC,WAAA,SAAoB,MAAA;EAAA,iBACP,iBAAA,CAAA;EAAA,OAIV,GAAA,EAAK,MAAA;EAAA,OACL,IAAA,EAAM,MAAA;EAAA,OACN,GAAA,EAAK,MAAA;EAAA,OACL,KAAA,EAAO,MAAA;EAAA,OACP,MAAA,EAAQ,MAAA;EAAA,OACR,GAAA,EAAK,MAAA;EAAA,OACL,KAAA,EAAO,MAAA;EAAA,OACP,KAAA,EAAO,MAAA;AAAA;AAAA,cAIH,KAAA,SA2BW,WAAA,GAAc,IAAA,CAAK,MAAA"}