lopata 0.2.1 → 0.3.1

package/src/bindings/images.ts

@@ -1,7 +1,7 @@
 // Images binding — Sharp-based implementation for local dev
 // Supports resize, rotate, format conversion, quality, draw overlays, and AVIF dimensions.
 
-import sharp from 'sharp'
+import type SharpNs from 'sharp'
 
 type ImageFormat = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp' | 'image/avif' | 'image/svg+xml'
 
@@ -16,15 +16,22 @@ export interface ImageTransformOptions {
 	width?: number
 	height?: number
 	fit?: 'contain' | 'cover' | 'crop' | 'scale-down' | 'pad'
+	gravity?: 'auto' | 'left' | 'right' | 'top' | 'bottom' | 'center' | { x: number; y: number }
 	rotate?: 0 | 90 | 180 | 270
 	blur?: number
 	brightness?: number
 	contrast?: number
+	gamma?: number
+	saturation?: number
 	sharpen?: number
-	trim?: { top?: number; right?: number; bottom?: number; left?: number }
+	trim?: number | boolean
 	flip?: boolean
 	flop?: boolean
 	background?: string
+	dpr?: number
+	border?: { color?: string; width?: number; top?: number; right?: number; bottom?: number; left?: number }
+	format?: 'avif' | 'webp' | 'jpeg' | 'png' | 'gif' | 'auto'
+	quality?: number | 'high' | 'medium-high' | 'medium-low' | 'low'
 }
 
 export interface DrawOptions {
@@ -37,8 +44,10 @@ export interface DrawOptions {
 }
 
 export interface OutputOptions {
-	format: 'image/png' | 'image/jpeg' | 'image/webp' | 'image/avif'
-	quality?: number
+	format: 'image/png' | 'image/jpeg' | 'image/webp' | 'image/avif' | 'image/gif'
+	quality?: number | 'high' | 'medium-high' | 'medium-low' | 'low'
+	compression?: 'fast'
+	metadata?: 'keep' | 'copyright' | 'none'
 }
 
 export interface ImageOutputResult {
@@ -46,6 +55,47 @@ export interface ImageOutputResult {
 	contentType(): string
 }
 
+// --- Lazy sharp loading ---
+
+let _sharpResolved = false
+let _sharp: typeof SharpNs | null = null
+let _sharpWarned = false
+
+async function getSharp(): Promise<typeof SharpNs | null> {
+	if (!_sharpResolved) {
+		try {
+			_sharp = (await import('sharp')).default
+		} catch {
+			_sharp = null
+		}
+		_sharpResolved = true
+	}
+	return _sharp
+}
+
+function warnSharpMissing() {
+	if (!_sharpWarned) {
+		console.warn('[lopata] sharp is not installed — image transformations will pass through unchanged. Install it: bun add sharp')
+		_sharpWarned = true
+	}
+}
+
+function passthroughResult(buf: Uint8Array, format: string): ImageOutputResult {
+	return {
+		image(): ReadableStream<Uint8Array> {
+			return new ReadableStream({
+				start(controller) {
+					controller.enqueue(buf)
+					controller.close()
+				},
+			})
+		},
+		contentType(): string {
+			return format
+		},
+	}
+}
+
 // --- PNG header parsing ---
 
 function parsePngSize(buf: Uint8Array): { width: number; height: number } | null {
@@ -229,11 +279,12 @@ async function readStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Arra
 
 // --- Sharp format mapping ---
 
-const MIME_TO_SHARP: Record<string, 'png' | 'jpeg' | 'webp' | 'avif'> = {
+const MIME_TO_SHARP: Record<string, 'png' | 'jpeg' | 'webp' | 'avif' | 'gif'> = {
 	'image/png': 'png',
 	'image/jpeg': 'jpeg',
 	'image/webp': 'webp',
 	'image/avif': 'avif',
+	'image/gif': 'gif',
 }
 
 const CF_FIT_TO_SHARP: Record<string, 'contain' | 'cover' | 'fill' | 'inside' | 'outside'> = {
@@ -244,6 +295,28 @@ const CF_FIT_TO_SHARP: Record<string, 'contain' | 'cover' | 'fill' | 'inside' |
 	pad: 'contain',
 }
 
+const QUALITY_PRESETS: Record<string, number> = {
+	high: 85,
+	'medium-high': 72,
+	'medium-low': 50,
+	low: 30,
+}
+
+function resolveQuality(q: number | string | undefined): number | undefined {
+	if (q === undefined) return undefined
+	if (typeof q === 'number') return q
+	return QUALITY_PRESETS[q]
+}
+
+const CF_GRAVITY_TO_SHARP: Record<string, string> = {
+	auto: 'attention',
+	center: 'centre',
+	left: 'west',
+	right: 'east',
+	top: 'north',
+	bottom: 'south',
+}
+
 // --- LazyImageTransformer: Sharp-based ---
 
 class LazyImageTransformer {
@@ -266,13 +339,29 @@ class LazyImageTransformer {
 	}
 
 	async output(options: OutputOptions): Promise<ImageOutputResult> {
+		const sharp = await getSharp()
+		if (!sharp) {
+			warnSharpMissing()
+			return passthroughResult(await this.streamPromise, options.format)
+		}
+
 		let currentBuf = Buffer.from(await this.streamPromise)
+		let transformFormat: string | undefined
 
 		// Apply each transform as a separate Sharp pipeline to ensure correct ordering
 		// (Sharp internally reorders operations within a single pipeline)
 		for (const t of this.transforms) {
+			if (t.format) transformFormat = t.format
 			let pipeline = sharp(currentBuf)
 
+			// DPR: multiply dimensions before resize
+			let effectiveWidth = t.width
+			let effectiveHeight = t.height
+			if (t.dpr && t.dpr !== 1) {
+				if (effectiveWidth) effectiveWidth = Math.round(effectiveWidth * t.dpr)
+				if (effectiveHeight) effectiveHeight = Math.round(effectiveHeight * t.dpr)
+			}
+
 			if (t.rotate !== undefined && t.rotate !== 0) {
 				pipeline = pipeline.rotate(t.rotate)
 			}
@@ -282,11 +371,21 @@ class LazyImageTransformer {
 			if (t.flop) {
 				pipeline = pipeline.flop()
 			}
-			if (t.width !== undefined || t.height !== undefined) {
+			if (effectiveWidth !== undefined || effectiveHeight !== undefined) {
 				const fitVal = t.fit ? CF_FIT_TO_SHARP[t.fit] ?? 'cover' : 'cover'
-				const resizeOpts: sharp.ResizeOptions = { fit: fitVal }
+				const resizeOpts: SharpNs.ResizeOptions = { fit: fitVal }
 				if (t.background) resizeOpts.background = t.background
-				pipeline = pipeline.resize(t.width ?? null, t.height ?? null, resizeOpts)
+				// Map gravity for resize positioning
+				if (t.gravity) {
+					if (typeof t.gravity === 'string') {
+						const mapped = CF_GRAVITY_TO_SHARP[t.gravity]
+						if (mapped) resizeOpts.position = mapped as any
+					} else {
+						// { x, y } — Sharp doesn't directly support arbitrary x,y so use percentage-based
+						resizeOpts.position = `${Math.round(t.gravity.x * 100)}% ${Math.round(t.gravity.y * 100)}%` as any
+					}
+				}
+				pipeline = pipeline.resize(effectiveWidth ?? null, effectiveHeight ?? null, resizeOpts)
 			}
 			if (t.blur !== undefined && t.blur > 0) {
 				pipeline = pipeline.blur(Math.max(t.blur, 0.3))
@@ -294,8 +393,36 @@ class LazyImageTransformer {
 			if (t.sharpen !== undefined && t.sharpen > 0) {
 				pipeline = pipeline.sharpen(t.sharpen)
 			}
-			if (t.brightness !== undefined && t.brightness !== 1) {
-				pipeline = pipeline.modulate({ brightness: t.brightness })
+			// Brightness and saturation via modulate
+			if ((t.brightness !== undefined && t.brightness !== 1) || (t.saturation !== undefined && t.saturation !== 1)) {
+				const modulateOpts: { brightness?: number; saturation?: number } = {}
+				if (t.brightness !== undefined) modulateOpts.brightness = t.brightness
+				if (t.saturation !== undefined) modulateOpts.saturation = t.saturation
+				pipeline = pipeline.modulate(modulateOpts)
+			}
+			// Contrast via linear transform: output = contrast * input + (128 * (1 - contrast))
+			if (t.contrast !== undefined && t.contrast !== 1) {
+				pipeline = pipeline.linear(t.contrast, 128 * (1 - t.contrast))
+			}
+			// Gamma
+			if (t.gamma !== undefined && t.gamma !== 1) {
+				pipeline = pipeline.gamma(t.gamma)
+			}
+			// Trim — CF's trim is a threshold value
+			if (t.trim !== undefined && t.trim !== false) {
+				const threshold = typeof t.trim === 'number' ? t.trim : 10
+				pipeline = pipeline.trim({ threshold })
+			}
+			// Border — extend image edges
+			if (t.border) {
+				const borderWidth = t.border.width ?? 0
+				pipeline = pipeline.extend({
+					top: t.border.top ?? borderWidth,
+					right: t.border.right ?? borderWidth,
+					bottom: t.border.bottom ?? borderWidth,
+					left: t.border.left ?? borderWidth,
+					background: t.border.color ?? '#000000',
+				})
 			}
 
 			currentBuf = Buffer.from(await pipeline.toBuffer())
@@ -303,18 +430,58 @@ class LazyImageTransformer {
 
 		// Apply draw overlays
 		if (this.overlays.length > 0) {
-			const composites: sharp.OverlayOptions[] = []
+			const baseMeta = await sharp(currentBuf).metadata()
+			const composites: SharpNs.OverlayOptions[] = []
 			for (const overlay of this.overlays) {
-				const overlayData = await overlay.streamPromise
-				const opts: sharp.OverlayOptions = { input: Buffer.from(overlayData) }
-				if (overlay.options?.top !== undefined) opts.top = overlay.options.top
-				if (overlay.options?.left !== undefined) opts.left = overlay.options.left
-				if (overlay.options?.bottom !== undefined && overlay.options?.top === undefined) {
-					opts.gravity = 'south'
+				let overlayBuf = Buffer.from(await overlay.streamPromise)
+
+				// Apply opacity to overlay by compositing with a semi-transparent blank
+				if (overlay.options?.opacity !== undefined && overlay.options.opacity < 1) {
+					const overlayMeta = await sharp(overlayBuf).metadata()
+					const w = overlayMeta.width ?? 1
+					const h = overlayMeta.height ?? 1
+					const alpha = Math.round(overlay.options.opacity * 255)
+					// Create a semi-transparent overlay: ensure alpha, then composite with a mask
+					overlayBuf = await sharp(overlayBuf)
+						.ensureAlpha()
+						.composite([{
+							input: Buffer.from(new Uint8Array(w * h * 4).fill(0).map((_, i) => i % 4 === 3 ? alpha : 255)),
+							raw: { width: w, height: h, channels: 4 },
+							blend: 'dest-in' as any,
+						}])
+						.toBuffer() as Buffer<ArrayBuffer>
 				}
-				if (overlay.options?.right !== undefined && overlay.options?.left === undefined) {
-					opts.gravity = 'east'
+
+				const opts: SharpNs.OverlayOptions = { input: overlayBuf }
+
+				// Compute position — handle bottom/right by converting to top/left
+				const hasTop = overlay.options?.top !== undefined
+				const hasLeft = overlay.options?.left !== undefined
+				const hasBottom = overlay.options?.bottom !== undefined
+				const hasRight = overlay.options?.right !== undefined
+
+				if (hasBottom || hasRight) {
+					const overlayMeta = await sharp(overlayBuf).metadata()
+					const baseW = baseMeta.width ?? 0
+					const baseH = baseMeta.height ?? 0
+					const overlayW = overlayMeta.width ?? 0
+					const overlayH = overlayMeta.height ?? 0
+
+					if (hasTop) {
+						opts.top = overlay.options!.top
+					} else if (hasBottom) {
+						opts.top = Math.max(0, baseH - overlayH - overlay.options!.bottom!)
+					}
+					if (hasLeft) {
+						opts.left = overlay.options!.left
+					} else if (hasRight) {
+						opts.left = Math.max(0, baseW - overlayW - overlay.options!.right!)
+					}
+				} else {
+					if (hasTop) opts.top = overlay.options!.top
+					if (hasLeft) opts.left = overlay.options!.left
 				}
+
 				if (overlay.options?.repeat === 'repeat') {
 					opts.tile = true
 				}
@@ -323,14 +490,50 @@ class LazyImageTransformer {
 			currentBuf = Buffer.from(await sharp(currentBuf).composite(composites).toBuffer())
 		}
 
-		// Output format
-		const sharpFmt = MIME_TO_SHARP[options.format] ?? 'png'
+		// Resolve output format — transform format overrides output if set
+		// "auto" → detect best format from source (default to webp)
+		let resolvedMime = options.format
+		if (transformFormat) {
+			if (transformFormat === 'auto') {
+				// Detect source format from buffer, default to webp
+				const sourceFormat = detectFormat(currentBuf)
+				resolvedMime = sourceFormat && sourceFormat !== 'image/svg+xml' ? sourceFormat : 'image/webp'
+			} else {
+				const shortToMime: Record<string, OutputOptions['format']> = {
+					avif: 'image/avif',
+					webp: 'image/webp',
+					jpeg: 'image/jpeg',
+					png: 'image/png',
+					gif: 'image/gif',
+				}
+				resolvedMime = shortToMime[transformFormat] ?? resolvedMime
+			}
+		}
+		const sharpFmt = MIME_TO_SHARP[resolvedMime] ?? 'png'
 		const formatOpts: Record<string, unknown> = {}
-		if (options.quality !== undefined) {
-			formatOpts.quality = options.quality
+		const resolvedQuality = resolveQuality(options.quality)
+		if (resolvedQuality !== undefined) {
+			formatOpts.quality = resolvedQuality
+		}
+		// Compression: "fast" → lower effort for supported formats
+		if (options.compression === 'fast') {
+			if (sharpFmt === 'png') formatOpts.compressionLevel = 1
+			if (sharpFmt === 'webp') formatOpts.effort = 0
+			if (sharpFmt === 'avif') formatOpts.effort = 0
 		}
-		const outputBuf = await sharp(currentBuf).toFormat(sharpFmt, formatOpts).toBuffer()
-		const contentType = options.format
+
+		let outputPipeline = sharp(currentBuf)
+
+		// Metadata handling
+		if (options.metadata === 'keep') {
+			outputPipeline = outputPipeline.keepMetadata()
+		} else if (options.metadata === 'copyright') {
+			outputPipeline = outputPipeline.withMetadata()
+		}
+		// 'none' is the default — Sharp strips metadata by default
+
+		const outputBuf = await outputPipeline.toFormat(sharpFmt, formatOpts).toBuffer()
+		const contentType = resolvedMime
 
 		return {
 			image(): ReadableStream<Uint8Array> {
@@ -360,14 +563,16 @@ export class ImagesBinding {
 		// Try our fast header parsers first, fall back to Sharp for AVIF
 		let dims = parseDimensions(buf, format)
 		if (!dims && format === 'image/avif') {
-			// Fallback: use Sharp metadata for AVIF
-			try {
-				const meta = await sharp(Buffer.from(buf)).metadata()
-				if (meta.width && meta.height) {
-					dims = { width: meta.width, height: meta.height }
+			const sharp = await getSharp()
+			if (sharp) {
+				try {
+					const meta = await sharp(Buffer.from(buf)).metadata()
+					if (meta.width && meta.height) {
+						dims = { width: meta.width, height: meta.height }
+					}
+				} catch {
+					// ignore — return 0,0
 				}
-			} catch {
-				// ignore — return 0,0
 			}
 		}
 		return {

package/src/bindings/queue.ts

@@ -39,6 +39,8 @@ interface ConsumerConfig {
 	maxBatchTimeout: number
 	maxRetries: number
 	deadLetterQueue: string | null
+	maxConcurrency?: number | null
+	retryDelay?: number | null
 	retentionPeriodSeconds?: number // default 345600 (4 days), matching CF default
 }
 
@@ -195,6 +197,7 @@ export class QueueConsumer {
 	private batchBuffer: { id: string; body: Uint8Array | Buffer; content_type: string; attempts: number; created_at: number }[] = []
 	private batchTimer: ReturnType<typeof setTimeout> | null = null
 	private polling = false
+	private _activeDeliveries = 0
 
 	constructor(
 		db: Database,
@@ -230,6 +233,8 @@ export class QueueConsumer {
 
 	async poll(): Promise<void> {
 		if (this.polling) return
+		// Check max_concurrency gate
+		if (this.config.maxConcurrency && this._activeDeliveries >= this.config.maxConcurrency) return
 		this.polling = true
 		try {
 			const now = Date.now()
@@ -258,6 +263,17 @@ export class QueueConsumer {
 
 	private async deliverBatch(
 		rows: { id: string; body: Uint8Array | Buffer; content_type: string; attempts: number; created_at: number }[],
+	): Promise<void> {
+		this._activeDeliveries++
+		try {
+			await this._deliverBatchInner(rows)
+		} finally {
+			this._activeDeliveries--
+		}
+	}
+
+	private async _deliverBatchInner(
+		rows: { id: string; body: Uint8Array | Buffer; content_type: string; attempts: number; created_at: number }[],
 	): Promise<void> {
 		// Increment attempts for all fetched messages
 		const ids = rows.map((r) => r.id)
@@ -330,7 +346,7 @@ export class QueueConsumer {
 				this.db.run("UPDATE queue_messages SET status = 'acked', completed_at = ? WHERE id = ?", [Date.now(), row.id])
 			} else {
 				// Retry
-				const delay = decision.delaySeconds ?? 0
+				const delay = decision.delaySeconds ?? this.config.retryDelay ?? 0
 				if (currentAttempts >= this.config.maxRetries) {
 					// Max retries exceeded — move to DLQ or mark as failed
 					if (this.config.deadLetterQueue) {

package/src/bindings/scheduled.ts

@@ -8,9 +8,11 @@ export interface ScheduledController {
 	noRetry(): void
 }
 
+// A CronField matcher that can check a value, optionally with full date context
+type CronFieldMatcher = (value: number, date: Date) => boolean
+
 interface CronField {
-	type: 'any' | 'values'
-	values: number[]
+	match: CronFieldMatcher
 }
 
 interface ParsedCron {
@@ -65,39 +67,161 @@ function resolveToken(token: string, names: Record<string, number> | null): numb
 	return parseInt(token, 10)
 }
 
-function parseField(field: string, min: number, max: number, names: Record<string, number> | null = null): CronField {
+/** Get the last day of a given month (1-indexed) */
+function lastDayOfMonth(year: number, month: number): number {
+	return new Date(year, month, 0).getDate()
+}
+
+/** Get the day-of-week (0=Sun) for a given date */
+function dayOfWeekFor(year: number, month: number, day: number): number {
+	return new Date(year, month - 1, day).getDay()
+}
+
+/** Find nearest weekday to the given day in the given month */
+function nearestWeekday(year: number, month: number, day: number): number {
+	const lastDay = lastDayOfMonth(year, month)
+	day = Math.min(day, lastDay)
+	const dow = dayOfWeekFor(year, month, day)
+	if (dow >= 1 && dow <= 5) return day // already weekday
+	if (dow === 6) {
+		// Saturday → Friday or Monday
+		return day > 1 ? day - 1 : day + 2
+	}
+	// Sunday → Monday or Friday
+	return day < lastDay ? day + 1 : day - 2
+}
+
+/** Find the Nth occurrence of a weekday in a month (1-based N) */
+function nthWeekdayOfMonth(year: number, month: number, weekday: number, n: number): number | null {
+	let count = 0
+	const lastDay = lastDayOfMonth(year, month)
+	for (let d = 1; d <= lastDay; d++) {
+		if (dayOfWeekFor(year, month, d) === weekday) {
+			count++
+			if (count === n) return d
+		}
+	}
+	return null // Nth occurrence doesn't exist
+}
+
+/** Find the last occurrence of a weekday in a month */
+function lastWeekdayOfMonth(year: number, month: number, weekday: number): number {
+	const lastDay = lastDayOfMonth(year, month)
+	for (let d = lastDay; d >= 1; d--) {
+		if (dayOfWeekFor(year, month, d) === weekday) return d
+	}
+	return lastDay // should never reach here
+}
+
+type FieldType = 'minute' | 'hour' | 'dayOfMonth' | 'month' | 'dayOfWeek'
+
+function parseField(field: string, min: number, max: number, fieldType: FieldType, names: Record<string, number> | null = null): CronField {
 	if (field === '*') {
-		return { type: 'any', values: [] }
+		return { match: () => true }
 	}
 
-	const values: number[] = []
+	// Collect matchers for each comma-separated part
+	const matchers: CronFieldMatcher[] = []
 
 	for (const part of field.split(',')) {
+		// LW — last weekday of month (day-of-month field only)
+		if (fieldType === 'dayOfMonth' && part.toUpperCase() === 'LW') {
+			matchers.push((_value, date) => {
+				const year = date.getFullYear()
+				const month = date.getMonth() + 1
+				const last = lastDayOfMonth(year, month)
+				const dow = dayOfWeekFor(year, month, last)
+				let lw: number
+				if (dow === 0) lw = last - 2 // Sun → Fri
+				else if (dow === 6) lw = last - 1 // Sat → Fri
+				else lw = last
+				return date.getDate() === lw
+			})
+			continue
+		}
+
+		// L in day-of-month — last day of month
+		if (fieldType === 'dayOfMonth' && part.toUpperCase() === 'L') {
+			matchers.push((_value, date) => {
+				return date.getDate() === lastDayOfMonth(date.getFullYear(), date.getMonth() + 1)
+			})
+			continue
+		}
+
+		// W in day-of-month — nearest weekday (e.g. 15W)
+		if (fieldType === 'dayOfMonth') {
+			const wMatch = part.match(/^(\d+)W$/i)
+			if (wMatch) {
+				const targetDay = parseInt(wMatch[1]!, 10)
+				matchers.push((_value, date) => {
+					return date.getDate() === nearestWeekday(date.getFullYear(), date.getMonth() + 1, targetDay)
+				})
+				continue
+			}
+		}
+
+		// # in day-of-week — Nth occurrence (e.g. 2#3 = 3rd Tuesday)
+		if (fieldType === 'dayOfWeek') {
+			const hashMatch = part.match(/^([a-zA-Z0-9]+)#(\d+)$/)
+			if (hashMatch) {
+				const weekday = resolveToken(hashMatch[1]!, names)
+				const n = parseInt(hashMatch[2]!, 10)
+				matchers.push((_value, date) => {
+					const nth = nthWeekdayOfMonth(date.getFullYear(), date.getMonth() + 1, weekday, n)
+					return nth !== null && date.getDate() === nth
+				})
+				continue
+			}
+		}
+
+		// L in day-of-week — last occurrence of that weekday (e.g. 5L or FRIL)
+		if (fieldType === 'dayOfWeek') {
+			const lMatch = part.match(/^([a-zA-Z0-9]+)L$/i)
+			if (lMatch) {
+				const weekday = resolveToken(lMatch[1]!, names)
+				matchers.push((_value, date) => {
+					const last = lastWeekdayOfMonth(date.getFullYear(), date.getMonth() + 1, weekday)
+					return date.getDate() === last
+				})
+				continue
+			}
+		}
+
+		// Step: */2 or 1-5/2
 		const stepMatch = part.match(/^(\*|([a-zA-Z0-9]+)-([a-zA-Z0-9]+))\/(\d+)$/)
 		if (stepMatch) {
 			const step = parseInt(stepMatch[4]!, 10)
 			const start = stepMatch[1] === '*' ? min : resolveToken(stepMatch[2]!, names)
 			const end = stepMatch[1] === '*' ? max : resolveToken(stepMatch[3]!, names)
+			const values: number[] = []
 			for (let i = start; i <= end; i += step) {
 				values.push(i)
 			}
+			matchers.push((value) => values.includes(value))
 			continue
 		}
 
+		// Range: 1-5
 		const rangeMatch = part.match(/^([a-zA-Z0-9]+)-([a-zA-Z0-9]+)$/)
 		if (rangeMatch) {
 			const start = resolveToken(rangeMatch[1]!, names)
 			const end = resolveToken(rangeMatch[2]!, names)
+			const values: number[] = []
 			for (let i = start; i <= end; i++) {
 				values.push(i)
 			}
+			matchers.push((value) => values.includes(value))
 			continue
 		}
 
-		values.push(resolveToken(part, names))
+		// Single value
+		const val = resolveToken(part, names)
+		matchers.push((value) => value === val)
 	}
 
-	return { type: 'values', values }
+	return {
+		match: (value, date) => matchers.some(m => m(value, date)),
+	}
 }
 
 export function parseCron(expression: string): ParsedCron {
@@ -118,26 +242,21 @@ export function parseCron(expression: string): ParsedCron {
 
 	return {
 		expression: trimmed,
-		minute: parseField(parts[0]!, 0, 59),
-		hour: parseField(parts[1]!, 0, 23),
-		dayOfMonth: parseField(parts[2]!, 1, 31),
-		month: parseField(parts[3]!, 1, 12, MONTH_NAMES),
-		dayOfWeek: parseField(parts[4]!, 0, 6, DAY_NAMES),
+		minute: parseField(parts[0]!, 0, 59, 'minute'),
+		hour: parseField(parts[1]!, 0, 23, 'hour'),
+		dayOfMonth: parseField(parts[2]!, 1, 31, 'dayOfMonth'),
+		month: parseField(parts[3]!, 1, 12, 'month', MONTH_NAMES),
+		dayOfWeek: parseField(parts[4]!, 0, 6, 'dayOfWeek', DAY_NAMES),
 	}
 }
 
-function fieldMatches(field: CronField, value: number): boolean {
-	if (field.type === 'any') return true
-	return field.values.includes(value)
-}
-
 export function cronMatchesDate(cron: ParsedCron, date: Date): boolean {
 	return (
-		fieldMatches(cron.minute, date.getMinutes())
-		&& fieldMatches(cron.hour, date.getHours())
-		&& fieldMatches(cron.dayOfMonth, date.getDate())
-		&& fieldMatches(cron.month, date.getMonth() + 1)
-		&& fieldMatches(cron.dayOfWeek, date.getDay())
+		cron.minute.match(date.getMinutes(), date)
+		&& cron.hour.match(date.getHours(), date)
+		&& cron.dayOfMonth.match(date.getDate(), date)
+		&& cron.month.match(date.getMonth() + 1, date)
+		&& cron.dayOfWeek.match(date.getDay(), date)
 	)
 }