@orchestr-sh/orchestr 1.11.0 → 1.11.2

package/dist/index.d.cts

@@ -1,25 +1,21 @@
+import { Event, EventClass } from "./Events/Event.cjs";
 import { Abstract, Binding, Concrete, Container } from "./Container/Container.cjs";
-import { ServiceProvider } from "./Foundation/ServiceProvider.cjs";
+import { EventListener, EventPayload, EventSubscriber, ListenerClosure, ListenerInterface, QueuedListener } from "./Events/types.cjs";
+import { DispatcherContract } from "./Events/Contracts/Dispatcher.cjs";
+import { Dispatcher } from "./Events/Dispatcher.cjs";
 import { Application } from "./Foundation/Application.cjs";
-import { Request } from "./Routing/Request.cjs";
+import { ServiceProvider } from "./Foundation/ServiceProvider.cjs";
+import { EventServiceProvider } from "./Events/EventServiceProvider.cjs";
+import { Dispatchable, applyDispatchable } from "./Events/Concerns/Dispatchable.cjs";
+import { Config as Config$1 } from "./Foundation/Config/Config.cjs";
+import { Facade } from "./Support/Facade.cjs";
+import { Config } from "./Facades/Config.cjs";
+import { DB } from "./Facades/DB.cjs";
 import { CookieOptions, Response } from "./Routing/Response.cjs";
 import { HttpMethod, Middleware, Route as Route$1, RouteAction } from "./Routing/Route.cjs";
+import { Request } from "./Routing/Request.cjs";
 import { Router } from "./Routing/Router.cjs";
-import { Kernel } from "./Foundation/Http/Kernel.cjs";
-import { ValidationRule, ValidationRuleObject, ValidationRules, Validator } from "./Foundation/Http/Validator.cjs";
-import { ValidationException } from "./Foundation/Http/ValidationException.cjs";
-import { FormRequest } from "./Foundation/Http/FormRequest.cjs";
-import { Rule } from "./Foundation/Http/Rule.cjs";
-import { Config as Config$1 } from "./Foundation/Config/Config.cjs";
-import { ConfigServiceProvider } from "./Foundation/Config/ConfigServiceProvider.cjs";
-import { Controller } from "./Routing/Controller.cjs";
-import { Facade } from "./Support/Facade.cjs";
 import { Route } from "./Facades/Route.cjs";
-import { Config } from "./Facades/Config.cjs";
-import { Event, EventClass } from "./Events/Event.cjs";
-import { EventListener, EventPayload, EventSubscriber, ListenerClosure, ListenerInterface, QueuedListener } from "./Events/types.cjs";
-import { DispatcherContract } from "./Events/Contracts/Dispatcher.cjs";
-import { Dispatcher } from "./Events/Dispatcher.cjs";
 import { Event as Event$1 } from "./Facades/Event.cjs";
 import { PendingDispatch } from "./Queue/PendingDispatch.cjs";
 import { JobMiddleware } from "./Queue/Middleware/JobMiddleware.cjs";
@@ -40,6 +36,13 @@ import { TaggedCache } from "./Cache/Tags/TaggedCache.cjs";
 import { Repository } from "./Cache/Repository.cjs";
 import { CacheConfig, CacheManager, StoreConfig, StoreFactory } from "./Cache/CacheManager.cjs";
 import { Cache } from "./Facades/Cache.cjs";
+import { Kernel } from "./Foundation/Http/Kernel.cjs";
+import { ValidationRule, ValidationRuleObject, ValidationRules, Validator } from "./Foundation/Http/Validator.cjs";
+import { ValidationException } from "./Foundation/Http/ValidationException.cjs";
+import { FormRequest } from "./Foundation/Http/FormRequest.cjs";
+import { Rule } from "./Foundation/Http/Rule.cjs";
+import { ConfigServiceProvider } from "./Foundation/Config/ConfigServiceProvider.cjs";
+import { Controller } from "./Routing/Controller.cjs";
 import { ViewEngine } from "./View/Engines/ViewEngine.cjs";
 import { TemplateEngine, TemplateEngineResolver } from "./View/Engines/TemplateEngine.cjs";
 import { View } from "./View/View.cjs";
@@ -60,7 +63,6 @@ import { Connection } from "./Database/Connection.cjs";
 import { DatabaseConnectionConfig, DatabaseManager, DatabaseManagerConfig } from "./Database/DatabaseManager.cjs";
 import { Expression, raw } from "./Database/Query/Expression.cjs";
 import { DrizzleAdapter } from "./Database/Adapters/DrizzleAdapter.cjs";
-import { DB } from "./Facades/DB.cjs";
 import { EnsembleCollection } from "./Database/Ensemble/EnsembleCollection.cjs";
 import { Relation } from "./Database/Ensemble/Relations/Relation.cjs";
 import { HasOne } from "./Database/Ensemble/Relations/HasOne.cjs";
@@ -142,8 +144,6 @@ import { DeployEnvCommand } from "./Console/Commands/DeployEnvCommand.cjs";
 import { DeployRollbackCommand } from "./Console/Commands/DeployRollbackCommand.cjs";
 import { DeployProvisionCommand } from "./Console/Commands/DeployProvisionCommand.cjs";
 import { ProvisionOptions, Provisioner } from "./Deploy/Provisioner.cjs";
-import { EventServiceProvider } from "./Events/EventServiceProvider.cjs";
-import { Dispatchable, applyDispatchable } from "./Events/Concerns/Dispatchable.cjs";
 import { ModelEvent } from "./Database/Ensemble/Events/ModelEvent.cjs";
 import { ModelRetrieved } from "./Database/Ensemble/Events/ModelRetrieved.cjs";
 import { ModelCreating } from "./Database/Ensemble/Events/ModelCreating.cjs";

package/dist/index.d.mts

@@ -1,25 +1,21 @@
+import { Event, EventClass } from "./Events/Event.mjs";
 import { Abstract, Binding, Concrete, Container } from "./Container/Container.mjs";
-import { ServiceProvider } from "./Foundation/ServiceProvider.mjs";
+import { EventListener, EventPayload, EventSubscriber, ListenerClosure, ListenerInterface, QueuedListener } from "./Events/types.mjs";
+import { DispatcherContract } from "./Events/Contracts/Dispatcher.mjs";
+import { Dispatcher } from "./Events/Dispatcher.mjs";
 import { Application } from "./Foundation/Application.mjs";
-import { Request } from "./Routing/Request.mjs";
+import { ServiceProvider } from "./Foundation/ServiceProvider.mjs";
+import { EventServiceProvider } from "./Events/EventServiceProvider.mjs";
+import { Dispatchable, applyDispatchable } from "./Events/Concerns/Dispatchable.mjs";
+import { Config as Config$1 } from "./Foundation/Config/Config.mjs";
+import { Facade } from "./Support/Facade.mjs";
+import { Config } from "./Facades/Config.mjs";
+import { DB } from "./Facades/DB.mjs";
 import { CookieOptions, Response } from "./Routing/Response.mjs";
 import { HttpMethod, Middleware, Route as Route$1, RouteAction } from "./Routing/Route.mjs";
+import { Request } from "./Routing/Request.mjs";
 import { Router } from "./Routing/Router.mjs";
-import { Kernel } from "./Foundation/Http/Kernel.mjs";
-import { ValidationRule, ValidationRuleObject, ValidationRules, Validator } from "./Foundation/Http/Validator.mjs";
-import { ValidationException } from "./Foundation/Http/ValidationException.mjs";
-import { FormRequest } from "./Foundation/Http/FormRequest.mjs";
-import { Rule } from "./Foundation/Http/Rule.mjs";
-import { Config as Config$1 } from "./Foundation/Config/Config.mjs";
-import { ConfigServiceProvider } from "./Foundation/Config/ConfigServiceProvider.mjs";
-import { Controller } from "./Routing/Controller.mjs";
-import { Facade } from "./Support/Facade.mjs";
 import { Route } from "./Facades/Route.mjs";
-import { Config } from "./Facades/Config.mjs";
-import { Event, EventClass } from "./Events/Event.mjs";
-import { EventListener, EventPayload, EventSubscriber, ListenerClosure, ListenerInterface, QueuedListener } from "./Events/types.mjs";
-import { DispatcherContract } from "./Events/Contracts/Dispatcher.mjs";
-import { Dispatcher } from "./Events/Dispatcher.mjs";
 import { Event as Event$1 } from "./Facades/Event.mjs";
 import { PendingDispatch } from "./Queue/PendingDispatch.mjs";
 import { JobMiddleware } from "./Queue/Middleware/JobMiddleware.mjs";
@@ -40,6 +36,13 @@ import { TaggedCache } from "./Cache/Tags/TaggedCache.mjs";
 import { Repository } from "./Cache/Repository.mjs";
 import { CacheConfig, CacheManager, StoreConfig, StoreFactory } from "./Cache/CacheManager.mjs";
 import { Cache } from "./Facades/Cache.mjs";
+import { Kernel } from "./Foundation/Http/Kernel.mjs";
+import { ValidationRule, ValidationRuleObject, ValidationRules, Validator } from "./Foundation/Http/Validator.mjs";
+import { ValidationException } from "./Foundation/Http/ValidationException.mjs";
+import { FormRequest } from "./Foundation/Http/FormRequest.mjs";
+import { Rule } from "./Foundation/Http/Rule.mjs";
+import { ConfigServiceProvider } from "./Foundation/Config/ConfigServiceProvider.mjs";
+import { Controller } from "./Routing/Controller.mjs";
 import { ViewEngine } from "./View/Engines/ViewEngine.mjs";
 import { TemplateEngine, TemplateEngineResolver } from "./View/Engines/TemplateEngine.mjs";
 import { View } from "./View/View.mjs";
@@ -60,7 +63,6 @@ import { Connection } from "./Database/Connection.mjs";
 import { DatabaseConnectionConfig, DatabaseManager, DatabaseManagerConfig } from "./Database/DatabaseManager.mjs";
 import { Expression, raw } from "./Database/Query/Expression.mjs";
 import { DrizzleAdapter } from "./Database/Adapters/DrizzleAdapter.mjs";
-import { DB } from "./Facades/DB.mjs";
 import { EnsembleCollection } from "./Database/Ensemble/EnsembleCollection.mjs";
 import { Relation } from "./Database/Ensemble/Relations/Relation.mjs";
 import { HasOne } from "./Database/Ensemble/Relations/HasOne.mjs";
@@ -142,8 +144,6 @@ import { DeployEnvCommand } from "./Console/Commands/DeployEnvCommand.mjs";
 import { DeployRollbackCommand } from "./Console/Commands/DeployRollbackCommand.mjs";
 import { DeployProvisionCommand } from "./Console/Commands/DeployProvisionCommand.mjs";
 import { ProvisionOptions, Provisioner } from "./Deploy/Provisioner.mjs";
-import { EventServiceProvider } from "./Events/EventServiceProvider.mjs";
-import { Dispatchable, applyDispatchable } from "./Events/Concerns/Dispatchable.mjs";
 import { ModelEvent } from "./Database/Ensemble/Events/ModelEvent.mjs";
 import { ModelRetrieved } from "./Database/Ensemble/Events/ModelRetrieved.mjs";
 import { ModelCreating } from "./Database/Ensemble/Events/ModelCreating.mjs";

package/docs/events-typescript-usage.md

@@ -0,0 +1,126 @@
+# Events TypeScript Usage Guide
+
+## Problem: TypeScript doesn't recognize static dispatch methods
+
+When you create an event class that extends `Event`, TypeScript may not automatically recognize the static `dispatch()`, `dispatchIf()`, `dispatchUnless()`, and `until()` methods that are added by the Dispatchable mixin.
+
+```typescript
+import { Event } from '@orchestr-sh/orchestr';
+
+class UserRegistered extends Event {
+  constructor(public user: User) {
+    super();
+  }
+}
+
+// TypeScript error: Property 'dispatch' does not exist on type 'typeof UserRegistered'
+UserRegistered.dispatch(user);
+```
+
+## Solution 1: Use type assertion (Quick Fix)
+
+The simplest solution is to cast your event class to the `EventClass` type:
+
+```typescript
+import { Event, type EventClass } from '@orchestr-sh/orchestr';
+
+class UserRegistered extends Event {
+  constructor(public user: User) {
+    super();
+  }
+}
+
+// Cast to EventClass to get proper typing
+const UserRegisteredEvent = UserRegistered as EventClass<UserRegistered>;
+
+// Now TypeScript recognizes the static methods
+UserRegisteredEvent.dispatch(user);
+UserRegisteredEvent.dispatchIf(condition, user);
+UserRegisteredEvent.dispatchUnless(condition, user);
+await UserRegisteredEvent.until(user);
+```
+
+## Solution 2: Use Event facade (Recommended)
+
+The recommended approach is to use the Event facade for dispatching. You can import it in two ways:
+
+**Option A: Subpath import (cleaner)**
+```typescript
+import { Event } from '@orchestr-sh/orchestr/Facades';
+
+class UserRegistered extends Event {
+  constructor(public user: User) {
+    super();
+  }
+}
+
+// Dispatch through the facade - fully typed
+Event.dispatch(new UserRegistered(user));
+Event.dispatchIf(condition, new UserRegistered(user));
+Event.dispatchUnless(condition, new UserRegistered(user));
+await Event.until(new UserRegistered(user));
+```
+
+**Option B: Named import from main package**
+```typescript
+import { EventFacade } from '@orchestr-sh/orchestr';
+
+// Use EventFacade to avoid naming conflict with Event base class
+EventFacade.dispatch(new UserRegistered(user));
+```
+
+## Solution 3: Export with proper typing
+
+Export your event classes with the proper type in your event files:
+
+```typescript
+// UserRegistered.ts
+import { Event, type EventClass } from '@orchestr-sh/orchestr';
+
+class UserRegisteredClass extends Event {
+  constructor(public user: User) {
+    super();
+  }
+}
+
+// Export with proper typing
+export const UserRegistered = UserRegisteredClass as EventClass<UserRegisteredClass>;
+export type UserRegistered = InstanceType<typeof UserRegistered>;
+```
+
+Then use it elsewhere:
+
+```typescript
+import { UserRegistered } from './Events/UserRegistered';
+
+// Full TypeScript support
+UserRegistered.dispatch(user);
+UserRegistered.dispatchIf(condition, user);
+```
+
+## Why This Happens
+
+The static methods (`dispatch`, `dispatchIf`, etc.) are added to the Event class at runtime by the `applyDispatchable()` function, which uses JavaScript's `Object.defineProperty`. TypeScript's type system doesn't automatically detect these runtime-added methods.
+
+The `EventClass<T>` type helper provides the correct type information to TypeScript, telling it that these static methods exist on your event class.
+
+## Best Practice Recommendation
+
+For most use cases, we recommend **Solution 2** (using the Event facade):
+
+```typescript
+Event.dispatch(new UserRegistered(user));
+```
+
+This approach:
+- ✅ Has full TypeScript support out of the box
+- ✅ Is more explicit and easier to understand
+- ✅ Works consistently across all event classes
+- ✅ Follows Laravel's recommended pattern
+- ✅ Makes testing easier (Event.fake() works seamlessly)
+
+Reserve the static class methods for cases where you want the syntactic sugar:
+
+```typescript
+UserRegistered.dispatch(user);  // Shorter, but requires type casting
+```

package/docs/future-improvements.md

@@ -0,0 +1,49 @@
+# Future Improvements
+
+## Traits Refactoring (Deferred)
+
+**Goal:** Refactor all mixins to use `@orchestr-sh/traits` for better PHP-like syntax and automatic TypeScript support.
+
+### Current Mixins to Migrate
+1. **Dispatchable** (Events) - Low risk, good starting point
+2. **HasDynamicRelations** (Ensemble) - Medium risk, uses Proxies
+3. **HasRelationships** (Ensemble) - High risk, core ORM functionality
+
+### Benefits
+- Eliminate need for `EventClass` type helper
+- More PHP-like trait syntax
+- Better TypeScript inference
+- Cleaner, more maintainable code
+
+### Prerequisites Before Starting
+1. ✅ Validate `@orchestr-sh/traits` handles:
+   - Static methods (e.g., `Dispatchable.dispatch()`)
+   - Property conflicts between traits
+   - Interaction with existing decorators (@DynamicRelation)
+   - Proxy objects (HasDynamicRelations)
+2. ✅ Create POC with Dispatchable trait only
+3. ✅ Verify test coverage is sufficient to catch regressions
+4. ✅ Gather user feedback on current DX - is this actually a pain point?
+
+### Migration Strategy (When Ready)
+**Phase 1:** Dispatchable trait (lowest risk)
+- Migrate Events/Concerns/Dispatchable to use traits
+- Ship and validate in production
+- Measure DX improvement
+
+**Phase 2:** HasDynamicRelations (if Phase 1 succeeds)
+- More complex due to Proxy usage
+- Test thoroughly with all relationship types
+
+**Phase 3:** HasRelationships (highest risk, save for last)
+- Core ORM functionality
+- Affects all models and relationships
+- Extensive testing required
+
+### Decision: Deferred
+**Reason:** Current implementation is production-ready (9.9/10 code review). The TypeScript typing issue has documented workarounds. No user pain point driving this change. Premature to refactor stable code.
+
+**Revisit when:**
+- Users report DX friction with current approach
+- `@orchestr-sh/traits` is proven in production
+- We have capacity for the migration effort

package/docs/validation.md

@@ -0,0 +1,201 @@
+# Validation Usage
+
+This guide shows how to validate request data using the Validator and the Rule builder. It covers defining rules, conditional logic, arrays, dates, numbers, networks and files, plus customizing error messages.
+
+## Quick Start
+
+- Create a Validator with input data and a rules object.
+- Use the Rule builder to compose rule instances.
+- Call `validate()` to run rules; read `errors()` for messages.
+
+```ts
+import { Validator } from '@/Foundation/Http/Validator';
+import { Rule } from '@/Foundation/Http/Rule';
+
+const data = { email: 'user@example.com', age: 18 };
+const rules = {
+  email: [Rule.required(), Rule.email()],
+  age: [Rule.required(), Rule.integer(), Rule.min(18)],
+};
+
+const v = new Validator(data, rules);
+const ok = await v.validate(); // true/false
+const errs = v.errors(); // { email?: string[], age?: string[] }
+```
+
+## Rule Builder
+
+Use `Rule.*()` methods to construct validation rules. Every call returns a rule object. Common examples:
+
+- Presence: `required()`, `present()`, `filled()`, `nullable()`, `sometimes()`
+- Strings: `string()`, `alpha()`, `alphaNum()`, `alphaDash()`, `lowercase()`, `uppercase()`, `ascii()`
+- Patterns: `regex(/.../)`, `notRegex(/.../)`, `email()`, `json()`
+- Numbers: `numeric()`, `integer()`, `decimal(places?)`, `min(n)`, `max(n)`, `between(min,max)`, `size(n)`
+- Digits: `digits(n)`, `digitsBetween(min,max)`, `minDigits(n)`, `maxDigits(n)`, `multipleOf(n)`
+- Comparison: `gt(fieldOrValue)`, `gte(fieldOrValue)`, `lt(fieldOrValue)`, `lte(fieldOrValue)`
+- Arrays: `array()`, `distinct()`, `in([...])`, `notIn([...])`, `inArray(field)`
+- Dates: `date()`, `dateEquals(date)`, `after(dateOrField)`, `afterOrEqual(...)`, `before(...)`, `beforeOrEqual(...)`
+- Network: `url()`, `activeUrl()`, `ip()`, `ipv4()`, `ipv6()`, `macAddress()`, `uuid()`, `timezone()`
+- Files: `file()`, `image()`, `mimetypes([...])`, `mimes([...])`
+- Conditionals: `accepted()`, `acceptedIf(field,val)`, `declined()`, `declinedIf(field,val)`
+
+## Conditional Presence
+
+Require a field based on other inputs:
+
+```ts
+const rules = {
+  type: [Rule.required(), Rule.string()],
+  cc: [Rule.requiredIf('type', 'card')], // required when type == 'card'
+};
+```
+
+Other variants:
+
+- `requiredUnless(field, val)`
+- `requiredWith(...fields)`
+- `requiredWithAll(...fields)`
+- `requiredWithout(...fields)`
+- `requiredWithoutAll(...fields)`
+
+Prohibited variants:
+
+- `prohibited()`
+- `prohibitedIf(field, val)`
+- `prohibitedUnless(field, val)`
+- `prohibits(...fields)` (current field prohibits the listed fields)
+
+## Starts/Ends With
+
+```ts
+const rules = {
+  slug: [Rule.startsWith(['user']), Rule.endsWith(['admin'])],
+};
+```
+
+## Comparisons
+
+Compare against another field or literal:
+
+```ts
+const rules = {
+  max: [Rule.gt('min')],       // max > min
+  threshold: [Rule.gte(10)],   // threshold >= 10
+};
+```
+
+## Arrays
+
+```ts
+const rules = {
+  tags: [Rule.array(), Rule.distinct()],
+  choice: [Rule.inArray('choices')],
+  status: [Rule.in(['open', 'closed'])],
+};
+```
+
+## Dates
+
+```ts
+const rules = {
+  start: [Rule.date(), Rule.after('2020-01-01')],
+  end: [Rule.date(), Rule.afterOrEqual('start')],
+};
+```
+
+## Files
+
+```ts
+const rules = {
+  avatar: [Rule.file(), Rule.image(), Rule.mimes(['png','jpg'])],
+  doc: [Rule.file(), Rule.mimetypes(['application/pdf'])],
+};
+```
+
+## Custom Messages
+
+Pass per-field messages via the Validator:
+
+```ts
+const messages = {
+  'email.required': 'Email is required',
+  'email.email': 'Email must be valid',
+};
+const v = new Validator(data, rules, messages);
+```
+
+Rule classes may also provide tailored messages when they are invokable; otherwise messages fall back to defaults.
+
+## Form Requests
+
+Encapsulate validation by extending `FormRequest`. Define `rules()` and `messages()` then call `validated()`:
+
+```ts
+import { FormRequest } from '@/Foundation/Http/FormRequest';
+import { Rule } from '@/Foundation/Http/Rule';
+
+class CreateUserRequest extends FormRequest {
+  rules() {
+    return {
+      email: [Rule.required(), Rule.email()],
+      password: [Rule.required(), Rule.string(), Rule.min(8)],
+    };
+  }
+  messages() {
+    return {
+      'password.min': 'Password must be at least 8 characters',
+    };
+  }
+}
+```
+
+Use it in your controller/handler to validate and access sanitized inputs.
+
+## Auth Validation
+
+Some rules interact with authentication and require app-specific wiring:
+
+- current_password
+  - Recognized as a token; by default it passes until you connect it to your auth system.
+  - Use as a string rule: 
+    ```ts
+    const rules = { current_password: 'current_password' };
+    ```
+  - Integration options:
+    - Prefer user identity checks in `FormRequest.authorize()`.
+    - Or provide a custom invokable rule that verifies the password:
+      ```ts
+      import { BaseRule } from '@/Foundation/Http/Rules';
+      import { Auth } from '@/Auth'; // your auth API
+      class CurrentPasswordRule extends BaseRule {
+        constructor() { super('current_password'); this.invokable = true; }
+        async passes(_attr: string, value: any): Promise<boolean> {
+          const user = Auth.user();
+          if (!user) return false;
+          return Auth.verify(user, String(value));
+        }
+        messageFor(attribute: string) { return `The ${attribute} is incorrect.`; }
+      }
+      const rules = { current_password: [new CurrentPasswordRule()] };
+      ```
+
+- password
+  - Builder: `Rule.password()`; enforcement is application-defined.
+  - Recommended: express policy via built-in tokens (`string|min|max|confirmed|regex`) or a custom invokable rule that centralizes password policy checks.
+
+- can:ability
+  - Builder: `Rule.can('update-post')` returns a token.
+  - Recommended: perform authorization in `FormRequest.authorize()`; use validation for data constraints. If you need field-level gating, implement an invokable rule that queries your Gate/Policy and returns an error message when unauthorized.
+
+## Error Handling
+
+- `validate()` returns `true/false`
+- `errors()` returns a map of field → error messages
+- Throw `ValidationException` or handle manually depending on your flow
+
+## Tips
+
+- Chain rules in arrays to compose complex constraints
+- Prefer field comparisons (gt/gte/lt/lte) for relational checks
+- Use conditional presence for dynamic forms
+- Keep messages clear and domain-specific for better UX

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orchestr-sh/orchestr",
   "type": "module",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "description": "A 1:1 Laravel replica in TypeScript - Brings Laravel's elegant syntax and architecture to Node.js",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -24,19 +24,57 @@
     }
   },
   "bin": {
-    "orchestr": "dist/Console/orchestr.js"
+    "orchestr": "dist/Console/orchestr.mjs"
   },
   "files": [
     "dist",
-    "README.md",
-    "LICENSE"
+    "docs",
+    "CODE_OF_CONDUCT.md",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "LICENSE",
+    "README.md"
   ],
   "release": {
     "branches": [
       "main"
     ],
     "plugins": [
-      "@semantic-release/commit-analyzer",
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "releaseRules": [
+            {
+              "type": "build",
+              "release": "patch"
+            },
+            {
+              "type": "ci",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "refactor",
+              "release": "patch"
+            },
+            {
+              "type": "style",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            }
+          ]
+        }
+      ],
       "@semantic-release/release-notes-generator",
       [
         "@semantic-release/changelog",
@@ -46,21 +84,17 @@
       ],
       "@semantic-release/npm",
       [
-        "@semantic-release/github",
+        "@semantic-release/git",
         {
           "assets": [
-            "dist",
-            "docs",
             "package.json",
             "package-lock.json",
-            "CODE_OF_CONDUCT.md",
-            "CHANGELOG.md",
-            "CONTRIBUTING.md",
-            "LICENSE",
-            "README.md"
-          ]
+            "CHANGELOG.md"
+          ],
+          "message": "chore(version): release ${nextRelease.version} [skip ci]"
         }
-      ]
+      ],
+      "@semantic-release/github"
     ]
   },
   "commitlint": {
@@ -73,12 +107,12 @@
     "prepublishOnly": "npm run build",
     "dev": "tsx watch examples/basic-app/server.ts",
     "prepare": "husky",
-    "lint": "oxlint 'src/**/*.ts' --type-aware --fix && oxfmt --write 'src/**/*.ts'",
-    "format": "oxfmt --write 'src/**/*.ts'",
-    "format:check": "oxfmt --check 'src/**/*.ts'",
+    "lint": "oxlint --type-aware --fix src && oxfmt --write src",
+    "format": "oxfmt --write src",
+    "format:check": "oxfmt --check src",
     "test": "vitest run",
-    "test:lint": "oxlint 'src/**/*.ts' --type-aware && oxfmt --check 'src/**/*.ts'",
-    "test:types": "oxlint 'src/**/*.ts' --type-aware --type-check",
+    "test:lint": "oxlint --type-aware src && oxfmt --check src",
+    "test:types": "oxlint --type-aware --type-check src",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage"
   },
@@ -114,27 +148,27 @@
   },
   "homepage": "https://github.com/orchestr-sh/orchestr#readme",
   "engines": {
-    "node": ">=22.0.0"
+    "node": "^22.18.0 || >=24.0.0"
   },
   "dependencies": {
     "drizzle-orm": ">=0.30.0",
     "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.4.4",
-    "@commitlint/config-conventional": "^20.4.4",
+    "@commitlint/cli": "^20.5.3",
+    "@commitlint/config-conventional": "^20.5.3",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^25.5.0",
-    "@vitest/coverage-v8": "^4.1.2",
+    "@types/node": "^25.6.2",
+    "@vitest/coverage-v8": "^4.1.5",
     "husky": "^9.1.7",
-    "lint-staged": "^16.4.0",
-    "oxfmt": "^0.43.0",
-    "oxlint": "^1.58.0",
-    "oxlint-tsgolint": "^0.19.0",
-    "tsdown": "^0.21.7",
+    "lint-staged": "^17.0.2",
+    "oxfmt": "^0.48.0",
+    "oxlint": "^1.63.0",
+    "oxlint-tsgolint": "^0.22.1",
+    "tsdown": "^0.22.0",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
     "drizzle-orm": ">=0.30.0",