@aigne/afs-scheduler 1.12.0-beta.5

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/dist/_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs

@@ -0,0 +1,11 @@
+
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __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;
+}
+
+//#endregion
+exports.__decorate = __decorate;

package/dist/_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs

@@ -0,0 +1,10 @@
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __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;
+}
+
+//#endregion
+export { __decorate };

package/dist/cron-parser.cjs

@@ -0,0 +1,202 @@
+
+//#region src/cron-parser.ts
+const FIELDS = [
+	{
+		min: 0,
+		max: 59,
+		name: "minute"
+	},
+	{
+		min: 0,
+		max: 23,
+		name: "hour"
+	},
+	{
+		min: 1,
+		max: 31,
+		name: "dayOfMonth"
+	},
+	{
+		min: 1,
+		max: 12,
+		name: "month"
+	},
+	{
+		min: 0,
+		max: 7,
+		name: "dayOfWeek"
+	}
+];
+function parseField(field, constraint) {
+	return field.split(",").map((part) => parsePart(part.trim(), constraint));
+}
+function parsePart(part, constraint) {
+	if (part.includes("/")) {
+		const segments = part.split("/");
+		const baseStr = segments[0];
+		const stepStr = segments[1];
+		const step = parseIntStrict(stepStr, constraint.name);
+		if (step <= 0) throw new Error(`Invalid step value 0 in ${constraint.name}`);
+		let base;
+		if (baseStr === "*") base = { type: "wildcard" };
+		else if (baseStr.includes("-")) base = parseRange(baseStr, constraint);
+		else {
+			const val = parseIntStrict(baseStr, constraint.name);
+			validateValue(val, constraint);
+			base = {
+				type: "range",
+				from: val,
+				to: constraint.max
+			};
+		}
+		return {
+			type: "step",
+			base,
+			step
+		};
+	}
+	if (part.includes("-")) return parseRange(part, constraint);
+	if (part === "*") return { type: "wildcard" };
+	const value = parseIntStrict(part, constraint.name);
+	validateValue(value, constraint);
+	return {
+		type: "value",
+		value
+	};
+}
+function parseRange(part, constraint) {
+	const segments = part.split("-");
+	const from = parseIntStrict(segments[0], constraint.name);
+	const to = parseIntStrict(segments[1], constraint.name);
+	validateValue(from, constraint);
+	validateValue(to, constraint);
+	if (from > to) throw new Error(`Invalid range ${from}-${to} in ${constraint.name}: from > to`);
+	return {
+		type: "range",
+		from,
+		to
+	};
+}
+function parseIntStrict(str, fieldName) {
+	if (!/^\d+$/.test(str)) throw new Error(`Invalid value "${str}" in ${fieldName}`);
+	return Number.parseInt(str, 10);
+}
+function validateValue(value, constraint) {
+	if (value < constraint.min || value > constraint.max) throw new Error(`Value ${value} out of range [${constraint.min}-${constraint.max}] for ${constraint.name}`);
+}
+/**
+* Parse a standard 5-field cron expression.
+*/
+function parseCron(expr) {
+	const trimmed = expr.trim();
+	if (!trimmed) throw new Error("Empty cron expression");
+	const fields = trimmed.split(/\s+/);
+	if (fields.length !== 5) throw new Error(`Expected 5 fields in cron expression, got ${fields.length}`);
+	return {
+		minute: parseField(fields[0], FIELDS[0]),
+		hour: parseField(fields[1], FIELDS[1]),
+		dayOfMonth: parseField(fields[2], FIELDS[2]),
+		month: parseField(fields[3], FIELDS[3]),
+		dayOfWeek: parseField(fields[4], FIELDS[4])
+	};
+}
+function matchesPart(value, part) {
+	switch (part.type) {
+		case "wildcard": return true;
+		case "value": return value === part.value;
+		case "range": return value >= part.from && value <= part.to;
+		case "step": {
+			const { base, step } = part;
+			if (base.type === "wildcard") return value % step === 0;
+			if (value < base.from || value > base.to) return false;
+			return (value - base.from) % step === 0;
+		}
+	}
+}
+function matchesField(value, parts) {
+	return parts.some((part) => matchesPart(value, part));
+}
+/**
+* Check if a cron expression matches a given time (evaluated in UTC).
+*/
+function isDue(expr, now) {
+	const cron = parseCron(expr);
+	const minute = now.getUTCMinutes();
+	const hour = now.getUTCHours();
+	const dayOfMonth = now.getUTCDate();
+	const month = now.getUTCMonth() + 1;
+	const dayOfWeek = now.getUTCDay();
+	if (!matchesField(minute, cron.minute)) return false;
+	if (!matchesField(hour, cron.hour)) return false;
+	if (!matchesField(dayOfMonth, cron.dayOfMonth)) return false;
+	if (!matchesField(month, cron.month)) return false;
+	if (!matchesField(dayOfWeek, cron.dayOfWeek.map((part) => normalizeDow(part)))) return false;
+	return true;
+}
+/**
+* Normalize day-of-week part: convert 7 to 0 (both mean Sunday).
+*/
+function normalizeDow(part) {
+	switch (part.type) {
+		case "value": return part.value === 7 ? {
+			type: "value",
+			value: 0
+		} : part;
+		case "range": return {
+			type: "range",
+			from: part.from === 7 ? 0 : part.from,
+			to: part.to === 7 ? 0 : part.to
+		};
+		default: return part;
+	}
+}
+/**
+* Calculate the next time a cron expression will fire after a given date (UTC).
+* The `after` time itself is excluded — if it exactly matches, the next occurrence is returned.
+*
+* Throws if no match found within 4 years (guards against impossible expressions like Feb 30).
+*/
+function nextRun(expr, after) {
+	const candidate = new Date(after.getTime());
+	candidate.setUTCSeconds(0, 0);
+	candidate.setUTCMinutes(candidate.getUTCMinutes() + 1);
+	const maxTime = after.getTime() + 4 * 365.25 * 24 * 60 * 60 * 1e3;
+	const cron = parseCron(expr);
+	const dowParts = cron.dayOfWeek.map((part) => normalizeDow(part));
+	while (candidate.getTime() <= maxTime) {
+		if (!matchesField(candidate.getUTCMonth() + 1, cron.month)) {
+			candidate.setUTCMonth(candidate.getUTCMonth() + 1, 1);
+			candidate.setUTCHours(0, 0, 0, 0);
+			continue;
+		}
+		const dayOfMonth = candidate.getUTCDate();
+		if (!matchesField(dayOfMonth, cron.dayOfMonth)) {
+			candidate.setUTCDate(dayOfMonth + 1);
+			candidate.setUTCHours(0, 0, 0, 0);
+			continue;
+		}
+		if (!matchesField(candidate.getUTCDay(), dowParts)) {
+			candidate.setUTCDate(candidate.getUTCDate() + 1);
+			candidate.setUTCHours(0, 0, 0, 0);
+			continue;
+		}
+		const hour = candidate.getUTCHours();
+		if (!matchesField(hour, cron.hour)) {
+			candidate.setUTCHours(hour + 1, 0, 0, 0);
+			continue;
+		}
+		const minute = candidate.getUTCMinutes();
+		if (!matchesField(minute, cron.minute)) {
+			candidate.setUTCMinutes(minute + 1);
+			candidate.setUTCSeconds(0, 0);
+			continue;
+		}
+		return new Date(candidate.getTime());
+	}
+	throw new Error(`No matching time found within 4 years for cron expression: ${expr}`);
+}
+
+//#endregion
+exports.isDue = isDue;
+exports.nextRun = nextRun;
+exports.parseCron = parseCron;

package/dist/cron-parser.d.cts

@@ -0,0 +1,65 @@
+//#region src/cron-parser.d.ts
+/**
+ * Cron expression parser and evaluator.
+ *
+ * Supports standard 5-field cron: minute hour dayOfMonth month dayOfWeek
+ *
+ * Field ranges:
+ *   minute:     0-59
+ *   hour:       0-23
+ *   dayOfMonth: 1-31
+ *   month:      1-12
+ *   dayOfWeek:  0-7 (0 and 7 both mean Sunday)
+ *
+ * Syntax per field:
+ *   *       wildcard (any value)
+ *   N       exact value
+ *   N-M     range (inclusive)
+ *   N/S     step from N
+ *   * /S    every S (step on wildcard)
+ *   N-M/S   step within range
+ *   A,B,C   comma-separated list of any of the above
+ */
+interface CronWildcard {
+  type: "wildcard";
+}
+interface CronValue {
+  type: "value";
+  value: number;
+}
+interface CronRange {
+  type: "range";
+  from: number;
+  to: number;
+}
+interface CronStep {
+  type: "step";
+  base: CronWildcard | CronRange;
+  step: number;
+}
+type CronPart = CronWildcard | CronValue | CronRange | CronStep;
+interface CronExpression {
+  minute: CronPart[];
+  hour: CronPart[];
+  dayOfMonth: CronPart[];
+  month: CronPart[];
+  dayOfWeek: CronPart[];
+}
+/**
+ * Parse a standard 5-field cron expression.
+ */
+declare function parseCron(expr: string): CronExpression;
+/**
+ * Check if a cron expression matches a given time (evaluated in UTC).
+ */
+declare function isDue(expr: string, now: Date): boolean;
+/**
+ * Calculate the next time a cron expression will fire after a given date (UTC).
+ * The `after` time itself is excluded — if it exactly matches, the next occurrence is returned.
+ *
+ * Throws if no match found within 4 years (guards against impossible expressions like Feb 30).
+ */
+declare function nextRun(expr: string, after: Date): Date;
+//#endregion
+export { CronExpression, CronPart, isDue, nextRun, parseCron };
+//# sourceMappingURL=cron-parser.d.cts.map

package/dist/cron-parser.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-parser.d.cts","names":[],"sources":["../src/cron-parser.ts"],"mappings":";;AA0BA;;;;;AAIA;;;;;AAKA;;;;;;;;;AAMA;UAfiB,YAAA;EACf,IAAA;AAAA;AAAA,UAGe,SAAA;EACf,IAAA;EACA,KAAA;AAAA;AAAA,UAGe,SAAA;EACf,IAAA;EACA,IAAA;EACA,EAAA;AAAA;AAAA,UAGe,QAAA;EACf,IAAA;EACA,IAAA,EAAM,YAAA,GAAe,SAAA;EACrB,IAAA;AAAA;AAAA,KAGU,QAAA,GAAW,YAAA,GAAe,SAAA,GAAY,SAAA,GAAY,QAAA;AAAA,UAE7C,cAAA;EACf,MAAA,EAAQ,QAAA;EACR,IAAA,EAAM,QAAA;EACN,UAAA,EAAY,QAAA;EACZ,KAAA,EAAO,QAAA;EACP,SAAA,EAAW,QAAA;AAAA;AALb;;;AAAA,iBAqGgB,SAAA,CAAU,IAAA,WAAe,cAAA;;;;iBAqDzB,KAAA,CAAM,IAAA,UAAc,GAAA,EAAK,IAAA;;;;;;;iBAkDzB,OAAA,CAAQ,IAAA,UAAc,KAAA,EAAO,IAAA,GAAO,IAAA"}

package/dist/cron-parser.d.mts

@@ -0,0 +1,65 @@
+//#region src/cron-parser.d.ts
+/**
+ * Cron expression parser and evaluator.
+ *
+ * Supports standard 5-field cron: minute hour dayOfMonth month dayOfWeek
+ *
+ * Field ranges:
+ *   minute:     0-59
+ *   hour:       0-23
+ *   dayOfMonth: 1-31
+ *   month:      1-12
+ *   dayOfWeek:  0-7 (0 and 7 both mean Sunday)
+ *
+ * Syntax per field:
+ *   *       wildcard (any value)
+ *   N       exact value
+ *   N-M     range (inclusive)
+ *   N/S     step from N
+ *   * /S    every S (step on wildcard)
+ *   N-M/S   step within range
+ *   A,B,C   comma-separated list of any of the above
+ */
+interface CronWildcard {
+  type: "wildcard";
+}
+interface CronValue {
+  type: "value";
+  value: number;
+}
+interface CronRange {
+  type: "range";
+  from: number;
+  to: number;
+}
+interface CronStep {
+  type: "step";
+  base: CronWildcard | CronRange;
+  step: number;
+}
+type CronPart = CronWildcard | CronValue | CronRange | CronStep;
+interface CronExpression {
+  minute: CronPart[];
+  hour: CronPart[];
+  dayOfMonth: CronPart[];
+  month: CronPart[];
+  dayOfWeek: CronPart[];
+}
+/**
+ * Parse a standard 5-field cron expression.
+ */
+declare function parseCron(expr: string): CronExpression;
+/**
+ * Check if a cron expression matches a given time (evaluated in UTC).
+ */
+declare function isDue(expr: string, now: Date): boolean;
+/**
+ * Calculate the next time a cron expression will fire after a given date (UTC).
+ * The `after` time itself is excluded — if it exactly matches, the next occurrence is returned.
+ *
+ * Throws if no match found within 4 years (guards against impossible expressions like Feb 30).
+ */
+declare function nextRun(expr: string, after: Date): Date;
+//#endregion
+export { CronExpression, CronPart, isDue, nextRun, parseCron };
+//# sourceMappingURL=cron-parser.d.mts.map

package/dist/cron-parser.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-parser.d.mts","names":[],"sources":["../src/cron-parser.ts"],"mappings":";;AA0BA;;;;;AAIA;;;;;AAKA;;;;;;;;;AAMA;UAfiB,YAAA;EACf,IAAA;AAAA;AAAA,UAGe,SAAA;EACf,IAAA;EACA,KAAA;AAAA;AAAA,UAGe,SAAA;EACf,IAAA;EACA,IAAA;EACA,EAAA;AAAA;AAAA,UAGe,QAAA;EACf,IAAA;EACA,IAAA,EAAM,YAAA,GAAe,SAAA;EACrB,IAAA;AAAA;AAAA,KAGU,QAAA,GAAW,YAAA,GAAe,SAAA,GAAY,SAAA,GAAY,QAAA;AAAA,UAE7C,cAAA;EACf,MAAA,EAAQ,QAAA;EACR,IAAA,EAAM,QAAA;EACN,UAAA,EAAY,QAAA;EACZ,KAAA,EAAO,QAAA;EACP,SAAA,EAAW,QAAA;AAAA;AALb;;;AAAA,iBAqGgB,SAAA,CAAU,IAAA,WAAe,cAAA;;;;iBAqDzB,KAAA,CAAM,IAAA,UAAc,GAAA,EAAK,IAAA;;;;;;;iBAkDzB,OAAA,CAAQ,IAAA,UAAc,KAAA,EAAO,IAAA,GAAO,IAAA"}

package/dist/cron-parser.mjs

@@ -0,0 +1,200 @@
+//#region src/cron-parser.ts
+const FIELDS = [
+	{
+		min: 0,
+		max: 59,
+		name: "minute"
+	},
+	{
+		min: 0,
+		max: 23,
+		name: "hour"
+	},
+	{
+		min: 1,
+		max: 31,
+		name: "dayOfMonth"
+	},
+	{
+		min: 1,
+		max: 12,
+		name: "month"
+	},
+	{
+		min: 0,
+		max: 7,
+		name: "dayOfWeek"
+	}
+];
+function parseField(field, constraint) {
+	return field.split(",").map((part) => parsePart(part.trim(), constraint));
+}
+function parsePart(part, constraint) {
+	if (part.includes("/")) {
+		const segments = part.split("/");
+		const baseStr = segments[0];
+		const stepStr = segments[1];
+		const step = parseIntStrict(stepStr, constraint.name);
+		if (step <= 0) throw new Error(`Invalid step value 0 in ${constraint.name}`);
+		let base;
+		if (baseStr === "*") base = { type: "wildcard" };
+		else if (baseStr.includes("-")) base = parseRange(baseStr, constraint);
+		else {
+			const val = parseIntStrict(baseStr, constraint.name);
+			validateValue(val, constraint);
+			base = {
+				type: "range",
+				from: val,
+				to: constraint.max
+			};
+		}
+		return {
+			type: "step",
+			base,
+			step
+		};
+	}
+	if (part.includes("-")) return parseRange(part, constraint);
+	if (part === "*") return { type: "wildcard" };
+	const value = parseIntStrict(part, constraint.name);
+	validateValue(value, constraint);
+	return {
+		type: "value",
+		value
+	};
+}
+function parseRange(part, constraint) {
+	const segments = part.split("-");
+	const from = parseIntStrict(segments[0], constraint.name);
+	const to = parseIntStrict(segments[1], constraint.name);
+	validateValue(from, constraint);
+	validateValue(to, constraint);
+	if (from > to) throw new Error(`Invalid range ${from}-${to} in ${constraint.name}: from > to`);
+	return {
+		type: "range",
+		from,
+		to
+	};
+}
+function parseIntStrict(str, fieldName) {
+	if (!/^\d+$/.test(str)) throw new Error(`Invalid value "${str}" in ${fieldName}`);
+	return Number.parseInt(str, 10);
+}
+function validateValue(value, constraint) {
+	if (value < constraint.min || value > constraint.max) throw new Error(`Value ${value} out of range [${constraint.min}-${constraint.max}] for ${constraint.name}`);
+}
+/**
+* Parse a standard 5-field cron expression.
+*/
+function parseCron(expr) {
+	const trimmed = expr.trim();
+	if (!trimmed) throw new Error("Empty cron expression");
+	const fields = trimmed.split(/\s+/);
+	if (fields.length !== 5) throw new Error(`Expected 5 fields in cron expression, got ${fields.length}`);
+	return {
+		minute: parseField(fields[0], FIELDS[0]),
+		hour: parseField(fields[1], FIELDS[1]),
+		dayOfMonth: parseField(fields[2], FIELDS[2]),
+		month: parseField(fields[3], FIELDS[3]),
+		dayOfWeek: parseField(fields[4], FIELDS[4])
+	};
+}
+function matchesPart(value, part) {
+	switch (part.type) {
+		case "wildcard": return true;
+		case "value": return value === part.value;
+		case "range": return value >= part.from && value <= part.to;
+		case "step": {
+			const { base, step } = part;
+			if (base.type === "wildcard") return value % step === 0;
+			if (value < base.from || value > base.to) return false;
+			return (value - base.from) % step === 0;
+		}
+	}
+}
+function matchesField(value, parts) {
+	return parts.some((part) => matchesPart(value, part));
+}
+/**
+* Check if a cron expression matches a given time (evaluated in UTC).
+*/
+function isDue(expr, now) {
+	const cron = parseCron(expr);
+	const minute = now.getUTCMinutes();
+	const hour = now.getUTCHours();
+	const dayOfMonth = now.getUTCDate();
+	const month = now.getUTCMonth() + 1;
+	const dayOfWeek = now.getUTCDay();
+	if (!matchesField(minute, cron.minute)) return false;
+	if (!matchesField(hour, cron.hour)) return false;
+	if (!matchesField(dayOfMonth, cron.dayOfMonth)) return false;
+	if (!matchesField(month, cron.month)) return false;
+	if (!matchesField(dayOfWeek, cron.dayOfWeek.map((part) => normalizeDow(part)))) return false;
+	return true;
+}
+/**
+* Normalize day-of-week part: convert 7 to 0 (both mean Sunday).
+*/
+function normalizeDow(part) {
+	switch (part.type) {
+		case "value": return part.value === 7 ? {
+			type: "value",
+			value: 0
+		} : part;
+		case "range": return {
+			type: "range",
+			from: part.from === 7 ? 0 : part.from,
+			to: part.to === 7 ? 0 : part.to
+		};
+		default: return part;
+	}
+}
+/**
+* Calculate the next time a cron expression will fire after a given date (UTC).
+* The `after` time itself is excluded — if it exactly matches, the next occurrence is returned.
+*
+* Throws if no match found within 4 years (guards against impossible expressions like Feb 30).
+*/
+function nextRun(expr, after) {
+	const candidate = new Date(after.getTime());
+	candidate.setUTCSeconds(0, 0);
+	candidate.setUTCMinutes(candidate.getUTCMinutes() + 1);
+	const maxTime = after.getTime() + 4 * 365.25 * 24 * 60 * 60 * 1e3;
+	const cron = parseCron(expr);
+	const dowParts = cron.dayOfWeek.map((part) => normalizeDow(part));
+	while (candidate.getTime() <= maxTime) {
+		if (!matchesField(candidate.getUTCMonth() + 1, cron.month)) {
+			candidate.setUTCMonth(candidate.getUTCMonth() + 1, 1);
+			candidate.setUTCHours(0, 0, 0, 0);
+			continue;
+		}
+		const dayOfMonth = candidate.getUTCDate();
+		if (!matchesField(dayOfMonth, cron.dayOfMonth)) {
+			candidate.setUTCDate(dayOfMonth + 1);
+			candidate.setUTCHours(0, 0, 0, 0);
+			continue;
+		}
+		if (!matchesField(candidate.getUTCDay(), dowParts)) {
+			candidate.setUTCDate(candidate.getUTCDate() + 1);
+			candidate.setUTCHours(0, 0, 0, 0);
+			continue;
+		}
+		const hour = candidate.getUTCHours();
+		if (!matchesField(hour, cron.hour)) {
+			candidate.setUTCHours(hour + 1, 0, 0, 0);
+			continue;
+		}
+		const minute = candidate.getUTCMinutes();
+		if (!matchesField(minute, cron.minute)) {
+			candidate.setUTCMinutes(minute + 1);
+			candidate.setUTCSeconds(0, 0);
+			continue;
+		}
+		return new Date(candidate.getTime());
+	}
+	throw new Error(`No matching time found within 4 years for cron expression: ${expr}`);
+}
+
+//#endregion
+export { isDue, nextRun, parseCron };
+//# sourceMappingURL=cron-parser.mjs.map

package/dist/cron-parser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-parser.mjs","names":[],"sources":["../src/cron-parser.ts"],"sourcesContent":["/**\n * Cron expression parser and evaluator.\n *\n * Supports standard 5-field cron: minute hour dayOfMonth month dayOfWeek\n *\n * Field ranges:\n *   minute:     0-59\n *   hour:       0-23\n *   dayOfMonth: 1-31\n *   month:      1-12\n *   dayOfWeek:  0-7 (0 and 7 both mean Sunday)\n *\n * Syntax per field:\n *   *       wildcard (any value)\n *   N       exact value\n *   N-M     range (inclusive)\n *   N/S     step from N\n *   * /S    every S (step on wildcard)\n *   N-M/S   step within range\n *   A,B,C   comma-separated list of any of the above\n */\n\n// ═══════════════════════════════════════════════════════════════════\n// Types\n// ═══════════════════════════════════════════════════════════════════\n\nexport interface CronWildcard {\n  type: \"wildcard\";\n}\n\nexport interface CronValue {\n  type: \"value\";\n  value: number;\n}\n\nexport interface CronRange {\n  type: \"range\";\n  from: number;\n  to: number;\n}\n\nexport interface CronStep {\n  type: \"step\";\n  base: CronWildcard | CronRange;\n  step: number;\n}\n\nexport type CronPart = CronWildcard | CronValue | CronRange | CronStep;\n\nexport interface CronExpression {\n  minute: CronPart[];\n  hour: CronPart[];\n  dayOfMonth: CronPart[];\n  month: CronPart[];\n  dayOfWeek: CronPart[];\n}\n\n// ═══════════════════════════════════════════════════════════════════\n// Field constraints\n// ═══════════════════════════════════════════════════════════════════\n\ninterface FieldConstraint {\n  min: number;\n  max: number;\n  name: string;\n}\n\nconst FIELDS: FieldConstraint[] = [\n  { min: 0, max: 59, name: \"minute\" },\n  { min: 0, max: 23, name: \"hour\" },\n  { min: 1, max: 31, name: \"dayOfMonth\" },\n  { min: 1, max: 12, name: \"month\" },\n  { min: 0, max: 7, name: \"dayOfWeek\" },\n];\n\n// ═══════════════════════════════════════════════════════════════════\n// Parser\n// ═══════════════════════════════════════════════════════════════════\n\nfunction parseField(field: string, constraint: FieldConstraint): CronPart[] {\n  const parts = field.split(\",\");\n  return parts.map((part) => parsePart(part.trim(), constraint));\n}\n\nfunction parsePart(part: string, constraint: FieldConstraint): CronPart {\n  // Step: base/step\n  if (part.includes(\"/\")) {\n    const segments = part.split(\"/\");\n    const baseStr = segments[0] as string;\n    const stepStr = segments[1] as string;\n    const step = parseIntStrict(stepStr, constraint.name);\n    if (step <= 0) throw new Error(`Invalid step value 0 in ${constraint.name}`);\n\n    let base: CronWildcard | CronRange;\n    if (baseStr === \"*\") {\n      base = { type: \"wildcard\" };\n    } else if (baseStr.includes(\"-\")) {\n      base = parseRange(baseStr, constraint);\n    } else {\n      // Treat single value as start of range to max\n      const val = parseIntStrict(baseStr, constraint.name);\n      validateValue(val, constraint);\n      base = { type: \"range\", from: val, to: constraint.max };\n    }\n\n    return { type: \"step\", base, step };\n  }\n\n  // Range: from-to\n  if (part.includes(\"-\")) {\n    return parseRange(part, constraint);\n  }\n\n  // Wildcard\n  if (part === \"*\") {\n    return { type: \"wildcard\" };\n  }\n\n  // Single value\n  const value = parseIntStrict(part, constraint.name);\n  validateValue(value, constraint);\n  return { type: \"value\", value };\n}\n\nfunction parseRange(part: string, constraint: FieldConstraint): CronRange {\n  const segments = part.split(\"-\");\n  const from = parseIntStrict(segments[0] as string, constraint.name);\n  const to = parseIntStrict(segments[1] as string, constraint.name);\n  validateValue(from, constraint);\n  validateValue(to, constraint);\n  if (from > to) throw new Error(`Invalid range ${from}-${to} in ${constraint.name}: from > to`);\n  return { type: \"range\", from, to };\n}\n\nfunction parseIntStrict(str: string, fieldName: string): number {\n  if (!/^\\d+$/.test(str)) throw new Error(`Invalid value \"${str}\" in ${fieldName}`);\n  return Number.parseInt(str, 10);\n}\n\nfunction validateValue(value: number, constraint: FieldConstraint): void {\n  if (value < constraint.min || value > constraint.max) {\n    throw new Error(\n      `Value ${value} out of range [${constraint.min}-${constraint.max}] for ${constraint.name}`,\n    );\n  }\n}\n\n/**\n * Parse a standard 5-field cron expression.\n */\nexport function parseCron(expr: string): CronExpression {\n  const trimmed = expr.trim();\n  if (!trimmed) throw new Error(\"Empty cron expression\");\n\n  const fields = trimmed.split(/\\s+/);\n  if (fields.length !== 5) {\n    throw new Error(`Expected 5 fields in cron expression, got ${fields.length}`);\n  }\n\n  return {\n    minute: parseField(fields[0] as string, FIELDS[0] as FieldConstraint),\n    hour: parseField(fields[1] as string, FIELDS[1] as FieldConstraint),\n    dayOfMonth: parseField(fields[2] as string, FIELDS[2] as FieldConstraint),\n    month: parseField(fields[3] as string, FIELDS[3] as FieldConstraint),\n    dayOfWeek: parseField(fields[4] as string, FIELDS[4] as FieldConstraint),\n  };\n}\n\n// ═══════════════════════════════════════════════════════════════════\n// Matcher — does a value match a cron part?\n// ═══════════════════════════════════════════════════════════════════\n\nfunction matchesPart(value: number, part: CronPart): boolean {\n  switch (part.type) {\n    case \"wildcard\":\n      return true;\n    case \"value\":\n      return value === part.value;\n    case \"range\":\n      return value >= part.from && value <= part.to;\n    case \"step\": {\n      const { base, step } = part;\n      if (base.type === \"wildcard\") {\n        return value % step === 0;\n      }\n      // Range-based step\n      if (value < base.from || value > base.to) return false;\n      return (value - base.from) % step === 0;\n    }\n  }\n}\n\nfunction matchesField(value: number, parts: CronPart[]): boolean {\n  return parts.some((part) => matchesPart(value, part));\n}\n\n// ═══════════════════════════════════════════════════════════════════\n// isDue\n// ═══════════════════════════════════════════════════════════════════\n\n/**\n * Check if a cron expression matches a given time (evaluated in UTC).\n */\nexport function isDue(expr: string, now: Date): boolean {\n  const cron = parseCron(expr);\n\n  const minute = now.getUTCMinutes();\n  const hour = now.getUTCHours();\n  const dayOfMonth = now.getUTCDate();\n  const month = now.getUTCMonth() + 1; // 0-based → 1-based\n  const dayOfWeek = now.getUTCDay(); // 0=Sunday\n\n  // Check each field\n  if (!matchesField(minute, cron.minute)) return false;\n  if (!matchesField(hour, cron.hour)) return false;\n  if (!matchesField(dayOfMonth, cron.dayOfMonth)) return false;\n  if (!matchesField(month, cron.month)) return false;\n\n  // dayOfWeek: normalize 7 → 0 in the cron parts for matching\n  const dowParts = cron.dayOfWeek.map((part) => normalizeDow(part));\n  if (!matchesField(dayOfWeek, dowParts)) return false;\n\n  return true;\n}\n\n/**\n * Normalize day-of-week part: convert 7 to 0 (both mean Sunday).\n */\nfunction normalizeDow(part: CronPart): CronPart {\n  switch (part.type) {\n    case \"value\":\n      return part.value === 7 ? { type: \"value\", value: 0 } : part;\n    case \"range\":\n      return {\n        type: \"range\",\n        from: part.from === 7 ? 0 : part.from,\n        to: part.to === 7 ? 0 : part.to,\n      };\n    default:\n      return part;\n  }\n}\n\n// ═══════════════════════════════════════════════════════════════════\n// nextRun\n// ═══════════════════════════════════════════════════════════════════\n\n/**\n * Calculate the next time a cron expression will fire after a given date (UTC).\n * The `after` time itself is excluded — if it exactly matches, the next occurrence is returned.\n *\n * Throws if no match found within 4 years (guards against impossible expressions like Feb 30).\n */\nexport function nextRun(expr: string, after: Date): Date {\n  // Start from the next minute after `after`\n  const candidate = new Date(after.getTime());\n  candidate.setUTCSeconds(0, 0);\n  candidate.setUTCMinutes(candidate.getUTCMinutes() + 1);\n\n  const maxTime = after.getTime() + 4 * 365.25 * 24 * 60 * 60 * 1000;\n\n  const cron = parseCron(expr);\n  const dowParts = cron.dayOfWeek.map((part) => normalizeDow(part));\n\n  while (candidate.getTime() <= maxTime) {\n    const month = candidate.getUTCMonth() + 1;\n    if (!matchesField(month, cron.month)) {\n      // Jump to first day of next month\n      candidate.setUTCMonth(candidate.getUTCMonth() + 1, 1);\n      candidate.setUTCHours(0, 0, 0, 0);\n      continue;\n    }\n\n    const dayOfMonth = candidate.getUTCDate();\n    if (!matchesField(dayOfMonth, cron.dayOfMonth)) {\n      // Jump to next day\n      candidate.setUTCDate(dayOfMonth + 1);\n      candidate.setUTCHours(0, 0, 0, 0);\n      continue;\n    }\n\n    const dayOfWeek = candidate.getUTCDay();\n    if (!matchesField(dayOfWeek, dowParts)) {\n      // Jump to next day\n      candidate.setUTCDate(candidate.getUTCDate() + 1);\n      candidate.setUTCHours(0, 0, 0, 0);\n      continue;\n    }\n\n    const hour = candidate.getUTCHours();\n    if (!matchesField(hour, cron.hour)) {\n      // Jump to next hour\n      candidate.setUTCHours(hour + 1, 0, 0, 0);\n      continue;\n    }\n\n    const minute = candidate.getUTCMinutes();\n    if (!matchesField(minute, cron.minute)) {\n      // Jump to next minute\n      candidate.setUTCMinutes(minute + 1);\n      candidate.setUTCSeconds(0, 0);\n      continue;\n    }\n\n    // All fields match\n    return new Date(candidate.getTime());\n  }\n\n  throw new Error(`No matching time found within 4 years for cron expression: ${expr}`);\n}\n"],"mappings":";AAmEA,MAAM,SAA4B;CAChC;EAAE,KAAK;EAAG,KAAK;EAAI,MAAM;EAAU;CACnC;EAAE,KAAK;EAAG,KAAK;EAAI,MAAM;EAAQ;CACjC;EAAE,KAAK;EAAG,KAAK;EAAI,MAAM;EAAc;CACvC;EAAE,KAAK;EAAG,KAAK;EAAI,MAAM;EAAS;CAClC;EAAE,KAAK;EAAG,KAAK;EAAG,MAAM;EAAa;CACtC;AAMD,SAAS,WAAW,OAAe,YAAyC;AAE1E,QADc,MAAM,MAAM,IAAI,CACjB,KAAK,SAAS,UAAU,KAAK,MAAM,EAAE,WAAW,CAAC;;AAGhE,SAAS,UAAU,MAAc,YAAuC;AAEtE,KAAI,KAAK,SAAS,IAAI,EAAE;EACtB,MAAM,WAAW,KAAK,MAAM,IAAI;EAChC,MAAM,UAAU,SAAS;EACzB,MAAM,UAAU,SAAS;EACzB,MAAM,OAAO,eAAe,SAAS,WAAW,KAAK;AACrD,MAAI,QAAQ,EAAG,OAAM,IAAI,MAAM,2BAA2B,WAAW,OAAO;EAE5E,IAAI;AACJ,MAAI,YAAY,IACd,QAAO,EAAE,MAAM,YAAY;WAClB,QAAQ,SAAS,IAAI,CAC9B,QAAO,WAAW,SAAS,WAAW;OACjC;GAEL,MAAM,MAAM,eAAe,SAAS,WAAW,KAAK;AACpD,iBAAc,KAAK,WAAW;AAC9B,UAAO;IAAE,MAAM;IAAS,MAAM;IAAK,IAAI,WAAW;IAAK;;AAGzD,SAAO;GAAE,MAAM;GAAQ;GAAM;GAAM;;AAIrC,KAAI,KAAK,SAAS,IAAI,CACpB,QAAO,WAAW,MAAM,WAAW;AAIrC,KAAI,SAAS,IACX,QAAO,EAAE,MAAM,YAAY;CAI7B,MAAM,QAAQ,eAAe,MAAM,WAAW,KAAK;AACnD,eAAc,OAAO,WAAW;AAChC,QAAO;EAAE,MAAM;EAAS;EAAO;;AAGjC,SAAS,WAAW,MAAc,YAAwC;CACxE,MAAM,WAAW,KAAK,MAAM,IAAI;CAChC,MAAM,OAAO,eAAe,SAAS,IAAc,WAAW,KAAK;CACnE,MAAM,KAAK,eAAe,SAAS,IAAc,WAAW,KAAK;AACjE,eAAc,MAAM,WAAW;AAC/B,eAAc,IAAI,WAAW;AAC7B,KAAI,OAAO,GAAI,OAAM,IAAI,MAAM,iBAAiB,KAAK,GAAG,GAAG,MAAM,WAAW,KAAK,aAAa;AAC9F,QAAO;EAAE,MAAM;EAAS;EAAM;EAAI;;AAGpC,SAAS,eAAe,KAAa,WAA2B;AAC9D,KAAI,CAAC,QAAQ,KAAK,IAAI,CAAE,OAAM,IAAI,MAAM,kBAAkB,IAAI,OAAO,YAAY;AACjF,QAAO,OAAO,SAAS,KAAK,GAAG;;AAGjC,SAAS,cAAc,OAAe,YAAmC;AACvE,KAAI,QAAQ,WAAW,OAAO,QAAQ,WAAW,IAC/C,OAAM,IAAI,MACR,SAAS,MAAM,iBAAiB,WAAW,IAAI,GAAG,WAAW,IAAI,QAAQ,WAAW,OACrF;;;;;AAOL,SAAgB,UAAU,MAA8B;CACtD,MAAM,UAAU,KAAK,MAAM;AAC3B,KAAI,CAAC,QAAS,OAAM,IAAI,MAAM,wBAAwB;CAEtD,MAAM,SAAS,QAAQ,MAAM,MAAM;AACnC,KAAI,OAAO,WAAW,EACpB,OAAM,IAAI,MAAM,6CAA6C,OAAO,SAAS;AAG/E,QAAO;EACL,QAAQ,WAAW,OAAO,IAAc,OAAO,GAAsB;EACrE,MAAM,WAAW,OAAO,IAAc,OAAO,GAAsB;EACnE,YAAY,WAAW,OAAO,IAAc,OAAO,GAAsB;EACzE,OAAO,WAAW,OAAO,IAAc,OAAO,GAAsB;EACpE,WAAW,WAAW,OAAO,IAAc,OAAO,GAAsB;EACzE;;AAOH,SAAS,YAAY,OAAe,MAAyB;AAC3D,SAAQ,KAAK,MAAb;EACE,KAAK,WACH,QAAO;EACT,KAAK,QACH,QAAO,UAAU,KAAK;EACxB,KAAK,QACH,QAAO,SAAS,KAAK,QAAQ,SAAS,KAAK;EAC7C,KAAK,QAAQ;GACX,MAAM,EAAE,MAAM,SAAS;AACvB,OAAI,KAAK,SAAS,WAChB,QAAO,QAAQ,SAAS;AAG1B,OAAI,QAAQ,KAAK,QAAQ,QAAQ,KAAK,GAAI,QAAO;AACjD,WAAQ,QAAQ,KAAK,QAAQ,SAAS;;;;AAK5C,SAAS,aAAa,OAAe,OAA4B;AAC/D,QAAO,MAAM,MAAM,SAAS,YAAY,OAAO,KAAK,CAAC;;;;;AAUvD,SAAgB,MAAM,MAAc,KAAoB;CACtD,MAAM,OAAO,UAAU,KAAK;CAE5B,MAAM,SAAS,IAAI,eAAe;CAClC,MAAM,OAAO,IAAI,aAAa;CAC9B,MAAM,aAAa,IAAI,YAAY;CACnC,MAAM,QAAQ,IAAI,aAAa,GAAG;CAClC,MAAM,YAAY,IAAI,WAAW;AAGjC,KAAI,CAAC,aAAa,QAAQ,KAAK,OAAO,CAAE,QAAO;AAC/C,KAAI,CAAC,aAAa,MAAM,KAAK,KAAK,CAAE,QAAO;AAC3C,KAAI,CAAC,aAAa,YAAY,KAAK,WAAW,CAAE,QAAO;AACvD,KAAI,CAAC,aAAa,OAAO,KAAK,MAAM,CAAE,QAAO;AAI7C,KAAI,CAAC,aAAa,WADD,KAAK,UAAU,KAAK,SAAS,aAAa,KAAK,CAAC,CAC3B,CAAE,QAAO;AAE/C,QAAO;;;;;AAMT,SAAS,aAAa,MAA0B;AAC9C,SAAQ,KAAK,MAAb;EACE,KAAK,QACH,QAAO,KAAK,UAAU,IAAI;GAAE,MAAM;GAAS,OAAO;GAAG,GAAG;EAC1D,KAAK,QACH,QAAO;GACL,MAAM;GACN,MAAM,KAAK,SAAS,IAAI,IAAI,KAAK;GACjC,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK;GAC9B;EACH,QACE,QAAO;;;;;;;;;AAcb,SAAgB,QAAQ,MAAc,OAAmB;CAEvD,MAAM,YAAY,IAAI,KAAK,MAAM,SAAS,CAAC;AAC3C,WAAU,cAAc,GAAG,EAAE;AAC7B,WAAU,cAAc,UAAU,eAAe,GAAG,EAAE;CAEtD,MAAM,UAAU,MAAM,SAAS,GAAG,IAAI,SAAS,KAAK,KAAK,KAAK;CAE9D,MAAM,OAAO,UAAU,KAAK;CAC5B,MAAM,WAAW,KAAK,UAAU,KAAK,SAAS,aAAa,KAAK,CAAC;AAEjE,QAAO,UAAU,SAAS,IAAI,SAAS;AAErC,MAAI,CAAC,aADS,UAAU,aAAa,GAAG,GACf,KAAK,MAAM,EAAE;AAEpC,aAAU,YAAY,UAAU,aAAa,GAAG,GAAG,EAAE;AACrD,aAAU,YAAY,GAAG,GAAG,GAAG,EAAE;AACjC;;EAGF,MAAM,aAAa,UAAU,YAAY;AACzC,MAAI,CAAC,aAAa,YAAY,KAAK,WAAW,EAAE;AAE9C,aAAU,WAAW,aAAa,EAAE;AACpC,aAAU,YAAY,GAAG,GAAG,GAAG,EAAE;AACjC;;AAIF,MAAI,CAAC,aADa,UAAU,WAAW,EACV,SAAS,EAAE;AAEtC,aAAU,WAAW,UAAU,YAAY,GAAG,EAAE;AAChD,aAAU,YAAY,GAAG,GAAG,GAAG,EAAE;AACjC;;EAGF,MAAM,OAAO,UAAU,aAAa;AACpC,MAAI,CAAC,aAAa,MAAM,KAAK,KAAK,EAAE;AAElC,aAAU,YAAY,OAAO,GAAG,GAAG,GAAG,EAAE;AACxC;;EAGF,MAAM,SAAS,UAAU,eAAe;AACxC,MAAI,CAAC,aAAa,QAAQ,KAAK,OAAO,EAAE;AAEtC,aAAU,cAAc,SAAS,EAAE;AACnC,aAAU,cAAc,GAAG,EAAE;AAC7B;;AAIF,SAAO,IAAI,KAAK,UAAU,SAAS,CAAC;;AAGtC,OAAM,IAAI,MAAM,8DAA8D,OAAO"}

package/dist/do-executor.cjs

@@ -0,0 +1,59 @@
+
+//#region src/do-executor.ts
+/**
+* TaskExecutor that delegates execution to a Cloudflare Durable Object.
+*
+* Each task gets its own DO instance (idFromName(taskId)), bypassing
+* the Workers 30-second CPU time limit.
+*
+* Error behavior matches LocalExecutor:
+* - Infrastructure failures (DO crash, network error, non-200) → throws
+*   → Scheduler marks task as "failed"
+* - Application results (exec returns { success: false }) → returns TaskResult
+*   → Scheduler marks task as "done" with the result
+*
+* Usage:
+* ```typescript
+* new AFSScheduler({ executor: new DOExecutor(env.TASK_DO) })
+* ```
+*/
+var DOExecutor = class {
+	constructor(doNamespace) {
+		this.doNamespace = doNamespace;
+	}
+	async run(taskId, taskPath, args, context) {
+		const doId = this.doNamespace.idFromName(taskId);
+		const stub = this.doNamespace.get(doId);
+		const body = {
+			taskId,
+			taskPath,
+			args
+		};
+		if (context) body.context = context;
+		const response = await stub.fetch(new Request("https://task/run", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		}));
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new Error(`DO returned ${response.status}: ${text}`);
+		}
+		const result = await response.json();
+		return {
+			success: result.success,
+			data: result.data,
+			error: result.error
+		};
+	}
+	async cancel(taskId) {
+		const doId = this.doNamespace.idFromName(taskId);
+		const stub = this.doNamespace.get(doId);
+		try {
+			await stub.fetch(new Request("https://task/cancel", { method: "POST" }));
+		} catch {}
+	}
+};
+
+//#endregion
+exports.DOExecutor = DOExecutor;