@velajs/vela 0.10.0 → 1.1.0

package/dist/schedule/cron-matcher.d.ts

@@ -0,0 +1,2 @@
+export type CronMatcher = (date: Date) => boolean;
+export declare function parseCron(expression: string): CronMatcher | null;

package/dist/schedule/cron-matcher.js

@@ -0,0 +1,62 @@
+export function parseCron(expression) {
+    const fields = expression.trim().split(/\s+/);
+    if (fields.length !== 5) return null;
+    const [minuteField, hourField, dayField, monthField, weekdayField] = fields;
+    const minute = parseField(minuteField, 0, 59);
+    const hour = parseField(hourField, 0, 23);
+    const day = parseField(dayField, 1, 31);
+    const month = parseField(monthField, 1, 12);
+    const weekday = parseField(weekdayField, 0, 7);
+    if (!minute || !hour || !day || !month || !weekday) return null;
+    return (date)=>minute(date.getMinutes()) && hour(date.getHours()) && day(date.getDate()) && month(date.getMonth() + 1) && weekday(date.getDay());
+}
+function parseField(field, min, max) {
+    const segments = field.split(',');
+    const predicates = [];
+    for (const rawSegment of segments){
+        const segment = rawSegment.trim();
+        if (!segment) return null;
+        const stepParts = segment.split('/');
+        if (stepParts.length > 2) return null;
+        const step = stepParts.length === 2 ? Number(stepParts[1]) : 1;
+        if (!Number.isInteger(step) || step <= 0) return null;
+        const range = parseRange(stepParts[0], min, max);
+        if (!range) return null;
+        predicates.push((value)=>{
+            if (value < range.start || value > range.end) return false;
+            return (value - range.start) % step === 0;
+        });
+    }
+    return (value)=>predicates.some((p)=>p(value));
+}
+function parseRange(segment, min, max) {
+    if (segment === '*') return {
+        start: min,
+        end: max
+    };
+    const bounds = segment.split('-');
+    if (bounds.length === 1) {
+        const value = parseCronNumber(bounds[0], min, max);
+        if (value === null) return null;
+        return {
+            start: value,
+            end: value
+        };
+    }
+    if (bounds.length !== 2) return null;
+    const start = parseCronNumber(bounds[0], min, max);
+    const end = parseCronNumber(bounds[1], min, max);
+    if (start === null || end === null || start > end) return null;
+    return {
+        start,
+        end
+    };
+}
+function parseCronNumber(raw, min, max) {
+    const value = Number(raw);
+    if (!Number.isInteger(value)) return null;
+    // Cron allows 0 and 7 as Sunday.
+    const normalized = max === 7 && value === 7 ? 0 : value;
+    if (normalized < min || normalized > max) return null;
+    return normalized;
+}

package/dist/schedule/index.d.ts

@@ -1,7 +1,8 @@
 export { ScheduleModule } from './schedule.module';
 export { ScheduleRegistry } from './schedule.registry';
 export type { RegisteredCronJob, RegisteredIntervalJob } from './schedule.registry';
-export { ScheduleExecutor } from './schedule.executor';
 export { Cron, Interval } from './schedule.decorators';
-export { SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA } from './schedule.tokens';
-export type { CronMetadata, IntervalMetadata, ScheduleModuleOptions } from './schedule.types';
+export { CRON_METADATA, INTERVAL_METADATA } from './schedule.tokens';
+export type { CronMetadata, IntervalMetadata } from './schedule.types';
+export { parseCron } from './cron-matcher';
+export type { CronMatcher } from './cron-matcher';

package/dist/schedule/index.js

@@ -1,5 +1,5 @@
 export { ScheduleModule } from "./schedule.module.js";
 export { ScheduleRegistry } from "./schedule.registry.js";
-export { ScheduleExecutor } from "./schedule.executor.js";
 export { Cron, Interval } from "./schedule.decorators.js";
-export { SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
+export { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
+export { parseCron } from "./cron-matcher.js";

package/dist/schedule/schedule.decorators.js

@@ -1,21 +1,18 @@
+import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
 export function Cron(expression) {
     return (target, propertyKey)=>{
-        const existing = Reflect.getMetadata(CRON_METADATA, target.constructor) ?? [];
-        existing.push({
+        MetadataRegistry.appendCustomClassMeta(target.constructor, CRON_METADATA, {
             expression,
             methodName: String(propertyKey)
         });
-        Reflect.defineMetadata(CRON_METADATA, existing, target.constructor);
     };
 }
 export function Interval(ms) {
     return (target, propertyKey)=>{
-        const existing = Reflect.getMetadata(INTERVAL_METADATA, target.constructor) ?? [];
-        existing.push({
+        MetadataRegistry.appendCustomClassMeta(target.constructor, INTERVAL_METADATA, {
             ms,
             methodName: String(propertyKey)
         });
-        Reflect.defineMetadata(INTERVAL_METADATA, existing, target.constructor);
     };
 }

package/dist/schedule/schedule.module.d.ts

@@ -1,8 +1,4 @@
-import type { AsyncModuleOptions, DynamicModule } from '../module/types';
-import type { ScheduleModuleOptions } from './schedule.types';
+import type { DynamicModule } from '../module/types';
 export declare class ScheduleModule {
-    static forRoot(options?: ScheduleModuleOptions): DynamicModule;
-    static forRootAsync(options: AsyncModuleOptions<ScheduleModuleOptions> & {
-        enableTimers?: boolean;
-    }): DynamicModule;
+    static forRoot(): DynamicModule;
 }

package/dist/schedule/schedule.module.js

@@ -1,53 +1,15 @@
-import { ScheduleExecutor } from "./schedule.executor.js";
 import { ScheduleRegistry } from "./schedule.registry.js";
-import { SCHEDULE_MODULE_OPTIONS } from "./schedule.tokens.js";
 export class ScheduleModule {
-    static forRoot(options = {}) {
-        const { enableTimers = false } = options;
+    static forRoot() {
         const providers = [
-            {
-                provide: SCHEDULE_MODULE_OPTIONS,
-                useValue: options
-            },
             ScheduleRegistry
         ];
-        const exports = [
-            SCHEDULE_MODULE_OPTIONS,
-            ScheduleRegistry
-        ];
-        if (enableTimers) {
-            providers.push(ScheduleExecutor);
-            exports.push(ScheduleExecutor);
-        }
-        return {
-            module: ScheduleModule,
-            providers,
-            exports
-        };
-    }
-    static forRootAsync(options) {
-        const { enableTimers = false } = options;
-        const providers = [
-            {
-                provide: SCHEDULE_MODULE_OPTIONS,
-                useFactory: options.useFactory,
-                inject: options.inject ?? []
-            },
-            ScheduleRegistry
-        ];
-        const exports = [
-            SCHEDULE_MODULE_OPTIONS,
-            ScheduleRegistry
-        ];
-        if (enableTimers) {
-            providers.push(ScheduleExecutor);
-            exports.push(ScheduleExecutor);
-        }
         return {
             module: ScheduleModule,
-            imports: options.imports ?? [],
             providers,
-            exports
+            exports: [
+                ScheduleRegistry
+            ]
         };
     }
 }

package/dist/schedule/schedule.registry.js

@@ -14,6 +14,7 @@ function _ts_param(paramIndex, decorator) {
 }
 import { Injectable, Inject } from "../container/index.js";
 import { Container } from "../container/container.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
 export class ScheduleRegistry {
     container;
@@ -26,8 +27,8 @@ export class ScheduleRegistry {
         const tokens = this.container.getTokens();
         for (const token of tokens){
             if (typeof token !== 'function') continue;
-            const cronMeta = Reflect.getMetadata(CRON_METADATA, token);
-            const intervalMeta = Reflect.getMetadata(INTERVAL_METADATA, token);
+            const cronMeta = MetadataRegistry.getCustomClassMeta(token, CRON_METADATA);
+            const intervalMeta = MetadataRegistry.getCustomClassMeta(token, INTERVAL_METADATA);
             if (!cronMeta && !intervalMeta) continue;
             let instance;
             try {

package/dist/schedule/schedule.tokens.d.ts

@@ -1,5 +1,2 @@
-import { InjectionToken } from '../container/types';
-import type { ScheduleModuleOptions } from './schedule.types';
-export declare const SCHEDULE_MODULE_OPTIONS: InjectionToken<ScheduleModuleOptions>;
 export declare const CRON_METADATA = "vela:cron";
 export declare const INTERVAL_METADATA = "vela:interval";

package/dist/schedule/schedule.tokens.js

@@ -1,4 +1,2 @@
-import { InjectionToken } from "../container/types.js";
-export const SCHEDULE_MODULE_OPTIONS = new InjectionToken('SCHEDULE_MODULE_OPTIONS');
 export const CRON_METADATA = 'vela:cron';
 export const INTERVAL_METADATA = 'vela:interval';

package/dist/schedule/schedule.types.d.ts

@@ -6,6 +6,3 @@ export interface IntervalMetadata {
     ms: number;
     methodName: string;
 }
-export interface ScheduleModuleOptions {
-    enableTimers?: boolean;
-}

package/dist/schedule-node/index.d.ts

@@ -0,0 +1,2 @@
+export { ScheduleNodeModule } from './schedule-node.module';
+export { ScheduleExecutor } from './schedule.executor';

package/dist/schedule-node/index.js

@@ -0,0 +1,2 @@
+export { ScheduleNodeModule } from "./schedule-node.module.js";
+export { ScheduleExecutor } from "./schedule.executor.js";

package/dist/schedule-node/schedule-node.module.d.ts

@@ -0,0 +1,4 @@
+import type { DynamicModule } from '../module/types';
+export declare class ScheduleNodeModule {
+    static forRoot(): DynamicModule;
+}

package/dist/schedule-node/schedule-node.module.js

@@ -0,0 +1,18 @@
+import { ScheduleRegistry } from "../schedule/schedule.registry.js";
+import { ScheduleExecutor } from "./schedule.executor.js";
+export class ScheduleNodeModule {
+    static forRoot() {
+        const providers = [
+            ScheduleRegistry,
+            ScheduleExecutor
+        ];
+        return {
+            module: ScheduleNodeModule,
+            providers,
+            exports: [
+                ScheduleRegistry,
+                ScheduleExecutor
+            ]
+        };
+    }
+}

package/dist/{schedule → schedule-node}/schedule.executor.d.ts

@@ -1,5 +1,5 @@
 import type { OnApplicationBootstrap, OnModuleDestroy } from '../lifecycle/index';
-import { ScheduleRegistry } from './schedule.registry';
+import { ScheduleRegistry } from '../schedule/schedule.registry';
 export declare class ScheduleExecutor implements OnApplicationBootstrap, OnModuleDestroy {
     private registry;
     private intervalTimers;
@@ -12,9 +12,6 @@ export declare class ScheduleExecutor implements OnApplicationBootstrap, OnModul
     private scheduleInterval;
     private scheduleCron;
     private invoke;
-    private getCronMatcher;
-    private parseField;
-    private parseRange;
-    private parseCronNumber;
+    private getMatcher;
     onModuleDestroy(): void;
 }

package/dist/schedule-node/schedule.executor.js

@@ -0,0 +1,91 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { Injectable } from "../container/index.js";
+import { parseCron } from "../schedule/cron-matcher.js";
+import { ScheduleRegistry } from "../schedule/schedule.registry.js";
+export class ScheduleExecutor {
+    registry;
+    intervalTimers = [];
+    cronTimers = [];
+    cronMatcherCache = new Map();
+    lastCronMinute = new Map();
+    running = true;
+    constructor(registry){
+        this.registry = registry;
+    }
+    onApplicationBootstrap() {
+        if (typeof setInterval !== 'function') {
+            throw new Error('@velajs/vela/schedule-node requires Node or Bun. Use a platform cron adapter on edge runtimes (e.g. CloudflareApplication.scheduled).');
+        }
+        for (const job of this.registry.getIntervalJobs()){
+            this.scheduleInterval(job.instance, job.methodName, job.ms);
+        }
+        const cronJobs = this.registry.getCronJobs();
+        for(let i = 0; i < cronJobs.length; i++){
+            const job = cronJobs[i];
+            this.scheduleCron(job.instance, job.methodName, job.expression, i);
+        }
+    }
+    scheduleInterval(instance, methodName, ms) {
+        if (!this.running) return;
+        const timer = setInterval(()=>{
+            void this.invoke(instance, methodName);
+        }, ms);
+        this.intervalTimers.push(timer);
+    }
+    scheduleCron(instance, methodName, expression, index) {
+        if (!this.running) return;
+        const matcher = this.getMatcher(expression);
+        if (!matcher) return;
+        const jobKey = `${index}:${methodName}:${expression}`;
+        const timer = setInterval(()=>{
+            const now = new Date();
+            const minuteKey = Math.floor(now.getTime() / 60_000);
+            if (this.lastCronMinute.get(jobKey) === minuteKey) return;
+            if (!matcher(now)) return;
+            this.lastCronMinute.set(jobKey, minuteKey);
+            void this.invoke(instance, methodName);
+        }, 1000);
+        this.cronTimers.push(timer);
+    }
+    async invoke(instance, methodName) {
+        try {
+            const method = instance[methodName];
+            if (typeof method === 'function') {
+                await method.call(instance);
+            }
+        } catch  {
+        // Swallow errors so the scheduler keeps running
+        }
+    }
+    getMatcher(expression) {
+        if (this.cronMatcherCache.has(expression)) {
+            return this.cronMatcherCache.get(expression) ?? null;
+        }
+        const matcher = parseCron(expression);
+        this.cronMatcherCache.set(expression, matcher);
+        return matcher;
+    }
+    onModuleDestroy() {
+        this.running = false;
+        for (const timer of this.intervalTimers)clearInterval(timer);
+        for (const timer of this.cronTimers)clearInterval(timer);
+        this.intervalTimers = [];
+        this.cronTimers = [];
+        this.lastCronMinute.clear();
+    }
+}
+ScheduleExecutor = _ts_decorate([
+    Injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ScheduleRegistry === "undefined" ? Object : ScheduleRegistry
+    ])
+], ScheduleExecutor);

package/dist/services/logger.d.ts

@@ -1,11 +1,12 @@
-export declare enum LogLevel {
-    VERBOSE = 0,
-    DEBUG = 1,
-    LOG = 2,
-    WARN = 3,
-    ERROR = 4,
-    SILENT = 5
-}
+export declare const LogLevel: {
+    readonly VERBOSE: 0;
+    readonly DEBUG: 1;
+    readonly LOG: 2;
+    readonly WARN: 3;
+    readonly ERROR: 4;
+    readonly SILENT: 5;
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
 export interface LoggerService {
     log(message: unknown, ...optionalParams: unknown[]): void;
     error(message: unknown, ...optionalParams: unknown[]): void;

package/dist/services/logger.js

@@ -8,15 +8,14 @@ function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 import { Injectable } from "../container/decorators.js";
-export var LogLevel = /*#__PURE__*/ function(LogLevel) {
-    LogLevel[LogLevel["VERBOSE"] = 0] = "VERBOSE";
-    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
-    LogLevel[LogLevel["LOG"] = 2] = "LOG";
-    LogLevel[LogLevel["WARN"] = 3] = "WARN";
-    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
-    LogLevel[LogLevel["SILENT"] = 5] = "SILENT";
-    return LogLevel;
-}({});
+export const LogLevel = {
+    VERBOSE: 0,
+    DEBUG: 1,
+    LOG: 2,
+    WARN: 3,
+    ERROR: 4,
+    SILENT: 5
+};
 const defaultWriter = (level, line, ...rest)=>{
     if (level === 'ERROR') return console.error(line, ...rest);
     if (level === 'WARN') return console.warn(line, ...rest);
@@ -35,7 +34,7 @@ function formatValue(v) {
     }
 }
 export class Logger {
-    static level = 2;
+    static level = LogLevel.LOG;
     static globalLogger;
     static globalContextProviders = [];
     static globalWriter = defaultWriter;
@@ -90,19 +89,19 @@ export class Logger {
         return child;
     }
     log(message, ...optionalParams) {
-        this.emit('LOG', 2, message, optionalParams);
+        this.emit('LOG', LogLevel.LOG, message, optionalParams);
     }
     error(message, ...optionalParams) {
-        this.emit('ERROR', 4, message, optionalParams);
+        this.emit('ERROR', LogLevel.ERROR, message, optionalParams);
     }
     warn(message, ...optionalParams) {
-        this.emit('WARN', 3, message, optionalParams);
+        this.emit('WARN', LogLevel.WARN, message, optionalParams);
     }
     debug(message, ...optionalParams) {
-        this.emit('DEBUG', 1, message, optionalParams);
+        this.emit('DEBUG', LogLevel.DEBUG, message, optionalParams);
     }
     verbose(message, ...optionalParams) {
-        this.emit('VERBOSE', 0, message, optionalParams);
+        this.emit('VERBOSE', LogLevel.VERBOSE, message, optionalParams);
     }
     emit(levelName, levelValue, message, rest) {
         if (Logger.level > levelValue) return;

package/dist/throttler/throttler.decorators.d.ts

@@ -1,3 +1,3 @@
 import type { ThrottleConfig } from './throttler.types';
-export declare const Throttle: (config: ThrottleConfig) => (target: Function | object, propertyKey?: string | symbol) => void;
-export declare const SkipThrottle: () => (target: Function | object, propertyKey?: string | symbol) => void;
+export declare const Throttle: (config: ThrottleConfig) => (target: object, propertyKey?: string | symbol) => void;
+export declare const SkipThrottle: () => (target: object, propertyKey?: string | symbol) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "0.10.0",
+  "version": "1.1.0",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,9 +10,17 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
+    },
     "./streaming": {
       "types": "./dist/streaming/index.d.ts",
       "import": "./dist/streaming/index.js"
+    },
+    "./schedule-node": {
+      "types": "./dist/schedule-node/index.d.ts",
+      "import": "./dist/schedule-node/index.js"
     }
   },
   "files": [
@@ -52,14 +60,6 @@
   "dependencies": {
     "hono": "^4"
   },
-  "peerDependencies": {
-    "@velajs/crud": ">=0.1.0"
-  },
-  "peerDependenciesMeta": {
-    "@velajs/crud": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@swc/cli": "^0.8.0",
     "@swc/core": "^1.15.11",

package/dist/schedule/schedule.executor.js

@@ -1,169 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-import { Injectable } from "../container/index.js";
-import { ScheduleRegistry } from "./schedule.registry.js";
-export class ScheduleExecutor {
-    registry;
-    intervalTimers = [];
-    cronTimers = [];
-    cronMatcherCache = new Map();
-    lastCronMinute = new Map();
-    running = true;
-    constructor(registry){
-        this.registry = registry;
-    }
-    onApplicationBootstrap() {
-        const intervalJobs = this.registry.getIntervalJobs();
-        const cronJobs = this.registry.getCronJobs();
-        for (const job of intervalJobs){
-            this.scheduleInterval(job.instance, job.methodName, job.ms);
-        }
-        for(let i = 0; i < cronJobs.length; i++){
-            const job = cronJobs[i];
-            this.scheduleCron(job.instance, job.methodName, job.expression, i);
-        }
-    }
-    scheduleInterval(instance, methodName, ms) {
-        if (!this.running) return;
-        const timer = setInterval(()=>{
-            void this.invoke(instance, methodName);
-        }, ms);
-        this.intervalTimers.push(timer);
-    }
-    scheduleCron(instance, methodName, expression, index) {
-        if (!this.running) return;
-        const matcher = this.getCronMatcher(expression);
-        if (!matcher) {
-            return;
-        }
-        const jobKey = `${index}:${methodName}:${expression}`;
-        const timer = setInterval(()=>{
-            const now = new Date();
-            const minuteKey = Math.floor(now.getTime() / 60_000);
-            if (this.lastCronMinute.get(jobKey) === minuteKey) {
-                return;
-            }
-            if (!matcher(now)) {
-                return;
-            }
-            this.lastCronMinute.set(jobKey, minuteKey);
-            void this.invoke(instance, methodName);
-        }, 1000);
-        this.cronTimers.push(timer);
-    }
-    async invoke(instance, methodName) {
-        try {
-            const method = instance[methodName];
-            if (typeof method === 'function') {
-                await method.call(instance);
-            }
-        } catch  {
-        // Swallow errors to keep the scheduler alive
-        }
-    }
-    getCronMatcher(expression) {
-        if (this.cronMatcherCache.has(expression)) {
-            return this.cronMatcherCache.get(expression) ?? null;
-        }
-        const fields = expression.trim().split(/\s+/);
-        if (fields.length !== 5) {
-            this.cronMatcherCache.set(expression, null);
-            return null;
-        }
-        const [minuteField, hourField, dayField, monthField, weekdayField] = fields;
-        const minuteMatcher = this.parseField(minuteField, 0, 59);
-        const hourMatcher = this.parseField(hourField, 0, 23);
-        const dayMatcher = this.parseField(dayField, 1, 31);
-        const monthMatcher = this.parseField(monthField, 1, 12);
-        const weekdayMatcher = this.parseField(weekdayField, 0, 7);
-        if (!minuteMatcher || !hourMatcher || !dayMatcher || !monthMatcher || !weekdayMatcher) {
-            this.cronMatcherCache.set(expression, null);
-            return null;
-        }
-        const matcher = (date)=>{
-            const weekday = date.getDay();
-            return minuteMatcher(date.getMinutes()) && hourMatcher(date.getHours()) && dayMatcher(date.getDate()) && monthMatcher(date.getMonth() + 1) && weekdayMatcher(weekday);
-        };
-        this.cronMatcherCache.set(expression, matcher);
-        return matcher;
-    }
-    parseField(field, min, max) {
-        const segments = field.split(',');
-        const predicates = [];
-        for (const rawSegment of segments){
-            const segment = rawSegment.trim();
-            if (!segment) return null;
-            const stepParts = segment.split('/');
-            if (stepParts.length > 2) return null;
-            const baseSegment = stepParts[0];
-            const step = stepParts.length === 2 ? Number(stepParts[1]) : 1;
-            if (!Number.isInteger(step) || step <= 0) return null;
-            const range = this.parseRange(baseSegment, min, max);
-            if (!range) return null;
-            predicates.push((value)=>{
-                if (value < range.start || value > range.end) return false;
-                return (value - range.start) % step === 0;
-            });
-        }
-        return (value)=>predicates.some((predicate)=>predicate(value));
-    }
-    parseRange(segment, min, max) {
-        if (segment === '*') {
-            return {
-                start: min,
-                end: max
-            };
-        }
-        const bounds = segment.split('-');
-        if (bounds.length === 1) {
-            const value = this.parseCronNumber(bounds[0], min, max);
-            if (value === null) return null;
-            return {
-                start: value,
-                end: value
-            };
-        }
-        if (bounds.length !== 2) return null;
-        const start = this.parseCronNumber(bounds[0], min, max);
-        const end = this.parseCronNumber(bounds[1], min, max);
-        if (start === null || end === null || start > end) return null;
-        return {
-            start,
-            end
-        };
-    }
-    parseCronNumber(raw, min, max) {
-        const value = Number(raw);
-        if (!Number.isInteger(value)) return null;
-        // Cron allows both 0 and 7 for Sunday.
-        const normalized = max === 7 && value === 7 ? 0 : value;
-        if (normalized < min || normalized > max) return null;
-        return normalized;
-    }
-    onModuleDestroy() {
-        this.running = false;
-        for (const timer of this.intervalTimers){
-            clearInterval(timer);
-        }
-        for (const timer of this.cronTimers){
-            clearInterval(timer);
-        }
-        this.intervalTimers = [];
-        this.cronTimers = [];
-        this.lastCronMinute.clear();
-    }
-}
-ScheduleExecutor = _ts_decorate([
-    Injectable(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ScheduleRegistry === "undefined" ? Object : ScheduleRegistry
-    ])
-], ScheduleExecutor);