@niscorp/tide 0.1.12 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -3,6 +3,119 @@ export { COMPARISON_OPS, PRIMARY_KEY, UNIQUE_BY } from './chunk-MGGWP6C7.js';
3
3
  import { isRecurring, ReflexSchema, FactInputSchema, clockOf, factOf, WEEKDAYS, isManual } from './chunk-SLLCUI65.js';
4
4
  export { ClockOnceSchema, ClockRecurringSchema, ClockTriggerSchema, ClockUnitSchema, DRAFT_TRIGGERS, EffectRefSchema, FactInputSchema, FactKindSchema, ManualTriggerSchema, OpSchema, PolicySchema, REFLEX_TRIGGERS, ReflexDraftSchema, ReflexSchema, RetrySchema, RunTriggerSchema, SelectionSchema, SignalTriggerSchema, TimeZoneSchema, TimerSchema, TimerTriggerSchema, TriggerSchema, WEEKDAYS, WriteTriggerSchema, draftSchemaOf, reflexSchemaOf } from './chunk-SLLCUI65.js';
5
5
 
6
+ // src/engine/occurrence.ts
7
+ var DAY_MS = 864e5;
8
+ var MAX_DAYS_SCANNED = 3700;
9
+ var FORMATTERS = /* @__PURE__ */ new Map();
10
+ var formatterFor = (tz) => {
11
+ const cached = FORMATTERS.get(tz);
12
+ if (cached !== void 0) return cached;
13
+ const built = new Intl.DateTimeFormat("en-US", {
14
+ timeZone: tz,
15
+ hourCycle: "h23",
16
+ year: "numeric",
17
+ month: "2-digit",
18
+ day: "2-digit",
19
+ hour: "2-digit",
20
+ minute: "2-digit",
21
+ second: "2-digit"
22
+ });
23
+ FORMATTERS.set(tz, built);
24
+ return built;
25
+ };
26
+ var zonedParts = (instant, tz) => {
27
+ const parts = formatterFor(tz).formatToParts(new Date(instant));
28
+ const read = (type) => {
29
+ const found = parts.find((part) => part.type === type);
30
+ return found === void 0 ? 0 : Number(found.value);
31
+ };
32
+ return {
33
+ year: read("year"),
34
+ month: read("month"),
35
+ day: read("day"),
36
+ hour: read("hour"),
37
+ minute: read("minute"),
38
+ second: read("second")
39
+ };
40
+ };
41
+ var offsetAt = (instant, tz) => {
42
+ const parts = zonedParts(instant, tz);
43
+ const asIfUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
44
+ return asIfUtc - Math.floor(instant / 1e3) * 1e3;
45
+ };
46
+ var rendersAs = (instant, tz, day, hour, minute) => {
47
+ const parts = zonedParts(instant, tz);
48
+ return parts.year === day.year && parts.month === day.month && parts.day === day.day && parts.hour === hour && parts.minute === minute;
49
+ };
50
+ var zonedToUtc = (day, hour, minute, tz) => {
51
+ const guess = Date.UTC(day.year, day.month - 1, day.day, hour, minute);
52
+ const before = offsetAt(guess - DAY_MS, tz);
53
+ const after = offsetAt(guess + DAY_MS, tz);
54
+ const candidates = before === after ? [guess - before] : [guess - before, guess - after];
55
+ const valid = candidates.filter((candidate) => rendersAs(candidate, tz, day, hour, minute));
56
+ return valid.length > 0 ? Math.min(...valid) : Math.max(...candidates);
57
+ };
58
+ var daysInMonth = (year, month) => new Date(Date.UTC(year, month, 0)).getUTCDate();
59
+ var weekdayOf = (day) => {
60
+ const index = new Date(Date.UTC(day.year, day.month - 1, day.day)).getUTCDay();
61
+ return WEEKDAYS[(index + 6) % 7] ?? "mon";
62
+ };
63
+ var splitInts = (value, separator) => value.split(separator).map((part) => Number(part));
64
+ var at2 = (values, index) => values[index] ?? 0;
65
+ var nextDay = (day) => {
66
+ const moved = new Date(Date.UTC(day.year, day.month - 1, day.day) + DAY_MS);
67
+ return { year: moved.getUTCFullYear(), month: moved.getUTCMonth() + 1, day: moved.getUTCDate() };
68
+ };
69
+ var ordinalOf = (day) => day.year * 1e4 + day.month * 100 + day.day;
70
+ var pad2 = (value) => String(value).padStart(2, "0");
71
+ var isDueOn = (clock, day) => {
72
+ if (clock.every === "day") return true;
73
+ if (clock.every === "week") return Array.isArray(clock.on) ? clock.on.some((one) => one === weekdayOf(day)) : weekdayOf(day) === clock.on;
74
+ if (clock.every === "month")
75
+ return typeof clock.on === "number" && day.day === Math.min(clock.on, daysInMonth(day.year, day.month));
76
+ if (typeof clock.on !== "string") return false;
77
+ const parts = splitInts(clock.on, "-");
78
+ const month = at2(parts, 0);
79
+ const dayOfMonth = at2(parts, 1);
80
+ return day.month === month && day.day === Math.min(dayOfMonth, daysInMonth(day.year, month));
81
+ };
82
+ var occurrenceKey = (clock, day) => {
83
+ if (clock.every === "year") return String(day.year);
84
+ if (clock.every === "month") return `${day.year}-${pad2(day.month)}`;
85
+ return `${day.year}-${pad2(day.month)}-${pad2(day.day)}`;
86
+ };
87
+ var occurrencesBetween = (clock, after, through, cap) => {
88
+ if (through <= after || cap <= 0) return [];
89
+ if (!isRecurring(clock)) {
90
+ const [date = "", time2 = ""] = clock.at.split("T");
91
+ const ymd = splitInts(date, "-");
92
+ const hms = splitInts(time2, ":");
93
+ const at = zonedToUtc({ year: at2(ymd, 0), month: at2(ymd, 1), day: at2(ymd, 2) }, at2(hms, 0), at2(hms, 1), clock.tz) + at2(hms, 2) * 1e3;
94
+ return at > after && at <= through ? [{ key: clock.at, at }] : [];
95
+ }
96
+ const time = splitInts(clock.at, ":");
97
+ const hour = at2(time, 0);
98
+ const minute = at2(time, 1);
99
+ const start = zonedParts(after, clock.tz);
100
+ const end = zonedParts(through, clock.tz);
101
+ const endOrdinal = ordinalOf(end);
102
+ const found = [];
103
+ let cursor = { year: start.year, month: start.month, day: start.day };
104
+ let scanned = 0;
105
+ while (ordinalOf(cursor) <= endOrdinal && scanned < MAX_DAYS_SCANNED) {
106
+ scanned += 1;
107
+ if (isDueOn(clock, cursor)) {
108
+ const at = zonedToUtc(cursor, hour, minute, clock.tz);
109
+ if (at > after && at <= through) {
110
+ found.push({ key: occurrenceKey(clock, cursor), at });
111
+ if (found.length >= cap) break;
112
+ }
113
+ }
114
+ cursor = nextDay(cursor);
115
+ }
116
+ return found;
117
+ };
118
+
6
119
  // src/errors.ts
7
120
  var TideError = class extends Error {
8
121
  code;
@@ -199,120 +312,6 @@ var admitReflexes = ({
199
312
  return { reflexes: kept, graph, refused };
200
313
  };
201
314
 
202
- // src/engine/occurrence.ts
203
- var HALF_DAY_MS = 432e5;
204
- var DAY_MS = 864e5;
205
- var MAX_DAYS_SCANNED = 3700;
206
- var FORMATTERS = /* @__PURE__ */ new Map();
207
- var formatterFor = (tz) => {
208
- const cached = FORMATTERS.get(tz);
209
- if (cached !== void 0) return cached;
210
- const built = new Intl.DateTimeFormat("en-US", {
211
- timeZone: tz,
212
- hourCycle: "h23",
213
- year: "numeric",
214
- month: "2-digit",
215
- day: "2-digit",
216
- hour: "2-digit",
217
- minute: "2-digit",
218
- second: "2-digit"
219
- });
220
- FORMATTERS.set(tz, built);
221
- return built;
222
- };
223
- var zonedParts = (instant, tz) => {
224
- const parts = formatterFor(tz).formatToParts(new Date(instant));
225
- const read = (type) => {
226
- const found = parts.find((part) => part.type === type);
227
- return found === void 0 ? 0 : Number(found.value);
228
- };
229
- return {
230
- year: read("year"),
231
- month: read("month"),
232
- day: read("day"),
233
- hour: read("hour"),
234
- minute: read("minute"),
235
- second: read("second")
236
- };
237
- };
238
- var offsetAt = (instant, tz) => {
239
- const parts = zonedParts(instant, tz);
240
- const asIfUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
241
- return asIfUtc - Math.floor(instant / 1e3) * 1e3;
242
- };
243
- var rendersAs = (instant, tz, day, hour, minute) => {
244
- const parts = zonedParts(instant, tz);
245
- return parts.year === day.year && parts.month === day.month && parts.day === day.day && parts.hour === hour && parts.minute === minute;
246
- };
247
- var zonedToUtc = (day, hour, minute, tz) => {
248
- const guess = Date.UTC(day.year, day.month - 1, day.day, hour, minute);
249
- const before = offsetAt(guess - HALF_DAY_MS, tz);
250
- const after = offsetAt(guess + HALF_DAY_MS, tz);
251
- const candidates = before === after ? [guess - before] : [guess - before, guess - after];
252
- const valid = candidates.filter((candidate) => rendersAs(candidate, tz, day, hour, minute));
253
- return valid.length > 0 ? Math.min(...valid) : Math.max(...candidates);
254
- };
255
- var daysInMonth = (year, month) => new Date(Date.UTC(year, month, 0)).getUTCDate();
256
- var weekdayOf = (day) => {
257
- const index = new Date(Date.UTC(day.year, day.month - 1, day.day)).getUTCDay();
258
- return WEEKDAYS[(index + 6) % 7] ?? "mon";
259
- };
260
- var splitInts = (value, separator) => value.split(separator).map((part) => Number(part));
261
- var at2 = (values, index) => values[index] ?? 0;
262
- var nextDay = (day) => {
263
- const moved = new Date(Date.UTC(day.year, day.month - 1, day.day) + DAY_MS);
264
- return { year: moved.getUTCFullYear(), month: moved.getUTCMonth() + 1, day: moved.getUTCDate() };
265
- };
266
- var ordinalOf = (day) => day.year * 1e4 + day.month * 100 + day.day;
267
- var pad2 = (value) => String(value).padStart(2, "0");
268
- var isDueOn = (clock, day) => {
269
- if (clock.every === "day") return true;
270
- if (clock.every === "week") return Array.isArray(clock.on) ? clock.on.some((one) => one === weekdayOf(day)) : weekdayOf(day) === clock.on;
271
- if (clock.every === "month")
272
- return typeof clock.on === "number" && day.day === Math.min(clock.on, daysInMonth(day.year, day.month));
273
- if (typeof clock.on !== "string") return false;
274
- const parts = splitInts(clock.on, "-");
275
- const month = at2(parts, 0);
276
- const dayOfMonth = at2(parts, 1);
277
- return day.month === month && day.day === Math.min(dayOfMonth, daysInMonth(day.year, month));
278
- };
279
- var occurrenceKey = (clock, day) => {
280
- if (clock.every === "year") return String(day.year);
281
- if (clock.every === "month") return `${day.year}-${pad2(day.month)}`;
282
- return `${day.year}-${pad2(day.month)}-${pad2(day.day)}`;
283
- };
284
- var occurrencesBetween = (clock, after, through, cap) => {
285
- if (through <= after || cap <= 0) return [];
286
- if (!isRecurring(clock)) {
287
- const [date = "", time2 = ""] = clock.at.split("T");
288
- const ymd = splitInts(date, "-");
289
- const hms = splitInts(time2, ":");
290
- const at = zonedToUtc({ year: at2(ymd, 0), month: at2(ymd, 1), day: at2(ymd, 2) }, at2(hms, 0), at2(hms, 1), clock.tz) + at2(hms, 2) * 1e3;
291
- return at > after && at <= through ? [{ key: clock.at, at }] : [];
292
- }
293
- const time = splitInts(clock.at, ":");
294
- const hour = at2(time, 0);
295
- const minute = at2(time, 1);
296
- const start = zonedParts(after, clock.tz);
297
- const end = zonedParts(through, clock.tz);
298
- const endOrdinal = ordinalOf(end);
299
- const found = [];
300
- let cursor = { year: start.year, month: start.month, day: start.day };
301
- let scanned = 0;
302
- while (ordinalOf(cursor) <= endOrdinal && scanned < MAX_DAYS_SCANNED) {
303
- scanned += 1;
304
- if (isDueOn(clock, cursor)) {
305
- const at = zonedToUtc(cursor, hour, minute, clock.tz);
306
- if (at > after && at <= through) {
307
- found.push({ key: occurrenceKey(clock, cursor), at });
308
- if (found.length >= cap) break;
309
- }
310
- }
311
- cursor = nextDay(cursor);
312
- }
313
- return found;
314
- };
315
-
316
315
  // src/engine/match.ts
317
316
  var openRun = async (deps, loaded, input) => {
318
317
  const { reflex, version } = loaded;
@@ -362,8 +361,8 @@ var openRun = async (deps, loaded, input) => {
362
361
  var factAsRow = (fact) => ({ ...fact });
363
362
  var reflexMatchesFact = (loaded, fact) => {
364
363
  const { reflex } = loaded;
365
- if (fact.kind === "manual") return fact.target === reflex.id;
366
364
  if (fact.as !== reflex.as) return false;
365
+ if (fact.kind === "manual") return fact.target === reflex.id;
367
366
  if (!reflex.enabled) return false;
368
367
  if (fact.at < loaded.armedAt) return false;
369
368
  if (isManual(reflex.on)) return false;
@@ -378,13 +377,11 @@ var reflexMatchesFact = (loaded, fact) => {
378
377
  var matchFacts = async (deps, now, limit) => {
379
378
  const report = { factsMatched: 0, runsCreated: 0, parked: 0 };
380
379
  if (deps.reflexes().length === 0) return report;
381
- const due = await deps.store.query({
382
- table: "fact",
383
- where: { deliveredAt: { isNull: true }, parked: { isNull: true } },
384
- order: [{ by: "at" }],
385
- limit: limit * 4
386
- });
387
- for (const fact of due.filter((candidate) => (candidate.notBefore ?? candidate.at) <= now).slice(0, limit)) {
380
+ const waiting = { deliveredAt: { isNull: true }, parked: { isNull: true } };
381
+ const immediate = await deps.store.query({ table: "fact", where: { ...waiting, notBefore: { isNull: true }, at: { lte: now } }, order: [{ by: "at" }], limit });
382
+ const delayed = await deps.store.query({ table: "fact", where: { ...waiting, notBefore: { lte: now } }, order: [{ by: "at" }], limit });
383
+ const due = [...immediate, ...delayed].sort((left, right) => left.at - right.at).slice(0, limit);
384
+ for (const fact of due) {
388
385
  if (fact.depth > deps.maxChainDepth && fact.released !== true) {
389
386
  const reason = `chain depth ${fact.depth} exceeds maxChainDepth ${deps.maxChainDepth}`;
390
387
  await deps.store.cas("fact", fact.id, {}, { parked: reason });
@@ -478,127 +475,6 @@ var materializeClocks = async (deps, now) => {
478
475
  return report;
479
476
  };
480
477
 
481
- // src/engine/fanout.ts
482
- var collectRows = async (source, cap) => {
483
- const resolved = await source;
484
- const rows = [];
485
- if (Symbol.asyncIterator in Object(resolved)) {
486
- for await (const row of resolved) {
487
- rows.push(row);
488
- if (rows.length > cap) throw new TideError("duplicate_unit", `selection exceeded maxFanOut (${cap})`);
489
- }
490
- return rows;
491
- }
492
- for (const row of resolved) {
493
- rows.push(row);
494
- if (rows.length > cap) throw new TideError("duplicate_unit", `selection exceeded maxFanOut (${cap})`);
495
- }
496
- return rows;
497
- };
498
- var unitsFrom = (rows, unitKey, base, reflexId) => {
499
- const seen = /* @__PURE__ */ new Set();
500
- return rows.map((row) => {
501
- const raw = unitKey === void 0 ? void 0 : row[unitKey];
502
- const unit = raw === void 0 || raw === null ? "" : String(raw);
503
- if (seen.has(unit))
504
- throw new TideError("duplicate_unit", `${reflexId}: duplicate unit key "${unit}" \u2014 the selection's unitKey is not unique`);
505
- seen.add(unit);
506
- return { unit, env: { ...base, row } };
507
- });
508
- };
509
- var factRowsOf = async (deps, run) => {
510
- const ids = run.factIds ?? [];
511
- if (ids.length === 0) return [];
512
- return deps.store.query({ table: "fact", where: { id: { in: [...ids] } } });
513
- };
514
- var fanOut = async (deps, now, limit) => {
515
- let created = 0;
516
- const pending = await deps.store.query({
517
- table: "run",
518
- where: { state: "pending" },
519
- order: [{ by: "dueAt" }],
520
- limit
521
- });
522
- for (const run of pending) {
523
- const loaded = deps.find(run.reflexId);
524
- if (loaded === void 0) {
525
- await deps.store.cas("run", run.id, { state: "pending" }, { state: "skipped", settledAt: now, drained: true, note: "reflex is no longer loaded" });
526
- continue;
527
- }
528
- try {
529
- const facts = await factRowsOf(deps, run);
530
- const units = await unitsForRun(deps, loaded, shapeOf(run), facts, now);
531
- created += await commitFanout(deps, run, units.map((unit) => taskOf(unit, run, loaded, now)), units.length, now);
532
- } catch (error) {
533
- const reason = error instanceof Error ? error.message : String(error);
534
- if (isTideError(error)) {
535
- await deps.store.cas("run", run.id, { state: "pending" }, { state: "skipped", settledAt: now, drained: true, note: `fan-out refused: ${reason}` });
536
- deps.emit({ type: "run.skipped", reflexId: run.reflexId, reason });
537
- continue;
538
- }
539
- await deps.store.cas("run", run.id, { state: "pending" }, { note: `fan-out deferred: ${reason}` });
540
- deps.emit({ type: "run.deferred", reflexId: run.reflexId, runId: run.id, reason });
541
- }
542
- }
543
- return created;
544
- };
545
- var commitFanout = async (deps, run, tasks, selected, now) => deps.store.transact(async (tx) => {
546
- const claimed = await tx.cas("run", run.id, { state: "pending" }, { state: "fanned" });
547
- if (!claimed) return 0;
548
- let written = 0;
549
- for (const task of tasks) if (await tx.appendIfAbsent("task", task) !== void 0) written += 1;
550
- const settledNow = written === 0;
551
- await tx.cas(
552
- "run",
553
- run.id,
554
- {},
555
- {
556
- selected,
557
- total: written,
558
- state: settledNow ? "settled" : "fanned",
559
- settledAt: settledNow ? now : void 0
560
- }
561
- );
562
- return written;
563
- });
564
- var taskOf = (unit, run, loaded, now) => ({
565
- runId: run.id,
566
- reflexId: loaded.reflex.id,
567
- unit: unit.unit,
568
- cause: run.cause,
569
- env: unit.env,
570
- // Carried on the task: a swept run must not reset the chain ceiling.
571
- depth: run.depth,
572
- state: "pending",
573
- attempt: 0,
574
- claimedUntil: 0,
575
- notBefore: run.dueAt > now ? run.dueAt : now,
576
- createdAt: now
577
- });
578
- var shapeOf = (run) => ({ cause: run.cause, occurrence: run.occurrence, dueAt: run.dueAt });
579
- var unitsForRun = async (deps, loaded, run, facts, now) => {
580
- const { reflex } = loaded;
581
- const base = buildEnv({
582
- params: reflex.params,
583
- occurrence: run.occurrence === void 0 ? void 0 : { key: run.occurrence, at: run.dueAt },
584
- fact: facts.length === 1 ? { ...facts[0] } : void 0,
585
- facts: facts.length > 1 ? facts.map((fact) => ({ ...fact })) : void 0,
586
- now
587
- });
588
- const carried = facts.map((fact) => fact.row).filter((row) => row !== void 0);
589
- if (carried.length > 0 && reflex.select === void 0) return unitsFrom(carried, void 0, base, reflex.id);
590
- if (reflex.select === void 0) return [{ unit: "", env: base }];
591
- if (deps.select === void 0)
592
- throw new TideError("store", `${reflex.id} has a selection but no \`select\` seam is wired`);
593
- const query = evaluateTemplate(deps.transform, reflex.select.query, base);
594
- const rows = await collectRows(
595
- deps.select(query, { reflexId: reflex.id, now, actor: deps.actorFor(reflex.as), env: base }),
596
- deps.maxFanOut
597
- );
598
- if (reflex.select.mode === "batch") return [{ unit: "", env: { ...base, rows } }];
599
- return unitsFrom(rows, reflex.select.unitKey, base, reflex.id);
600
- };
601
-
602
478
  // src/engine/facts.ts
603
479
  var rootOf = async (store, cause) => {
604
480
  if (cause === void 0) return void 0;
@@ -652,6 +528,7 @@ var claimTasks = async (deps, now, limit, token) => {
652
528
  return deps.store.claim({
653
529
  table: "task",
654
530
  where: {
531
+ reflexId: { in: deps.reflexes().map((loaded) => loaded.reflex.id) },
655
532
  state: { in: ["pending", "retrying", "claimed"] },
656
533
  notBefore: { lte: now },
657
534
  claimedUntil: { lte: now }
@@ -664,7 +541,8 @@ var claimTasks = async (deps, now, limit, token) => {
664
541
  onePer: serialReflexIds.length === 0 ? void 0 : { column: "reflexId", held: { state: "claimed", claimedUntil: { gt: now } }, only: serialReflexIds }
665
542
  });
666
543
  };
667
- var executeTasks = async (deps, now, limit) => {
544
+ var leaseRenewed = async (deps, task, token, clock) => clock === void 0 || deps.store.cas("task", task.id, { token, attempt: task.attempt }, { claimedUntil: Math.max(task.claimedUntil, clock() + deps.leaseMs) });
545
+ var executeTasks = async (deps, now, limit, clock) => {
668
546
  const report = { executed: 0, succeeded: 0, failed: 0, retrying: 0, reclaimed: 0 };
669
547
  const lapsed = new Set(
670
548
  (await deps.store.query({
@@ -682,6 +560,7 @@ var executeTasks = async (deps, now, limit) => {
682
560
  }
683
561
  const loaded = deps.find(task.reflexId);
684
562
  if (loaded === void 0) continue;
563
+ if (!await leaseRenewed(deps, task, token, clock)) continue;
685
564
  const { reflex } = loaded;
686
565
  const registry = deps.effectsFor(reflex.as);
687
566
  const handler = registry[reflex.effect.name];
@@ -808,29 +687,164 @@ var reopenTask = async (deps, taskId, now) => deps.store.transact(async (tx) =>
808
687
  return true;
809
688
  });
810
689
  var settleRuns = async (deps, now) => {
811
- const settled = await deps.store.claim({
690
+ const settled = await deps.store.query({
812
691
  table: "run",
813
692
  where: { state: "settled", drained: { ne: true } },
814
693
  order: [{ by: "settledAt" }],
815
- limit: 200,
816
- set: { drained: true }
694
+ limit: 200
817
695
  });
696
+ let drained = 0;
818
697
  for (const run of settled) {
819
- deps.emit({ type: "run.settled", run });
820
- const admission = await admitFact(deps.store, {
821
- kind: "run",
822
- reflex: run.reflexId,
823
- runId: run.id,
824
- occurrence: run.occurrence,
825
- stats: { total: run.total, done: run.done, failed: run.failed },
826
- at: now,
827
- depth: run.depth + 1,
828
- cause: `run:${run.id}`,
829
- as: run.as
830
- }, deps.maxChainFacts);
698
+ const admission = await deps.store.transact(async (tx) => {
699
+ if (!await tx.cas("run", run.id, { state: "settled", drained: { ne: true } }, { drained: true })) return void 0;
700
+ return admitFact(tx, {
701
+ kind: "run",
702
+ reflex: run.reflexId,
703
+ runId: run.id,
704
+ occurrence: run.occurrence,
705
+ stats: { total: run.total, done: run.done, failed: run.failed },
706
+ at: now,
707
+ depth: run.depth + 1,
708
+ cause: `run:${run.id}`,
709
+ as: run.as
710
+ }, deps.maxChainFacts);
711
+ }).catch(() => void 0);
712
+ if (admission === void 0) continue;
713
+ drained += 1;
714
+ deps.emit({ type: "run.settled", run: { ...run, drained: true } });
831
715
  announceFact(deps.emit, admission);
832
716
  }
833
- return settled.length;
717
+ return drained;
718
+ };
719
+
720
+ // src/engine/fanout.ts
721
+ var collectRows = async (source, cap) => {
722
+ const resolved = await source;
723
+ const rows = [];
724
+ if (Symbol.asyncIterator in Object(resolved)) {
725
+ for await (const row of resolved) {
726
+ rows.push(row);
727
+ if (rows.length > cap) throw new TideError("duplicate_unit", `selection exceeded maxFanOut (${cap})`);
728
+ }
729
+ return rows;
730
+ }
731
+ for (const row of resolved) {
732
+ rows.push(row);
733
+ if (rows.length > cap) throw new TideError("duplicate_unit", `selection exceeded maxFanOut (${cap})`);
734
+ }
735
+ return rows;
736
+ };
737
+ var unitsFrom = (rows, unitKey, base, reflexId) => {
738
+ const seen = /* @__PURE__ */ new Set();
739
+ return rows.map((row) => {
740
+ const raw = unitKey === void 0 ? void 0 : row[unitKey];
741
+ const unit = raw === void 0 || raw === null ? "" : String(raw);
742
+ if (seen.has(unit))
743
+ throw new TideError("duplicate_unit", `${reflexId}: duplicate unit key "${unit}" \u2014 the selection's unitKey is not unique`);
744
+ seen.add(unit);
745
+ return { unit, env: { ...base, row } };
746
+ });
747
+ };
748
+ var factRowsOf = async (deps, run) => {
749
+ const ids = run.factIds ?? [];
750
+ if (ids.length === 0) return [];
751
+ return deps.store.query({ table: "fact", where: { id: { in: [...ids] } } });
752
+ };
753
+ var fanOut = async (deps, now, limit) => {
754
+ let created = 0;
755
+ if (!deps.hasLoaded()) return created;
756
+ if (deps.deferred.size > 0) {
757
+ const still = await deps.store.query({ table: "run", where: { id: { in: [...deps.deferred.keys()] }, state: "pending" } });
758
+ const pendingIds = new Set(still.map((run) => run.id));
759
+ for (const runId of deps.deferred.keys()) if (!pendingIds.has(runId)) deps.deferred.delete(runId);
760
+ }
761
+ const waiting = new Set(
762
+ [...deps.deferred].filter(([, deferral]) => deferral.until > now && deps.find(deferral.reflexId) !== void 0).map(([runId]) => runId)
763
+ );
764
+ const page = await deps.store.query({ table: "run", where: { state: "pending" }, order: [{ by: "dueAt" }], limit: limit + waiting.size });
765
+ const pending = page.filter((run) => !waiting.has(run.id)).slice(0, limit);
766
+ for (const run of pending) {
767
+ const loaded = deps.find(run.reflexId);
768
+ if (loaded === void 0) {
769
+ await deps.store.cas("run", run.id, { state: "pending" }, { state: "skipped", settledAt: now, drained: true, note: "reflex is no longer loaded" });
770
+ continue;
771
+ }
772
+ try {
773
+ const facts = await factRowsOf(deps, run);
774
+ const units = await unitsForRun(deps, loaded, shapeOf(run), facts, now);
775
+ created += await commitFanout(deps, run, units.map((unit) => taskOf(unit, run, loaded, now)), units.length, now);
776
+ } catch (error) {
777
+ const reason = error instanceof Error ? error.message : String(error);
778
+ if (isTideError(error)) {
779
+ await deps.store.cas("run", run.id, { state: "pending" }, { state: "skipped", settledAt: now, drained: true, note: `fan-out refused: ${reason}` });
780
+ deps.emit({ type: "run.skipped", reflexId: run.reflexId, reason });
781
+ continue;
782
+ }
783
+ await deps.store.cas("run", run.id, { state: "pending" }, { note: `fan-out deferred: ${reason}` });
784
+ const count = (deps.deferred.get(run.id)?.count ?? 0) + 1;
785
+ const retry = loaded.reflex.policy.retry;
786
+ const wait = backoffFor(Math.min(count, retry?.max ?? 3), retry?.baseMs ?? 6e4, retry?.backoff ?? "exponential");
787
+ deps.deferred.set(run.id, { reflexId: run.reflexId, count, until: now + Math.min(wait, Number.MAX_SAFE_INTEGER) });
788
+ deps.emit({ type: "run.deferred", reflexId: run.reflexId, runId: run.id, reason });
789
+ }
790
+ }
791
+ return created;
792
+ };
793
+ var commitFanout = async (deps, run, tasks, selected, now) => deps.store.transact(async (tx) => {
794
+ const claimed = await tx.cas("run", run.id, { state: "pending" }, { state: "fanned" });
795
+ if (!claimed) return 0;
796
+ let written = 0;
797
+ for (const task of tasks) if (await tx.appendIfAbsent("task", task) !== void 0) written += 1;
798
+ const settledNow = written === 0;
799
+ await tx.cas(
800
+ "run",
801
+ run.id,
802
+ {},
803
+ {
804
+ selected,
805
+ total: written,
806
+ state: settledNow ? "settled" : "fanned",
807
+ settledAt: settledNow ? now : void 0
808
+ }
809
+ );
810
+ return written;
811
+ });
812
+ var taskOf = (unit, run, loaded, now) => ({
813
+ runId: run.id,
814
+ reflexId: loaded.reflex.id,
815
+ unit: unit.unit,
816
+ cause: run.cause,
817
+ env: unit.env,
818
+ // Carried on the task: a swept run must not reset the chain ceiling.
819
+ depth: run.depth,
820
+ state: "pending",
821
+ attempt: 0,
822
+ claimedUntil: 0,
823
+ notBefore: run.dueAt > now ? run.dueAt : now,
824
+ createdAt: now
825
+ });
826
+ var shapeOf = (run) => ({ cause: run.cause, occurrence: run.occurrence, dueAt: run.dueAt });
827
+ var unitsForRun = async (deps, loaded, run, facts, now) => {
828
+ const { reflex } = loaded;
829
+ const base = buildEnv({
830
+ params: reflex.params,
831
+ occurrence: run.occurrence === void 0 ? void 0 : { key: run.occurrence, at: run.dueAt },
832
+ fact: facts.length === 1 ? { ...facts[0] } : void 0,
833
+ facts: facts.length > 1 ? facts.map((fact) => ({ ...fact })) : void 0,
834
+ now
835
+ });
836
+ const carried = facts.map((fact) => fact.row).filter((row) => row !== void 0);
837
+ if (carried.length > 0 && reflex.select === void 0) return unitsFrom(carried, void 0, base, reflex.id);
838
+ if (reflex.select === void 0) return [{ unit: "", env: base }];
839
+ if (deps.select === void 0)
840
+ throw new TideError("store", `${reflex.id} has a selection but no \`select\` seam is wired`);
841
+ const query = evaluateTemplate(deps.transform, reflex.select.query, base);
842
+ const rows = await collectRows(
843
+ deps.select(query, { reflexId: reflex.id, now, actor: deps.actorFor(reflex.as), env: base }),
844
+ deps.maxFanOut
845
+ );
846
+ if (reflex.select.mode === "batch") return [{ unit: "", env: { ...base, rows } }];
847
+ return unitsFrom(rows, reflex.select.unitKey, base, reflex.id);
834
848
  };
835
849
 
836
850
  // src/engine/advance.ts
@@ -841,7 +855,7 @@ var runAdvance = async (deps, options) => {
841
855
  const clocks = await materializeClocks(deps, now);
842
856
  const matched = await matchFacts(deps, now, limit);
843
857
  const tasksCreated = await fanOut(deps, now, limit);
844
- const executed = await executeTasks(deps, now, limit);
858
+ const executed = await executeTasks(deps, now, limit, options.clock);
845
859
  const runsSettled = await settleRuns(deps, now);
846
860
  return {
847
861
  now,
@@ -884,19 +898,20 @@ var nextDue = async (deps, now) => {
884
898
  consider(delayed?.notBefore);
885
899
  const [run] = await deps.store.query({ table: "run", where: { state: "pending" }, order: [{ by: "dueAt" }], limit: 1 });
886
900
  consider(run?.dueAt);
901
+ const loaded = { in: deps.reflexes().map((entry) => entry.reflex.id) };
887
902
  const [waiting] = await deps.store.query({
888
903
  table: "task",
889
- where: { state: { in: ["pending", "retrying"] } },
904
+ where: { reflexId: loaded, state: { in: ["pending", "retrying"] } },
890
905
  order: [{ by: "notBefore" }],
891
906
  limit: 1
892
907
  });
893
908
  consider(waiting?.notBefore);
894
- const [claimed] = await deps.store.query({ table: "task", where: { state: "claimed" }, order: [{ by: "claimedUntil" }], limit: 1 });
909
+ const [claimed] = await deps.store.query({ table: "task", where: { reflexId: loaded, state: "claimed" }, order: [{ by: "claimedUntil" }], limit: 1 });
895
910
  consider(claimed?.claimedUntil);
896
- for (const loaded of deps.reflexes()) {
897
- const clock = clockOf(loaded.reflex.on);
911
+ for (const loaded2 of deps.reflexes()) {
912
+ const clock = clockOf(loaded2.reflex.on);
898
913
  if (clock !== void 0) {
899
- const state = await stateOf(deps, loaded.reflex.id);
914
+ const state = await stateOf(deps, loaded2.reflex.id);
900
915
  if (state?.materializedThrough === void 0) {
901
916
  consider(now);
902
917
  continue;
@@ -977,6 +992,20 @@ var DEFAULT_MAX_CHAIN_DEPTH = 24;
977
992
  var DEFAULT_MAX_CHAIN_FACTS = 1e4;
978
993
  var DEFAULT_MAX_FAN_OUT = 1e4;
979
994
  var DEFAULT_LEASE_MS = 3e5;
995
+ var missingDateWarnings = (reflex) => {
996
+ const clock = clockOf(reflex.on);
997
+ if (clock === void 0 || isRecurring(clock)) return [];
998
+ const named = clock.at.slice(0, 10);
999
+ const [year = 0, month = 0, day = 0] = named.split("-").map(Number);
1000
+ const asWritten = /* @__PURE__ */ new Date(0);
1001
+ asWritten.setUTCFullYear(year, month - 1, day);
1002
+ if (asWritten.getUTCFullYear() === year && asWritten.getUTCMonth() === month - 1 && asWritten.getUTCDate() === day) return [];
1003
+ const [fires] = occurrencesBetween(clock, -Infinity, Infinity, 1);
1004
+ if (fires === void 0) return [];
1005
+ const local = zonedParts(fires.at, clock.tz);
1006
+ const on = [local.year, local.month, local.day].map((part, index) => String(part).padStart(index === 0 ? 4 : 2, "0")).join("-");
1007
+ return [`${reflex.id}: clock.at names ${named}, which does not exist \u2014 it fires on ${on}`];
1008
+ };
980
1009
  var createTide = (config) => {
981
1010
  const loaded = /* @__PURE__ */ new Map();
982
1011
  let effectsCache;
@@ -986,6 +1015,7 @@ var createTide = (config) => {
986
1015
  return effectsCache;
987
1016
  };
988
1017
  let tokens = 0;
1018
+ let hasLoaded = false;
989
1019
  const deps = {
990
1020
  store: config.store,
991
1021
  transform: config.transform,
@@ -998,13 +1028,22 @@ var createTide = (config) => {
998
1028
  leaseMs: config.leaseMs ?? DEFAULT_LEASE_MS,
999
1029
  emit: config.onEvent ?? (() => void 0),
1000
1030
  reflexes: () => [...loaded.values()],
1031
+ hasLoaded: () => hasLoaded,
1001
1032
  find: (id) => loaded.get(id),
1002
1033
  nextToken: () => {
1003
1034
  tokens += 1;
1004
1035
  return `tok_${tokens.toString(36)}`;
1005
- }
1036
+ },
1037
+ deferred: /* @__PURE__ */ new Map()
1038
+ };
1039
+ const everLoaded = /* @__PURE__ */ new Set();
1040
+ let lastLoad = Promise.resolve();
1041
+ const load = (input, options) => {
1042
+ const turn = lastLoad.then(() => loadNow(input, options));
1043
+ lastLoad = turn.catch(() => void 0);
1044
+ return turn;
1006
1045
  };
1007
- const load = async (input, options) => {
1046
+ const loadNow = async (input, options) => {
1008
1047
  const { reflexes: parsed, graph, refused } = admitReflexes({ input, effectsOf: mergedEffects, isolate: options?.isolate === true });
1009
1048
  const previously = new Set(loaded.keys());
1010
1049
  const next = /* @__PURE__ */ new Map();
@@ -1012,13 +1051,19 @@ var createTide = (config) => {
1012
1051
  const stored = await stateOf(deps, reflex.id);
1013
1052
  const armedAt = stored?.armedAt ?? options?.at ?? 0;
1014
1053
  if (stored === void 0) await config.store.appendIfAbsent("state", { reflexId: reflex.id, armedAt });
1015
- if (!previously.has(reflex.id) && stored?.materializedThrough !== void 0 && options?.at !== void 0)
1054
+ const entering = !previously.has(reflex.id) && (options?.resume !== true || everLoaded.has(reflex.id));
1055
+ if (entering && stored?.materializedThrough !== void 0 && options?.at !== void 0)
1016
1056
  await config.store.cas("state", reflex.id, {}, { materializedThrough: Math.max(stored.materializedThrough, options.at) });
1017
1057
  next.set(reflex.id, { reflex, version: versionOf(reflex), armedAt });
1018
1058
  }
1019
1059
  loaded.clear();
1020
1060
  for (const [id, entry] of next) loaded.set(id, entry);
1021
- return { loaded: parsed.length, cycles: graph.cycles, blind: graph.blind, warnings: graph.warnings, refused };
1061
+ for (const id of next.keys()) everLoaded.add(id);
1062
+ hasLoaded = true;
1063
+ const leaseWarnings = parsed.filter((reflex) => reflex.policy.timeoutMs >= deps.leaseMs).map(
1064
+ (reflex) => `${reflex.id}: timeoutMs ${reflex.policy.timeoutMs} is not shorter than leaseMs ${deps.leaseMs} \u2014 another instance may claim the task again while its effect still runs`
1065
+ );
1066
+ return { loaded: parsed.length, cycles: graph.cycles, blind: graph.blind, warnings: [...graph.warnings, ...leaseWarnings, ...parsed.flatMap(missingDateWarnings)], refused };
1022
1067
  };
1023
1068
  const mergedEffects = (parsed) => {
1024
1069
  if (typeof config.effects !== "function") return config.effects ?? {};
@@ -1043,6 +1088,7 @@ var createTide = (config) => {
1043
1088
  throw new TideError("invalid_fact", `fact did not parse: ${result.error.issues.map((i) => i.message).join("; ")}`, {
1044
1089
  issues: result.error.issues
1045
1090
  });
1091
+ if (result.data.kind === "run") throw new TideError("invalid_fact", "a run fact is minted by tide when a run settles; it is not ingested");
1046
1092
  if (!watchable(result.data)) return void 0;
1047
1093
  const admission = await admitFact(config.store, { ...result.data, cause: options?.cause, depth: options?.depth ?? 0, as: options?.as }, deps.maxChainFacts);
1048
1094
  announceFact(deps.emit, admission);
@@ -1102,13 +1148,12 @@ var createTide = (config) => {
1102
1148
  }),
1103
1149
  task: (id) => one("task", id),
1104
1150
  facts: async (filter) => {
1105
- const found = await config.store.query({
1106
- table: "fact",
1107
- order: [{ by: "at", dir: "desc" }],
1108
- limit: filter?.reflexId === void 0 ? filter?.limit : void 0
1109
- });
1110
- const matched = filter?.reflexId === void 0 ? found : found.filter((fact) => fact.reflex === filter.reflexId || fact.target === filter.reflexId);
1111
- return filter?.limit === void 0 ? matched : matched.slice(0, filter.limit);
1151
+ const newest = { order: [{ by: "at", dir: "desc" }], limit: filter?.limit };
1152
+ if (filter?.reflexId === void 0) return config.store.query({ table: "fact", ...newest });
1153
+ const minted = await config.store.query({ table: "fact", where: { reflex: filter.reflexId }, ...newest });
1154
+ const aimed = await config.store.query({ table: "fact", where: { target: filter.reflexId }, ...newest });
1155
+ const matched = [...new Map([...minted, ...aimed].map((fact) => [fact.id, fact])).values()].sort((left, right) => right.at - left.at);
1156
+ return filter.limit === void 0 ? matched : matched.slice(0, filter.limit);
1112
1157
  },
1113
1158
  fact: (id) => one("fact", id),
1114
1159
  causeChain,
@@ -1224,26 +1269,31 @@ var createMemoryStore = () => {
1224
1269
  spec.order
1225
1270
  );
1226
1271
  const taken = /* @__PURE__ */ new Set();
1227
- const restricted = new Set(spec.onePer?.only ?? []);
1272
+ const restricted = spec.onePer?.only ?? [];
1228
1273
  if (spec.onePer !== void 0) {
1229
1274
  for (const row of rowsOf(spec.table))
1230
1275
  if (matches(row, spec.onePer.held)) taken.add(String(row[spec.onePer.column]));
1231
1276
  }
1232
- const claimed = [];
1277
+ const groupOf = (row) => spec.onePer === void 0 ? void 0 : String(row[spec.onePer.column]);
1278
+ const chosen = [];
1279
+ for (const group of restricted) {
1280
+ if (chosen.length >= spec.limit) break;
1281
+ if (taken.has(group)) continue;
1282
+ const first = candidates.find((row) => groupOf(row) === group);
1283
+ if (first === void 0) continue;
1284
+ taken.add(group);
1285
+ chosen.push(first);
1286
+ }
1233
1287
  for (const row of candidates) {
1234
- if (claimed.length >= spec.limit) break;
1235
- if (spec.onePer !== void 0) {
1236
- const group = String(row[spec.onePer.column]);
1237
- if (restricted.has(group)) {
1238
- if (taken.has(group)) continue;
1239
- taken.add(group);
1240
- }
1241
- }
1288
+ if (chosen.length >= spec.limit) break;
1289
+ const group = groupOf(row);
1290
+ if (group === void 0 || !restricted.includes(group)) chosen.push(row);
1291
+ }
1292
+ return sorted(chosen, spec.order).map((row) => {
1242
1293
  const next = applied(row, spec.set);
1243
1294
  tables[spec.table].set(keyOf(spec.table, next), next);
1244
- claimed.push(next);
1245
- }
1246
- return claimed;
1295
+ return next;
1296
+ });
1247
1297
  };
1248
1298
  const cas = async (table, id, expect, set) => {
1249
1299
  const row = tables[table].get(id);
@@ -1305,7 +1355,7 @@ var createTideDriver = (config) => {
1305
1355
  let timer;
1306
1356
  const drain = async () => {
1307
1357
  for (let steps = 0; steps < MAX_STEPS_PER_DRAIN; steps += 1) {
1308
- const report = await tide.advance({ now: now() });
1358
+ const report = await tide.advance({ now: now(), clock: now });
1309
1359
  if (progressOf(report) === 0) return;
1310
1360
  }
1311
1361
  console.error(`[tide:driver] a drain exceeded ${MAX_STEPS_PER_DRAIN} steps \u2014 stopping this pass; the janitor will resume it`);