@shware/workflow 0.0.0-stage → 0.0.0

package/dist/engine/time-scale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-scale.cjs","names":[],"sources":["../../src/engine/time-scale.ts"],"sourcesContent":["/**\n * Debug time scale: divide every duration in a workflow's IR by a factor so a\n * journey written in days plays out in seconds — with a factor of 3600, a\n * `delay('2 days')` sleeps 48 s, a `waitUntil(..., { timeout: '3 days' })`\n * gives up after 72 s, and a goal `within: '30 days'` closes after 12 min.\n *\n * Everything that is a Duration scales together (delays, random delays, wait\n * timeouts, goal and `performed(... within)` windows inside the workflow), so\n * the journey keeps its shape, just faster. What does not scale: wall-clock\n * `timeWindow`s (they are times of day, not durations). Segment definitions\n * live in the store rather than the workflow body; `scaleSegmentWindows`\n * scales them as they are read, so a segment's `within` keeps pace too.\n *\n * Durations are recognised structurally — an object whose only keys are\n * `value` (the source text) and `ms` — which is the DurationIR shape and\n * nothing else in the IR. The text is kept so the studio still shows what was\n * written.\n */\nexport function scaleDurations<T>(ir: T, factor: number): T {\n  if (!(factor > 0) || factor === 1) return ir;\n  return walk(ir, factor) as T;\n}\n\nfunction walk(value: unknown, factor: number): unknown {\n  if (Array.isArray(value)) return value.map((item) => walk(item, factor));\n  if (value === null || typeof value !== 'object') return value;\n  const record = value as Record<string, unknown>;\n  const keys = Object.keys(record);\n  if (keys.length === 2 && typeof record.value === 'string' && typeof record.ms === 'number') {\n    return { value: record.value, ms: Math.max(0, Math.round(record.ms / factor)) };\n  }\n  return Object.fromEntries(keys.map((key) => [key, walk(record[key], factor)]));\n}\n\n/**\n * A store whose segment definitions come back scaled by `factor` — what journeyWorker reads\n * through in fast-forward, so a segment's windows (`performed(e.login, { within: '7 days' })`)\n * shrink with the journeys that reference it, and with the segment triggers it routes. Every\n * other method is the store's own.\n */\nexport function scaleSegmentWindows<\n  S extends { getSegmentCondition(name: string): Promise<unknown> },\n>(store: S, factor: number): S {\n  if (!(factor > 0) || factor === 1) return store;\n  return new Proxy(store, {\n    get(target, property) {\n      if (property === 'getSegmentCondition') {\n        return async (name: string) =>\n          scaleDurations(await target.getSegmentCondition(name), factor);\n      }\n      const value: unknown = Reflect.get(target, property, target);\n      return typeof value === 'function' ? value.bind(target) : value;\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,eAAkB,IAAO,QAAmB;CAC1D,IAAI,EAAE,SAAS,MAAM,WAAW,GAAG,OAAO;CAC1C,OAAO,KAAK,IAAI,MAAM;AACxB;AAEA,SAAS,KAAK,OAAgB,QAAyB;CACrD,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,KAAK,SAAS,KAAK,MAAM,MAAM,CAAC;CACvE,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO;CACxD,MAAM,SAAS;CACf,MAAM,OAAO,OAAO,KAAK,MAAM;CAC/B,IAAI,KAAK,WAAW,KAAK,OAAO,OAAO,UAAU,YAAY,OAAO,OAAO,OAAO,UAChF,OAAO;EAAE,OAAO,OAAO;EAAO,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,KAAK,MAAM,CAAC;CAAE;CAEhF,OAAO,OAAO,YAAY,KAAK,KAAK,QAAQ,CAAC,KAAK,KAAK,OAAO,MAAM,MAAM,CAAC,CAAC,CAAC;AAC/E;;;;;;;AAQA,SAAgB,oBAEd,OAAU,QAAmB;CAC7B,IAAI,EAAE,SAAS,MAAM,WAAW,GAAG,OAAO;CAC1C,OAAO,IAAI,MAAM,OAAO,EACtB,IAAI,QAAQ,UAAU;EACpB,IAAI,aAAa,uBACf,OAAO,OAAO,SACZ,eAAe,MAAM,OAAO,oBAAoB,IAAI,GAAG,MAAM;EAEjE,MAAM,QAAiB,QAAQ,IAAI,QAAQ,UAAU,MAAM;EAC3D,OAAO,OAAO,UAAU,aAAa,MAAM,KAAK,MAAM,IAAI;CAC5D,EACF,CAAC;AACH"}

package/dist/engine/time-scale.d.cts

@@ -0,0 +1,31 @@
+//#region src/engine/time-scale.d.ts
+/**
+ * Debug time scale: divide every duration in a workflow's IR by a factor so a
+ * journey written in days plays out in seconds — with a factor of 3600, a
+ * `delay('2 days')` sleeps 48 s, a `waitUntil(..., { timeout: '3 days' })`
+ * gives up after 72 s, and a goal `within: '30 days'` closes after 12 min.
+ *
+ * Everything that is a Duration scales together (delays, random delays, wait
+ * timeouts, goal and `performed(... within)` windows inside the workflow), so
+ * the journey keeps its shape, just faster. What does not scale: wall-clock
+ * `timeWindow`s (they are times of day, not durations). Segment definitions
+ * live in the store rather than the workflow body; `scaleSegmentWindows`
+ * scales them as they are read, so a segment's `within` keeps pace too.
+ *
+ * Durations are recognised structurally — an object whose only keys are
+ * `value` (the source text) and `ms` — which is the DurationIR shape and
+ * nothing else in the IR. The text is kept so the studio still shows what was
+ * written.
+ */
+export declare function scaleDurations<T>(ir: T, factor: number): T;
+/**
+ * A store whose segment definitions come back scaled by `factor` — what journeyWorker reads
+ * through in fast-forward, so a segment's windows (`performed(e.login, { within: '7 days' })`)
+ * shrink with the journeys that reference it, and with the segment triggers it routes. Every
+ * other method is the store's own.
+ */
+export declare function scaleSegmentWindows<S extends {
+  getSegmentCondition(name: string): Promise<unknown>;
+}>(store: S, factor: number): S;
+//#endregion
+//# sourceMappingURL=time-scale.d.cts.map

package/dist/engine/time-scale.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-scale.d.cts","names":[],"sources":["../../src/engine/time-scale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;wBAkBgB,eAAe,GAAG,IAAI,GAAG,iBAAiB;;;;;;;wBAsB1C,oBACd;EAAY,oBAAoB,eAAe;GAC/C,OAAO,GAAG,iBAAiB"}

package/dist/engine/time-scale.d.mts

@@ -0,0 +1,31 @@
+//#region src/engine/time-scale.d.ts
+/**
+ * Debug time scale: divide every duration in a workflow's IR by a factor so a
+ * journey written in days plays out in seconds — with a factor of 3600, a
+ * `delay('2 days')` sleeps 48 s, a `waitUntil(..., { timeout: '3 days' })`
+ * gives up after 72 s, and a goal `within: '30 days'` closes after 12 min.
+ *
+ * Everything that is a Duration scales together (delays, random delays, wait
+ * timeouts, goal and `performed(... within)` windows inside the workflow), so
+ * the journey keeps its shape, just faster. What does not scale: wall-clock
+ * `timeWindow`s (they are times of day, not durations). Segment definitions
+ * live in the store rather than the workflow body; `scaleSegmentWindows`
+ * scales them as they are read, so a segment's `within` keeps pace too.
+ *
+ * Durations are recognised structurally — an object whose only keys are
+ * `value` (the source text) and `ms` — which is the DurationIR shape and
+ * nothing else in the IR. The text is kept so the studio still shows what was
+ * written.
+ */
+export declare function scaleDurations<T>(ir: T, factor: number): T;
+/**
+ * A store whose segment definitions come back scaled by `factor` — what journeyWorker reads
+ * through in fast-forward, so a segment's windows (`performed(e.login, { within: '7 days' })`)
+ * shrink with the journeys that reference it, and with the segment triggers it routes. Every
+ * other method is the store's own.
+ */
+export declare function scaleSegmentWindows<S extends {
+  getSegmentCondition(name: string): Promise<unknown>;
+}>(store: S, factor: number): S;
+//#endregion
+//# sourceMappingURL=time-scale.d.mts.map

package/dist/engine/time-scale.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-scale.d.mts","names":[],"sources":["../../src/engine/time-scale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;wBAkBgB,eAAe,GAAG,IAAI,GAAG,iBAAiB;;;;;;;wBAsB1C,oBACd;EAAY,oBAAoB,eAAe;GAC/C,OAAO,GAAG,iBAAiB"}

package/dist/engine/time-scale.mjs

@@ -0,0 +1,52 @@
+//#region src/engine/time-scale.ts
+/**
+* Debug time scale: divide every duration in a workflow's IR by a factor so a
+* journey written in days plays out in seconds — with a factor of 3600, a
+* `delay('2 days')` sleeps 48 s, a `waitUntil(..., { timeout: '3 days' })`
+* gives up after 72 s, and a goal `within: '30 days'` closes after 12 min.
+*
+* Everything that is a Duration scales together (delays, random delays, wait
+* timeouts, goal and `performed(... within)` windows inside the workflow), so
+* the journey keeps its shape, just faster. What does not scale: wall-clock
+* `timeWindow`s (they are times of day, not durations). Segment definitions
+* live in the store rather than the workflow body; `scaleSegmentWindows`
+* scales them as they are read, so a segment's `within` keeps pace too.
+*
+* Durations are recognised structurally — an object whose only keys are
+* `value` (the source text) and `ms` — which is the DurationIR shape and
+* nothing else in the IR. The text is kept so the studio still shows what was
+* written.
+*/
+function scaleDurations(ir, factor) {
+	if (!(factor > 0) || factor === 1) return ir;
+	return walk(ir, factor);
+}
+function walk(value, factor) {
+	if (Array.isArray(value)) return value.map((item) => walk(item, factor));
+	if (value === null || typeof value !== "object") return value;
+	const record = value;
+	const keys = Object.keys(record);
+	if (keys.length === 2 && typeof record.value === "string" && typeof record.ms === "number") return {
+		value: record.value,
+		ms: Math.max(0, Math.round(record.ms / factor))
+	};
+	return Object.fromEntries(keys.map((key) => [key, walk(record[key], factor)]));
+}
+/**
+* A store whose segment definitions come back scaled by `factor` — what journeyWorker reads
+* through in fast-forward, so a segment's windows (`performed(e.login, { within: '7 days' })`)
+* shrink with the journeys that reference it, and with the segment triggers it routes. Every
+* other method is the store's own.
+*/
+function scaleSegmentWindows(store, factor) {
+	if (!(factor > 0) || factor === 1) return store;
+	return new Proxy(store, { get(target, property) {
+		if (property === "getSegmentCondition") return async (name) => scaleDurations(await target.getSegmentCondition(name), factor);
+		const value = Reflect.get(target, property, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+//#endregion
+export { scaleDurations, scaleSegmentWindows };
+
+//# sourceMappingURL=time-scale.mjs.map

package/dist/engine/time-scale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-scale.mjs","names":[],"sources":["../../src/engine/time-scale.ts"],"sourcesContent":["/**\n * Debug time scale: divide every duration in a workflow's IR by a factor so a\n * journey written in days plays out in seconds — with a factor of 3600, a\n * `delay('2 days')` sleeps 48 s, a `waitUntil(..., { timeout: '3 days' })`\n * gives up after 72 s, and a goal `within: '30 days'` closes after 12 min.\n *\n * Everything that is a Duration scales together (delays, random delays, wait\n * timeouts, goal and `performed(... within)` windows inside the workflow), so\n * the journey keeps its shape, just faster. What does not scale: wall-clock\n * `timeWindow`s (they are times of day, not durations). Segment definitions\n * live in the store rather than the workflow body; `scaleSegmentWindows`\n * scales them as they are read, so a segment's `within` keeps pace too.\n *\n * Durations are recognised structurally — an object whose only keys are\n * `value` (the source text) and `ms` — which is the DurationIR shape and\n * nothing else in the IR. The text is kept so the studio still shows what was\n * written.\n */\nexport function scaleDurations<T>(ir: T, factor: number): T {\n  if (!(factor > 0) || factor === 1) return ir;\n  return walk(ir, factor) as T;\n}\n\nfunction walk(value: unknown, factor: number): unknown {\n  if (Array.isArray(value)) return value.map((item) => walk(item, factor));\n  if (value === null || typeof value !== 'object') return value;\n  const record = value as Record<string, unknown>;\n  const keys = Object.keys(record);\n  if (keys.length === 2 && typeof record.value === 'string' && typeof record.ms === 'number') {\n    return { value: record.value, ms: Math.max(0, Math.round(record.ms / factor)) };\n  }\n  return Object.fromEntries(keys.map((key) => [key, walk(record[key], factor)]));\n}\n\n/**\n * A store whose segment definitions come back scaled by `factor` — what journeyWorker reads\n * through in fast-forward, so a segment's windows (`performed(e.login, { within: '7 days' })`)\n * shrink with the journeys that reference it, and with the segment triggers it routes. Every\n * other method is the store's own.\n */\nexport function scaleSegmentWindows<\n  S extends { getSegmentCondition(name: string): Promise<unknown> },\n>(store: S, factor: number): S {\n  if (!(factor > 0) || factor === 1) return store;\n  return new Proxy(store, {\n    get(target, property) {\n      if (property === 'getSegmentCondition') {\n        return async (name: string) =>\n          scaleDurations(await target.getSegmentCondition(name), factor);\n      }\n      const value: unknown = Reflect.get(target, property, target);\n      return typeof value === 'function' ? value.bind(target) : value;\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,eAAkB,IAAO,QAAmB;CAC1D,IAAI,EAAE,SAAS,MAAM,WAAW,GAAG,OAAO;CAC1C,OAAO,KAAK,IAAI,MAAM;AACxB;AAEA,SAAS,KAAK,OAAgB,QAAyB;CACrD,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,KAAK,SAAS,KAAK,MAAM,MAAM,CAAC;CACvE,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO;CACxD,MAAM,SAAS;CACf,MAAM,OAAO,OAAO,KAAK,MAAM;CAC/B,IAAI,KAAK,WAAW,KAAK,OAAO,OAAO,UAAU,YAAY,OAAO,OAAO,OAAO,UAChF,OAAO;EAAE,OAAO,OAAO;EAAO,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,KAAK,MAAM,CAAC;CAAE;CAEhF,OAAO,OAAO,YAAY,KAAK,KAAK,QAAQ,CAAC,KAAK,KAAK,OAAO,MAAM,MAAM,CAAC,CAAC,CAAC;AAC/E;;;;;;;AAQA,SAAgB,oBAEd,OAAU,QAAmB;CAC7B,IAAI,EAAE,SAAS,MAAM,WAAW,GAAG,OAAO;CAC1C,OAAO,IAAI,MAAM,OAAO,EACtB,IAAI,QAAQ,UAAU;EACpB,IAAI,aAAa,uBACf,OAAO,OAAO,SACZ,eAAe,MAAM,OAAO,oBAAoB,IAAI,GAAG,MAAM;EAEjE,MAAM,QAAiB,QAAQ,IAAI,QAAQ,UAAU,MAAM;EAC3D,OAAO,OAAO,UAAU,aAAa,MAAM,KAAK,MAAM,IAAI;CAC5D,EACF,CAAC;AACH"}

package/dist/engine/time-window.cjs

@@ -0,0 +1,149 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/engine/time-window.ts
+/**
+* Time-window scheduling — when does the next send window open?
+*
+* Pure functions of (nowMs, days, between, tz): the interpreter calls them
+* inside a durable step, so the answer is checkpointed and replay-safe.
+* Timezone math goes through Intl.DateTimeFormat (available in Node, workerd
+* and browsers alike) — no tz database dependency. An unknown timezone falls
+* back to UTC rather than failing the journey.
+*/
+const DAY_MS = 864e5;
+/** Indexed by Date#getUTCDay, matching WeekdayIR's lowercase three-letter form. */
+const WEEKDAYS = [
+	"sun",
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat"
+];
+const formatters = /* @__PURE__ */ new Map();
+/** Cached per-timezone formatter; throws on an invalid timezone id. */
+function formatterFor(tz) {
+	let dtf = formatters.get(tz);
+	if (dtf === void 0) {
+		dtf = new Intl.DateTimeFormat("en-US", {
+			timeZone: tz,
+			hourCycle: "h23",
+			year: "numeric",
+			month: "numeric",
+			day: "numeric",
+			hour: "numeric",
+			minute: "numeric"
+		});
+		formatters.set(tz, dtf);
+	}
+	return dtf;
+}
+/** Validate a timezone id, falling back to UTC — a bad profile value must not wedge the journey. */
+function resolveTimeZone(tz) {
+	try {
+		formatterFor(tz);
+		return tz;
+	} catch {
+		return "UTC";
+	}
+}
+function localParts(ms, tz) {
+	const parts = {};
+	for (const part of formatterFor(tz).formatToParts(new Date(ms))) parts[part.type] = part.value;
+	return {
+		year: Number(parts.year),
+		month: Number(parts.month),
+		day: Number(parts.day),
+		hour: Number(parts.hour),
+		minute: Number(parts.minute)
+	};
+}
+/** The zone's UTC offset at an instant, as (wall clock read as if it were UTC) − instant. */
+function offsetMsAt(ts, tz) {
+	const p = localParts(ts, tz);
+	return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute) - ts;
+}
+/**
+* The first instant at or after `before` whose offset differs from the one
+* there — i.e. the DST transition separating the two bounds. Bisects on the
+* minute grid, the finest granularity any tz rule uses, so the loop lands on
+* the transition itself rather than merely near it.
+*/
+function transitionBetween(before, after, tz) {
+	const startOffset = offsetMsAt(before, tz);
+	let lo = before;
+	let hi = after;
+	while (hi - lo > 6e4) {
+		const mid = lo + Math.floor((hi - lo) / 12e4) * 6e4;
+		if (offsetMsAt(mid, tz) === startOffset) lo = mid;
+		else hi = mid;
+	}
+	return hi;
+}
+/**
+* The UTC instant at which the wall clock in `tz` reads y-m-d hh:mm.
+*
+* Guess the UTC value from the offset at the guess, read it back through the
+* timezone and correct by the difference; a second pass settles every wall
+* time that exists, and picks the earlier of the two when a fall-back repeats
+* an hour.
+*
+* A wall time inside a spring-forward gap exists on no clock, so the two
+* corrections straddle the transition and neither reads back as asked. The
+* convention here is the usual one: move forward to the first instant that
+* does exist, i.e. the transition itself — 02:30 on a US spring-forward day
+* resolves to 03:00. Without that branch the correction bottoms out on the low
+* side and the window opens an hour *before* its configured start.
+*/
+function zonedInstant(year, month, day, hour, minute, tz) {
+	const target = Date.UTC(year, month - 1, day, hour, minute);
+	const first = target - offsetMsAt(target, tz);
+	if (offsetMsAt(first, tz) === target - first) return first;
+	const second = target - offsetMsAt(first, tz);
+	if (offsetMsAt(second, tz) === target - second) return second;
+	return transitionBetween(Math.min(first, second), Math.max(first, second), tz);
+}
+const TIME = /^(\d{1,2}):(\d{2})$/;
+function parseTime(value) {
+	const match = TIME.exec(value);
+	if (!match) return null;
+	const hh = Number(match[1]);
+	const mm = Number(match[2]);
+	if (hh > 23 || mm > 59) return null;
+	return {
+		hh,
+		mm
+	};
+}
+/**
+* The instant the next [start, end) window opens in `tz`, or null when nowMs
+* is already inside a window. Scans nine calendar days so every weekday is
+* reachable. Malformed times (the DSL validates its own input, but IR may come
+* from elsewhere) disable the window — better to send now than to hold a user
+* forever on a config typo.
+*/
+function nextWindowStart(nowMs, days, between, tz) {
+	const start = parseTime(between[0]);
+	const end = parseTime(between[1]);
+	if (start === null || end === null) return null;
+	const zone = resolveTimeZone(tz);
+	const today = localParts(nowMs, zone);
+	const firstDay = Date.UTC(today.year, today.month - 1, today.day);
+	for (let offset = 0; offset < 9; offset++) {
+		const date = new Date(firstDay + offset * DAY_MS);
+		if (!days.includes(WEEKDAYS[date.getUTCDay()])) continue;
+		const year = date.getUTCFullYear();
+		const month = date.getUTCMonth() + 1;
+		const day = date.getUTCDate();
+		const opensAt = zonedInstant(year, month, day, start.hh, start.mm, zone);
+		const closesAt = zonedInstant(year, month, day, end.hh, end.mm, zone);
+		if (nowMs < opensAt) return opensAt;
+		if (nowMs < closesAt) return null;
+	}
+	return null;
+}
+//#endregion
+exports.nextWindowStart = nextWindowStart;
+exports.resolveTimeZone = resolveTimeZone;
+
+//# sourceMappingURL=time-window.cjs.map

package/dist/engine/time-window.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-window.cjs","names":[],"sources":["../../src/engine/time-window.ts"],"sourcesContent":["/**\n * Time-window scheduling — when does the next send window open?\n *\n * Pure functions of (nowMs, days, between, tz): the interpreter calls them\n * inside a durable step, so the answer is checkpointed and replay-safe.\n * Timezone math goes through Intl.DateTimeFormat (available in Node, workerd\n * and browsers alike) — no tz database dependency. An unknown timezone falls\n * back to UTC rather than failing the journey.\n */\n\nconst DAY_MS = 86_400_000;\n\n/** Indexed by Date#getUTCDay, matching WeekdayIR's lowercase three-letter form. */\nconst WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];\n\ninterface LocalParts {\n  year: number;\n  month: number;\n  day: number;\n  hour: number;\n  minute: number;\n}\n\nconst formatters = new Map<string, Intl.DateTimeFormat>();\n\n/** Cached per-timezone formatter; throws on an invalid timezone id. */\nfunction formatterFor(tz: string): Intl.DateTimeFormat {\n  let dtf = formatters.get(tz);\n  if (dtf === undefined) {\n    dtf = new Intl.DateTimeFormat('en-US', {\n      timeZone: tz,\n      hourCycle: 'h23',\n      year: 'numeric',\n      month: 'numeric',\n      day: 'numeric',\n      hour: 'numeric',\n      minute: 'numeric',\n    });\n    formatters.set(tz, dtf);\n  }\n  return dtf;\n}\n\n/** Validate a timezone id, falling back to UTC — a bad profile value must not wedge the journey. */\nexport function resolveTimeZone(tz: string): string {\n  try {\n    formatterFor(tz);\n    return tz;\n  } catch {\n    return 'UTC';\n  }\n}\n\nfunction localParts(ms: number, tz: string): LocalParts {\n  const parts: Partial<Record<string, string>> = {};\n  for (const part of formatterFor(tz).formatToParts(new Date(ms))) {\n    parts[part.type] = part.value;\n  }\n  return {\n    year: Number(parts.year),\n    month: Number(parts.month),\n    day: Number(parts.day),\n    hour: Number(parts.hour),\n    minute: Number(parts.minute),\n  };\n}\n\n/** The zone's UTC offset at an instant, as (wall clock read as if it were UTC) − instant. */\nfunction offsetMsAt(ts: number, tz: string): number {\n  const p = localParts(ts, tz);\n  return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute) - ts;\n}\n\n/**\n * The first instant at or after `before` whose offset differs from the one\n * there — i.e. the DST transition separating the two bounds. Bisects on the\n * minute grid, the finest granularity any tz rule uses, so the loop lands on\n * the transition itself rather than merely near it.\n */\nfunction transitionBetween(before: number, after: number, tz: string): number {\n  const startOffset = offsetMsAt(before, tz);\n  let lo = before;\n  let hi = after;\n  while (hi - lo > 60_000) {\n    // Halve on whole minutes: both bounds stay minute-aligned, so mid is\n    // strictly inside (lo, hi) and the loop cannot stall.\n    const mid = lo + Math.floor((hi - lo) / 120_000) * 60_000;\n    if (offsetMsAt(mid, tz) === startOffset) lo = mid;\n    else hi = mid;\n  }\n  return hi;\n}\n\n/**\n * The UTC instant at which the wall clock in `tz` reads y-m-d hh:mm.\n *\n * Guess the UTC value from the offset at the guess, read it back through the\n * timezone and correct by the difference; a second pass settles every wall\n * time that exists, and picks the earlier of the two when a fall-back repeats\n * an hour.\n *\n * A wall time inside a spring-forward gap exists on no clock, so the two\n * corrections straddle the transition and neither reads back as asked. The\n * convention here is the usual one: move forward to the first instant that\n * does exist, i.e. the transition itself — 02:30 on a US spring-forward day\n * resolves to 03:00. Without that branch the correction bottoms out on the low\n * side and the window opens an hour *before* its configured start.\n */\nfunction zonedInstant(\n  year: number,\n  month: number,\n  day: number,\n  hour: number,\n  minute: number,\n  tz: string\n): number {\n  const target = Date.UTC(year, month - 1, day, hour, minute);\n  const first = target - offsetMsAt(target, tz);\n  if (offsetMsAt(first, tz) === target - first) return first;\n  const second = target - offsetMsAt(first, tz);\n  if (offsetMsAt(second, tz) === target - second) return second;\n  return transitionBetween(Math.min(first, second), Math.max(first, second), tz);\n}\n\nconst TIME = /^(\\d{1,2}):(\\d{2})$/;\n\nfunction parseTime(value: string): { hh: number; mm: number } | null {\n  const match = TIME.exec(value);\n  if (!match) return null;\n  const hh = Number(match[1]);\n  const mm = Number(match[2]);\n  if (hh > 23 || mm > 59) return null;\n  return { hh, mm };\n}\n\n/**\n * The instant the next [start, end) window opens in `tz`, or null when nowMs\n * is already inside a window. Scans nine calendar days so every weekday is\n * reachable. Malformed times (the DSL validates its own input, but IR may come\n * from elsewhere) disable the window — better to send now than to hold a user\n * forever on a config typo.\n */\nexport function nextWindowStart(\n  nowMs: number,\n  days: readonly string[],\n  between: readonly [string, string],\n  tz: string\n): number | null {\n  const start = parseTime(between[0]);\n  const end = parseTime(between[1]);\n  if (start === null || end === null) return null;\n  const zone = resolveTimeZone(tz);\n\n  // Step the local *calendar*, not the absolute clock: a spring-forward day is\n  // 23 hours long, so nowMs + n·24h crosses two local midnights and skips that\n  // date entirely — the send would be held until the weekday came round again.\n  // Date.UTC arithmetic over the civil date has no DST to trip on, and\n  // getUTCDay names the same weekday the zone does.\n  const today = localParts(nowMs, zone);\n  const firstDay = Date.UTC(today.year, today.month - 1, today.day);\n\n  for (let offset = 0; offset < 9; offset++) {\n    const date = new Date(firstDay + offset * DAY_MS);\n    if (!days.includes(WEEKDAYS[date.getUTCDay()])) continue;\n    const year = date.getUTCFullYear();\n    const month = date.getUTCMonth() + 1;\n    const day = date.getUTCDate();\n    const opensAt = zonedInstant(year, month, day, start.hh, start.mm, zone);\n    const closesAt = zonedInstant(year, month, day, end.hh, end.mm, zone);\n    if (nowMs < opensAt) return opensAt;\n    if (nowMs < closesAt) return null;\n    // Past this day's window (e.g. 23:00 against 09:00–17:00) → keep scanning forward\n  }\n  return null; // no allowed day in range (an empty days list) → do not wait\n}\n"],"mappings":"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"}

package/dist/engine/time-window.d.cts

@@ -0,0 +1,22 @@
+//#region src/engine/time-window.d.ts
+/**
+ * Time-window scheduling — when does the next send window open?
+ *
+ * Pure functions of (nowMs, days, between, tz): the interpreter calls them
+ * inside a durable step, so the answer is checkpointed and replay-safe.
+ * Timezone math goes through Intl.DateTimeFormat (available in Node, workerd
+ * and browsers alike) — no tz database dependency. An unknown timezone falls
+ * back to UTC rather than failing the journey.
+ */
+/** Validate a timezone id, falling back to UTC — a bad profile value must not wedge the journey. */
+export declare function resolveTimeZone(tz: string): string;
+/**
+ * The instant the next [start, end) window opens in `tz`, or null when nowMs
+ * is already inside a window. Scans nine calendar days so every weekday is
+ * reachable. Malformed times (the DSL validates its own input, but IR may come
+ * from elsewhere) disable the window — better to send now than to hold a user
+ * forever on a config typo.
+ */
+export declare function nextWindowStart(nowMs: number, days: readonly string[], between: readonly [string, string], tz: string): number | null;
+//#endregion
+//# sourceMappingURL=time-window.d.cts.map

package/dist/engine/time-window.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-window.d.cts","names":[],"sources":["../../src/engine/time-window.ts"],"mappings":";;;;;;;;;;;wBA4CgB,gBAAgB;;;;;;;;wBAkGhB,gBACd,eACA,yBACA,oCACA"}

package/dist/engine/time-window.d.mts

@@ -0,0 +1,22 @@
+//#region src/engine/time-window.d.ts
+/**
+ * Time-window scheduling — when does the next send window open?
+ *
+ * Pure functions of (nowMs, days, between, tz): the interpreter calls them
+ * inside a durable step, so the answer is checkpointed and replay-safe.
+ * Timezone math goes through Intl.DateTimeFormat (available in Node, workerd
+ * and browsers alike) — no tz database dependency. An unknown timezone falls
+ * back to UTC rather than failing the journey.
+ */
+/** Validate a timezone id, falling back to UTC — a bad profile value must not wedge the journey. */
+export declare function resolveTimeZone(tz: string): string;
+/**
+ * The instant the next [start, end) window opens in `tz`, or null when nowMs
+ * is already inside a window. Scans nine calendar days so every weekday is
+ * reachable. Malformed times (the DSL validates its own input, but IR may come
+ * from elsewhere) disable the window — better to send now than to hold a user
+ * forever on a config typo.
+ */
+export declare function nextWindowStart(nowMs: number, days: readonly string[], between: readonly [string, string], tz: string): number | null;
+//#endregion
+//# sourceMappingURL=time-window.d.mts.map

package/dist/engine/time-window.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-window.d.mts","names":[],"sources":["../../src/engine/time-window.ts"],"mappings":";;;;;;;;;;;wBA4CgB,gBAAgB;;;;;;;;wBAkGhB,gBACd,eACA,yBACA,oCACA"}

package/dist/engine/time-window.mjs

@@ -0,0 +1,147 @@
+//#region src/engine/time-window.ts
+/**
+* Time-window scheduling — when does the next send window open?
+*
+* Pure functions of (nowMs, days, between, tz): the interpreter calls them
+* inside a durable step, so the answer is checkpointed and replay-safe.
+* Timezone math goes through Intl.DateTimeFormat (available in Node, workerd
+* and browsers alike) — no tz database dependency. An unknown timezone falls
+* back to UTC rather than failing the journey.
+*/
+const DAY_MS = 864e5;
+/** Indexed by Date#getUTCDay, matching WeekdayIR's lowercase three-letter form. */
+const WEEKDAYS = [
+	"sun",
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat"
+];
+const formatters = /* @__PURE__ */ new Map();
+/** Cached per-timezone formatter; throws on an invalid timezone id. */
+function formatterFor(tz) {
+	let dtf = formatters.get(tz);
+	if (dtf === void 0) {
+		dtf = new Intl.DateTimeFormat("en-US", {
+			timeZone: tz,
+			hourCycle: "h23",
+			year: "numeric",
+			month: "numeric",
+			day: "numeric",
+			hour: "numeric",
+			minute: "numeric"
+		});
+		formatters.set(tz, dtf);
+	}
+	return dtf;
+}
+/** Validate a timezone id, falling back to UTC — a bad profile value must not wedge the journey. */
+function resolveTimeZone(tz) {
+	try {
+		formatterFor(tz);
+		return tz;
+	} catch {
+		return "UTC";
+	}
+}
+function localParts(ms, tz) {
+	const parts = {};
+	for (const part of formatterFor(tz).formatToParts(new Date(ms))) parts[part.type] = part.value;
+	return {
+		year: Number(parts.year),
+		month: Number(parts.month),
+		day: Number(parts.day),
+		hour: Number(parts.hour),
+		minute: Number(parts.minute)
+	};
+}
+/** The zone's UTC offset at an instant, as (wall clock read as if it were UTC) − instant. */
+function offsetMsAt(ts, tz) {
+	const p = localParts(ts, tz);
+	return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute) - ts;
+}
+/**
+* The first instant at or after `before` whose offset differs from the one
+* there — i.e. the DST transition separating the two bounds. Bisects on the
+* minute grid, the finest granularity any tz rule uses, so the loop lands on
+* the transition itself rather than merely near it.
+*/
+function transitionBetween(before, after, tz) {
+	const startOffset = offsetMsAt(before, tz);
+	let lo = before;
+	let hi = after;
+	while (hi - lo > 6e4) {
+		const mid = lo + Math.floor((hi - lo) / 12e4) * 6e4;
+		if (offsetMsAt(mid, tz) === startOffset) lo = mid;
+		else hi = mid;
+	}
+	return hi;
+}
+/**
+* The UTC instant at which the wall clock in `tz` reads y-m-d hh:mm.
+*
+* Guess the UTC value from the offset at the guess, read it back through the
+* timezone and correct by the difference; a second pass settles every wall
+* time that exists, and picks the earlier of the two when a fall-back repeats
+* an hour.
+*
+* A wall time inside a spring-forward gap exists on no clock, so the two
+* corrections straddle the transition and neither reads back as asked. The
+* convention here is the usual one: move forward to the first instant that
+* does exist, i.e. the transition itself — 02:30 on a US spring-forward day
+* resolves to 03:00. Without that branch the correction bottoms out on the low
+* side and the window opens an hour *before* its configured start.
+*/
+function zonedInstant(year, month, day, hour, minute, tz) {
+	const target = Date.UTC(year, month - 1, day, hour, minute);
+	const first = target - offsetMsAt(target, tz);
+	if (offsetMsAt(first, tz) === target - first) return first;
+	const second = target - offsetMsAt(first, tz);
+	if (offsetMsAt(second, tz) === target - second) return second;
+	return transitionBetween(Math.min(first, second), Math.max(first, second), tz);
+}
+const TIME = /^(\d{1,2}):(\d{2})$/;
+function parseTime(value) {
+	const match = TIME.exec(value);
+	if (!match) return null;
+	const hh = Number(match[1]);
+	const mm = Number(match[2]);
+	if (hh > 23 || mm > 59) return null;
+	return {
+		hh,
+		mm
+	};
+}
+/**
+* The instant the next [start, end) window opens in `tz`, or null when nowMs
+* is already inside a window. Scans nine calendar days so every weekday is
+* reachable. Malformed times (the DSL validates its own input, but IR may come
+* from elsewhere) disable the window — better to send now than to hold a user
+* forever on a config typo.
+*/
+function nextWindowStart(nowMs, days, between, tz) {
+	const start = parseTime(between[0]);
+	const end = parseTime(between[1]);
+	if (start === null || end === null) return null;
+	const zone = resolveTimeZone(tz);
+	const today = localParts(nowMs, zone);
+	const firstDay = Date.UTC(today.year, today.month - 1, today.day);
+	for (let offset = 0; offset < 9; offset++) {
+		const date = new Date(firstDay + offset * DAY_MS);
+		if (!days.includes(WEEKDAYS[date.getUTCDay()])) continue;
+		const year = date.getUTCFullYear();
+		const month = date.getUTCMonth() + 1;
+		const day = date.getUTCDate();
+		const opensAt = zonedInstant(year, month, day, start.hh, start.mm, zone);
+		const closesAt = zonedInstant(year, month, day, end.hh, end.mm, zone);
+		if (nowMs < opensAt) return opensAt;
+		if (nowMs < closesAt) return null;
+	}
+	return null;
+}
+//#endregion
+export { nextWindowStart, resolveTimeZone };
+
+//# sourceMappingURL=time-window.mjs.map

package/dist/engine/time-window.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-window.mjs","names":[],"sources":["../../src/engine/time-window.ts"],"sourcesContent":["/**\n * Time-window scheduling — when does the next send window open?\n *\n * Pure functions of (nowMs, days, between, tz): the interpreter calls them\n * inside a durable step, so the answer is checkpointed and replay-safe.\n * Timezone math goes through Intl.DateTimeFormat (available in Node, workerd\n * and browsers alike) — no tz database dependency. An unknown timezone falls\n * back to UTC rather than failing the journey.\n */\n\nconst DAY_MS = 86_400_000;\n\n/** Indexed by Date#getUTCDay, matching WeekdayIR's lowercase three-letter form. */\nconst WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];\n\ninterface LocalParts {\n  year: number;\n  month: number;\n  day: number;\n  hour: number;\n  minute: number;\n}\n\nconst formatters = new Map<string, Intl.DateTimeFormat>();\n\n/** Cached per-timezone formatter; throws on an invalid timezone id. */\nfunction formatterFor(tz: string): Intl.DateTimeFormat {\n  let dtf = formatters.get(tz);\n  if (dtf === undefined) {\n    dtf = new Intl.DateTimeFormat('en-US', {\n      timeZone: tz,\n      hourCycle: 'h23',\n      year: 'numeric',\n      month: 'numeric',\n      day: 'numeric',\n      hour: 'numeric',\n      minute: 'numeric',\n    });\n    formatters.set(tz, dtf);\n  }\n  return dtf;\n}\n\n/** Validate a timezone id, falling back to UTC — a bad profile value must not wedge the journey. */\nexport function resolveTimeZone(tz: string): string {\n  try {\n    formatterFor(tz);\n    return tz;\n  } catch {\n    return 'UTC';\n  }\n}\n\nfunction localParts(ms: number, tz: string): LocalParts {\n  const parts: Partial<Record<string, string>> = {};\n  for (const part of formatterFor(tz).formatToParts(new Date(ms))) {\n    parts[part.type] = part.value;\n  }\n  return {\n    year: Number(parts.year),\n    month: Number(parts.month),\n    day: Number(parts.day),\n    hour: Number(parts.hour),\n    minute: Number(parts.minute),\n  };\n}\n\n/** The zone's UTC offset at an instant, as (wall clock read as if it were UTC) − instant. */\nfunction offsetMsAt(ts: number, tz: string): number {\n  const p = localParts(ts, tz);\n  return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute) - ts;\n}\n\n/**\n * The first instant at or after `before` whose offset differs from the one\n * there — i.e. the DST transition separating the two bounds. Bisects on the\n * minute grid, the finest granularity any tz rule uses, so the loop lands on\n * the transition itself rather than merely near it.\n */\nfunction transitionBetween(before: number, after: number, tz: string): number {\n  const startOffset = offsetMsAt(before, tz);\n  let lo = before;\n  let hi = after;\n  while (hi - lo > 60_000) {\n    // Halve on whole minutes: both bounds stay minute-aligned, so mid is\n    // strictly inside (lo, hi) and the loop cannot stall.\n    const mid = lo + Math.floor((hi - lo) / 120_000) * 60_000;\n    if (offsetMsAt(mid, tz) === startOffset) lo = mid;\n    else hi = mid;\n  }\n  return hi;\n}\n\n/**\n * The UTC instant at which the wall clock in `tz` reads y-m-d hh:mm.\n *\n * Guess the UTC value from the offset at the guess, read it back through the\n * timezone and correct by the difference; a second pass settles every wall\n * time that exists, and picks the earlier of the two when a fall-back repeats\n * an hour.\n *\n * A wall time inside a spring-forward gap exists on no clock, so the two\n * corrections straddle the transition and neither reads back as asked. The\n * convention here is the usual one: move forward to the first instant that\n * does exist, i.e. the transition itself — 02:30 on a US spring-forward day\n * resolves to 03:00. Without that branch the correction bottoms out on the low\n * side and the window opens an hour *before* its configured start.\n */\nfunction zonedInstant(\n  year: number,\n  month: number,\n  day: number,\n  hour: number,\n  minute: number,\n  tz: string\n): number {\n  const target = Date.UTC(year, month - 1, day, hour, minute);\n  const first = target - offsetMsAt(target, tz);\n  if (offsetMsAt(first, tz) === target - first) return first;\n  const second = target - offsetMsAt(first, tz);\n  if (offsetMsAt(second, tz) === target - second) return second;\n  return transitionBetween(Math.min(first, second), Math.max(first, second), tz);\n}\n\nconst TIME = /^(\\d{1,2}):(\\d{2})$/;\n\nfunction parseTime(value: string): { hh: number; mm: number } | null {\n  const match = TIME.exec(value);\n  if (!match) return null;\n  const hh = Number(match[1]);\n  const mm = Number(match[2]);\n  if (hh > 23 || mm > 59) return null;\n  return { hh, mm };\n}\n\n/**\n * The instant the next [start, end) window opens in `tz`, or null when nowMs\n * is already inside a window. Scans nine calendar days so every weekday is\n * reachable. Malformed times (the DSL validates its own input, but IR may come\n * from elsewhere) disable the window — better to send now than to hold a user\n * forever on a config typo.\n */\nexport function nextWindowStart(\n  nowMs: number,\n  days: readonly string[],\n  between: readonly [string, string],\n  tz: string\n): number | null {\n  const start = parseTime(between[0]);\n  const end = parseTime(between[1]);\n  if (start === null || end === null) return null;\n  const zone = resolveTimeZone(tz);\n\n  // Step the local *calendar*, not the absolute clock: a spring-forward day is\n  // 23 hours long, so nowMs + n·24h crosses two local midnights and skips that\n  // date entirely — the send would be held until the weekday came round again.\n  // Date.UTC arithmetic over the civil date has no DST to trip on, and\n  // getUTCDay names the same weekday the zone does.\n  const today = localParts(nowMs, zone);\n  const firstDay = Date.UTC(today.year, today.month - 1, today.day);\n\n  for (let offset = 0; offset < 9; offset++) {\n    const date = new Date(firstDay + offset * DAY_MS);\n    if (!days.includes(WEEKDAYS[date.getUTCDay()])) continue;\n    const year = date.getUTCFullYear();\n    const month = date.getUTCMonth() + 1;\n    const day = date.getUTCDate();\n    const opensAt = zonedInstant(year, month, day, start.hh, start.mm, zone);\n    const closesAt = zonedInstant(year, month, day, end.hh, end.mm, zone);\n    if (nowMs < opensAt) return opensAt;\n    if (nowMs < closesAt) return null;\n    // Past this day's window (e.g. 23:00 against 09:00–17:00) → keep scanning forward\n  }\n  return null; // no allowed day in range (an empty days list) → do not wait\n}\n"],"mappings":"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"}