@shware/workflow 3.2.0 → 4.0.0

package/dist/engine/ports.d.mts

@@ -17,10 +17,11 @@ import { ChannelIR, ConditionIR, ScalarIR } from "../ir.mjs";
 export interface EngineStep {
   /** Durable step: fn's return value is checkpointed; on replay the result is reused without re-running. */
   do<T>(name: string, fn: () => Promise<T>): Promise<T>;
-  /** Durable sleep: suspended time is not billed. */
+  /**
+   * Durable sleep: suspended time is not billed. The only sleep primitive — a wait until an
+   * absolute instant is the interpreter checkpointing the remaining time, then sleeping it.
+   */
   sleep(name: string, ms: number): Promise<void>;
-  /** Sleep until an absolute instant (used by time_window). */
-  sleepUntil(name: string, timestampMs: number): Promise<void>;
   /**
    * Durable: register interest in the named events (Cloudflare: write the
    * subscription table; AWS: create a callback and store its id). Must
@@ -43,8 +44,18 @@ export interface EngineStep {
   /**
    * Wait for a wake-up or a timeout. A registration from `subscribe` must
    * already exist — this call only parks the instance.
+   *
+   * Both numbers are checkpointed by the interpreter, so they are replay-stable: `timeoutMs`
+   * is how long this attempt may park (the remaining time when it was computed), `deadlineMs`
+   * the absolute instant the whole wait gives up. An adapter that learns of a timeout only by
+   * a thrown error (Cloudflare) decides against `deadlineMs` — the clock at the replay that
+   * first runs that decision is what matters, not when the park began; one whose wake handle
+   * carries its own timeout (AWS) set it from `deadlineMs` at subscribe and ignores both here.
    */
-  waitForWake(name: string, timeoutMs: number): Promise<'event' | 'timeout'>;
+  waitForWake(name: string, wait: {
+    timeoutMs: number;
+    deadlineMs: number;
+  }): Promise<'event' | 'timeout'>;
 }
 /** One device a push can go to: the provider token (APNs device token, FCM registration token) and the platform that picks the provider. */
 export interface PushDevice {
@@ -113,6 +124,12 @@ export interface MessageTracking {
   link?: (url: string, purpose: LinkPurpose) => string;
   /** Loaded when the email is opened. */
   pixel?: string;
+  /**
+   * This copy's one-click unsubscribe endpoint (RFC 8058): a POST there, with no confirmation
+   * and no session, unsubscribes the recipient. The email sender puts it in the
+   * `List-Unsubscribe` header, so a mail client's own unsubscribe button works.
+   */
+  unsubscribe?: string;
   /** Extra string keys in the push payload. */
   data?: Record<string, string>;
   /**
@@ -203,8 +220,6 @@ export interface EventSink {
 export interface ActionInvocation {
   /** Registry name; the code itself lives in the deployed bundle (dual-plane model, see dsl/action.ts). */
   action: string;
-  /** Code-identity pin from the IR the journey is running; adapters compare it against the registered implementation. */
-  codeHash?: string | undefined;
   /** Already resolved: user_property references have been replaced by actual values (same contract as message props). */
   args: Record<string, ScalarIR | undefined>;
   userId: string;

package/dist/engine/ports.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ports.d.mts","names":[],"sources":["../../src/engine/ports.ts"],"mappings":";;;;;;;;;;;;;;;;iBAiBiB;;EAEf,GAAG,GAAG,cAAc,UAAU,QAAQ,KAAK,QAAQ;;EAGnD,MAAM,cAAc,aAAa;;EAGjC,WAAW,cAAc,sBAAsB;;;;;;;;;;;;;;;EAgB/C,UACE,cACA,2BACA;IAAY;MACX;;EAGH,YAAY,eAAe;;;;;EAM3B,YAAY,cAAc,oBAAoB;;;iBAI/B;EACf;EACA;;;iBAIe;;;;;;EAMf,YACE,eACA;IAAS;IAAkB;IAAkB,QAAQ;MACpD;EACH,YAAY,eAAe,QAAQ;;EAEnC,oBAAoB,eAAe,QAAQ;;EAE3C,eAAe,QAAQ;;EAEvB,cAAc,SAAS,YAAY;;iBAGpB;;EAEf;EACA;EACA;EACA,SAAS;EACT;;EAEA,OAAO,eAAe;EACtB;;;;;;EAMA;;EAEA,SAAS;;;;;;EAMT;;EAEA,WAAW;;;YAID;;;;;;iBAOK;;;;;EAKf,QAAQ,aAAa,SAAS;;EAE9B;;EAEA,OAAO;;;;;;EAMP,eAAe;;;;;;;iBAQA;EACf;EACA;;iBAGe;EACf,KAAK,SAAS,kBAAkB,eAAe;;;;;;;;;iBAUhC;;EAEf,SAAS;IACP;IACA;IACA;IACA;MACE;;EAEJ,aAAa;IACX;IACA;IACA;IACA;IACA;MACE;;EAEJ,iBAAiB,SAAS,kBAAkB,QAAQ;;EAEpD,aAAa,SAAS,iBAAiB;IAAU;MAAoB,aAAa;;EAElF,UAAU;IACR;IACA;IACA;IACA,QAAQ;IACR;;IAEA;MACE;;;;;;;;;iBAUW;EACf,SAAS;IACP,SAAS;IACT;IACA,OAAO,eAAe;MACpB,eAAe;;;iBAIJ;;;;;;;;EAQf,KAAK,eAAe,SAAS,eAAe,uBAAuB,aAAa;;;iBAIjE;;EAEf;;EAEA;;EAEA,MAAM,eAAe;EACrB;;EAEA;;;;;;;iBAQe;EACf,OAAO,YAAY,mBAAmB;;iBAGvB;EACf;;EAEA;;;;;;;EAOA;EACA,MAAM;EACN,OAAO;EACP,UAAU;EACV,QAAQ;;EAER,UAAU;;EAEV,YAAY;;EAEZ,WAAW;;;;;;;YAQD;EACN;;EACA;EAAkB;;EAClB;;EACA;;EACA"}
+{"version":3,"file":"ports.d.mts","names":[],"sources":["../../src/engine/ports.ts"],"mappings":";;;;;;;;;;;;;;;;iBAiBiB;;EAEf,GAAG,GAAG,cAAc,UAAU,QAAQ,KAAK,QAAQ;;;;;EAMnD,MAAM,cAAc,aAAa;;;;;;;;;;;;;;;EAgBjC,UACE,cACA,2BACA;IAAY;MACX;;EAGH,YAAY,eAAe;;;;;;;;;;;;EAa3B,YACE,cACA;IAAQ;IAAmB;MAC1B;;;iBAIY;EACf;EACA;;;iBAIe;;;;;;EAMf,YACE,eACA;IAAS;IAAkB;IAAkB,QAAQ;MACpD;EACH,YAAY,eAAe,QAAQ;;EAEnC,oBAAoB,eAAe,QAAQ;;EAE3C,eAAe,QAAQ;;EAEvB,cAAc,SAAS,YAAY;;iBAGpB;;EAEf;EACA;EACA;EACA,SAAS;EACT;;EAEA,OAAO,eAAe;EACtB;;;;;;EAMA;;EAEA,SAAS;;;;;;EAMT;;EAEA,WAAW;;;YAID;;;;;;iBAOK;;;;;EAKf,QAAQ,aAAa,SAAS;;EAE9B;;;;;;EAMA;;EAEA,OAAO;;;;;;EAMP,eAAe;;;;;;;iBAQA;EACf;EACA;;iBAGe;EACf,KAAK,SAAS,kBAAkB,eAAe;;;;;;;;;iBAUhC;;EAEf,SAAS;IACP;IACA;IACA;IACA;MACE;;EAEJ,aAAa;IACX;IACA;IACA;IACA;IACA;MACE;;EAEJ,iBAAiB,SAAS,kBAAkB,QAAQ;;EAEpD,aAAa,SAAS,iBAAiB;IAAU;MAAoB,aAAa;;EAElF,UAAU;IACR;IACA;IACA;IACA,QAAQ;IACR;;IAEA;MACE;;;;;;;;;iBAUW;EACf,SAAS;IACP,SAAS;IACT;IACA,OAAO,eAAe;MACpB,eAAe;;;iBAIJ;;;;;;;;EAQf,KAAK,eAAe,SAAS,eAAe,uBAAuB,aAAa;;;iBAIjE;;EAEf;;EAEA,MAAM,eAAe;EACrB;;EAEA;;;;;;;iBAQe;EACf,OAAO,YAAY,mBAAmB;;iBAGvB;EACf;;EAEA;;;;;;;EAOA;EACA,MAAM;EACN,OAAO;EACP,UAAU;EACV,QAAQ;;EAER,UAAU;;EAEV,YAAY;;EAEZ,WAAW;;;;;;;YAQD;EACN;;EACA;EAAkB;;EAClB;;EACA;;EACA"}

package/dist/engine/retry.cjs

@@ -7,6 +7,18 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 * instead of burning the retry budget and delaying the journey. Every runtime adapter asks this
 * one rule.
 */
+/**
+* A failure a retry would only repeat: a missing or malformed configuration, a provider refusing
+* the request itself, an input the runtime cannot act on. Thrown inside a durable step, it ends
+* the step at once (`isRetryable` is false) instead of burning the retry budget.
+*/
+var PermanentError = class extends Error {
+	name = "PermanentError";
+	retryable = false;
+	constructor(message, options) {
+		super(message, options);
+	}
+};
 /** Errors the engine raises that are deterministic by construction. */
 const DETERMINISTIC = /* @__PURE__ */ new Set(["TemplateValidationError", "ContractValidationError"]);
 /**
@@ -23,6 +35,7 @@ function isRetryableStatus(status) {
 	return status === 408 || status === 429 || status >= 500;
 }
 //#endregion
+exports.PermanentError = PermanentError;
 exports.isRetryable = isRetryable;
 exports.isRetryableStatus = isRetryableStatus;
 

package/dist/engine/retry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"retry.cjs","names":[],"sources":["../../src/engine/retry.ts"],"sourcesContent":["/**\n * Which step failures a retry would only repeat. A durable step retries what it throws; an\n * error that is the same on every attempt — a template refusing its props, the contract\n * refusing an emitted event, a provider rejecting the request itself — ends the step at once\n * instead of burning the retry budget and delaying the journey. Every runtime adapter asks this\n * one rule.\n */\n\n/** Errors the engine raises that are deterministic by construction. */\nconst DETERMINISTIC = new Set(['TemplateValidationError', 'ContractValidationError']);\n\n/**\n * False for an error a retry cannot fix: one of the engine's deterministic refusals, or any\n * error that says so with `retryable: false` (the transports' 4xx answers).\n */\nexport function isRetryable(error: unknown): boolean {\n  if (!(error instanceof Error)) return true;\n  if (DETERMINISTIC.has(error.name)) return false;\n  return (error as { retryable?: unknown }).retryable !== false;\n}\n\n/** An HTTP answer a retry can change: a timeout, throttling, or the provider's own fault. */\nexport function isRetryableStatus(status: number): boolean {\n  return status === 408 || status === 429 || status >= 500;\n}\n"],"mappings":";;;;;;;;;;AASA,MAAM,gCAAgB,IAAI,IAAI,CAAC,2BAA2B,yBAAyB,CAAC;;;;;AAMpF,SAAgB,YAAY,OAAyB;CACnD,IAAI,EAAE,iBAAiB,QAAQ,OAAO;CACtC,IAAI,cAAc,IAAI,MAAM,IAAI,GAAG,OAAO;CAC1C,OAAQ,MAAkC,cAAc;AAC1D;;AAGA,SAAgB,kBAAkB,QAAyB;CACzD,OAAO,WAAW,OAAO,WAAW,OAAO,UAAU;AACvD"}
+{"version":3,"file":"retry.cjs","names":[],"sources":["../../src/engine/retry.ts"],"sourcesContent":["/**\n * Which step failures a retry would only repeat. A durable step retries what it throws; an\n * error that is the same on every attempt — a template refusing its props, the contract\n * refusing an emitted event, a provider rejecting the request itself — ends the step at once\n * instead of burning the retry budget and delaying the journey. Every runtime adapter asks this\n * one rule.\n */\n\n/**\n * A failure a retry would only repeat: a missing or malformed configuration, a provider refusing\n * the request itself, an input the runtime cannot act on. Thrown inside a durable step, it ends\n * the step at once (`isRetryable` is false) instead of burning the retry budget.\n */\nexport class PermanentError extends Error {\n  override readonly name: string = 'PermanentError';\n  readonly retryable = false;\n  constructor(message: string, options?: { cause?: unknown }) {\n    super(message, options);\n  }\n}\n\n/** Errors the engine raises that are deterministic by construction. */\nconst DETERMINISTIC = new Set(['TemplateValidationError', 'ContractValidationError']);\n\n/**\n * False for an error a retry cannot fix: one of the engine's deterministic refusals, or any\n * error that says so with `retryable: false` (the transports' 4xx answers).\n */\nexport function isRetryable(error: unknown): boolean {\n  if (!(error instanceof Error)) return true;\n  if (DETERMINISTIC.has(error.name)) return false;\n  return (error as { retryable?: unknown }).retryable !== false;\n}\n\n/** An HTTP answer a retry can change: a timeout, throttling, or the provider's own fault. */\nexport function isRetryableStatus(status: number): boolean {\n  return status === 408 || status === 429 || status >= 500;\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAiC;CACjC,YAAqB;CACrB,YAAY,SAAiB,SAA+B;EAC1D,MAAM,SAAS,OAAO;CACxB;AACF;;AAGA,MAAM,gCAAgB,IAAI,IAAI,CAAC,2BAA2B,yBAAyB,CAAC;;;;;AAMpF,SAAgB,YAAY,OAAyB;CACnD,IAAI,EAAE,iBAAiB,QAAQ,OAAO;CACtC,IAAI,cAAc,IAAI,MAAM,IAAI,GAAG,OAAO;CAC1C,OAAQ,MAAkC,cAAc;AAC1D;;AAGA,SAAgB,kBAAkB,QAAyB;CACzD,OAAO,WAAW,OAAO,WAAW,OAAO,UAAU;AACvD"}

package/dist/engine/retry.d.cts

@@ -6,6 +6,18 @@
  * instead of burning the retry budget and delaying the journey. Every runtime adapter asks this
  * one rule.
  */
+/**
+ * A failure a retry would only repeat: a missing or malformed configuration, a provider refusing
+ * the request itself, an input the runtime cannot act on. Thrown inside a durable step, it ends
+ * the step at once (`isRetryable` is false) instead of burning the retry budget.
+ */
+export declare class PermanentError extends Error {
+  readonly name: string;
+  readonly retryable = false;
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
 /**
  * False for an error a retry cannot fix: one of the engine's deterministic refusals, or any
  * error that says so with `retryable: false` (the transports' 4xx answers).

package/dist/engine/retry.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"retry.d.cts","names":[],"sources":["../../src/engine/retry.ts"],"mappings":";;;;;;;;;;;;wBAegB,YAAY;;wBAOZ,kBAAkB"}
+{"version":3,"file":"retry.d.cts","names":[],"sources":["../../src/engine/retry.ts"],"mappings":";;;;;;;;;;;;;qBAaa,uBAAuB;WAChB;WACT;EACT,YAAY,iBAAiB;IAAY;;;;;;;wBAY3B,YAAY;;wBAOZ,kBAAkB"}

package/dist/engine/retry.d.mts

@@ -6,6 +6,18 @@
  * instead of burning the retry budget and delaying the journey. Every runtime adapter asks this
  * one rule.
  */
+/**
+ * A failure a retry would only repeat: a missing or malformed configuration, a provider refusing
+ * the request itself, an input the runtime cannot act on. Thrown inside a durable step, it ends
+ * the step at once (`isRetryable` is false) instead of burning the retry budget.
+ */
+export declare class PermanentError extends Error {
+  readonly name: string;
+  readonly retryable = false;
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
 /**
  * False for an error a retry cannot fix: one of the engine's deterministic refusals, or any
  * error that says so with `retryable: false` (the transports' 4xx answers).

package/dist/engine/retry.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"retry.d.mts","names":[],"sources":["../../src/engine/retry.ts"],"mappings":";;;;;;;;;;;;wBAegB,YAAY;;wBAOZ,kBAAkB"}
+{"version":3,"file":"retry.d.mts","names":[],"sources":["../../src/engine/retry.ts"],"mappings":";;;;;;;;;;;;;qBAaa,uBAAuB;WAChB;WACT;EACT,YAAY,iBAAiB;IAAY;;;;;;;wBAY3B,YAAY;;wBAOZ,kBAAkB"}

package/dist/engine/retry.mjs

@@ -6,6 +6,18 @@
 * instead of burning the retry budget and delaying the journey. Every runtime adapter asks this
 * one rule.
 */
+/**
+* A failure a retry would only repeat: a missing or malformed configuration, a provider refusing
+* the request itself, an input the runtime cannot act on. Thrown inside a durable step, it ends
+* the step at once (`isRetryable` is false) instead of burning the retry budget.
+*/
+var PermanentError = class extends Error {
+	name = "PermanentError";
+	retryable = false;
+	constructor(message, options) {
+		super(message, options);
+	}
+};
 /** Errors the engine raises that are deterministic by construction. */
 const DETERMINISTIC = /* @__PURE__ */ new Set(["TemplateValidationError", "ContractValidationError"]);
 /**
@@ -22,6 +34,6 @@ function isRetryableStatus(status) {
 	return status === 408 || status === 429 || status >= 500;
 }
 //#endregion
-export { isRetryable, isRetryableStatus };
+export { PermanentError, isRetryable, isRetryableStatus };
 
 //# sourceMappingURL=retry.mjs.map

package/dist/engine/retry.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"retry.mjs","names":[],"sources":["../../src/engine/retry.ts"],"sourcesContent":["/**\n * Which step failures a retry would only repeat. A durable step retries what it throws; an\n * error that is the same on every attempt — a template refusing its props, the contract\n * refusing an emitted event, a provider rejecting the request itself — ends the step at once\n * instead of burning the retry budget and delaying the journey. Every runtime adapter asks this\n * one rule.\n */\n\n/** Errors the engine raises that are deterministic by construction. */\nconst DETERMINISTIC = new Set(['TemplateValidationError', 'ContractValidationError']);\n\n/**\n * False for an error a retry cannot fix: one of the engine's deterministic refusals, or any\n * error that says so with `retryable: false` (the transports' 4xx answers).\n */\nexport function isRetryable(error: unknown): boolean {\n  if (!(error instanceof Error)) return true;\n  if (DETERMINISTIC.has(error.name)) return false;\n  return (error as { retryable?: unknown }).retryable !== false;\n}\n\n/** An HTTP answer a retry can change: a timeout, throttling, or the provider's own fault. */\nexport function isRetryableStatus(status: number): boolean {\n  return status === 408 || status === 429 || status >= 500;\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,gCAAgB,IAAI,IAAI,CAAC,2BAA2B,yBAAyB,CAAC;;;;;AAMpF,SAAgB,YAAY,OAAyB;CACnD,IAAI,EAAE,iBAAiB,QAAQ,OAAO;CACtC,IAAI,cAAc,IAAI,MAAM,IAAI,GAAG,OAAO;CAC1C,OAAQ,MAAkC,cAAc;AAC1D;;AAGA,SAAgB,kBAAkB,QAAyB;CACzD,OAAO,WAAW,OAAO,WAAW,OAAO,UAAU;AACvD"}
+{"version":3,"file":"retry.mjs","names":[],"sources":["../../src/engine/retry.ts"],"sourcesContent":["/**\n * Which step failures a retry would only repeat. A durable step retries what it throws; an\n * error that is the same on every attempt — a template refusing its props, the contract\n * refusing an emitted event, a provider rejecting the request itself — ends the step at once\n * instead of burning the retry budget and delaying the journey. Every runtime adapter asks this\n * one rule.\n */\n\n/**\n * A failure a retry would only repeat: a missing or malformed configuration, a provider refusing\n * the request itself, an input the runtime cannot act on. Thrown inside a durable step, it ends\n * the step at once (`isRetryable` is false) instead of burning the retry budget.\n */\nexport class PermanentError extends Error {\n  override readonly name: string = 'PermanentError';\n  readonly retryable = false;\n  constructor(message: string, options?: { cause?: unknown }) {\n    super(message, options);\n  }\n}\n\n/** Errors the engine raises that are deterministic by construction. */\nconst DETERMINISTIC = new Set(['TemplateValidationError', 'ContractValidationError']);\n\n/**\n * False for an error a retry cannot fix: one of the engine's deterministic refusals, or any\n * error that says so with `retryable: false` (the transports' 4xx answers).\n */\nexport function isRetryable(error: unknown): boolean {\n  if (!(error instanceof Error)) return true;\n  if (DETERMINISTIC.has(error.name)) return false;\n  return (error as { retryable?: unknown }).retryable !== false;\n}\n\n/** An HTTP answer a retry can change: a timeout, throttling, or the provider's own fault. */\nexport function isRetryableStatus(status: number): boolean {\n  return status === 408 || status === 429 || status >= 500;\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAiC;CACjC,YAAqB;CACrB,YAAY,SAAiB,SAA+B;EAC1D,MAAM,SAAS,OAAO;CACxB;AACF;;AAGA,MAAM,gCAAgB,IAAI,IAAI,CAAC,2BAA2B,yBAAyB,CAAC;;;;;AAMpF,SAAgB,YAAY,OAAyB;CACnD,IAAI,EAAE,iBAAiB,QAAQ,OAAO;CACtC,IAAI,cAAc,IAAI,MAAM,IAAI,GAAG,OAAO;CAC1C,OAAQ,MAAkC,cAAc;AAC1D;;AAGA,SAAgB,kBAAkB,QAAyB;CACzD,OAAO,WAAW,OAAO,WAAW,OAAO,UAAU;AACvD"}

package/dist/engine/time-scale.cjs

@@ -13,25 +13,96 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 * 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.
+* The walk follows the IR's own structure — the fields that hold a Duration
+* are known — so a message prop or an event payload that happens to look like
+* one (`{ value, ms }`) is left alone. The source 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);
+	return {
+		...ir,
+		trigger: ir.trigger.type === "event" ? {
+			...ir.trigger,
+			...ir.trigger.filter === void 0 ? {} : { filter: scaleCondition(ir.trigger.filter, factor) }
+		} : ir.trigger,
+		...ir.goal === void 0 ? {} : { goal: {
+			...ir.goal,
+			condition: scaleCondition(ir.goal.condition, factor),
+			...ir.goal.within === void 0 ? {} : { within: scale(ir.goal.within, factor) }
+		} },
+		...ir.exitWhen === void 0 ? {} : { exitWhen: scaleCondition(ir.exitWhen, factor) },
+		flow: scaleFlow(ir.flow, factor)
+	};
+}
+/** A condition with its `performed(... within)` windows divided by `factor`. */
+function scaleCondition(condition, factor) {
+	if (!(factor > 0) || factor === 1) return condition;
+	switch (condition.type) {
+		case "and":
+		case "or": return {
+			...condition,
+			conditions: condition.conditions.map((child) => scaleCondition(child, factor))
+		};
+		case "not": return {
+			...condition,
+			condition: scaleCondition(condition.condition, factor)
+		};
+		case "performed": return condition.within === void 0 ? condition : {
+			...condition,
+			within: scale(condition.within, factor)
+		};
+		default: return condition;
+	}
+}
+function scaleFlow(nodes, factor) {
+	return nodes.map((node) => scaleNode(node, factor));
+}
+function scaleNode(node, factor) {
+	switch (node.type) {
+		case "delay": return {
+			...node,
+			duration: scale(node.duration, factor)
+		};
+		case "random_delay": return {
+			...node,
+			min: scale(node.min, factor),
+			max: scale(node.max, factor)
+		};
+		case "wait_until": return {
+			...node,
+			condition: scaleCondition(node.condition, factor),
+			timeout: scale(node.timeout, factor),
+			onTimeout: Array.isArray(node.onTimeout) ? scaleFlow(node.onTimeout, factor) : node.onTimeout
+		};
+		case "branch": return {
+			...node,
+			cases: node.cases.map((branch) => ({
+				...branch,
+				condition: scaleCondition(branch.condition, factor),
+				flow: scaleFlow(branch.flow, factor)
+			})),
+			...node.otherwise === void 0 ? {} : { otherwise: scaleFlow(node.otherwise, factor) }
+		};
+		case "filter": return {
+			...node,
+			condition: scaleCondition(node.condition, factor)
+		};
+		case "cohort": return {
+			...node,
+			arms: node.arms.map((arm) => ({
+				...arm,
+				flow: scaleFlow(arm.flow, factor)
+			}))
+		};
+		default: return node;
+	}
 }
-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))
+function scale(duration, factor) {
+	return {
+		value: duration.value,
+		ms: Math.max(0, Math.round(duration.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
@@ -42,12 +113,16 @@ function walk(value, factor) {
 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);
+		if (property === "getSegmentCondition") return async (name) => {
+			const condition = await target.getSegmentCondition(name);
+			return condition === void 0 ? void 0 : scaleCondition(condition, factor);
+		};
 		const value = Reflect.get(target, property, target);
 		return typeof value === "function" ? value.bind(target) : value;
 	} });
 }
 //#endregion
+exports.scaleCondition = scaleCondition;
 exports.scaleDurations = scaleDurations;
 exports.scaleSegmentWindows = scaleSegmentWindows;
 

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

@@ -1 +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"}
+{"version":3,"file":"time-scale.cjs","names":[],"sources":["../../src/engine/time-scale.ts"],"sourcesContent":["import type { ConditionIR, DurationIR, NodeIR, WorkflowIR } from '../ir';\n\n/**\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 * The walk follows the IR's own structure — the fields that hold a Duration\n * are known — so a message prop or an event payload that happens to look like\n * one (`{ value, ms }`) is left alone. The source text is kept so the studio\n * still shows what was written.\n */\nexport function scaleDurations(ir: WorkflowIR, factor: number): WorkflowIR {\n  if (!(factor > 0) || factor === 1) return ir;\n  return {\n    ...ir,\n    trigger:\n      ir.trigger.type === 'event'\n        ? {\n            ...ir.trigger,\n            ...(ir.trigger.filter === undefined\n              ? {}\n              : { filter: scaleCondition(ir.trigger.filter, factor) }),\n          }\n        : ir.trigger,\n    ...(ir.goal === undefined\n      ? {}\n      : {\n          goal: {\n            ...ir.goal,\n            condition: scaleCondition(ir.goal.condition, factor),\n            ...(ir.goal.within === undefined ? {} : { within: scale(ir.goal.within, factor) }),\n          },\n        }),\n    ...(ir.exitWhen === undefined ? {} : { exitWhen: scaleCondition(ir.exitWhen, factor) }),\n    flow: scaleFlow(ir.flow, factor),\n  };\n}\n\n/** A condition with its `performed(... within)` windows divided by `factor`. */\nexport function scaleCondition(condition: ConditionIR, factor: number): ConditionIR {\n  if (!(factor > 0) || factor === 1) return condition;\n  switch (condition.type) {\n    case 'and':\n    case 'or':\n      return {\n        ...condition,\n        conditions: condition.conditions.map((child) => scaleCondition(child, factor)),\n      };\n    case 'not':\n      return { ...condition, condition: scaleCondition(condition.condition, factor) };\n    case 'performed':\n      return condition.within === undefined\n        ? condition\n        : { ...condition, within: scale(condition.within, factor) };\n    default:\n      return condition;\n  }\n}\n\nfunction scaleFlow(nodes: readonly NodeIR[], factor: number): NodeIR[] {\n  return nodes.map((node) => scaleNode(node, factor));\n}\n\nfunction scaleNode(node: NodeIR, factor: number): NodeIR {\n  switch (node.type) {\n    case 'delay':\n      return { ...node, duration: scale(node.duration, factor) };\n    case 'random_delay':\n      return { ...node, min: scale(node.min, factor), max: scale(node.max, factor) };\n    case 'wait_until':\n      return {\n        ...node,\n        condition: scaleCondition(node.condition, factor),\n        timeout: scale(node.timeout, factor),\n        onTimeout: Array.isArray(node.onTimeout)\n          ? scaleFlow(node.onTimeout, factor)\n          : node.onTimeout,\n      };\n    case 'branch':\n      return {\n        ...node,\n        cases: node.cases.map((branch) => ({\n          ...branch,\n          condition: scaleCondition(branch.condition, factor),\n          flow: scaleFlow(branch.flow, factor),\n        })),\n        ...(node.otherwise === undefined ? {} : { otherwise: scaleFlow(node.otherwise, factor) }),\n      };\n    case 'filter':\n      return { ...node, condition: scaleCondition(node.condition, factor) };\n    case 'cohort':\n      return {\n        ...node,\n        arms: node.arms.map((arm) => ({ ...arm, flow: scaleFlow(arm.flow, factor) })),\n      };\n    default:\n      return node;\n  }\n}\n\nfunction scale(duration: DurationIR, factor: number): DurationIR {\n  return { value: duration.value, ms: Math.max(0, Math.round(duration.ms / 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<ConditionIR | undefined> },\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          const condition = await target.getSegmentCondition(name);\n          return condition === undefined ? undefined : scaleCondition(condition, factor);\n        };\n      }\n      const value: unknown = Reflect.get(target, property, target);\n      return typeof value === 'function' ? value.bind(target) : value;\n    },\n  });\n}\n"],"mappings":"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"}

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

@@ -1,3 +1,4 @@
+import { ConditionIR, WorkflowIR } from "../ir.cjs";
 //#region src/engine/time-scale.d.ts
 /**
  * Debug time scale: divide every duration in a workflow's IR by a factor so a
@@ -12,12 +13,14 @@
  * 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.
+ * The walk follows the IR's own structure — the fields that hold a Duration
+ * are known — so a message prop or an event payload that happens to look like
+ * one (`{ value, ms }`) is left alone. The source text is kept so the studio
+ * still shows what was written.
  */
-export declare function scaleDurations<T>(ir: T, factor: number): T;
+export declare function scaleDurations(ir: WorkflowIR, factor: number): WorkflowIR;
+/** A condition with its `performed(... within)` windows divided by `factor`. */
+export declare function scaleCondition(condition: ConditionIR, factor: number): ConditionIR;
 /**
  * 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' })`)
@@ -25,7 +28,7 @@ export declare function scaleDurations<T>(ir: T, factor: number): T;
  * other method is the store's own.
  */
 export declare function scaleSegmentWindows<S extends {
-  getSegmentCondition(name: string): Promise<unknown>;
+  getSegmentCondition(name: string): Promise<ConditionIR | undefined>;
 }>(store: S, factor: number): S;
 //#endregion
 //# sourceMappingURL=time-scale.d.cts.map

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

@@ -1 +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"}
+{"version":3,"file":"time-scale.d.cts","names":[],"sources":["../../src/engine/time-scale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;wBAoBgB,eAAe,IAAI,YAAY,iBAAiB;;wBA4BhD,eAAe,WAAW,aAAa,iBAAiB;;;;;;;wBAuExD,oBACd;EAAY,oBAAoB,eAAe,QAAQ;GACvD,OAAO,GAAG,iBAAiB"}

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

@@ -1,3 +1,4 @@
+import { ConditionIR, WorkflowIR } from "../ir.mjs";
 //#region src/engine/time-scale.d.ts
 /**
  * Debug time scale: divide every duration in a workflow's IR by a factor so a
@@ -12,12 +13,14 @@
  * 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.
+ * The walk follows the IR's own structure — the fields that hold a Duration
+ * are known — so a message prop or an event payload that happens to look like
+ * one (`{ value, ms }`) is left alone. The source text is kept so the studio
+ * still shows what was written.
  */
-export declare function scaleDurations<T>(ir: T, factor: number): T;
+export declare function scaleDurations(ir: WorkflowIR, factor: number): WorkflowIR;
+/** A condition with its `performed(... within)` windows divided by `factor`. */
+export declare function scaleCondition(condition: ConditionIR, factor: number): ConditionIR;
 /**
  * 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' })`)
@@ -25,7 +28,7 @@ export declare function scaleDurations<T>(ir: T, factor: number): T;
  * other method is the store's own.
  */
 export declare function scaleSegmentWindows<S extends {
-  getSegmentCondition(name: string): Promise<unknown>;
+  getSegmentCondition(name: string): Promise<ConditionIR | undefined>;
 }>(store: S, factor: number): S;
 //#endregion
 //# sourceMappingURL=time-scale.d.mts.map

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

@@ -1 +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"}
+{"version":3,"file":"time-scale.d.mts","names":[],"sources":["../../src/engine/time-scale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;wBAoBgB,eAAe,IAAI,YAAY,iBAAiB;;wBA4BhD,eAAe,WAAW,aAAa,iBAAiB;;;;;;;wBAuExD,oBACd;EAAY,oBAAoB,eAAe,QAAQ;GACvD,OAAO,GAAG,iBAAiB"}

package/dist/engine/time-scale.mjs

@@ -12,25 +12,96 @@
 * 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.
+* The walk follows the IR's own structure — the fields that hold a Duration
+* are known — so a message prop or an event payload that happens to look like
+* one (`{ value, ms }`) is left alone. The source 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);
+	return {
+		...ir,
+		trigger: ir.trigger.type === "event" ? {
+			...ir.trigger,
+			...ir.trigger.filter === void 0 ? {} : { filter: scaleCondition(ir.trigger.filter, factor) }
+		} : ir.trigger,
+		...ir.goal === void 0 ? {} : { goal: {
+			...ir.goal,
+			condition: scaleCondition(ir.goal.condition, factor),
+			...ir.goal.within === void 0 ? {} : { within: scale(ir.goal.within, factor) }
+		} },
+		...ir.exitWhen === void 0 ? {} : { exitWhen: scaleCondition(ir.exitWhen, factor) },
+		flow: scaleFlow(ir.flow, factor)
+	};
+}
+/** A condition with its `performed(... within)` windows divided by `factor`. */
+function scaleCondition(condition, factor) {
+	if (!(factor > 0) || factor === 1) return condition;
+	switch (condition.type) {
+		case "and":
+		case "or": return {
+			...condition,
+			conditions: condition.conditions.map((child) => scaleCondition(child, factor))
+		};
+		case "not": return {
+			...condition,
+			condition: scaleCondition(condition.condition, factor)
+		};
+		case "performed": return condition.within === void 0 ? condition : {
+			...condition,
+			within: scale(condition.within, factor)
+		};
+		default: return condition;
+	}
+}
+function scaleFlow(nodes, factor) {
+	return nodes.map((node) => scaleNode(node, factor));
+}
+function scaleNode(node, factor) {
+	switch (node.type) {
+		case "delay": return {
+			...node,
+			duration: scale(node.duration, factor)
+		};
+		case "random_delay": return {
+			...node,
+			min: scale(node.min, factor),
+			max: scale(node.max, factor)
+		};
+		case "wait_until": return {
+			...node,
+			condition: scaleCondition(node.condition, factor),
+			timeout: scale(node.timeout, factor),
+			onTimeout: Array.isArray(node.onTimeout) ? scaleFlow(node.onTimeout, factor) : node.onTimeout
+		};
+		case "branch": return {
+			...node,
+			cases: node.cases.map((branch) => ({
+				...branch,
+				condition: scaleCondition(branch.condition, factor),
+				flow: scaleFlow(branch.flow, factor)
+			})),
+			...node.otherwise === void 0 ? {} : { otherwise: scaleFlow(node.otherwise, factor) }
+		};
+		case "filter": return {
+			...node,
+			condition: scaleCondition(node.condition, factor)
+		};
+		case "cohort": return {
+			...node,
+			arms: node.arms.map((arm) => ({
+				...arm,
+				flow: scaleFlow(arm.flow, factor)
+			}))
+		};
+		default: return node;
+	}
 }
-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))
+function scale(duration, factor) {
+	return {
+		value: duration.value,
+		ms: Math.max(0, Math.round(duration.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
@@ -41,12 +112,15 @@ function walk(value, factor) {
 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);
+		if (property === "getSegmentCondition") return async (name) => {
+			const condition = await target.getSegmentCondition(name);
+			return condition === void 0 ? void 0 : scaleCondition(condition, factor);
+		};
 		const value = Reflect.get(target, property, target);
 		return typeof value === "function" ? value.bind(target) : value;
 	} });
 }
 //#endregion
-export { scaleDurations, scaleSegmentWindows };
+export { scaleCondition, scaleDurations, scaleSegmentWindows };
 
 //# sourceMappingURL=time-scale.mjs.map

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

@@ -1 +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"}
+{"version":3,"file":"time-scale.mjs","names":[],"sources":["../../src/engine/time-scale.ts"],"sourcesContent":["import type { ConditionIR, DurationIR, NodeIR, WorkflowIR } from '../ir';\n\n/**\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 * The walk follows the IR's own structure — the fields that hold a Duration\n * are known — so a message prop or an event payload that happens to look like\n * one (`{ value, ms }`) is left alone. The source text is kept so the studio\n * still shows what was written.\n */\nexport function scaleDurations(ir: WorkflowIR, factor: number): WorkflowIR {\n  if (!(factor > 0) || factor === 1) return ir;\n  return {\n    ...ir,\n    trigger:\n      ir.trigger.type === 'event'\n        ? {\n            ...ir.trigger,\n            ...(ir.trigger.filter === undefined\n              ? {}\n              : { filter: scaleCondition(ir.trigger.filter, factor) }),\n          }\n        : ir.trigger,\n    ...(ir.goal === undefined\n      ? {}\n      : {\n          goal: {\n            ...ir.goal,\n            condition: scaleCondition(ir.goal.condition, factor),\n            ...(ir.goal.within === undefined ? {} : { within: scale(ir.goal.within, factor) }),\n          },\n        }),\n    ...(ir.exitWhen === undefined ? {} : { exitWhen: scaleCondition(ir.exitWhen, factor) }),\n    flow: scaleFlow(ir.flow, factor),\n  };\n}\n\n/** A condition with its `performed(... within)` windows divided by `factor`. */\nexport function scaleCondition(condition: ConditionIR, factor: number): ConditionIR {\n  if (!(factor > 0) || factor === 1) return condition;\n  switch (condition.type) {\n    case 'and':\n    case 'or':\n      return {\n        ...condition,\n        conditions: condition.conditions.map((child) => scaleCondition(child, factor)),\n      };\n    case 'not':\n      return { ...condition, condition: scaleCondition(condition.condition, factor) };\n    case 'performed':\n      return condition.within === undefined\n        ? condition\n        : { ...condition, within: scale(condition.within, factor) };\n    default:\n      return condition;\n  }\n}\n\nfunction scaleFlow(nodes: readonly NodeIR[], factor: number): NodeIR[] {\n  return nodes.map((node) => scaleNode(node, factor));\n}\n\nfunction scaleNode(node: NodeIR, factor: number): NodeIR {\n  switch (node.type) {\n    case 'delay':\n      return { ...node, duration: scale(node.duration, factor) };\n    case 'random_delay':\n      return { ...node, min: scale(node.min, factor), max: scale(node.max, factor) };\n    case 'wait_until':\n      return {\n        ...node,\n        condition: scaleCondition(node.condition, factor),\n        timeout: scale(node.timeout, factor),\n        onTimeout: Array.isArray(node.onTimeout)\n          ? scaleFlow(node.onTimeout, factor)\n          : node.onTimeout,\n      };\n    case 'branch':\n      return {\n        ...node,\n        cases: node.cases.map((branch) => ({\n          ...branch,\n          condition: scaleCondition(branch.condition, factor),\n          flow: scaleFlow(branch.flow, factor),\n        })),\n        ...(node.otherwise === undefined ? {} : { otherwise: scaleFlow(node.otherwise, factor) }),\n      };\n    case 'filter':\n      return { ...node, condition: scaleCondition(node.condition, factor) };\n    case 'cohort':\n      return {\n        ...node,\n        arms: node.arms.map((arm) => ({ ...arm, flow: scaleFlow(arm.flow, factor) })),\n      };\n    default:\n      return node;\n  }\n}\n\nfunction scale(duration: DurationIR, factor: number): DurationIR {\n  return { value: duration.value, ms: Math.max(0, Math.round(duration.ms / 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<ConditionIR | undefined> },\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          const condition = await target.getSegmentCondition(name);\n          return condition === undefined ? undefined : scaleCondition(condition, factor);\n        };\n      }\n      const value: unknown = Reflect.get(target, property, target);\n      return typeof value === 'function' ? value.bind(target) : value;\n    },\n  });\n}\n"],"mappings":"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"}