@ecosy/schedule 0.1.0 → 0.1.1

package/dist/schedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.js","sources":["../src/schedule.ts"],"sourcesContent":["import { Registry, type IRegistry } from \"./registry\";\nimport { DEFAULT_TIMEOUT, runTarget } from \"./runner\";\nimport { Task, type TaskStatus } from \"./task\";\nimport type {\n  ClassType, Coordinator, ErrorHandler, Hook, InjectMap, Injected, NotFoundHandler,\n  Source, TaskDefinition, TaskEvent, TaskParser,\n} from \"./types\";\n\n/** How often due tasks are checked. One second, because expressions have a seconds field. */\nconst DEFAULT_TICK = 1_000;\nconst DEFAULT_SYNC = 60_000;\nconst DEFAULT_RETRY = 0;\n\n/** What happens to a task that disappears from the source. */\nexport type CascadePolicy =\n  /** Stop scheduling, let the run in flight finish, then drop it. */\n  | \"drain\"\n  /** Stop scheduling now. A file target is killed; the other two are let go — see `runner`. */\n  | \"stop\"\n  /** Leave it running. For when the source is not the only authority. */\n  | \"keep\";\n\ninterface Descriptor<Entry, Context> {\n  injects: InjectMap;\n  source?: Source<Entry, Context>;\n  parser?: ClassType<TaskParser<Entry>>;\n  registry: IRegistry<Context>;\n  coordinator?: ClassType<Coordinator>;\n  hook?: ClassType<Hook>;\n  retry: number;\n  timeout: number;\n  syncMs: number | false;\n  tickMs: number;\n  cascade: CascadePolicy;\n  onError?: ErrorHandler;\n  notFound?: NotFoundHandler;\n}\n\nexport interface ScheduleStatus {\n  running: boolean;\n  lastSyncAt: Date | null;\n  lastSyncOk: boolean | null;\n  tasks: TaskStatus[];\n}\n\n/**\n * A configured scheduler.\n *\n * A plain instance with no global state: constructing two gives two, and\n * whether that should happen is the caller's business. Whatever runs this once\n * — a bootstrap, a framework's init — already owns that question, and\n * answering it here as well would only take the choice away.\n */\nexport class ScheduleRunner<Entry = string, Context = unknown> {\n  private readonly d: Descriptor<Entry, Context>;\n  private readonly tasks = new Map<string, Task>();\n\n  private context!: Injected<Context, InjectMap>;\n  private parser!: TaskParser<Entry>;\n  private coordinator?: Coordinator;\n  private hook?: Hook;\n\n  private tickTimer: ReturnType<typeof setInterval> | null = null;\n  private syncTimer: ReturnType<typeof setInterval> | null = null;\n  private inFlight = new Set<Promise<void>>();\n\n  private started = false;\n  private lastSyncAt: Date | null = null;\n  private lastSyncOk: boolean | null = null;\n\n  constructor(descriptor: Descriptor<Entry, Context>) {\n    this.d = descriptor;\n  }\n\n  async start(): Promise<void> {\n    // Idempotent on a single instance: starting twice must not produce two\n    // sets of timers. This says nothing about two separate instances.\n    if (this.started) return;\n    if (!this.d.source) throw new Error(\"Schedule: a source is required — call .source(...)\");\n    if (!this.d.parser) throw new Error(\"Schedule: a task parser is required — call .task(...)\");\n\n    this.started = true;\n\n    const context = {} as Record<string, unknown>;\n    for (const [name, Token] of Object.entries(this.d.injects)) context[name] = new Token();\n    this.context = context as Injected<Context, InjectMap>;\n\n    this.parser = new this.d.parser();\n    this.coordinator = this.d.coordinator && new this.d.coordinator();\n    this.hook = this.d.hook && new this.d.hook();\n\n    await this.sync();\n\n    this.tickTimer = setInterval(() => this.tick(), this.d.tickMs);\n\n    /* `false` means the source is read once, at start, and never reconciled\n       again — right for a task list baked into the deployment, wrong for one an\n       operator edits. The reconcile still happened above, so the tasks are\n       loaded either way. */\n    if (this.d.syncMs !== false) {\n      this.syncTimer = setInterval(() => {\n        this.sync().catch((error) => {\n          console.warn(\"[schedule] sync failed:\", error);\n        });\n      }, this.d.syncMs);\n    }\n  }\n\n  /** Clears both timers and waits for runs already in flight. */\n  async stop(): Promise<void> {\n    if (this.tickTimer) clearInterval(this.tickTimer);\n    if (this.syncTimer) clearInterval(this.syncTimer);\n    this.tickTimer = this.syncTimer = null;\n    this.started = false;\n\n    await Promise.allSettled([...this.inFlight]);\n  }\n\n  status(): ScheduleStatus {\n    return {\n      running: this.started,\n      lastSyncAt: this.lastSyncAt,\n      lastSyncOk: this.lastSyncOk,\n      tasks: [...this.tasks.values()].map((task) => task.status()),\n    };\n  }\n\n  /* ------------------------------------------------------------ syncing */\n\n  private async read(): Promise<Entry[]> {\n    return new this.d.source!().read(this.context as Context);\n  }\n\n  /**\n   * Re-reads the source and reconciles.\n   *\n   * Two failure modes are kept apart on purpose. A source that throws leaves\n   * the schedule exactly as it was — a database blip is not an instruction to\n   * cancel everything. A source that returns nothing while tasks exist is\n   * treated the same way: it is far more likely to be a partial read than a\n   * deliberate deletion of every job at once, and getting that wrong wipes a\n   * schedule during an incident, which is the worst possible moment.\n   */\n  async sync(): Promise<void> {\n    let entries: Entry[];\n\n    try {\n      entries = await this.read();\n\n      /* A source that answers with something other than a list is a broken\n         source, not an empty schedule. Checked here so it goes down the same\n         path as a failed read — report it, keep the tasks already running —\n         rather than throwing past this try and out of a timer callback. */\n      if (!Array.isArray(entries)) {\n        throw new Error(`source returned ${typeof entries}, expected an array`);\n      }\n\n      this.lastSyncOk = true;\n    } catch (error) {\n      this.lastSyncOk = false;\n      this.lastSyncAt = new Date();\n      await this.report(`source read failed: ${error instanceof Error ? error.message : String(error)}`);\n      return;\n    }\n\n    this.lastSyncAt = new Date();\n\n    const seen = new Set<string>();\n    const now = new Date();\n\n    for (const entry of entries) {\n      let definition: TaskDefinition;\n\n      try {\n        definition = this.parser.parse(entry);\n      } catch (error) {\n        await this.report(`unparseable entry: ${error instanceof Error ? error.message : String(error)}`);\n        continue;\n      }\n\n      seen.add(definition.key);\n      const existing = this.tasks.get(definition.key);\n\n      if (existing) existing.update(definition, now);\n      else this.tasks.set(definition.key, new Task(definition, now));\n    }\n\n    if (entries.length === 0 && this.tasks.size > 0) {\n      await this.report(`source returned nothing while ${this.tasks.size} tasks are live — keeping them`);\n      return;\n    }\n\n    for (const [key, task] of this.tasks) {\n      if (seen.has(key)) continue;\n      if (this.d.cascade === \"keep\") continue;\n\n      task.nextAt = null;\n\n      // `drain` leaves the entry until the run in flight settles; the tick\n      // loop drops it once `running` clears.\n      if (this.d.cascade === \"stop\" || !task.running) this.tasks.delete(key);\n    }\n  }\n\n  /* ------------------------------------------------------------ running */\n\n  private tick(): void {\n    const now = new Date();\n\n    for (const [key, task] of this.tasks) {\n      // A drained task keeps its slot only until its run settles.\n      if (task.nextAt === null && !task.running) {\n        this.tasks.delete(key);\n        continue;\n      }\n\n      if (!task.due(now)) continue;\n\n      const run = this.run(task).finally(() => this.inFlight.delete(run));\n      this.inFlight.add(run);\n    }\n  }\n\n  private async run(task: Task): Promise<void> {\n    // Advanced before the run, so a slow task does not drag its own schedule\n    // along behind it. Overlap is held off by `running`, not by the clock.\n    const scheduledFor = task.advance();\n    task.running = true;\n\n    try {\n      if (this.coordinator && !(await this.coordinator.claim(task.key, scheduledFor))) {\n        return; // another instance owns this fire\n      }\n\n      const definition = task.current;\n      const attempts = (definition.retry ?? this.d.retry) + 1;\n      const timeout = definition.timeout ?? this.d.timeout;\n\n      let event!: TaskEvent;\n\n      for (let attempt = 1; attempt <= attempts; attempt++) {\n        const startedAt = new Date();\n        const outcome = await runTarget(definition, this.d.registry, this.context, timeout, this.d.notFound);\n\n        event = {\n          key: task.key,\n          scheduledFor,\n          startedAt,\n          durationMs: Date.now() - startedAt.getTime(),\n          attempt,\n          ok: outcome.ok,\n          reason: outcome.reason,\n          detail: outcome.detail,\n          raw: outcome.raw,\n        };\n\n        if (outcome.ok) break;\n\n        await this.d.onError?.(event, definition);\n\n        // Backoff between attempts: retrying a failing endpoint three times in\n        // the same millisecond is three failures, not three chances.\n        if (attempt < attempts) {\n          await new Promise((r) => setTimeout(r, Math.min(2 ** attempt * 1000, 30_000)));\n        }\n      }\n\n      task.record(event.ok, event.startedAt);\n\n      // A hook that throws or hangs must not take the run down with it — the\n      // work already happened, and reporting is a separate concern.\n      await this.safely(() => this.hook?.notify(event));\n      await this.safely(() => this.coordinator?.release(task.key, scheduledFor, event));\n    } finally {\n      task.running = false;\n    }\n  }\n\n  private async safely(work: () => unknown): Promise<void> {\n    try {\n      await work();\n    } catch (error) {\n      console.warn(\"[schedule] reporting failed:\", error);\n    }\n  }\n\n  private async report(detail: string): Promise<void> {\n    console.warn(`[schedule] ${detail}`);\n\n    await this.safely(() =>\n      this.d.onError?.(\n        { key: \"@schedule\", scheduledFor: new Date(), startedAt: new Date(), durationMs: 0, attempt: 1, ok: false, reason: \"unknown\", detail },\n        { key: \"@schedule\", expression: \"\", target: { type: \"handler\", key: \"@schedule\" } },\n      ),\n    );\n  }\n}\n\n/* -------------------------------------------------------------- the chain */\n\nexport interface IScheduleBuilder<Entry = string, Context = unknown>\n  extends ClassType<ScheduleRunner<Entry, Context>> {\n  source<E>(source: Source<E, Context>): IScheduleBuilder<E, Context>;\n  task(parser: ClassType<TaskParser<Entry>>): IScheduleBuilder<Entry, Context>;\n  registry(registry: IRegistry<Context>): IScheduleBuilder<Entry, Context>;\n  coordinator(coordinator: ClassType<Coordinator>): IScheduleBuilder<Entry, Context>;\n  hook(hook: ClassType<Hook>): IScheduleBuilder<Entry, Context>;\n  retry(times: number): IScheduleBuilder<Entry, Context>;\n  timeout(ms: number): IScheduleBuilder<Entry, Context>;\n  /**\n   * Whether, and how often, the source is re-read and reconciled against the\n   * tasks already running: a source entry that is new becomes a task, one that\n   * changed is updated, one that disappeared is handled by `cascade`.\n   *\n   * `false` turns the repeat off — read once at start and never again.\n   * `true` uses the default interval. A number sets it.\n   */\n  sync(every: number | boolean): IScheduleBuilder<Entry, Context>;\n  tick(ms: number): IScheduleBuilder<Entry, Context>;\n  cascade(policy: CascadePolicy): IScheduleBuilder<Entry, Context>;\n  onError(handler: ErrorHandler): IScheduleBuilder<Entry, Context>;\n  notFound(handler: NotFoundHandler): IScheduleBuilder<Entry, Context>;\n}\n\nfunction chain<Entry, Context>(d: Descriptor<Entry, Context>): IScheduleBuilder<Entry, Context> {\n  // Each step returns a new class rather than mutating one, so a\n  // half-configured chain can be shared as a base and branched.\n  const step = <E>(patch: Partial<Descriptor<E, Context>>) =>\n    chain({ ...(d as unknown as Descriptor<E, Context>), ...patch });\n\n  return class extends ScheduleRunner<Entry, Context> {\n    constructor() {\n      super(d);\n    }\n\n    static source<E>(source: Source<E, Context>) { return step<E>({ source }); }\n    static task(parser: ClassType<TaskParser<Entry>>) { return step<Entry>({ parser }); }\n    static registry(registry: IRegistry<Context>) { return step<Entry>({ registry }); }\n    static coordinator(coordinator: ClassType<Coordinator>) { return step<Entry>({ coordinator }); }\n    static hook(hook: ClassType<Hook>) { return step<Entry>({ hook }); }\n    static retry(times: number) { return step<Entry>({ retry: times }); }\n    static timeout(ms: number) { return step<Entry>({ timeout: ms }); }\n    static sync(every: number | boolean) {\n      const syncMs = every === true ? DEFAULT_SYNC : every;\n      return step<Entry>({ syncMs });\n    }\n    static tick(ms: number) { return step<Entry>({ tickMs: ms }); }\n    static cascade(policy: CascadePolicy) { return step<Entry>({ cascade: policy }); }\n    static onError(handler: ErrorHandler) { return step<Entry>({ onError: handler }); }\n    static notFound(handler: NotFoundHandler) { return step<Entry>({ notFound: handler }); }\n  } as unknown as IScheduleBuilder<Entry, Context>;\n}\n\n/**\n * Chain-style configuration for a scheduler.\n *\n * ```ts\n * export const AppSchedule = Schedule({ db: DataSource })\n *   .source((ctx) => ctx.db.query(\"select * from crons\"))\n *   .task(RowParser)\n *   .registry(Registry.add(Registry(\"session.cleanup\", (ctx) => ...)))\n *   .coordinator(PgCoordinator)\n *   .hook(Hook.combine(LoggerHook, TelegramHook))\n *   .retry(2)\n *   .sync(30_000)\n *   .cascade(\"drain\");\n *\n * const schedule = new AppSchedule();\n * await schedule.start();\n * ```\n *\n * The chain is the class — there is no terminal to call, and whoever holds the\n * instance decides when it starts and stops.\n */\nexport function Schedule<Injects extends InjectMap = Record<string, never>>(\n  injects: Injects = {} as Injects,\n): IScheduleBuilder<string, Injected<unknown, Injects>> {\n  return chain({\n    injects,\n    registry: Registry.empty(),\n    retry: DEFAULT_RETRY,\n    timeout: DEFAULT_TIMEOUT,\n    syncMs: DEFAULT_SYNC,\n    tickMs: DEFAULT_TICK,\n    cascade: \"drain\",\n  });\n}\n"],"names":["DEFAULT_TICK","DEFAULT_SYNC","DEFAULT_RETRY","ScheduleRunner","descriptor","__publicField","context","name","Token","error","task","entries","seen","now","entry","definition","existing","Task","key","run","scheduledFor","attempts","timeout","event","attempt","startedAt","outcome","runTarget","r","work","detail","chain","d","step","patch","source","parser","registry","coordinator","hook","times","ms","every","policy","handler","Schedule","injects","Registry","DEFAULT_TIMEOUT"],"mappings":"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"}

package/dist/schedule.mjs

@@ -0,0 +1,2 @@
+import{Registry as w}from"./registry.mjs";import{runTarget as f,DEFAULT_TIMEOUT as m}from"./runner.mjs";import{Task as p}from"./task.mjs";var g=Object.defineProperty,S=(n,t,e)=>t in n?g(n,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):n[t]=e,i=(n,t,e)=>S(n,typeof t!="symbol"?t+"":t,e);const T=1e3,l=6e4,A=0;class d{constructor(t){i(this,"d"),i(this,"tasks",new Map),i(this,"context"),i(this,"parser"),i(this,"coordinator"),i(this,"hook"),i(this,"tickTimer",null),i(this,"syncTimer",null),i(this,"inFlight",new Set),i(this,"started",!1),i(this,"lastSyncAt",null),i(this,"lastSyncOk",null),this.d=t}async start(){if(this.started)return;if(!this.d.source)throw new Error("Schedule: a source is required \u2014 call .source(...)");if(!this.d.parser)throw new Error("Schedule: a task parser is required \u2014 call .task(...)");this.started=!0;const t={};for(const[e,s]of Object.entries(this.d.injects))t[e]=new s;this.context=t,this.parser=new this.d.parser,this.coordinator=this.d.coordinator&&new this.d.coordinator,this.hook=this.d.hook&&new this.d.hook,await this.sync(),this.tickTimer=setInterval(()=>this.tick(),this.d.tickMs),this.d.syncMs!==!1&&(this.syncTimer=setInterval(()=>{this.sync().catch(e=>{console.warn("[schedule] sync failed:",e)})},this.d.syncMs))}async stop(){this.tickTimer&&clearInterval(this.tickTimer),this.syncTimer&&clearInterval(this.syncTimer),this.tickTimer=this.syncTimer=null,this.started=!1,await Promise.allSettled([...this.inFlight])}status(){return{running:this.started,lastSyncAt:this.lastSyncAt,lastSyncOk:this.lastSyncOk,tasks:[...this.tasks.values()].map(t=>t.status())}}async read(){return new this.d.source().read(this.context)}async sync(){let t;try{if(t=await this.read(),!Array.isArray(t))throw new Error(`source returned ${typeof t}, expected an array`);this.lastSyncOk=!0}catch(r){this.lastSyncOk=!1,this.lastSyncAt=new Date,await this.report(`source read failed: ${r instanceof Error?r.message:String(r)}`);return}this.lastSyncAt=new Date;const e=new Set,s=new Date;for(const r of t){let a;try{a=this.parser.parse(r)}catch(c){await this.report(`unparseable entry: ${c instanceof Error?c.message:String(c)}`);continue}e.add(a.key);const o=this.tasks.get(a.key);o?o.update(a,s):this.tasks.set(a.key,new p(a,s))}if(t.length===0&&this.tasks.size>0){await this.report(`source returned nothing while ${this.tasks.size} tasks are live \u2014 keeping them`);return}for(const[r,a]of this.tasks)e.has(r)||this.d.cascade!=="keep"&&(a.nextAt=null,(this.d.cascade==="stop"||!a.running)&&this.tasks.delete(r))}tick(){const t=new Date;for(const[e,s]of this.tasks){if(s.nextAt===null&&!s.running){this.tasks.delete(e);continue}if(!s.due(t))continue;const r=this.run(s).finally(()=>this.inFlight.delete(r));this.inFlight.add(r)}}async run(t){const e=t.advance();t.running=!0;try{if(this.coordinator&&!await this.coordinator.claim(t.key,e))return;const s=t.current,r=(s.retry??this.d.retry)+1,a=s.timeout??this.d.timeout;let o;for(let c=1;c<=r;c++){const u=new Date,h=await f(s,this.d.registry,this.context,a,this.d.notFound);if(o={key:t.key,scheduledFor:e,startedAt:u,durationMs:Date.now()-u.getTime(),attempt:c,ok:h.ok,reason:h.reason,detail:h.detail,raw:h.raw},h.ok)break;await this.d.onError?.(o,s),c<r&&await new Promise(k=>setTimeout(k,Math.min(2**c*1e3,3e4)))}t.record(o.ok,o.startedAt),await this.safely(()=>this.hook?.notify(o)),await this.safely(()=>this.coordinator?.release(t.key,e,o))}finally{t.running=!1}}async safely(t){try{await t()}catch(e){console.warn("[schedule] reporting failed:",e)}}async report(t){console.warn(`[schedule] ${t}`),await this.safely(()=>this.d.onError?.({key:"@schedule",scheduledFor:new Date,startedAt:new Date,durationMs:0,attempt:1,ok:!1,reason:"unknown",detail:t},{key:"@schedule",expression:"",target:{type:"handler",key:"@schedule"}}))}}function y(n){const t=e=>y({...n,...e});return class extends d{constructor(){super(n)}static source(e){return t({source:e})}static task(e){return t({parser:e})}static registry(e){return t({registry:e})}static coordinator(e){return t({coordinator:e})}static hook(e){return t({hook:e})}static retry(e){return t({retry:e})}static timeout(e){return t({timeout:e})}static sync(e){return t({syncMs:e===!0?l:e})}static tick(e){return t({tickMs:e})}static cascade(e){return t({cascade:e})}static onError(e){return t({onError:e})}static notFound(e){return t({notFound:e})}}}function M(n={}){return y({injects:n,registry:w.empty(),retry:A,timeout:m,syncMs:l,tickMs:T,cascade:"drain"})}export{M as Schedule,d as ScheduleRunner};
+//# sourceMappingURL=schedule.mjs.map

package/dist/schedule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.mjs","sources":["../src/schedule.ts"],"sourcesContent":["import { Registry, type IRegistry } from \"./registry\";\nimport { DEFAULT_TIMEOUT, runTarget } from \"./runner\";\nimport { Task, type TaskStatus } from \"./task\";\nimport type {\n  ClassType, Coordinator, ErrorHandler, Hook, InjectMap, Injected, NotFoundHandler,\n  Source, TaskDefinition, TaskEvent, TaskParser,\n} from \"./types\";\n\n/** How often due tasks are checked. One second, because expressions have a seconds field. */\nconst DEFAULT_TICK = 1_000;\nconst DEFAULT_SYNC = 60_000;\nconst DEFAULT_RETRY = 0;\n\n/** What happens to a task that disappears from the source. */\nexport type CascadePolicy =\n  /** Stop scheduling, let the run in flight finish, then drop it. */\n  | \"drain\"\n  /** Stop scheduling now. A file target is killed; the other two are let go — see `runner`. */\n  | \"stop\"\n  /** Leave it running. For when the source is not the only authority. */\n  | \"keep\";\n\ninterface Descriptor<Entry, Context> {\n  injects: InjectMap;\n  source?: Source<Entry, Context>;\n  parser?: ClassType<TaskParser<Entry>>;\n  registry: IRegistry<Context>;\n  coordinator?: ClassType<Coordinator>;\n  hook?: ClassType<Hook>;\n  retry: number;\n  timeout: number;\n  syncMs: number | false;\n  tickMs: number;\n  cascade: CascadePolicy;\n  onError?: ErrorHandler;\n  notFound?: NotFoundHandler;\n}\n\nexport interface ScheduleStatus {\n  running: boolean;\n  lastSyncAt: Date | null;\n  lastSyncOk: boolean | null;\n  tasks: TaskStatus[];\n}\n\n/**\n * A configured scheduler.\n *\n * A plain instance with no global state: constructing two gives two, and\n * whether that should happen is the caller's business. Whatever runs this once\n * — a bootstrap, a framework's init — already owns that question, and\n * answering it here as well would only take the choice away.\n */\nexport class ScheduleRunner<Entry = string, Context = unknown> {\n  private readonly d: Descriptor<Entry, Context>;\n  private readonly tasks = new Map<string, Task>();\n\n  private context!: Injected<Context, InjectMap>;\n  private parser!: TaskParser<Entry>;\n  private coordinator?: Coordinator;\n  private hook?: Hook;\n\n  private tickTimer: ReturnType<typeof setInterval> | null = null;\n  private syncTimer: ReturnType<typeof setInterval> | null = null;\n  private inFlight = new Set<Promise<void>>();\n\n  private started = false;\n  private lastSyncAt: Date | null = null;\n  private lastSyncOk: boolean | null = null;\n\n  constructor(descriptor: Descriptor<Entry, Context>) {\n    this.d = descriptor;\n  }\n\n  async start(): Promise<void> {\n    // Idempotent on a single instance: starting twice must not produce two\n    // sets of timers. This says nothing about two separate instances.\n    if (this.started) return;\n    if (!this.d.source) throw new Error(\"Schedule: a source is required — call .source(...)\");\n    if (!this.d.parser) throw new Error(\"Schedule: a task parser is required — call .task(...)\");\n\n    this.started = true;\n\n    const context = {} as Record<string, unknown>;\n    for (const [name, Token] of Object.entries(this.d.injects)) context[name] = new Token();\n    this.context = context as Injected<Context, InjectMap>;\n\n    this.parser = new this.d.parser();\n    this.coordinator = this.d.coordinator && new this.d.coordinator();\n    this.hook = this.d.hook && new this.d.hook();\n\n    await this.sync();\n\n    this.tickTimer = setInterval(() => this.tick(), this.d.tickMs);\n\n    /* `false` means the source is read once, at start, and never reconciled\n       again — right for a task list baked into the deployment, wrong for one an\n       operator edits. The reconcile still happened above, so the tasks are\n       loaded either way. */\n    if (this.d.syncMs !== false) {\n      this.syncTimer = setInterval(() => {\n        this.sync().catch((error) => {\n          console.warn(\"[schedule] sync failed:\", error);\n        });\n      }, this.d.syncMs);\n    }\n  }\n\n  /** Clears both timers and waits for runs already in flight. */\n  async stop(): Promise<void> {\n    if (this.tickTimer) clearInterval(this.tickTimer);\n    if (this.syncTimer) clearInterval(this.syncTimer);\n    this.tickTimer = this.syncTimer = null;\n    this.started = false;\n\n    await Promise.allSettled([...this.inFlight]);\n  }\n\n  status(): ScheduleStatus {\n    return {\n      running: this.started,\n      lastSyncAt: this.lastSyncAt,\n      lastSyncOk: this.lastSyncOk,\n      tasks: [...this.tasks.values()].map((task) => task.status()),\n    };\n  }\n\n  /* ------------------------------------------------------------ syncing */\n\n  private async read(): Promise<Entry[]> {\n    return new this.d.source!().read(this.context as Context);\n  }\n\n  /**\n   * Re-reads the source and reconciles.\n   *\n   * Two failure modes are kept apart on purpose. A source that throws leaves\n   * the schedule exactly as it was — a database blip is not an instruction to\n   * cancel everything. A source that returns nothing while tasks exist is\n   * treated the same way: it is far more likely to be a partial read than a\n   * deliberate deletion of every job at once, and getting that wrong wipes a\n   * schedule during an incident, which is the worst possible moment.\n   */\n  async sync(): Promise<void> {\n    let entries: Entry[];\n\n    try {\n      entries = await this.read();\n\n      /* A source that answers with something other than a list is a broken\n         source, not an empty schedule. Checked here so it goes down the same\n         path as a failed read — report it, keep the tasks already running —\n         rather than throwing past this try and out of a timer callback. */\n      if (!Array.isArray(entries)) {\n        throw new Error(`source returned ${typeof entries}, expected an array`);\n      }\n\n      this.lastSyncOk = true;\n    } catch (error) {\n      this.lastSyncOk = false;\n      this.lastSyncAt = new Date();\n      await this.report(`source read failed: ${error instanceof Error ? error.message : String(error)}`);\n      return;\n    }\n\n    this.lastSyncAt = new Date();\n\n    const seen = new Set<string>();\n    const now = new Date();\n\n    for (const entry of entries) {\n      let definition: TaskDefinition;\n\n      try {\n        definition = this.parser.parse(entry);\n      } catch (error) {\n        await this.report(`unparseable entry: ${error instanceof Error ? error.message : String(error)}`);\n        continue;\n      }\n\n      seen.add(definition.key);\n      const existing = this.tasks.get(definition.key);\n\n      if (existing) existing.update(definition, now);\n      else this.tasks.set(definition.key, new Task(definition, now));\n    }\n\n    if (entries.length === 0 && this.tasks.size > 0) {\n      await this.report(`source returned nothing while ${this.tasks.size} tasks are live — keeping them`);\n      return;\n    }\n\n    for (const [key, task] of this.tasks) {\n      if (seen.has(key)) continue;\n      if (this.d.cascade === \"keep\") continue;\n\n      task.nextAt = null;\n\n      // `drain` leaves the entry until the run in flight settles; the tick\n      // loop drops it once `running` clears.\n      if (this.d.cascade === \"stop\" || !task.running) this.tasks.delete(key);\n    }\n  }\n\n  /* ------------------------------------------------------------ running */\n\n  private tick(): void {\n    const now = new Date();\n\n    for (const [key, task] of this.tasks) {\n      // A drained task keeps its slot only until its run settles.\n      if (task.nextAt === null && !task.running) {\n        this.tasks.delete(key);\n        continue;\n      }\n\n      if (!task.due(now)) continue;\n\n      const run = this.run(task).finally(() => this.inFlight.delete(run));\n      this.inFlight.add(run);\n    }\n  }\n\n  private async run(task: Task): Promise<void> {\n    // Advanced before the run, so a slow task does not drag its own schedule\n    // along behind it. Overlap is held off by `running`, not by the clock.\n    const scheduledFor = task.advance();\n    task.running = true;\n\n    try {\n      if (this.coordinator && !(await this.coordinator.claim(task.key, scheduledFor))) {\n        return; // another instance owns this fire\n      }\n\n      const definition = task.current;\n      const attempts = (definition.retry ?? this.d.retry) + 1;\n      const timeout = definition.timeout ?? this.d.timeout;\n\n      let event!: TaskEvent;\n\n      for (let attempt = 1; attempt <= attempts; attempt++) {\n        const startedAt = new Date();\n        const outcome = await runTarget(definition, this.d.registry, this.context, timeout, this.d.notFound);\n\n        event = {\n          key: task.key,\n          scheduledFor,\n          startedAt,\n          durationMs: Date.now() - startedAt.getTime(),\n          attempt,\n          ok: outcome.ok,\n          reason: outcome.reason,\n          detail: outcome.detail,\n          raw: outcome.raw,\n        };\n\n        if (outcome.ok) break;\n\n        await this.d.onError?.(event, definition);\n\n        // Backoff between attempts: retrying a failing endpoint three times in\n        // the same millisecond is three failures, not three chances.\n        if (attempt < attempts) {\n          await new Promise((r) => setTimeout(r, Math.min(2 ** attempt * 1000, 30_000)));\n        }\n      }\n\n      task.record(event.ok, event.startedAt);\n\n      // A hook that throws or hangs must not take the run down with it — the\n      // work already happened, and reporting is a separate concern.\n      await this.safely(() => this.hook?.notify(event));\n      await this.safely(() => this.coordinator?.release(task.key, scheduledFor, event));\n    } finally {\n      task.running = false;\n    }\n  }\n\n  private async safely(work: () => unknown): Promise<void> {\n    try {\n      await work();\n    } catch (error) {\n      console.warn(\"[schedule] reporting failed:\", error);\n    }\n  }\n\n  private async report(detail: string): Promise<void> {\n    console.warn(`[schedule] ${detail}`);\n\n    await this.safely(() =>\n      this.d.onError?.(\n        { key: \"@schedule\", scheduledFor: new Date(), startedAt: new Date(), durationMs: 0, attempt: 1, ok: false, reason: \"unknown\", detail },\n        { key: \"@schedule\", expression: \"\", target: { type: \"handler\", key: \"@schedule\" } },\n      ),\n    );\n  }\n}\n\n/* -------------------------------------------------------------- the chain */\n\nexport interface IScheduleBuilder<Entry = string, Context = unknown>\n  extends ClassType<ScheduleRunner<Entry, Context>> {\n  source<E>(source: Source<E, Context>): IScheduleBuilder<E, Context>;\n  task(parser: ClassType<TaskParser<Entry>>): IScheduleBuilder<Entry, Context>;\n  registry(registry: IRegistry<Context>): IScheduleBuilder<Entry, Context>;\n  coordinator(coordinator: ClassType<Coordinator>): IScheduleBuilder<Entry, Context>;\n  hook(hook: ClassType<Hook>): IScheduleBuilder<Entry, Context>;\n  retry(times: number): IScheduleBuilder<Entry, Context>;\n  timeout(ms: number): IScheduleBuilder<Entry, Context>;\n  /**\n   * Whether, and how often, the source is re-read and reconciled against the\n   * tasks already running: a source entry that is new becomes a task, one that\n   * changed is updated, one that disappeared is handled by `cascade`.\n   *\n   * `false` turns the repeat off — read once at start and never again.\n   * `true` uses the default interval. A number sets it.\n   */\n  sync(every: number | boolean): IScheduleBuilder<Entry, Context>;\n  tick(ms: number): IScheduleBuilder<Entry, Context>;\n  cascade(policy: CascadePolicy): IScheduleBuilder<Entry, Context>;\n  onError(handler: ErrorHandler): IScheduleBuilder<Entry, Context>;\n  notFound(handler: NotFoundHandler): IScheduleBuilder<Entry, Context>;\n}\n\nfunction chain<Entry, Context>(d: Descriptor<Entry, Context>): IScheduleBuilder<Entry, Context> {\n  // Each step returns a new class rather than mutating one, so a\n  // half-configured chain can be shared as a base and branched.\n  const step = <E>(patch: Partial<Descriptor<E, Context>>) =>\n    chain({ ...(d as unknown as Descriptor<E, Context>), ...patch });\n\n  return class extends ScheduleRunner<Entry, Context> {\n    constructor() {\n      super(d);\n    }\n\n    static source<E>(source: Source<E, Context>) { return step<E>({ source }); }\n    static task(parser: ClassType<TaskParser<Entry>>) { return step<Entry>({ parser }); }\n    static registry(registry: IRegistry<Context>) { return step<Entry>({ registry }); }\n    static coordinator(coordinator: ClassType<Coordinator>) { return step<Entry>({ coordinator }); }\n    static hook(hook: ClassType<Hook>) { return step<Entry>({ hook }); }\n    static retry(times: number) { return step<Entry>({ retry: times }); }\n    static timeout(ms: number) { return step<Entry>({ timeout: ms }); }\n    static sync(every: number | boolean) {\n      const syncMs = every === true ? DEFAULT_SYNC : every;\n      return step<Entry>({ syncMs });\n    }\n    static tick(ms: number) { return step<Entry>({ tickMs: ms }); }\n    static cascade(policy: CascadePolicy) { return step<Entry>({ cascade: policy }); }\n    static onError(handler: ErrorHandler) { return step<Entry>({ onError: handler }); }\n    static notFound(handler: NotFoundHandler) { return step<Entry>({ notFound: handler }); }\n  } as unknown as IScheduleBuilder<Entry, Context>;\n}\n\n/**\n * Chain-style configuration for a scheduler.\n *\n * ```ts\n * export const AppSchedule = Schedule({ db: DataSource })\n *   .source((ctx) => ctx.db.query(\"select * from crons\"))\n *   .task(RowParser)\n *   .registry(Registry.add(Registry(\"session.cleanup\", (ctx) => ...)))\n *   .coordinator(PgCoordinator)\n *   .hook(Hook.combine(LoggerHook, TelegramHook))\n *   .retry(2)\n *   .sync(30_000)\n *   .cascade(\"drain\");\n *\n * const schedule = new AppSchedule();\n * await schedule.start();\n * ```\n *\n * The chain is the class — there is no terminal to call, and whoever holds the\n * instance decides when it starts and stops.\n */\nexport function Schedule<Injects extends InjectMap = Record<string, never>>(\n  injects: Injects = {} as Injects,\n): IScheduleBuilder<string, Injected<unknown, Injects>> {\n  return chain({\n    injects,\n    registry: Registry.empty(),\n    retry: DEFAULT_RETRY,\n    timeout: DEFAULT_TIMEOUT,\n    syncMs: DEFAULT_SYNC,\n    tickMs: DEFAULT_TICK,\n    cascade: \"drain\",\n  });\n}\n"],"names":["DEFAULT_TICK","DEFAULT_SYNC","DEFAULT_RETRY","ScheduleRunner","descriptor","__publicField","context","name","Token","error","task","entries","seen","now","entry","definition","existing","Task","key","run","scheduledFor","attempts","timeout","event","attempt","startedAt","outcome","runTarget","r","work","detail","chain","d","step","patch","source","parser","registry","coordinator","hook","times","ms","every","policy","handler","Schedule","injects","Registry","DEFAULT_TIMEOUT"],"mappings":"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"}

package/dist/source/index.d.ts

@@ -0,0 +1,37 @@
+import type { ClassType, Promisable, SourceAdapter, TaskDefinition, TaskParser } from "../types";
+/**
+ * Built-in sources and the line format they produce.
+ *
+ * Only local files and HTTP: sharing a file between instances behind a load
+ * balancer is a mount, not a library concern.
+ */
+/**
+ * Wraps a reader function into a source class.
+ *
+ * `.source()` takes a class, not a callback, so that nothing in the scheduler
+ * has to work out at runtime what it was handed. This keeps the one-line case
+ * one line without reintroducing that ambiguity.
+ */
+export declare function Source<Entry = string, Context = unknown>(read: (context: Context) => Promisable<Entry[]>): ClassType<SourceAdapter<Entry, Context>>;
+export declare function FileSource(path: string): ClassType<SourceAdapter<string, unknown>>;
+export declare function HttpSource(url: string, init?: RequestInit): ClassType<SourceAdapter<string, unknown>>;
+/**
+ * Crontab-shaped, one task per line:
+ *
+ * ```
+ * # every five minutes
+ * 0 *\/5 * * * *  handler:session.cleanup
+ * 0 0 3 * * *     api:https://app/internal/report   tz=Asia/Ho_Chi_Minh retry=2
+ * 0 0 4 * * *     file:./scripts/rollup.js          name=nightly-rollup
+ * ```
+ *
+ * The target doubles as the key, since one target on one schedule is the usual
+ * case. `name=` overrides it, which is what you need to run the same handler on
+ * two different expressions.
+ */
+export declare class LineParser implements TaskParser<string> {
+    parse(line: string): TaskDefinition;
+    private target;
+    private options;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/source/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/source/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAc,MAAM,UAAU,CAAC;AAE7G;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,GAAG,MAAM,EAAE,OAAO,GAAG,OAAO,EACtD,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,UAAU,CAAC,KAAK,EAAE,CAAC,GAC9C,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAM1C;AAUD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAOlF;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAYrG;AAID;;;;;;;;;;;;;GAaG;AACH,qBAAa,UAAW,YAAW,UAAU,CAAC,MAAM,CAAC;IACnD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;IA0BnC,OAAO,CAAC,MAAM;IAed,OAAO,CAAC,OAAO;CAUhB"}

package/dist/source/index.js

@@ -0,0 +1,3 @@
+"use strict";var l=Object.create;var o=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var p=Object.getPrototypeOf,h=Object.prototype.hasOwnProperty;var w=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of d(e))!h.call(t,i)&&i!==r&&o(t,i,{get:()=>e[i],enumerable:!(n=f(e,i))||n.enumerable});return t};var m=(t,e,r)=>(r=t!=null?l(p(t)):{},w(e||!t||!t.__esModule?o(r,"default",{value:t,enumerable:!0}):r,t));function y(t){return class{read(e){return t(e)}}}function c(t){return t.split(`
+`).map(e=>e.trim()).filter(e=>e.length>0&&!e.startsWith("#"))}function S(t){return class{async read(){const{readFile:e}=await import("node:fs/promises");return c(await e(t,"utf-8"))}}}function $(t,e){return class{async read(){const r=await fetch(t,e);if(!r.ok)throw new Error(`HttpSource: ${t} answered ${r.status}`);return c(await r.text())}}}class g{parse(e){const r=e.split(/\s+/),n=r.findIndex(u=>/^(handler|api|file):/.test(u));if(n<5||n>6)throw new Error(`LineParser: expected a handler:/api:/file: target after 5 or 6 cron fields \u2014 "${e}"`);const i=r.slice(0,n).join(" "),a=this.target(r[n],e),s=this.options(r.slice(n+1));return{key:s.name??r[n],expression:i,target:a,timezone:s.tz,enabled:s.enabled!=="false",retry:s.retry===void 0?void 0:Number(s.retry),timeout:s.timeout===void 0?void 0:Number(s.timeout)}}target(e,r){const n=e.indexOf(":"),i=e.slice(0,n),a=e.slice(n+1);if(!a)throw new Error(`LineParser: "${i}:" has no value \u2014 "${r}"`);switch(i){case"handler":return{type:"handler",key:a};case"api":return{type:"api",url:a};case"file":return{type:"file",path:a};default:throw new Error(`LineParser: unknown target "${i}" \u2014 "${r}"`)}}options(e){const r={};for(const n of e){const i=n.indexOf("=");i>0&&(r[n.slice(0,i)]=n.slice(i+1))}return r}}exports.FileSource=S,exports.HttpSource=$,exports.LineParser=g,exports.Source=y;
+//# sourceMappingURL=index.js.map

package/dist/source/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/source/index.ts"],"sourcesContent":["import type { ClassType, Promisable, SourceAdapter, TaskDefinition, TaskParser, TaskTarget } from \"../types\";\n\n/**\n * Built-in sources and the line format they produce.\n *\n * Only local files and HTTP: sharing a file between instances behind a load\n * balancer is a mount, not a library concern.\n */\n\n/**\n * Wraps a reader function into a source class.\n *\n * `.source()` takes a class, not a callback, so that nothing in the scheduler\n * has to work out at runtime what it was handed. This keeps the one-line case\n * one line without reintroducing that ambiguity.\n */\nexport function Source<Entry = string, Context = unknown>(\n  read: (context: Context) => Promisable<Entry[]>,\n): ClassType<SourceAdapter<Entry, Context>> {\n  return class implements SourceAdapter<Entry, Context> {\n    read(context: Context) {\n      return read(context);\n    }\n  };\n}\n\n/** Drops comments and blank lines. Everything else is a task. */\nfunction lines(text: string): string[] {\n  return text\n    .split(\"\\n\")\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0 && !line.startsWith(\"#\"));\n}\n\nexport function FileSource(path: string): ClassType<SourceAdapter<string, unknown>> {\n  return class implements SourceAdapter<string, unknown> {\n    async read(): Promise<string[]> {\n      const { readFile } = await import(\"node:fs/promises\");\n      return lines(await readFile(path, \"utf-8\"));\n    }\n  };\n}\n\nexport function HttpSource(url: string, init?: RequestInit): ClassType<SourceAdapter<string, unknown>> {\n  return class implements SourceAdapter<string, unknown> {\n    async read(): Promise<string[]> {\n      const response = await fetch(url, init);\n\n      // Thrown, not swallowed: the scheduler treats a failed read as \"keep\n      // what we have\", and it can only do that if it hears about the failure.\n      if (!response.ok) throw new Error(`HttpSource: ${url} answered ${response.status}`);\n\n      return lines(await response.text());\n    }\n  };\n}\n\n/* ------------------------------------------------------------ line format */\n\n/**\n * Crontab-shaped, one task per line:\n *\n * ```\n * # every five minutes\n * 0 *\\/5 * * * *  handler:session.cleanup\n * 0 0 3 * * *     api:https://app/internal/report   tz=Asia/Ho_Chi_Minh retry=2\n * 0 0 4 * * *     file:./scripts/rollup.js          name=nightly-rollup\n * ```\n *\n * The target doubles as the key, since one target on one schedule is the usual\n * case. `name=` overrides it, which is what you need to run the same handler on\n * two different expressions.\n */\nexport class LineParser implements TaskParser<string> {\n  parse(line: string): TaskDefinition {\n    const tokens = line.split(/\\s+/);\n\n    // Five cron fields or six, then the target: count from the target\n    // backwards would be ambiguous, so find it by its `kind:` prefix.\n    const targetAt = tokens.findIndex((token) => /^(handler|api|file):/.test(token));\n\n    if (targetAt < 5 || targetAt > 6) {\n      throw new Error(`LineParser: expected a handler:/api:/file: target after 5 or 6 cron fields — \"${line}\"`);\n    }\n\n    const expression = tokens.slice(0, targetAt).join(\" \");\n    const target = this.target(tokens[targetAt], line);\n    const options = this.options(tokens.slice(targetAt + 1));\n\n    return {\n      key: options.name ?? tokens[targetAt],\n      expression,\n      target,\n      timezone: options.tz,\n      enabled: options.enabled !== \"false\",\n      retry: options.retry === undefined ? undefined : Number(options.retry),\n      timeout: options.timeout === undefined ? undefined : Number(options.timeout),\n    };\n  }\n\n  private target(token: string, line: string): TaskTarget {\n    const at = token.indexOf(\":\");\n    const kind = token.slice(0, at);\n    const rest = token.slice(at + 1);\n\n    if (!rest) throw new Error(`LineParser: \"${kind}:\" has no value — \"${line}\"`);\n\n    switch (kind) {\n      case \"handler\": return { type: \"handler\", key: rest };\n      case \"api\": return { type: \"api\", url: rest };\n      case \"file\": return { type: \"file\", path: rest };\n      default: throw new Error(`LineParser: unknown target \"${kind}\" — \"${line}\"`);\n    }\n  }\n\n  private options(tokens: string[]): Record<string, string | undefined> {\n    const options: Record<string, string> = {};\n\n    for (const token of tokens) {\n      const at = token.indexOf(\"=\");\n      if (at > 0) options[token.slice(0, at)] = token.slice(at + 1);\n    }\n\n    return options;\n  }\n}\n"],"names":["Source","read","context","lines","text","line","FileSource","path","readFile","HttpSource","url","init","response","LineParser","tokens","targetAt","token","expression","target","options","at","kind","rest"],"mappings":"wdAgBO,SAASA,EACdC,EAC0C,CAC1C,OAAO,KAA+C,CACpD,KAAKC,EAAkB,CACrB,OAAOD,EAAKC,CAAO,CACrB,CACF,CACF,CAGA,SAASC,EAAMC,EAAwB,CACrC,OAAOA,EACJ,MAAM;AAAA,CAAI,EACV,IAAKC,GAASA,EAAK,MAAM,EACzB,OAAQA,GAASA,EAAK,OAAS,GAAK,CAACA,EAAK,WAAW,GAAG,CAAC,CAC9D,CAEO,SAASC,EAAWC,EAAyD,CAClF,OAAO,KAAgD,CACrD,MAAM,MAA0B,CAC9B,KAAM,CAAE,SAAAC,CAAS,EAAI,KAAM,QAAO,kBAAkB,EACpD,OAAOL,EAAM,MAAMK,EAASD,EAAM,OAAO,CAAC,CAC5C,CACF,CACF,CAEO,SAASE,EAAWC,EAAaC,EAA+D,CACrG,OAAO,KAAgD,CACrD,MAAM,MAA0B,CAC9B,MAAMC,EAAW,MAAM,MAAMF,EAAKC,CAAI,EAItC,GAAI,CAACC,EAAS,GAAI,MAAM,IAAI,MAAM,eAAeF,CAAG,aAAaE,EAAS,MAAM,EAAE,EAElF,OAAOT,EAAM,MAAMS,EAAS,MAAM,CACpC,CACF,CACF,CAkBO,MAAMC,CAAyC,CACpD,MAAMR,EAA8B,CAClC,MAAMS,EAAST,EAAK,MAAM,KAAK,EAIzBU,EAAWD,EAAO,UAAWE,GAAU,uBAAuB,KAAKA,CAAK,CAAC,EAE/E,GAAID,EAAW,GAAKA,EAAW,EAC7B,MAAM,IAAI,MAAM,sFAAiFV,CAAI,GAAG,EAG1G,MAAMY,EAAaH,EAAO,MAAM,EAAGC,CAAQ,EAAE,KAAK,GAAG,EAC/CG,EAAS,KAAK,OAAOJ,EAAOC,CAAQ,EAAGV,CAAI,EAC3Cc,EAAU,KAAK,QAAQL,EAAO,MAAMC,EAAW,CAAC,CAAC,EAEvD,MAAO,CACL,IAAKI,EAAQ,MAAQL,EAAOC,CAAQ,EACpC,WAAAE,EACA,OAAAC,EACA,SAAUC,EAAQ,GAClB,QAASA,EAAQ,UAAY,QAC7B,MAAOA,EAAQ,QAAU,OAAY,OAAY,OAAOA,EAAQ,KAAK,EACrE,QAASA,EAAQ,UAAY,OAAY,OAAY,OAAOA,EAAQ,OAAO,CAC7E,CACF,CAEQ,OAAOH,EAAeX,EAA0B,CACtD,MAAMe,EAAKJ,EAAM,QAAQ,GAAG,EACtBK,EAAOL,EAAM,MAAM,EAAGI,CAAE,EACxBE,EAAON,EAAM,MAAMI,EAAK,CAAC,EAE/B,GAAI,CAACE,EAAM,MAAM,IAAI,MAAM,gBAAgBD,CAAI,2BAAsBhB,CAAI,GAAG,EAE5E,OAAQgB,EAAAA,CACN,IAAK,UAAW,MAAO,CAAE,KAAM,UAAW,IAAKC,CAAK,EACpD,IAAK,MAAO,MAAO,CAAE,KAAM,MAAO,IAAKA,CAAK,EAC5C,IAAK,OAAQ,MAAO,CAAE,KAAM,OAAQ,KAAMA,CAAK,EAC/C,QAAS,MAAM,IAAI,MAAM,+BAA+BD,CAAI,aAAQhB,CAAI,GAAG,CAC7E,CACF,CAEQ,QAAQS,EAAsD,CACpE,MAAMK,EAAkC,CAAA,EAExC,UAAWH,KAASF,EAAQ,CAC1B,MAAMM,EAAKJ,EAAM,QAAQ,GAAG,EACxBI,EAAK,IAAGD,EAAQH,EAAM,MAAM,EAAGI,CAAE,CAAC,EAAIJ,EAAM,MAAMI,EAAK,CAAC,EAC9D,CAEA,OAAOD,CACT,CACF"}

package/dist/source/index.mjs

@@ -0,0 +1,3 @@
+function u(n){return class{read(e){return n(e)}}}function o(n){return n.split(`
+`).map(e=>e.trim()).filter(e=>e.length>0&&!e.startsWith("#"))}function l(n){return class{async read(){const{readFile:e}=await import("node:fs/promises");return o(await e(n,"utf-8"))}}}function f(n,e){return class{async read(){const r=await fetch(n,e);if(!r.ok)throw new Error(`HttpSource: ${n} answered ${r.status}`);return o(await r.text())}}}class d{parse(e){const r=e.split(/\s+/),t=r.findIndex(c=>/^(handler|api|file):/.test(c));if(t<5||t>6)throw new Error(`LineParser: expected a handler:/api:/file: target after 5 or 6 cron fields \u2014 "${e}"`);const i=r.slice(0,t).join(" "),s=this.target(r[t],e),a=this.options(r.slice(t+1));return{key:a.name??r[t],expression:i,target:s,timezone:a.tz,enabled:a.enabled!=="false",retry:a.retry===void 0?void 0:Number(a.retry),timeout:a.timeout===void 0?void 0:Number(a.timeout)}}target(e,r){const t=e.indexOf(":"),i=e.slice(0,t),s=e.slice(t+1);if(!s)throw new Error(`LineParser: "${i}:" has no value \u2014 "${r}"`);switch(i){case"handler":return{type:"handler",key:s};case"api":return{type:"api",url:s};case"file":return{type:"file",path:s};default:throw new Error(`LineParser: unknown target "${i}" \u2014 "${r}"`)}}options(e){const r={};for(const t of e){const i=t.indexOf("=");i>0&&(r[t.slice(0,i)]=t.slice(i+1))}return r}}export{l as FileSource,f as HttpSource,d as LineParser,u as Source};
+//# sourceMappingURL=index.mjs.map

package/dist/source/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../src/source/index.ts"],"sourcesContent":["import type { ClassType, Promisable, SourceAdapter, TaskDefinition, TaskParser, TaskTarget } from \"../types\";\n\n/**\n * Built-in sources and the line format they produce.\n *\n * Only local files and HTTP: sharing a file between instances behind a load\n * balancer is a mount, not a library concern.\n */\n\n/**\n * Wraps a reader function into a source class.\n *\n * `.source()` takes a class, not a callback, so that nothing in the scheduler\n * has to work out at runtime what it was handed. This keeps the one-line case\n * one line without reintroducing that ambiguity.\n */\nexport function Source<Entry = string, Context = unknown>(\n  read: (context: Context) => Promisable<Entry[]>,\n): ClassType<SourceAdapter<Entry, Context>> {\n  return class implements SourceAdapter<Entry, Context> {\n    read(context: Context) {\n      return read(context);\n    }\n  };\n}\n\n/** Drops comments and blank lines. Everything else is a task. */\nfunction lines(text: string): string[] {\n  return text\n    .split(\"\\n\")\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0 && !line.startsWith(\"#\"));\n}\n\nexport function FileSource(path: string): ClassType<SourceAdapter<string, unknown>> {\n  return class implements SourceAdapter<string, unknown> {\n    async read(): Promise<string[]> {\n      const { readFile } = await import(\"node:fs/promises\");\n      return lines(await readFile(path, \"utf-8\"));\n    }\n  };\n}\n\nexport function HttpSource(url: string, init?: RequestInit): ClassType<SourceAdapter<string, unknown>> {\n  return class implements SourceAdapter<string, unknown> {\n    async read(): Promise<string[]> {\n      const response = await fetch(url, init);\n\n      // Thrown, not swallowed: the scheduler treats a failed read as \"keep\n      // what we have\", and it can only do that if it hears about the failure.\n      if (!response.ok) throw new Error(`HttpSource: ${url} answered ${response.status}`);\n\n      return lines(await response.text());\n    }\n  };\n}\n\n/* ------------------------------------------------------------ line format */\n\n/**\n * Crontab-shaped, one task per line:\n *\n * ```\n * # every five minutes\n * 0 *\\/5 * * * *  handler:session.cleanup\n * 0 0 3 * * *     api:https://app/internal/report   tz=Asia/Ho_Chi_Minh retry=2\n * 0 0 4 * * *     file:./scripts/rollup.js          name=nightly-rollup\n * ```\n *\n * The target doubles as the key, since one target on one schedule is the usual\n * case. `name=` overrides it, which is what you need to run the same handler on\n * two different expressions.\n */\nexport class LineParser implements TaskParser<string> {\n  parse(line: string): TaskDefinition {\n    const tokens = line.split(/\\s+/);\n\n    // Five cron fields or six, then the target: count from the target\n    // backwards would be ambiguous, so find it by its `kind:` prefix.\n    const targetAt = tokens.findIndex((token) => /^(handler|api|file):/.test(token));\n\n    if (targetAt < 5 || targetAt > 6) {\n      throw new Error(`LineParser: expected a handler:/api:/file: target after 5 or 6 cron fields — \"${line}\"`);\n    }\n\n    const expression = tokens.slice(0, targetAt).join(\" \");\n    const target = this.target(tokens[targetAt], line);\n    const options = this.options(tokens.slice(targetAt + 1));\n\n    return {\n      key: options.name ?? tokens[targetAt],\n      expression,\n      target,\n      timezone: options.tz,\n      enabled: options.enabled !== \"false\",\n      retry: options.retry === undefined ? undefined : Number(options.retry),\n      timeout: options.timeout === undefined ? undefined : Number(options.timeout),\n    };\n  }\n\n  private target(token: string, line: string): TaskTarget {\n    const at = token.indexOf(\":\");\n    const kind = token.slice(0, at);\n    const rest = token.slice(at + 1);\n\n    if (!rest) throw new Error(`LineParser: \"${kind}:\" has no value — \"${line}\"`);\n\n    switch (kind) {\n      case \"handler\": return { type: \"handler\", key: rest };\n      case \"api\": return { type: \"api\", url: rest };\n      case \"file\": return { type: \"file\", path: rest };\n      default: throw new Error(`LineParser: unknown target \"${kind}\" — \"${line}\"`);\n    }\n  }\n\n  private options(tokens: string[]): Record<string, string | undefined> {\n    const options: Record<string, string> = {};\n\n    for (const token of tokens) {\n      const at = token.indexOf(\"=\");\n      if (at > 0) options[token.slice(0, at)] = token.slice(at + 1);\n    }\n\n    return options;\n  }\n}\n"],"names":["Source","read","context","lines","text","line","FileSource","path","readFile","HttpSource","url","init","response","LineParser","tokens","targetAt","token","expression","target","options","at","kind","rest"],"mappings":"AAgBO,SAASA,EACdC,EAC0C,CAC1C,OAAO,KAA+C,CACpD,KAAKC,EAAkB,CACrB,OAAOD,EAAKC,CAAO,CACrB,CACF,CACF,CAGA,SAASC,EAAMC,EAAwB,CACrC,OAAOA,EACJ,MAAM;AAAA,CAAI,EACV,IAAKC,GAASA,EAAK,MAAM,EACzB,OAAQA,GAASA,EAAK,OAAS,GAAK,CAACA,EAAK,WAAW,GAAG,CAAC,CAC9D,CAEO,SAASC,EAAWC,EAAyD,CAClF,OAAO,KAAgD,CACrD,MAAM,MAA0B,CAC9B,KAAM,CAAE,SAAAC,CAAS,EAAI,KAAM,QAAO,kBAAkB,EACpD,OAAOL,EAAM,MAAMK,EAASD,EAAM,OAAO,CAAC,CAC5C,CACF,CACF,CAEO,SAASE,EAAWC,EAAaC,EAA+D,CACrG,OAAO,KAAgD,CACrD,MAAM,MAA0B,CAC9B,MAAMC,EAAW,MAAM,MAAMF,EAAKC,CAAI,EAItC,GAAI,CAACC,EAAS,GAAI,MAAM,IAAI,MAAM,eAAeF,CAAG,aAAaE,EAAS,MAAM,EAAE,EAElF,OAAOT,EAAM,MAAMS,EAAS,MAAM,CACpC,CACF,CACF,CAkBO,MAAMC,CAAyC,CACpD,MAAMR,EAA8B,CAClC,MAAMS,EAAST,EAAK,MAAM,KAAK,EAIzBU,EAAWD,EAAO,UAAWE,GAAU,uBAAuB,KAAKA,CAAK,CAAC,EAE/E,GAAID,EAAW,GAAKA,EAAW,EAC7B,MAAM,IAAI,MAAM,sFAAiFV,CAAI,GAAG,EAG1G,MAAMY,EAAaH,EAAO,MAAM,EAAGC,CAAQ,EAAE,KAAK,GAAG,EAC/CG,EAAS,KAAK,OAAOJ,EAAOC,CAAQ,EAAGV,CAAI,EAC3Cc,EAAU,KAAK,QAAQL,EAAO,MAAMC,EAAW,CAAC,CAAC,EAEvD,MAAO,CACL,IAAKI,EAAQ,MAAQL,EAAOC,CAAQ,EACpC,WAAAE,EACA,OAAAC,EACA,SAAUC,EAAQ,GAClB,QAASA,EAAQ,UAAY,QAC7B,MAAOA,EAAQ,QAAU,OAAY,OAAY,OAAOA,EAAQ,KAAK,EACrE,QAASA,EAAQ,UAAY,OAAY,OAAY,OAAOA,EAAQ,OAAO,CAC7E,CACF,CAEQ,OAAOH,EAAeX,EAA0B,CACtD,MAAMe,EAAKJ,EAAM,QAAQ,GAAG,EACtBK,EAAOL,EAAM,MAAM,EAAGI,CAAE,EACxBE,EAAON,EAAM,MAAMI,EAAK,CAAC,EAE/B,GAAI,CAACE,EAAM,MAAM,IAAI,MAAM,gBAAgBD,CAAI,2BAAsBhB,CAAI,GAAG,EAE5E,OAAQgB,EAAAA,CACN,IAAK,UAAW,MAAO,CAAE,KAAM,UAAW,IAAKC,CAAK,EACpD,IAAK,MAAO,MAAO,CAAE,KAAM,MAAO,IAAKA,CAAK,EAC5C,IAAK,OAAQ,MAAO,CAAE,KAAM,OAAQ,KAAMA,CAAK,EAC/C,QAAS,MAAM,IAAI,MAAM,+BAA+BD,CAAI,aAAQhB,CAAI,GAAG,CAC7E,CACF,CAEQ,QAAQS,EAAsD,CACpE,MAAMK,EAAkC,CAAA,EAExC,UAAWH,KAASF,EAAQ,CAC1B,MAAMM,EAAKJ,EAAM,QAAQ,GAAG,EACxBI,EAAK,IAAGD,EAAQH,EAAM,MAAM,EAAGI,CAAE,CAAC,EAAIJ,EAAM,MAAMI,EAAK,CAAC,EAC9D,CAEA,OAAOD,CACT,CACF"}

package/dist/task.d.ts

@@ -0,0 +1,60 @@
+import type { TaskDefinition } from "./types";
+export interface TaskStatus {
+    key: string;
+    enabled: boolean;
+    expression: string;
+    timezone: string;
+    nextAt: Date | null;
+    running: boolean;
+    lastRunAt: Date | null;
+    lastOk: boolean | null;
+    runs: number;
+    failures: number;
+}
+/**
+ * One scheduled task: its definition, when it fires next, and how it has been
+ * doing.
+ *
+ * The split between the two matters at sync time. A definition that changed
+ * gets a freshly computed schedule — the new expression decides the next fire,
+ * not an adjustment of the old one — while the history carries over, because
+ * "when did this last succeed" is the question people ask after an edit, not
+ * before it.
+ */
+export declare class Task {
+    readonly key: string;
+    private definition;
+    private cron;
+    nextAt: Date | null;
+    running: boolean;
+    lastRunAt: Date | null;
+    lastOk: boolean | null;
+    runs: number;
+    failures: number;
+    constructor(definition: TaskDefinition, from?: Date);
+    get enabled(): boolean;
+    get timezone(): string;
+    get current(): TaskDefinition;
+    /** Recomputes the next fire from scratch. History is untouched. */
+    private schedule;
+    /**
+     * Applies a changed definition.
+     *
+     * Only reparses when the expression or zone actually moved: reparsing on
+     * every sync would reset `nextAt` each time and, for anything firing less
+     * often than the sync interval, push the fire permanently into the future.
+     */
+    update(definition: TaskDefinition, from?: Date): void;
+    due(now: Date): boolean;
+    /**
+     * Moves to the fire after this one.
+     *
+     * Called the moment a run is picked up, before it finishes, so a task that
+     * takes longer than its interval does not push its own schedule along behind
+     * it. Overlap is prevented by `running`, not by delaying the clock.
+     */
+    advance(): Date;
+    record(ok: boolean, at: Date): void;
+    status(): TaskStatus;
+}
+//# sourceMappingURL=task.d.ts.map

package/dist/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../src/task.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,IAAI,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,qBAAa,IAAI;IACf,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,IAAI,CAAiB;IAE7B,MAAM,EAAE,IAAI,GAAG,IAAI,CAAQ;IAC3B,OAAO,UAAS;IAEhB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAQ;IAC9B,MAAM,EAAE,OAAO,GAAG,IAAI,CAAQ;IAC9B,IAAI,SAAK;IACT,QAAQ,SAAK;gBAED,UAAU,EAAE,cAAc,EAAE,IAAI,GAAE,IAAiB;IAO/D,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,OAAO,IAAI,cAAc,CAE5B;IAED,mEAAmE;IACnE,OAAO,CAAC,QAAQ;IAIhB;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,EAAE,cAAc,EAAE,IAAI,GAAE,IAAiB,GAAG,IAAI;IAcjE,GAAG,CAAC,GAAG,EAAE,IAAI,GAAG,OAAO;IAIvB;;;;;;OAMG;IACH,OAAO,IAAI,IAAI;IAMf,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,GAAG,IAAI;IAOnC,MAAM,IAAI,UAAU;CAcrB"}

package/dist/task.js

@@ -0,0 +1,2 @@
+"use strict";var s=require("./cron.js"),h=Object.defineProperty,a=(n,t,e)=>t in n?h(n,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):n[t]=e,i=(n,t,e)=>a(n,typeof t!="symbol"?t+"":t,e);class l{constructor(t,e=new Date){i(this,"key"),i(this,"definition"),i(this,"cron"),i(this,"nextAt",null),i(this,"running",!1),i(this,"lastRunAt",null),i(this,"lastOk",null),i(this,"runs",0),i(this,"failures",0),this.key=t.key,this.definition=t,this.cron=s.parseCron(t.expression),this.schedule(e)}get enabled(){return this.definition.enabled!==!1}get timezone(){return this.definition.timezone??"UTC"}get current(){return this.definition}schedule(t){this.nextAt=this.enabled?s.nextFire(this.cron,t,this.timezone):null}update(t,e=new Date){const r=t.expression!==this.definition.expression||t.timezone!==this.definition.timezone||t.enabled!==!1!==this.enabled;this.definition=t,r&&(this.cron=s.parseCron(t.expression),this.schedule(e))}due(t){return this.enabled&&!this.running&&this.nextAt!==null&&this.nextAt<=t}advance(){const t=this.nextAt??new Date;return this.nextAt=s.nextFire(this.cron,t,this.timezone),t}record(t,e){this.runs++,t||this.failures++,this.lastRunAt=e,this.lastOk=t}status(){return{key:this.key,enabled:this.enabled,expression:this.definition.expression,timezone:this.timezone,nextAt:this.nextAt,running:this.running,lastRunAt:this.lastRunAt,lastOk:this.lastOk,runs:this.runs,failures:this.failures}}}exports.Task=l;
+//# sourceMappingURL=task.js.map

package/dist/task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","sources":["../src/task.ts"],"sourcesContent":["import { nextFire, parseCron, type CronExpression } from \"./cron\";\nimport type { TaskDefinition } from \"./types\";\n\nexport interface TaskStatus {\n  key: string;\n  enabled: boolean;\n  expression: string;\n  timezone: string;\n  nextAt: Date | null;\n  running: boolean;\n  lastRunAt: Date | null;\n  lastOk: boolean | null;\n  runs: number;\n  failures: number;\n}\n\n/**\n * One scheduled task: its definition, when it fires next, and how it has been\n * doing.\n *\n * The split between the two matters at sync time. A definition that changed\n * gets a freshly computed schedule — the new expression decides the next fire,\n * not an adjustment of the old one — while the history carries over, because\n * \"when did this last succeed\" is the question people ask after an edit, not\n * before it.\n */\nexport class Task {\n  readonly key: string;\n\n  private definition: TaskDefinition;\n  private cron: CronExpression;\n\n  nextAt: Date | null = null;\n  running = false;\n\n  lastRunAt: Date | null = null;\n  lastOk: boolean | null = null;\n  runs = 0;\n  failures = 0;\n\n  constructor(definition: TaskDefinition, from: Date = new Date()) {\n    this.key = definition.key;\n    this.definition = definition;\n    this.cron = parseCron(definition.expression);\n    this.schedule(from);\n  }\n\n  get enabled(): boolean {\n    return this.definition.enabled !== false;\n  }\n\n  get timezone(): string {\n    return this.definition.timezone ?? \"UTC\";\n  }\n\n  get current(): TaskDefinition {\n    return this.definition;\n  }\n\n  /** Recomputes the next fire from scratch. History is untouched. */\n  private schedule(from: Date): void {\n    this.nextAt = this.enabled ? nextFire(this.cron, from, this.timezone) : null;\n  }\n\n  /**\n   * Applies a changed definition.\n   *\n   * Only reparses when the expression or zone actually moved: reparsing on\n   * every sync would reset `nextAt` each time and, for anything firing less\n   * often than the sync interval, push the fire permanently into the future.\n   */\n  update(definition: TaskDefinition, from: Date = new Date()): void {\n    const rescheduled =\n      definition.expression !== this.definition.expression ||\n      definition.timezone !== this.definition.timezone ||\n      (definition.enabled !== false) !== this.enabled;\n\n    this.definition = definition;\n\n    if (rescheduled) {\n      this.cron = parseCron(definition.expression);\n      this.schedule(from);\n    }\n  }\n\n  due(now: Date): boolean {\n    return this.enabled && !this.running && this.nextAt !== null && this.nextAt <= now;\n  }\n\n  /**\n   * Moves to the fire after this one.\n   *\n   * Called the moment a run is picked up, before it finishes, so a task that\n   * takes longer than its interval does not push its own schedule along behind\n   * it. Overlap is prevented by `running`, not by delaying the clock.\n   */\n  advance(): Date {\n    const fired = this.nextAt ?? new Date();\n    this.nextAt = nextFire(this.cron, fired, this.timezone);\n    return fired;\n  }\n\n  record(ok: boolean, at: Date): void {\n    this.runs++;\n    if (!ok) this.failures++;\n    this.lastRunAt = at;\n    this.lastOk = ok;\n  }\n\n  status(): TaskStatus {\n    return {\n      key: this.key,\n      enabled: this.enabled,\n      expression: this.definition.expression,\n      timezone: this.timezone,\n      nextAt: this.nextAt,\n      running: this.running,\n      lastRunAt: this.lastRunAt,\n      lastOk: this.lastOk,\n      runs: this.runs,\n      failures: this.failures,\n    };\n  }\n}\n"],"names":["Task","definition","from","__publicField","parseCron","nextFire","rescheduled","now","fired","ok","at"],"mappings":"sMA0BaA,CAAK,CAchB,YAAYC,EAA4BC,EAAa,IAAI,KAAQ,CAbjEC,EAAA,KAAS,KAAA,EAETA,EAAA,KAAQ,cACRA,EAAA,KAAQ,MAAA,EAERA,EAAA,KAAA,SAAsB,IAAA,EACtBA,EAAA,KAAA,UAAU,EAAA,EAEVA,EAAA,KAAA,YAAyB,IAAA,EACzBA,EAAA,cAAyB,IAAA,EACzBA,EAAA,KAAA,OAAO,CAAA,EACPA,EAAA,KAAA,WAAW,GAGT,KAAK,IAAMF,EAAW,IACtB,KAAK,WAAaA,EAClB,KAAK,KAAOG,EAAAA,UAAUH,EAAW,UAAU,EAC3C,KAAK,SAASC,CAAI,CACpB,CAEA,IAAI,SAAmB,CACrB,OAAO,KAAK,WAAW,UAAY,EACrC,CAEA,IAAI,UAAmB,CACrB,OAAO,KAAK,WAAW,UAAY,KACrC,CAEA,IAAI,SAA0B,CAC5B,OAAO,KAAK,UACd,CAGQ,SAASA,EAAkB,CACjC,KAAK,OAAS,KAAK,QAAUG,EAAAA,SAAS,KAAK,KAAMH,EAAM,KAAK,QAAQ,EAAI,IAC1E,CASA,OAAOD,EAA4BC,EAAa,IAAI,KAAc,CAChE,MAAMI,EACJL,EAAW,aAAe,KAAK,WAAW,YAC1CA,EAAW,WAAa,KAAK,WAAW,UACvCA,EAAW,UAAY,KAAW,KAAK,QAE1C,KAAK,WAAaA,EAEdK,IACF,KAAK,KAAOF,EAAAA,UAAUH,EAAW,UAAU,EAC3C,KAAK,SAASC,CAAI,EAEtB,CAEA,IAAIK,EAAoB,CACtB,OAAO,KAAK,SAAW,CAAC,KAAK,SAAW,KAAK,SAAW,MAAQ,KAAK,QAAUA,CACjF,CASA,SAAgB,CACd,MAAMC,EAAQ,KAAK,QAAU,IAAI,KACjC,OAAA,KAAK,OAASH,EAAAA,SAAS,KAAK,KAAMG,EAAO,KAAK,QAAQ,EAC/CA,CACT,CAEA,OAAOC,EAAaC,EAAgB,CAClC,KAAK,OACAD,GAAI,KAAK,WACd,KAAK,UAAYC,EACjB,KAAK,OAASD,CAChB,CAEA,QAAqB,CACnB,MAAO,CACL,IAAK,KAAK,IACV,QAAS,KAAK,QACd,WAAY,KAAK,WAAW,WAC5B,SAAU,KAAK,SACf,OAAQ,KAAK,OACb,QAAS,KAAK,QACd,UAAW,KAAK,UAChB,OAAQ,KAAK,OACb,KAAM,KAAK,KACX,SAAU,KAAK,QACjB,CACF,CACF"}

package/dist/task.mjs

@@ -0,0 +1,2 @@
+import{parseCron as s,nextFire as r}from"./cron.mjs";var l=Object.defineProperty,o=(n,t,e)=>t in n?l(n,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):n[t]=e,i=(n,t,e)=>o(n,typeof t!="symbol"?t+"":t,e);class a{constructor(t,e=new Date){i(this,"key"),i(this,"definition"),i(this,"cron"),i(this,"nextAt",null),i(this,"running",!1),i(this,"lastRunAt",null),i(this,"lastOk",null),i(this,"runs",0),i(this,"failures",0),this.key=t.key,this.definition=t,this.cron=s(t.expression),this.schedule(e)}get enabled(){return this.definition.enabled!==!1}get timezone(){return this.definition.timezone??"UTC"}get current(){return this.definition}schedule(t){this.nextAt=this.enabled?r(this.cron,t,this.timezone):null}update(t,e=new Date){const h=t.expression!==this.definition.expression||t.timezone!==this.definition.timezone||t.enabled!==!1!==this.enabled;this.definition=t,h&&(this.cron=s(t.expression),this.schedule(e))}due(t){return this.enabled&&!this.running&&this.nextAt!==null&&this.nextAt<=t}advance(){const t=this.nextAt??new Date;return this.nextAt=r(this.cron,t,this.timezone),t}record(t,e){this.runs++,t||this.failures++,this.lastRunAt=e,this.lastOk=t}status(){return{key:this.key,enabled:this.enabled,expression:this.definition.expression,timezone:this.timezone,nextAt:this.nextAt,running:this.running,lastRunAt:this.lastRunAt,lastOk:this.lastOk,runs:this.runs,failures:this.failures}}}export{a as Task};
+//# sourceMappingURL=task.mjs.map

package/dist/task.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.mjs","sources":["../src/task.ts"],"sourcesContent":["import { nextFire, parseCron, type CronExpression } from \"./cron\";\nimport type { TaskDefinition } from \"./types\";\n\nexport interface TaskStatus {\n  key: string;\n  enabled: boolean;\n  expression: string;\n  timezone: string;\n  nextAt: Date | null;\n  running: boolean;\n  lastRunAt: Date | null;\n  lastOk: boolean | null;\n  runs: number;\n  failures: number;\n}\n\n/**\n * One scheduled task: its definition, when it fires next, and how it has been\n * doing.\n *\n * The split between the two matters at sync time. A definition that changed\n * gets a freshly computed schedule — the new expression decides the next fire,\n * not an adjustment of the old one — while the history carries over, because\n * \"when did this last succeed\" is the question people ask after an edit, not\n * before it.\n */\nexport class Task {\n  readonly key: string;\n\n  private definition: TaskDefinition;\n  private cron: CronExpression;\n\n  nextAt: Date | null = null;\n  running = false;\n\n  lastRunAt: Date | null = null;\n  lastOk: boolean | null = null;\n  runs = 0;\n  failures = 0;\n\n  constructor(definition: TaskDefinition, from: Date = new Date()) {\n    this.key = definition.key;\n    this.definition = definition;\n    this.cron = parseCron(definition.expression);\n    this.schedule(from);\n  }\n\n  get enabled(): boolean {\n    return this.definition.enabled !== false;\n  }\n\n  get timezone(): string {\n    return this.definition.timezone ?? \"UTC\";\n  }\n\n  get current(): TaskDefinition {\n    return this.definition;\n  }\n\n  /** Recomputes the next fire from scratch. History is untouched. */\n  private schedule(from: Date): void {\n    this.nextAt = this.enabled ? nextFire(this.cron, from, this.timezone) : null;\n  }\n\n  /**\n   * Applies a changed definition.\n   *\n   * Only reparses when the expression or zone actually moved: reparsing on\n   * every sync would reset `nextAt` each time and, for anything firing less\n   * often than the sync interval, push the fire permanently into the future.\n   */\n  update(definition: TaskDefinition, from: Date = new Date()): void {\n    const rescheduled =\n      definition.expression !== this.definition.expression ||\n      definition.timezone !== this.definition.timezone ||\n      (definition.enabled !== false) !== this.enabled;\n\n    this.definition = definition;\n\n    if (rescheduled) {\n      this.cron = parseCron(definition.expression);\n      this.schedule(from);\n    }\n  }\n\n  due(now: Date): boolean {\n    return this.enabled && !this.running && this.nextAt !== null && this.nextAt <= now;\n  }\n\n  /**\n   * Moves to the fire after this one.\n   *\n   * Called the moment a run is picked up, before it finishes, so a task that\n   * takes longer than its interval does not push its own schedule along behind\n   * it. Overlap is prevented by `running`, not by delaying the clock.\n   */\n  advance(): Date {\n    const fired = this.nextAt ?? new Date();\n    this.nextAt = nextFire(this.cron, fired, this.timezone);\n    return fired;\n  }\n\n  record(ok: boolean, at: Date): void {\n    this.runs++;\n    if (!ok) this.failures++;\n    this.lastRunAt = at;\n    this.lastOk = ok;\n  }\n\n  status(): TaskStatus {\n    return {\n      key: this.key,\n      enabled: this.enabled,\n      expression: this.definition.expression,\n      timezone: this.timezone,\n      nextAt: this.nextAt,\n      running: this.running,\n      lastRunAt: this.lastRunAt,\n      lastOk: this.lastOk,\n      runs: this.runs,\n      failures: this.failures,\n    };\n  }\n}\n"],"names":["Task","definition","from","__publicField","parseCron","nextFire","rescheduled","now","fired","ok","at"],"mappings":"uNA0BaA,CAAK,CAchB,YAAYC,EAA4BC,EAAa,IAAI,KAAQ,CAbjEC,EAAA,KAAS,KAAA,EAETA,EAAA,KAAQ,cACRA,EAAA,KAAQ,MAAA,EAERA,EAAA,KAAA,SAAsB,IAAA,EACtBA,EAAA,KAAA,UAAU,EAAA,EAEVA,EAAA,KAAA,YAAyB,IAAA,EACzBA,EAAA,cAAyB,IAAA,EACzBA,EAAA,KAAA,OAAO,CAAA,EACPA,EAAA,KAAA,WAAW,GAGT,KAAK,IAAMF,EAAW,IACtB,KAAK,WAAaA,EAClB,KAAK,KAAOG,EAAUH,EAAW,UAAU,EAC3C,KAAK,SAASC,CAAI,CACpB,CAEA,IAAI,SAAmB,CACrB,OAAO,KAAK,WAAW,UAAY,EACrC,CAEA,IAAI,UAAmB,CACrB,OAAO,KAAK,WAAW,UAAY,KACrC,CAEA,IAAI,SAA0B,CAC5B,OAAO,KAAK,UACd,CAGQ,SAASA,EAAkB,CACjC,KAAK,OAAS,KAAK,QAAUG,EAAS,KAAK,KAAMH,EAAM,KAAK,QAAQ,EAAI,IAC1E,CASA,OAAOD,EAA4BC,EAAa,IAAI,KAAc,CAChE,MAAMI,EACJL,EAAW,aAAe,KAAK,WAAW,YAC1CA,EAAW,WAAa,KAAK,WAAW,UACvCA,EAAW,UAAY,KAAW,KAAK,QAE1C,KAAK,WAAaA,EAEdK,IACF,KAAK,KAAOF,EAAUH,EAAW,UAAU,EAC3C,KAAK,SAASC,CAAI,EAEtB,CAEA,IAAIK,EAAoB,CACtB,OAAO,KAAK,SAAW,CAAC,KAAK,SAAW,KAAK,SAAW,MAAQ,KAAK,QAAUA,CACjF,CASA,SAAgB,CACd,MAAMC,EAAQ,KAAK,QAAU,IAAI,KACjC,OAAA,KAAK,OAASH,EAAS,KAAK,KAAMG,EAAO,KAAK,QAAQ,EAC/CA,CACT,CAEA,OAAOC,EAAaC,EAAgB,CAClC,KAAK,OACAD,GAAI,KAAK,WACd,KAAK,UAAYC,EACjB,KAAK,OAASD,CAChB,CAEA,QAAqB,CACnB,MAAO,CACL,IAAK,KAAK,IACV,QAAS,KAAK,QACd,WAAY,KAAK,WAAW,WAC5B,SAAU,KAAK,SACf,OAAQ,KAAK,OACb,QAAS,KAAK,QACd,UAAW,KAAK,UAChB,OAAQ,KAAK,OACb,KAAM,KAAK,KACX,SAAU,KAAK,QACjB,CACF,CACF"}

package/{src/types.ts → dist/types.d.ts}

@@ -6,7 +6,6 @@
  * when absent, so a scheduler with just a source and a registry is a complete,
  * working single-instance scheduler.
  */
-
 /**
  * A class constructible with no arguments.
  *
@@ -19,84 +18,77 @@
  * here: nothing has to work out at runtime what it was given.
  */
 export type ClassType<Instance = unknown> = new () => Instance;
-
 export type InjectMap = Record<string, ClassType>;
-
 export type Injected<Context, Injects extends InjectMap> = Context & {
-  [K in keyof Injects]: Injects[K] extends ClassType<infer Instance> ? Instance : never;
+    [K in keyof Injects]: Injects[K] extends ClassType<infer Instance> ? Instance : never;
 };
-
 export type Promisable<T> = T | Promise<T>;
-
-/* ------------------------------------------------------------ task shape */
-
 /**
  * What a task does when it fires.
  *
  * Three kinds, and they fail in genuinely different ways — see `TaskFailure`.
  */
-export type TaskTarget =
-  /** A function registered in code. Fast and typed; cannot be interrupted. */
-  | { type: "handler"; key: string }
-  /** An HTTP call. Works across instances; the request can be abandoned but the server keeps going. */
-  | { type: "api"; url: string; method?: string; headers?: Record<string, string>; body?: string }
-  /** A child process. The only kind that can genuinely be killed. */
-  | { type: "file"; path: string; args?: string[] };
-
+export type TaskTarget = 
+/** A function registered in code. Fast and typed; cannot be interrupted. */
+{
+    type: "handler";
+    key: string;
+}
+/** An HTTP call. Works across instances; the request can be abandoned but the server keeps going. */
+ | {
+    type: "api";
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}
+/** A child process. The only kind that can genuinely be killed. */
+ | {
+    type: "file";
+    path: string;
+    args?: string[];
+};
 /** One task, after a parser has read it out of whatever the source returned. */
 export interface TaskDefinition {
-  /** Unique. Used for the registry lookup, for coordination, and as the sync identity. */
-  key: string;
-  /** Six-field cron, or five for standard crontab. */
-  expression: string;
-  target: TaskTarget;
-  /** IANA zone. Defaults to UTC — never the host zone, which differs between machines. */
-  timezone?: string;
-  /** False keeps the task known but unscheduled, so its history survives a pause. */
-  enabled?: boolean;
-  /** Overrides the schedule-level default. */
-  retry?: number;
-  /** Milliseconds. Overrides the schedule-level default. */
-  timeout?: number;
+    /** Unique. Used for the registry lookup, for coordination, and as the sync identity. */
+    key: string;
+    /** Six-field cron, or five for standard crontab. */
+    expression: string;
+    target: TaskTarget;
+    /** IANA zone. Defaults to UTC — never the host zone, which differs between machines. */
+    timezone?: string;
+    /** False keeps the task known but unscheduled, so its history survives a pause. */
+    enabled?: boolean;
+    /** Overrides the schedule-level default. */
+    retry?: number;
+    /** Milliseconds. Overrides the schedule-level default. */
+    timeout?: number;
 }
-
 /** Turns one entry from a source into a task. Implement this to accept your own format. */
 export interface TaskParser<Entry = string> {
-  parse(entry: Entry): TaskDefinition;
+    parse(entry: Entry): TaskDefinition;
 }
-
-/* -------------------------------------------------------------- outcomes */
-
 /**
  * Why a run failed, normalised across the three target kinds.
  *
  * Without this every consumer of a hook would branch on target type to find
  * out what went wrong. `raw` keeps the original for anyone who needs it.
  */
-export type TaskFailure =
-  | "throw"    // handler threw
-  | "status"   // api answered outside 2xx
-  | "timeout"  // deadline passed
-  | "exit"     // file exited non-zero, or was killed
-  | "unknown";
-
+export type TaskFailure = "throw" | "status" | "timeout" | "exit" | "unknown";
 export interface TaskEvent {
-  key: string;
-  /** The fire time this run belongs to, computed from the expression — not `now`. */
-  scheduledFor: Date;
-  startedAt: Date;
-  durationMs: number;
-  /** 1 for the first try. */
-  attempt: number;
-  ok: boolean;
-  reason?: TaskFailure;
-  detail?: string;
-  /** Whatever the target produced: return value, response body, stdout. */
-  raw?: unknown;
+    key: string;
+    /** The fire time this run belongs to, computed from the expression — not `now`. */
+    scheduledFor: Date;
+    startedAt: Date;
+    durationMs: number;
+    /** 1 for the first try. */
+    attempt: number;
+    ok: boolean;
+    reason?: TaskFailure;
+    detail?: string;
+    /** Whatever the target produced: return value, response body, stdout. */
+    raw?: unknown;
 }
-
-/* ----------------------------------------------------------------- ports */
-
 /**
  * Where task definitions come from. Required.
  *
@@ -105,11 +97,9 @@ export interface TaskEvent {
  * `Source(fn)` wraps a one-line reader into one, so brevity costs nothing.
  */
 export interface SourceAdapter<Entry = string, Context = unknown> {
-  read(context: Context): Promisable<Entry[]>;
+    read(context: Context): Promisable<Entry[]>;
 }
-
 export type Source<Entry = string, Context = unknown> = ClassType<SourceAdapter<Entry, Context>>;
-
 /**
  * Decides which instance runs a given fire. Optional.
  *
@@ -123,12 +113,11 @@ export type Source<Entry = string, Context = unknown> = ClassType<SourceAdapter<
  * it leaves a run history behind for free.
  */
 export interface Coordinator {
-  /** True when this instance won the right to run. False when another already has it. */
-  claim(key: string, scheduledFor: Date): Promisable<boolean>;
-  /** Called once the run ends, so an abandoned claim can be told from a live one. */
-  release(key: string, scheduledFor: Date, event: TaskEvent): Promisable<void>;
+    /** True when this instance won the right to run. False when another already has it. */
+    claim(key: string, scheduledFor: Date): Promisable<boolean>;
+    /** Called once the run ends, so an abandoned claim can be told from a live one. */
+    release(key: string, scheduledFor: Date, event: TaskEvent): Promisable<void>;
 }
-
 /**
  * Where run outcomes go. Optional — without one, a finished task reports
  * nowhere.
@@ -137,11 +126,10 @@ export interface Coordinator {
  * downstream ever branches on how many there are.
  */
 export interface Hook {
-  notify(event: TaskEvent): Promisable<void>;
+    notify(event: TaskEvent): Promisable<void>;
 }
-
 /** Called when a source entry names a handler that was never registered. */
 export type NotFoundHandler = (key: string, task: TaskDefinition) => Promisable<void>;
-
 /** Called when a run fails, before any retry decision. */
 export type ErrorHandler = (event: TaskEvent, task: TaskDefinition) => Promisable<void>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/types.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -1,30 +1,34 @@
 {
   "name": "@ecosy/schedule",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Cron scheduling with pluggable sources, coordination and reporting — no dependencies, runs anywhere Node does",
-  "main": "src/index.ts",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/index.d.ts",
-      "default": "./src/index.ts"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
     },
     "./source": {
       "source": "./src/source/index.ts",
       "types": "./dist/source/index.d.ts",
-      "default": "./src/source/index.ts"
+      "import": "./dist/source/index.mjs",
+      "require": "./dist/source/index.js"
     },
     "./hook": {
       "source": "./src/hook/index.ts",
       "types": "./dist/hook/index.d.ts",
-      "default": "./src/hook/index.ts"
+      "import": "./dist/hook/index.mjs",
+      "require": "./dist/hook/index.js"
     }
   },
   "license": "MIT",
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "yarn build"
+    "build": "tsc && rollup -c",
+    "prepublishOnly": "yarn clean && yarn build",
+    "clean": "rimraf dist"
   },
   "publishConfig": {
     "access": "public"
@@ -35,7 +39,19 @@
   },
   "author": "material-atomic",
   "devDependencies": {
+    "@rollup/plugin-commonjs": "^29.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@types/node": "^26.2.0",
+    "esbuild": "^0.25.0",
+    "glob": "^13.0.6",
+    "rimraf": "^6.1.3",
+    "rollup": "^4.62.4",
+    "rollup-plugin-esbuild": "^6.2.1",
     "typescript": "^5.9.3"
-  }
+  },
+  "module": "./dist/index.mjs",
+  "files": [
+    "dist",
+    "README.md"
+  ]
 }