@namzu/sdk 45.0.0 → 46.0.0

package/src/schedules/describe.ts

@@ -0,0 +1,138 @@
+/**
+ * A schedule in words, for a confirmation screen or a listing.
+ *
+ * Covers the common shapes exactly and falls back to the expression itself
+ * for anything else, rather than paraphrasing it wrongly.
+ */
+
+import { parseCronExpression } from './cron.js'
+import type { CronExpression, ScheduleSpec } from './types.js'
+import { formatWall } from './tz.js'
+
+const MINUTE = 60_000
+const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+const MONTH_NAMES = [
+	'January',
+	'February',
+	'March',
+	'April',
+	'May',
+	'June',
+	'July',
+	'August',
+	'September',
+	'October',
+	'November',
+	'December',
+]
+
+export interface DescribeScheduleOptions {
+	/** Zone an `at` or `every` anchor is shown in. Default UTC. */
+	readonly tz?: string
+}
+
+function pad(n: number): string {
+	return String(n).padStart(2, '0')
+}
+
+function plural(n: number, unit: string): string {
+	return `${n} ${unit}${n === 1 ? '' : 's'}`
+}
+
+function describeInterval(ms: number): string {
+	if (ms % (7 * 24 * 60 * MINUTE) === 0) {
+		const w = ms / (7 * 24 * 60 * MINUTE)
+		return w === 1 ? 'every week' : `every ${plural(w, 'week')}`
+	}
+	if (ms % (24 * 60 * MINUTE) === 0) {
+		const d = ms / (24 * 60 * MINUTE)
+		return d === 1 ? 'every 24 hours' : `every ${plural(d, 'day')}`
+	}
+	if (ms % (60 * MINUTE) === 0) {
+		const h = ms / (60 * MINUTE)
+		return h === 1 ? 'every hour' : `every ${plural(h, 'hour')}`
+	}
+	const m = ms / MINUTE
+	return m === 1 ? 'every minute' : `every ${plural(m, 'minute')}`
+}
+
+/** `1,2,3,5` → `1–3, 5`. */
+function ranges(values: readonly number[], name: (n: number) => string): string {
+	const out: string[] = []
+	let i = 0
+	while (i < values.length) {
+		let j = i
+		while (j + 1 < values.length && (values[j + 1] as number) === (values[j] as number) + 1) j++
+		const a = values[i] as number
+		const b = values[j] as number
+		if (j - i >= 2) out.push(`${name(a)} through ${name(b)}`)
+		else for (let k = i; k <= j; k++) out.push(name(values[k] as number))
+		i = j + 1
+	}
+	return out.join(', ')
+}
+
+function isFull(values: readonly number[], min: number, max: number): boolean {
+	return values.length === max - min + 1
+}
+
+function describeDays(e: CronExpression): string {
+	const allDom = !e.domRestricted
+	const allDow = !e.dowRestricted
+	const allMonths = isFull(e.months, 1, 12)
+	let days: string
+	if (allDom && allDow) days = 'every day'
+	else if (allDom) days = `on ${ranges(e.daysOfWeek, (d) => DAY_NAMES[d] ?? String(d))}`
+	else if (allDow) days = `on day ${ranges(e.daysOfMonth, String)} of the month`
+	else
+		days = `on day ${ranges(e.daysOfMonth, String)} of the month and on ${ranges(e.daysOfWeek, (d) => DAY_NAMES[d] ?? String(d))}`
+	if (!allMonths) days += ` in ${ranges(e.months, (m) => MONTH_NAMES[m - 1] ?? String(m))}`
+	return days
+}
+
+function describeTimes(e: CronExpression, source: string): string {
+	const [mi = '', ho = ''] = source.split(' ')
+	const allMinutes = isFull(e.minutes, 0, 59)
+	const allHours = isFull(e.hours, 0, 23)
+	if (allMinutes && allHours) return 'every minute'
+	const stepMinute = /^\*\/(\d+)$/.exec(mi)
+	if (stepMinute && allHours) return `every ${plural(Number(stepMinute[1]), 'minute')}`
+	if (allHours && e.minutes.length <= 4) {
+		return e.minutes.length === 1 && e.minutes[0] === 0
+			? 'every hour, on the hour'
+			: `every hour at minute ${e.minutes.join(', ')}`
+	}
+	const stepHour = /^\*\/(\d+)$/.exec(ho)
+	if (stepHour && e.minutes.length === 1) {
+		return `every ${plural(Number(stepHour[1]), 'hour')} at minute ${e.minutes[0]}`
+	}
+	if (e.hours.length * e.minutes.length <= 6) {
+		const times: string[] = []
+		for (const h of e.hours) for (const m of e.minutes) times.push(`${pad(h)}:${pad(m)}`)
+		return `at ${times.join(', ')}`
+	}
+	return `at minute ${ranges(e.minutes, String)} of hour ${ranges(e.hours, String)}`
+}
+
+/** The schedule in words: `at 03:00 every day (Europe/Istanbul)`. */
+export function describeSchedule(
+	spec: ScheduleSpec,
+	options: DescribeScheduleOptions = {},
+): string {
+	const tz = options.tz ?? 'UTC'
+	switch (spec.kind) {
+		case 'at':
+			return `once at ${formatWall(Date.parse(spec.at), tz)} (${tz})`
+		case 'every':
+			return describeInterval(spec.everyMs)
+		case 'cron': {
+			let e: CronExpression
+			try {
+				e = parseCronExpression(spec.expr)
+			} catch {
+				return `cron "${spec.expr}" (${spec.tz})`
+			}
+			return `${describeTimes(e, e.source)} ${describeDays(e)} (${spec.tz})`
+		}
+	}
+}

package/src/schedules/errors.ts

@@ -0,0 +1,15 @@
+/**
+ * A schedule, cron expression or time zone that cannot be used.
+ *
+ * `token` names the piece of the input that was refused, so a caller can
+ * point at it instead of repeating the whole expression back.
+ */
+export class ScheduleValidationError extends Error {
+	readonly token: string | undefined
+
+	constructor(message: string, token?: string) {
+		super(message)
+		this.name = 'ScheduleValidationError'
+		this.token = token
+	}
+}

package/src/schedules/evaluate.ts

@@ -0,0 +1,178 @@
+/**
+ * What to do about one job now: fire, skip, record a miss, or nothing.
+ *
+ * Pure: no clock, no I/O. The host passes the instant, the state it kept and
+ * whether an occurrence was already claimed, and applies the decision itself
+ * (append history, claim, dispatch). Evaluating the same `(state, now)` twice
+ * gives the same answer, so a host that lost its in-memory queue rebuilds it
+ * by evaluating again; an already-claimed key is never fired twice.
+ *
+ * Rules, in order:
+ *
+ * 1. Occurrences due are those in `(lastEvaluatedAt, now]`, counted with a
+ *    cap and never enumerated. A new job counts from its creation. A changed
+ *    revision counts from the change, so editing `0 3 * * *` into `0 4 * * *`
+ *    does not invent catch-ups for 04:00s that never belonged to the job.
+ * 2. `lastEvaluatedAt` never moves backwards: after a backward clock jump
+ *    nothing is due until the wall clock passes it again.
+ * 3. A job that is not active produces skip records only (paused and
+ *    awaiting-confirmation are collapsed per evaluation). A one-shot whose
+ *    time passed while inactive is expired.
+ * 4. The latest due occurrence fires on time (`scheduled`, or `late` once
+ *    more than five seconds late) within the late grace; within the catch-up
+ *    window it fires once as `catch-up` and everything earlier is one
+ *    `missed` record; older than the window, nothing fires.
+ * 5. An unfinished run of the same job skips what came due meanwhile.
+ * 6. A provider quota hold skips what comes due before the hold ends.
+ */
+
+import { countOccurrences, nextFireTime, previousFireTime } from './next-fire.js'
+import type {
+	ScheduleDecision,
+	ScheduleEvaluationInput,
+	ScheduleMissedReason,
+	ScheduleSkipReason,
+} from './types.js'
+
+/** Default catch-up window: seven days. */
+export const SCHEDULE_CATCH_UP_WINDOW_MS = 7 * 24 * 60 * 60 * 1000
+/** Default grace for a fire to still count as on time: two minutes. */
+export const SCHEDULE_LATE_GRACE_MS = 120_000
+/** A fire later than this is reported `late` rather than `scheduled`. */
+const LATE_THRESHOLD_MS = 5_000
+
+type Skip = ScheduleDecision['skip'][number]
+
+function missedReason(input: ScheduleEvaluationInput, firstMissed: Date): ScheduleMissedReason {
+	const gap = input.daemon.observedGap
+	if (gap && firstMissed.getTime() >= gap.from.getTime()) {
+		if (gap.kind === 'asleep') return 'machine-asleep'
+		if (gap.kind === 'clock-forward') return 'clock-jumped-forward'
+	}
+	return 'daemon-not-running'
+}
+
+/** Evaluate one job at `now`. */
+export function evaluateJob(input: ScheduleEvaluationInput): ScheduleDecision {
+	const { job, state, now } = input
+	const nowMs = now.getTime()
+	const lateGrace = input.lateGraceMs ?? SCHEDULE_LATE_GRACE_MS
+	const windowMs = job.catchUp?.windowMs ?? SCHEDULE_CATCH_UP_WINDOW_MS
+
+	let baseMs = Date.parse(state.lastEvaluatedAt ?? job.createdAt)
+	if (!Number.isFinite(baseMs)) baseMs = Date.parse(job.createdAt)
+	if (state.jobRevision !== undefined && state.jobRevision !== job.revision) {
+		baseMs = Math.max(baseMs, Date.parse(job.updatedAt))
+	}
+	const nextState = (evaluatedMs: number): ScheduleDecision['nextState'] => {
+		const next = nextFireTime(job.spec, new Date(evaluatedMs))
+		return {
+			lastEvaluatedAt: new Date(evaluatedMs),
+			...(next ? { nextFireAt: next } : {}),
+			jobRevision: job.revision,
+		}
+	}
+
+	if (job.state === 'completed' || job.state === 'expired') {
+		return {
+			skip: [],
+			nextState: { lastEvaluatedAt: new Date(Math.max(baseMs, nowMs)), jobRevision: job.revision },
+		}
+	}
+	// Rule 2: a clock that went backwards decides nothing new.
+	if (nowMs <= baseMs) return { skip: [], nextState: nextState(baseMs) }
+
+	const due = countOccurrences(job.spec, new Date(baseMs), now)
+	if (due.count === 0 || !due.latest) {
+		if (job.spec.kind === 'at' && Date.parse(job.spec.at) <= baseMs && job.state !== 'active') {
+			return { skip: [], jobTransition: 'expired', nextState: nextState(nowMs) }
+		}
+		return { skip: [], nextState: nextState(nowMs) }
+	}
+	const latest = due.latest
+
+	const collapsed = (reason: ScheduleSkipReason): Skip[] => [
+		{ scheduledFor: latest, reason, count: due.count },
+	]
+
+	if (job.state === 'paused' || job.state === 'pending-confirmation') {
+		const reason: ScheduleSkipReason = job.state === 'paused' ? 'paused' : 'awaiting-confirmation'
+		return {
+			skip: collapsed(reason),
+			...(job.spec.kind === 'at' ? { jobTransition: 'expired' as const } : {}),
+			nextState: nextState(nowMs),
+		}
+	}
+
+	const hold = state.quotaHoldUntil ? Date.parse(state.quotaHoldUntil) : Number.NaN
+	if (Number.isFinite(hold) && hold > nowMs) {
+		return { skip: collapsed('quota-hold'), nextState: nextState(nowMs) }
+	}
+
+	if (state.activeRun) {
+		return {
+			skip: collapsed(
+				state.activeRun.status === 'awaiting-approval'
+					? 'previous-run-awaiting-approval'
+					: 'previous-run-active',
+			),
+			nextState: nextState(nowMs),
+		}
+	}
+
+	const key = String(latest.getTime())
+	const lateBy = nowMs - latest.getTime()
+	const earlier = due.count - 1
+	const missedBefore = (): ScheduleDecision['missed'] | undefined => {
+		if (earlier <= 0 || !due.first) return undefined
+		// The occurrence just before the fired one.
+		const to = previousFireTime(job.spec, new Date(latest.getTime() - 1)) ?? due.first
+		return {
+			from: due.first,
+			to,
+			count: earlier,
+			capped: due.capped,
+			reason: missedReason(input, due.first),
+		}
+	}
+	const transition = job.spec.kind === 'at' ? { jobTransition: 'completed' as const } : {}
+
+	if (input.isClaimed?.(key)) {
+		// Somebody already started it; nothing to fire, nothing missed.
+		return { skip: [], ...transition, nextState: nextState(nowMs) }
+	}
+
+	if (lateBy <= lateGrace || lateBy <= windowMs) {
+		const trigger =
+			lateBy <= lateGrace ? (lateBy > LATE_THRESHOLD_MS ? 'late' : 'scheduled') : 'catch-up'
+		const missed = missedBefore()
+		return {
+			fire: { key, scheduledFor: latest, trigger },
+			skip: [],
+			...(missed ? { missed } : {}),
+			...transition,
+			nextState: nextState(nowMs),
+		}
+	}
+
+	// Everything due is older than the window.
+	const first = due.first ?? latest
+	return {
+		skip: [
+			{
+				scheduledFor: latest,
+				reason: job.spec.kind === 'at' ? 'one-shot-expired' : 'beyond-catch-up-window',
+				count: 1,
+			},
+		],
+		missed: {
+			from: first,
+			to: latest,
+			count: due.count,
+			capped: due.capped,
+			reason: missedReason(input, first),
+		},
+		...(job.spec.kind === 'at' ? { jobTransition: 'expired' as const } : {}),
+		nextState: nextState(nowMs),
+	}
+}

package/src/schedules/index.ts

@@ -0,0 +1,18 @@
+export { parseCronExpression } from './cron.js'
+export { describeSchedule } from './describe.js'
+export type { DescribeScheduleOptions } from './describe.js'
+export { ScheduleValidationError } from './errors.js'
+export {
+	SCHEDULE_CATCH_UP_WINDOW_MS,
+	SCHEDULE_LATE_GRACE_MS,
+	evaluateJob,
+} from './evaluate.js'
+export {
+	countOccurrences,
+	nextFireTime,
+	previousFireTime,
+} from './next-fire.js'
+export { parseDuration, parseScheduleSpec, upcomingFireTimes } from './spec.js'
+export type { ParseScheduleOptions } from './spec.js'
+export { hostTimeZone, validateTimeZone } from './tz.js'
+export type * from './types.js'

package/src/schedules/next-fire.ts

@@ -0,0 +1,257 @@
+/**
+ * When a spec fires: the next instant, the previous one, and how many fall
+ * in a window.
+ *
+ * Cron is walked a local DAY at a time — never a minute at a time over years
+ * — and a day with no DST change is computed arithmetically from one offset.
+ * Only a day whose offset changes is examined slot by slot, and that is where
+ * cronie's rule is applied:
+ *
+ * - a fixed-time expression (`30 2 * * *`) whose time falls in a
+ *   spring-forward gap fires once, at the first instant after the gap;
+ *   whose time is repeated by a fall-back fires once, at the first of the two;
+ * - a wildcard or step expression (`0 * * * *`, `*\/15 * * * *`) fires at
+ *   every instant whose wall time matches: the repeated hour runs twice and
+ *   slots inside the gap do not exist.
+ */
+
+import { cronMatchesDay, parseCronExpression } from './cron.js'
+import { ScheduleValidationError } from './errors.js'
+import type { CronExpression, OccurrenceCount, ScheduleSpec } from './types.js'
+import { civil, firstInstantAfterGap, instantsForWall, offsetAt, validateTimeZone } from './tz.js'
+
+const MINUTE = 60_000
+const HOUR = 60 * MINUTE
+const DAY = 24 * HOUR
+/** How far ahead a cron search looks before deciding the expression never fires. */
+export const CRON_HORIZON_DAYS = 366 * 5 + 2
+/**
+ * Occurrence counts stop here. Counting a day without a DST change costs one
+ * multiplication, so the cap bounds the pathological case (a years-long gap
+ * on a per-minute job) rather than the ordinary one.
+ */
+export const OCCURRENCE_COUNT_CAP = 100_000
+
+const parsedCache = new Map<string, CronExpression>()
+
+function cronOf(expr: string): CronExpression {
+	let parsed = parsedCache.get(expr)
+	if (!parsed) {
+		parsed = parseCronExpression(expr)
+		if (parsedCache.size > 256) parsedCache.clear()
+		parsedCache.set(expr, parsed)
+	}
+	return parsed
+}
+
+/** The local-midnight wall value of the day containing `wall`. */
+function dayStart(wall: number): number {
+	return Math.floor(wall / DAY) * DAY
+}
+
+/**
+ * Every instant the expression fires on one local day (`dayWall` is that
+ * day's midnight as a wall value), ascending.
+ */
+export function cronInstantsOnDay(expr: CronExpression, tz: string, dayWall: number): number[] {
+	const c = civil(dayWall)
+	if (!cronMatchesDay(expr, c.month, c.day, c.weekday)) return []
+	const before = offsetAt(dayWall - 14 * HOUR, tz)
+	const after = offsetAt(dayWall + DAY + 14 * HOUR, tz)
+	const out: number[] = []
+	if (before === after) {
+		for (const h of expr.hours)
+			for (const m of expr.minutes) out.push(dayWall + h * HOUR + m * MINUTE - before)
+		return out
+	}
+	// A day the offset changes on (or next to): slot by slot.
+	const seen = new Set<number>()
+	for (const h of expr.hours) {
+		for (const m of expr.minutes) {
+			const wall = dayWall + h * HOUR + m * MINUTE
+			const instants = instantsForWall(wall, tz)
+			if (instants.length === 0) {
+				if (expr.fixedTime) {
+					const shifted = firstInstantAfterGap(wall, tz)
+					if (!seen.has(shifted)) {
+						seen.add(shifted)
+						out.push(shifted)
+					}
+				}
+				continue
+			}
+			const chosen = expr.fixedTime ? instants.slice(0, 1) : instants
+			for (const t of chosen) {
+				if (seen.has(t)) continue
+				seen.add(t)
+				out.push(t)
+			}
+		}
+	}
+	return out.sort((a, b) => a - b)
+}
+
+function validEvery(spec: { everyMs: number; anchorAt: string }): number {
+	const anchor = Date.parse(spec.anchorAt)
+	if (!Number.isFinite(anchor)) {
+		throw new ScheduleValidationError(`anchor "${spec.anchorAt}" is not a date`, spec.anchorAt)
+	}
+	if (!Number.isSafeInteger(spec.everyMs) || spec.everyMs < MINUTE || spec.everyMs % MINUTE !== 0) {
+		throw new ScheduleValidationError(
+			'an interval must be a whole number of minutes, at least one',
+			String(spec.everyMs),
+		)
+	}
+	return anchor
+}
+
+/**
+ * The first instant strictly after `afterExclusive` at which `spec` fires,
+ * or `null` when there is none (a past `at`, or a cron expression with no
+ * occurrence in the next five years).
+ */
+export function nextFireTime(spec: ScheduleSpec, afterExclusive: Date): Date | null {
+	const after = afterExclusive.getTime()
+	switch (spec.kind) {
+		case 'at': {
+			const at = Date.parse(spec.at)
+			return Number.isFinite(at) && at > after ? new Date(at) : null
+		}
+		case 'every': {
+			const anchor = validEvery(spec)
+			const k = after < anchor ? 1 : Math.floor((after - anchor) / spec.everyMs) + 1
+			return new Date(anchor + Math.max(1, k) * spec.everyMs)
+		}
+		case 'cron': {
+			const expr = cronOf(spec.expr)
+			const tz = spec.tz
+			// A day early: a gap-shifted or offset-crossing instant of the
+			// previous local day can still lie after `after`.
+			let day = dayStart(after + offsetAt(after, tz)) - DAY
+			for (let i = 0; i <= CRON_HORIZON_DAYS; i++, day += DAY) {
+				for (const t of cronInstantsOnDay(expr, tz, day)) if (t > after) return new Date(t)
+			}
+			return null
+		}
+	}
+}
+
+/**
+ * The last instant at or before `atOrBefore` at which `spec` fired, or
+ * `null` if none within the horizon (or before the anchor / the `at`).
+ */
+export function previousFireTime(spec: ScheduleSpec, atOrBefore: Date): Date | null {
+	const before = atOrBefore.getTime()
+	switch (spec.kind) {
+		case 'at': {
+			const at = Date.parse(spec.at)
+			return Number.isFinite(at) && at <= before ? new Date(at) : null
+		}
+		case 'every': {
+			const anchor = validEvery(spec)
+			const k = Math.floor((before - anchor) / spec.everyMs)
+			return k >= 1 ? new Date(anchor + k * spec.everyMs) : null
+		}
+		case 'cron': {
+			const expr = cronOf(spec.expr)
+			const tz = spec.tz
+			let day = dayStart(before + offsetAt(before, tz)) + DAY
+			for (let i = 0; i <= CRON_HORIZON_DAYS; i++, day -= DAY) {
+				const instants = cronInstantsOnDay(expr, tz, day)
+				for (let j = instants.length - 1; j >= 0; j--) {
+					const t = instants[j] as number
+					if (t <= before) return new Date(t)
+				}
+			}
+			return null
+		}
+	}
+}
+
+/**
+ * How many times `spec` fires in `(fromExclusive, toInclusive]`, with the
+ * first and latest of them. Stops counting at `cap` (default 100 000) and
+ * says so, without enumerating beyond it; the latest is exact either way.
+ */
+export function countOccurrences(
+	spec: ScheduleSpec,
+	fromExclusive: Date,
+	toInclusive: Date,
+	cap: number = OCCURRENCE_COUNT_CAP,
+): OccurrenceCount {
+	const from = fromExclusive.getTime()
+	const to = toInclusive.getTime()
+	if (to <= from) return { count: 0, capped: false }
+	switch (spec.kind) {
+		case 'at': {
+			const at = Date.parse(spec.at)
+			return at > from && at <= to
+				? { count: 1, capped: false, first: new Date(at), latest: new Date(at) }
+				: { count: 0, capped: false }
+		}
+		case 'every': {
+			const anchor = validEvery(spec)
+			const firstK = from < anchor ? 1 : Math.floor((from - anchor) / spec.everyMs) + 1
+			const lastK = Math.floor((to - anchor) / spec.everyMs)
+			if (lastK < Math.max(1, firstK)) return { count: 0, capped: false }
+			const k0 = Math.max(1, firstK)
+			const total = lastK - k0 + 1
+			return {
+				count: Math.min(total, cap),
+				capped: total > cap,
+				first: new Date(anchor + k0 * spec.everyMs),
+				latest: new Date(anchor + lastK * spec.everyMs),
+			}
+		}
+		case 'cron': {
+			const expr = cronOf(spec.expr)
+			const tz = spec.tz
+			const latest = previousFireTime(spec, toInclusive)
+			if (!latest || latest.getTime() <= from) return { count: 0, capped: false }
+			const perUniformDay = expr.hours.length * expr.minutes.length
+			let count = 0
+			let first: number | undefined
+			const lastDay = dayStart(to + offsetAt(to, tz)) + DAY
+			for (let day = dayStart(from + offsetAt(from, tz)) - DAY; day <= lastDay; day += DAY) {
+				const c = civil(day)
+				if (!cronMatchesDay(expr, c.month, c.day, c.weekday)) continue
+				const o1 = offsetAt(day - 14 * HOUR, tz)
+				const o2 = offsetAt(day + DAY + 14 * HOUR, tz)
+				const dayFirst = day - o1
+				const dayLast = day + DAY - o1
+				if (first !== undefined && o1 === o2 && dayFirst > from && dayLast <= to) {
+					count += perUniformDay
+				} else {
+					for (const t of cronInstantsOnDay(expr, tz, day)) {
+						if (t <= from || t > to) continue
+						if (first === undefined) first = t
+						count++
+					}
+				}
+				if (count > cap) break
+			}
+			return {
+				count: Math.min(count, cap),
+				capped: count > cap,
+				...(first !== undefined ? { first: new Date(first) } : {}),
+				latest,
+			}
+		}
+	}
+}
+
+/** Validate a spec as a whole: its zone, its expression, and that it can ever fire after `now`. */
+export function assertSpecFires(spec: ScheduleSpec, now: Date): void {
+	if (spec.kind === 'cron') {
+		validateTimeZone(spec.tz)
+		cronOf(spec.expr)
+	}
+	if (nextFireTime(spec, now) === null) {
+		throw new ScheduleValidationError(
+			spec.kind === 'at'
+				? `${spec.at} is in the past`
+				: `"${spec.kind === 'cron' ? spec.expr : ''}" never fires in the next five years`,
+			spec.kind === 'cron' ? spec.expr : spec.kind === 'at' ? spec.at : undefined,
+		)
+	}
+}