@anu8151/adonisjs-blueprint 0.3.9 → 0.4.1

package/build/{base_generator-ClKso0XJ.d.ts → base_generator-DOMn-U0f.d.ts}

@@ -1,3 +1,4 @@
+import { n as Macroable, r as Exception, t as HookHandler } from "./types-DGOelf2A.js";
 import { Codemods } from "@adonisjs/core/ace/codemods";
 import { AssemblerRcFile } from "@adonisjs/assembler/types";
 import diagnostics_channel from "node:diagnostics_channel";
@@ -309,84 +310,6 @@ declare class StubsManager {
   })): Promise<string[]>;
 }
 //#endregion
-//#region node_modules/@poppinss/exception/build/src/exception.d.ts
-/**
- * Create a custom error class with the ability to define the error
- * code, status, and the help text.
- *
- * ```js
- * export class FileNotFoundException extends Exception {
- *   static status = 500
- *   static code = 'E_FILE_NOT_FOUND'
- * }
- *
- * throw new FileNotFoundException(
- *  `Unable to find file from ${filePath} location`
- * )
- * ```
- */
-declare class Exception extends Error {
-  /**
-   * Define the error metadata as static properties to avoid
-   * setting them repeatedly on the error instance
-   */
-  static help?: string;
-  static code?: string;
-  static status?: number;
-  static message?: string;
-  /**
-   * Name of the class that raised the exception.
-   */
-  name: string;
-  /**
-   * Optional help description for the error. You can use it to define additional
-   * human readable information for the error.
-   */
-  help?: string;
-  /**
-   * A machine readable error code. This will allow the error handling logic
-   * to narrow down exceptions based upon the error code.
-   */
-  code?: string;
-  /**
-   * A status code for the error. Usually helpful when converting errors
-   * to HTTP responses.
-   */
-  status: number;
-  constructor(message?: string, options?: ErrorOptions & {
-    code?: string;
-    status?: number;
-  });
-  get [Symbol.toStringTag](): string;
-  toString(): string;
-}
-declare class InvalidArgumentsException extends Exception {
-  static code: string;
-  static status: number;
-}
-declare class RuntimeException extends Exception {
-  static code: string;
-  static status: number;
-}
-/**
- * Helper to create an anonymous error class.
- *
- * ```ts
- *
- * const E_RESOURCE_NOT_FOUND = createError<[number]>(
- *   'Unable to find resource with id %d',
- *   'E_RESOURCE_NOT_FOUND'
- * )
- * const id = 1
- * throw new E_RESOURCE_NOT_FOUND([id])
- *```
- */
-declare function createError<T extends any[] = never>(message: string, code: string, status?: number): typeof Exception & T extends never ? {
-  new (args?: any, options?: ErrorOptions): Exception;
-} : {
-  new (args: T, options?: ErrorOptions): Exception;
-};
-//#endregion
 //#region node_modules/@adonisjs/fold/build/src/resolver.d.ts
 /**
  * Container resolver exposes the APIs to resolve bindings. You can think
@@ -1527,248 +1450,6 @@ declare function parseBindingReference(binding: string | [LazyImport<Constructor
  */
 declare const containerMake: diagnostics_channel.TracingChannel<"adonisjs.container.make", ContainerMakeTracingData>;
 //#endregion
-//#region node_modules/@poppinss/macroable/build/index.d.ts
-/**
- * Abstract class that adds capabilities for extending classes from outside-in,
- * in the form of macros, instance properties, and getters.
- *
- * @example
- * ```ts
- * class User extends Macroable {
- *   name: string
- *   constructor(name: string) {
- *     super()
- *     this.name = name
- *   }
- * }
- *
- * // Add a macro
- * User.macro('greet', function() {
- *   return `Hello, ${this.name}`
- * })
- *
- * // Add a getter
- * User.getter('upperName', function() {
- *   return this.name.toUpperCase()
- * })
- *
- * const user = new User('John')
- * user.greet() // "Hello, John"
- * user.upperName // "JOHN"
- * ```
- */
-declare abstract class Macroable {
-  /**
-   * Set of instance properties that will be added to each instance during construction.
-   * Each entry contains a key and value pair representing the property name and its value.
-   */
-  protected static instanceMacros: Set<{
-    key: string | symbol | number;
-    value: unknown;
-  }>;
-  /**
-   * Adds a macro (property or method) to the class prototype.
-   * Macros are standard properties that get added to the class prototype,
-   * making them available on all instances of the class.
-   *
-   * @param name - The name of the property or method to add
-   * @param value - The value to assign to the property or method
-   *
-   * @example
-   * ```ts
-   * // Add a property macro
-   * MyClass.macro('version', '1.0.0')
-   *
-   * // Add a method macro
-   * MyClass.macro('greet', function() {
-   *   return 'Hello!'
-   * })
-   *
-   * const instance = new MyClass()
-   * instance.version // "1.0.0"
-   * instance.greet() // "Hello!"
-   * ```
-   */
-  static macro<T extends {
-    new (...args: any[]): any;
-  }, K extends keyof InstanceType<T>>(this: T, name: K, value: InstanceType<T>[K]): void;
-  /**
-   * Adds an instance property that will be assigned to each instance during construction.
-   * Unlike macros which are added to the prototype, instance properties are unique to each instance.
-   *
-   * @param name - The name of the property to add to instances
-   * @param value - The value to assign to the property on each instance
-   *
-   * @example
-   * ```ts
-   * // Add an instance method
-   * MyClass.instanceProperty('save', function() {
-   *   console.log('Saving...', this.id)
-   * })
-   *
-   * const { save } = new MyClass()
-   * save()
-   * ```
-   */
-  static instanceProperty<T extends {
-    new (...args: any[]): any;
-  }, K extends keyof InstanceType<T>>(this: T, name: K, value: InstanceType<T>[K]): void;
-  /**
-   * Adds a getter property to the class prototype using Object.defineProperty.
-   * Getters are computed properties that are evaluated each time they are accessed,
-   * unless the singleton flag is enabled.
-   *
-   * @param name - The name of the getter property
-   * @param accumulator - Function that computes and returns the property value
-   * @param singleton - If true, the getter value is cached after first access
-   *
-   * @example
-   * ```ts
-   * // Add a regular getter
-   * MyClass.getter('timestamp', function() {
-   *   return Date.now()
-   * })
-   *
-   * // Add a singleton getter (cached after first access)
-   * MyClass.getter('config', function() {
-   *   return loadConfig()
-   * }, true)
-   *
-   * const instance = new MyClass()
-   * instance.timestamp // Computed each time
-   * instance.config // Computed once, then cached
-   * ```
-   */
-  static getter<T extends {
-    new (...args: any[]): any;
-  }, K extends keyof InstanceType<T>>(this: T, name: K, accumulator: () => InstanceType<T>[K], singleton?: boolean): void;
-  /**
-   * Constructor that applies all registered instance properties to the new instance.
-   * This method iterates through the instanceMacros set and assigns each property
-   * to the instance, binding functions to the instance context.
-   */
-  constructor();
-}
-//#endregion
-//#region node_modules/@poppinss/hooks/build/src/runner.d.ts
-/**
- * Runner allows running a set of specific hook handlers for a given
- * event. You can grab the instance of the runner using the "hook.runner" method.
- *
- * ```ts
- * const hooks = new Hooks()
- *
- * await hooks.runner('saving').run()
- * ```
- */
-declare class Runner<HookArgs extends any[], CleanUpArgs extends any[]> {
-  #private;
-  action: string;
-  /**
-   * Find if cleanup is pending or not
-   *
-   * @example
-   * ```ts
-   * const runner = hooks.runner('saving')
-   * await runner.run()
-   *
-   * if (runner.isCleanupPending) {
-   *   await runner.cleanup()
-   * }
-   * ```
-   */
-  get isCleanupPending(): boolean;
-  /**
-   * Create a new Runner instance
-   *
-   * @param action - The name of the event/action this runner handles
-   * @param hookHandlers - Optional set of hook handlers to initialize with
-   *
-   * @example
-   * ```ts
-   * const runner = new Runner('saving', new Set([handler1, handler2]))
-   * ```
-   */
-  constructor(action: string, hookHandlers?: Set<HookHandler<HookArgs, CleanUpArgs> | HookHandlerProvider<HookArgs, CleanUpArgs>>);
-  /**
-   * Ignore specific or all hook handlers. Calling this
-   * method multiple times will result in overwriting
-   * the existing state.
-   *
-   * @param handlersToIgnore - Array of handler names to ignore, or undefined to skip all hooks
-   *
-   * @example
-   * ```ts
-   * // Skip specific handlers
-   * runner.without(['hashPassword', 'validateEmail']).run()
-   *
-   * // Skip all handlers
-   * runner.without().run()
-   * ```
-   */
-  without(handlersToIgnore?: string[]): this;
-  /**
-   * Execute handlers
-   *
-   * @param data - Arguments to pass to the hook handlers
-   *
-   * @example
-   * ```ts
-   * const runner = hooks.runner('saving')
-   * await runner.run(user, { email: 'new@example.com' })
-   * ```
-   */
-  run(...data: HookArgs): Promise<void>;
-  /**
-   * Execute handlers in reverse order
-   *
-   * @param data - Arguments to pass to the hook handlers
-   *
-   * @example
-   * ```ts
-   * const runner = hooks.runner('deleting')
-   * await runner.runReverse(user)
-   * ```
-   */
-  runReverse(...data: HookArgs): Promise<void>;
-  /**
-   * Execute cleanup actions
-   *
-   * @param data - Arguments to pass to the cleanup handlers
-   *
-   * @example
-   * ```ts
-   * const runner = hooks.runner('saving')
-   * await runner.run(user)
-   *
-   * // Later, cleanup any resources
-   * await runner.cleanup(user)
-   * ```
-   */
-  cleanup(...data: CleanUpArgs): Promise<void>;
-}
-//#endregion
-//#region node_modules/@poppinss/hooks/build/src/types.d.ts
-/**
- * Shape of the cleanup handler
- */
-type CleanupHandler<Args extends any[]> = (...args: Args) => void | Promise<void>;
-/**
- * Shape of the hook handler
- */
-type HookHandler<Args extends any[], CleanUpArgs extends any[]> = (...args: Args) => void | CleanupHandler<CleanUpArgs> | Promise<void> | Promise<CleanupHandler<CleanUpArgs>>;
-/**
- * Extracts args from a hook handler type
- */
-type ExtractHookHandlerArgs<Handler> = Handler extends HookHandler<infer A, infer B> ? [A, B] : never;
-/**
- * Hook represented as an object with handle method
- */
-type HookHandlerProvider<Args extends any[], CleanUpArgs extends any[]> = {
-  name: string;
-  handle(event: string, ...args: Args): void | CleanupHandler<CleanUpArgs> | Promise<void> | Promise<CleanupHandler<CleanUpArgs>>;
-};
-//#endregion
 //#region node_modules/@adonisjs/application/build/src/feature_flags.d.ts
 /**
  * A light weight implementation of feature flags to conditionally enable

package/build/{event_generator-B83LtJmu.d.ts → event_generator-DVSh_7fH.d.ts}

@@ -1,4 +1,4 @@
-import { t as BaseGenerator } from "./base_generator-ClKso0XJ.js";
+import { t as BaseGenerator } from "./base_generator-DOMn-U0f.js";
 
 //#region src/generators/event_generator.d.ts
 declare class EventGenerator extends BaseGenerator {

package/build/{job_generator-GmmbUvVL.d.ts → job_generator-BxEjVVDl.d.ts}

@@ -1,4 +1,4 @@
-import { t as BaseGenerator } from "./base_generator-ClKso0XJ.js";
+import { t as BaseGenerator } from "./base_generator-DOMn-U0f.js";
 
 //#region src/generators/job_generator.d.ts
 declare class JobGenerator extends BaseGenerator {

package/build/{mail_generator-B-TNNzl3.d.ts → mail_generator-2j0SThZE.d.ts}

@@ -1,4 +1,4 @@
-import { t as BaseGenerator } from "./base_generator-ClKso0XJ.js";
+import { t as BaseGenerator } from "./base_generator-DOMn-U0f.js";
 
 //#region src/generators/mail_generator.d.ts
 declare class MailGenerator extends BaseGenerator {

package/build/{notification_generator-C8kSV8HA.d.ts → notification_generator-BvDpMRu-.d.ts}

@@ -1,4 +1,4 @@
-import { t as BaseGenerator } from "./base_generator-ClKso0XJ.js";
+import { t as BaseGenerator } from "./base_generator-DOMn-U0f.js";
 
 //#region src/generators/notification_generator.d.ts
 declare class NotificationGenerator extends BaseGenerator {

package/build/{service_generator-Slb920qs.d.ts → service_generator-DkhvTVzm.d.ts}

@@ -1,4 +1,4 @@
-import { t as BaseGenerator } from "./base_generator-ClKso0XJ.js";
+import { t as BaseGenerator } from "./base_generator-DOMn-U0f.js";
 
 //#region src/generators/service_generator.d.ts
 declare class ServiceGenerator extends BaseGenerator {

package/build/src/commands/main.d.ts

@@ -1 +1,11 @@
 export declare const commands: (() => Promise<typeof import("./erase.js")>)[];
+/**
+ * Metadata for the commands.
+ * Used by Ace Kernel to display help/list.
+ */
+export declare function getMetaData(): Promise<import("@adonisjs/ace/types").CommandMetaData[]>;
+/**
+ * Loads a command by its name.
+ * Used by Ace Kernel when running a command.
+ */
+export declare function load(commandName: string): Promise<any>;

package/build/src/commands/main.js

@@ -6,5 +6,40 @@ const commands = [
 	() => import("./stubs.js"),
 	() => import("./init.js")
 ];
+/**
+* Metadata for the commands.
+* Used by Ace Kernel to display help/list.
+*/
+async function getMetaData() {
+	const [build, erase, trace, stubs, init] = await Promise.all([
+		import("./build.js"),
+		import("./erase.js"),
+		import("./trace.js"),
+		import("./stubs.js"),
+		import("./init.js")
+	]);
+	return [
+		build.default.serialize(),
+		erase.default.serialize(),
+		trace.default.serialize(),
+		stubs.default.serialize(),
+		init.default.serialize()
+	];
+}
+/**
+* Loads a command by its name.
+* Used by Ace Kernel when running a command.
+*/
+async function load(commandName) {
+	const map = {
+		"blueprint:build": () => import("./build.js"),
+		"blueprint:erase": () => import("./erase.js"),
+		"blueprint:trace": () => import("./trace.js"),
+		"blueprint:stubs": () => import("./stubs.js"),
+		"blueprint:init": () => import("./init.js")
+	};
+	if (map[commandName]) return map[commandName]();
+	throw new Error(`Command "${commandName}" not found`);
+}
 //#endregion
-export { commands };
+export { commands, getMetaData, load };

package/build/types-DGOelf2A.d.ts

@@ -0,0 +1,321 @@
+//#region node_modules/@poppinss/exception/build/src/exception.d.ts
+/**
+ * Create a custom error class with the ability to define the error
+ * code, status, and the help text.
+ *
+ * ```js
+ * export class FileNotFoundException extends Exception {
+ *   static status = 500
+ *   static code = 'E_FILE_NOT_FOUND'
+ * }
+ *
+ * throw new FileNotFoundException(
+ *  `Unable to find file from ${filePath} location`
+ * )
+ * ```
+ */
+declare class Exception extends Error {
+  /**
+   * Define the error metadata as static properties to avoid
+   * setting them repeatedly on the error instance
+   */
+  static help?: string;
+  static code?: string;
+  static status?: number;
+  static message?: string;
+  /**
+   * Name of the class that raised the exception.
+   */
+  name: string;
+  /**
+   * Optional help description for the error. You can use it to define additional
+   * human readable information for the error.
+   */
+  help?: string;
+  /**
+   * A machine readable error code. This will allow the error handling logic
+   * to narrow down exceptions based upon the error code.
+   */
+  code?: string;
+  /**
+   * A status code for the error. Usually helpful when converting errors
+   * to HTTP responses.
+   */
+  status: number;
+  constructor(message?: string, options?: ErrorOptions & {
+    code?: string;
+    status?: number;
+  });
+  get [Symbol.toStringTag](): string;
+  toString(): string;
+}
+declare class InvalidArgumentsException extends Exception {
+  static code: string;
+  static status: number;
+}
+declare class RuntimeException extends Exception {
+  static code: string;
+  static status: number;
+}
+/**
+ * Helper to create an anonymous error class.
+ *
+ * ```ts
+ *
+ * const E_RESOURCE_NOT_FOUND = createError<[number]>(
+ *   'Unable to find resource with id %d',
+ *   'E_RESOURCE_NOT_FOUND'
+ * )
+ * const id = 1
+ * throw new E_RESOURCE_NOT_FOUND([id])
+ *```
+ */
+declare function createError<T extends any[] = never>(message: string, code: string, status?: number): typeof Exception & T extends never ? {
+  new (args?: any, options?: ErrorOptions): Exception;
+} : {
+  new (args: T, options?: ErrorOptions): Exception;
+};
+//#endregion
+//#region node_modules/@poppinss/macroable/build/index.d.ts
+/**
+ * Abstract class that adds capabilities for extending classes from outside-in,
+ * in the form of macros, instance properties, and getters.
+ *
+ * @example
+ * ```ts
+ * class User extends Macroable {
+ *   name: string
+ *   constructor(name: string) {
+ *     super()
+ *     this.name = name
+ *   }
+ * }
+ *
+ * // Add a macro
+ * User.macro('greet', function() {
+ *   return `Hello, ${this.name}`
+ * })
+ *
+ * // Add a getter
+ * User.getter('upperName', function() {
+ *   return this.name.toUpperCase()
+ * })
+ *
+ * const user = new User('John')
+ * user.greet() // "Hello, John"
+ * user.upperName // "JOHN"
+ * ```
+ */
+declare abstract class Macroable {
+  /**
+   * Set of instance properties that will be added to each instance during construction.
+   * Each entry contains a key and value pair representing the property name and its value.
+   */
+  protected static instanceMacros: Set<{
+    key: string | symbol | number;
+    value: unknown;
+  }>;
+  /**
+   * Adds a macro (property or method) to the class prototype.
+   * Macros are standard properties that get added to the class prototype,
+   * making them available on all instances of the class.
+   *
+   * @param name - The name of the property or method to add
+   * @param value - The value to assign to the property or method
+   *
+   * @example
+   * ```ts
+   * // Add a property macro
+   * MyClass.macro('version', '1.0.0')
+   *
+   * // Add a method macro
+   * MyClass.macro('greet', function() {
+   *   return 'Hello!'
+   * })
+   *
+   * const instance = new MyClass()
+   * instance.version // "1.0.0"
+   * instance.greet() // "Hello!"
+   * ```
+   */
+  static macro<T extends {
+    new (...args: any[]): any;
+  }, K extends keyof InstanceType<T>>(this: T, name: K, value: InstanceType<T>[K]): void;
+  /**
+   * Adds an instance property that will be assigned to each instance during construction.
+   * Unlike macros which are added to the prototype, instance properties are unique to each instance.
+   *
+   * @param name - The name of the property to add to instances
+   * @param value - The value to assign to the property on each instance
+   *
+   * @example
+   * ```ts
+   * // Add an instance method
+   * MyClass.instanceProperty('save', function() {
+   *   console.log('Saving...', this.id)
+   * })
+   *
+   * const { save } = new MyClass()
+   * save()
+   * ```
+   */
+  static instanceProperty<T extends {
+    new (...args: any[]): any;
+  }, K extends keyof InstanceType<T>>(this: T, name: K, value: InstanceType<T>[K]): void;
+  /**
+   * Adds a getter property to the class prototype using Object.defineProperty.
+   * Getters are computed properties that are evaluated each time they are accessed,
+   * unless the singleton flag is enabled.
+   *
+   * @param name - The name of the getter property
+   * @param accumulator - Function that computes and returns the property value
+   * @param singleton - If true, the getter value is cached after first access
+   *
+   * @example
+   * ```ts
+   * // Add a regular getter
+   * MyClass.getter('timestamp', function() {
+   *   return Date.now()
+   * })
+   *
+   * // Add a singleton getter (cached after first access)
+   * MyClass.getter('config', function() {
+   *   return loadConfig()
+   * }, true)
+   *
+   * const instance = new MyClass()
+   * instance.timestamp // Computed each time
+   * instance.config // Computed once, then cached
+   * ```
+   */
+  static getter<T extends {
+    new (...args: any[]): any;
+  }, K extends keyof InstanceType<T>>(this: T, name: K, accumulator: () => InstanceType<T>[K], singleton?: boolean): void;
+  /**
+   * Constructor that applies all registered instance properties to the new instance.
+   * This method iterates through the instanceMacros set and assigns each property
+   * to the instance, binding functions to the instance context.
+   */
+  constructor();
+}
+//#endregion
+//#region node_modules/@poppinss/hooks/build/src/runner.d.ts
+/**
+ * Runner allows running a set of specific hook handlers for a given
+ * event. You can grab the instance of the runner using the "hook.runner" method.
+ *
+ * ```ts
+ * const hooks = new Hooks()
+ *
+ * await hooks.runner('saving').run()
+ * ```
+ */
+declare class Runner<HookArgs extends any[], CleanUpArgs extends any[]> {
+  #private;
+  action: string;
+  /**
+   * Find if cleanup is pending or not
+   *
+   * @example
+   * ```ts
+   * const runner = hooks.runner('saving')
+   * await runner.run()
+   *
+   * if (runner.isCleanupPending) {
+   *   await runner.cleanup()
+   * }
+   * ```
+   */
+  get isCleanupPending(): boolean;
+  /**
+   * Create a new Runner instance
+   *
+   * @param action - The name of the event/action this runner handles
+   * @param hookHandlers - Optional set of hook handlers to initialize with
+   *
+   * @example
+   * ```ts
+   * const runner = new Runner('saving', new Set([handler1, handler2]))
+   * ```
+   */
+  constructor(action: string, hookHandlers?: Set<HookHandler<HookArgs, CleanUpArgs> | HookHandlerProvider<HookArgs, CleanUpArgs>>);
+  /**
+   * Ignore specific or all hook handlers. Calling this
+   * method multiple times will result in overwriting
+   * the existing state.
+   *
+   * @param handlersToIgnore - Array of handler names to ignore, or undefined to skip all hooks
+   *
+   * @example
+   * ```ts
+   * // Skip specific handlers
+   * runner.without(['hashPassword', 'validateEmail']).run()
+   *
+   * // Skip all handlers
+   * runner.without().run()
+   * ```
+   */
+  without(handlersToIgnore?: string[]): this;
+  /**
+   * Execute handlers
+   *
+   * @param data - Arguments to pass to the hook handlers
+   *
+   * @example
+   * ```ts
+   * const runner = hooks.runner('saving')
+   * await runner.run(user, { email: 'new@example.com' })
+   * ```
+   */
+  run(...data: HookArgs): Promise<void>;
+  /**
+   * Execute handlers in reverse order
+   *
+   * @param data - Arguments to pass to the hook handlers
+   *
+   * @example
+   * ```ts
+   * const runner = hooks.runner('deleting')
+   * await runner.runReverse(user)
+   * ```
+   */
+  runReverse(...data: HookArgs): Promise<void>;
+  /**
+   * Execute cleanup actions
+   *
+   * @param data - Arguments to pass to the cleanup handlers
+   *
+   * @example
+   * ```ts
+   * const runner = hooks.runner('saving')
+   * await runner.run(user)
+   *
+   * // Later, cleanup any resources
+   * await runner.cleanup(user)
+   * ```
+   */
+  cleanup(...data: CleanUpArgs): Promise<void>;
+}
+//#endregion
+//#region node_modules/@poppinss/hooks/build/src/types.d.ts
+/**
+ * Shape of the cleanup handler
+ */
+type CleanupHandler<Args extends any[]> = (...args: Args) => void | Promise<void>;
+/**
+ * Shape of the hook handler
+ */
+type HookHandler<Args extends any[], CleanUpArgs extends any[]> = (...args: Args) => void | CleanupHandler<CleanUpArgs> | Promise<void> | Promise<CleanupHandler<CleanUpArgs>>;
+/**
+ * Extracts args from a hook handler type
+ */
+type ExtractHookHandlerArgs<Handler> = Handler extends HookHandler<infer A, infer B> ? [A, B] : never;
+/**
+ * Hook represented as an object with handle method
+ */
+type HookHandlerProvider<Args extends any[], CleanUpArgs extends any[]> = {
+  name: string;
+  handle(event: string, ...args: Args): void | CleanupHandler<CleanUpArgs> | Promise<void> | Promise<CleanupHandler<CleanUpArgs>>;
+};
+//#endregion
+export { Macroable as n, Exception as r, HookHandler as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anu8151/adonisjs-blueprint",
   "description": "Blueprint for AdonisJS 7",
-  "version": "0.3.9",
+  "version": "0.4.1",
   "engines": {
     "node": ">=24.0.0"
   },