@shware/workflow 9.0.1 → 9.0.3

package/README.md

@@ -1404,6 +1404,17 @@ the sweep's maintenance marks an entry left unadmitted for 15 minutes, whose
 instance the runtime does not know or reports ended, as failed, so the user's
 next trigger re-enters. Neither can start a second journey for the pair.
 
+An instance can also end after it was admitted without finalizing its entry:
+terminated from the dashboard or the API, errored for good because a step kept
+failing, or evicted. The same maintenance samples the entries admitted more than
+15 minutes ago (a bounded random sample each sweep, so every entry is reached
+eventually however many journeys are running), and one whose instance the
+runtime reports `complete`, `errored` or `terminated`, or no longer knows, is
+marked failed, its wake subscriptions dropped and its ending reported — what the
+finalize step would have done. An instance still running, or one whose lookup
+fails for any other reason, is left alone. The next trigger of the pair then
+re-enters.
+
 ## Exports
 
 | Subpath                        | Contents                                                                                           |

package/dist/engine/time-scale.cjs

@@ -10,8 +10,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 * 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.
+* and trigger routes live in the store rather than the workflow body;
+* `scaleSegmentWindows` scales them as they are read — one segment for an
+* event-driven evaluation, all of them for the scheduled sweep, a route's
+* profile gate at ingest — so a segment's `within` keeps pace everywhere.
 *
 * 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
@@ -105,20 +107,40 @@ function scale(duration, 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.
+* A store whose segment definitions come back scaled by `factor` — what the journey host leases
+* 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 read that
+* hands out a stored condition is scaled: `getSegmentCondition` (event-driven evaluation),
+* `listSegments` (the scheduled sweep, which narrows candidates in SQL and evaluates with those
+* definitions) and `findTriggers` (the profile gate an event trigger checks before it starts a
+* journey, which `scaleDurations` scales inside the journey too). 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) => {
-			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;
+		if (typeof value !== "function") return value;
+		switch (property) {
+			case "getSegmentCondition": return async (name) => {
+				const condition = await target.getSegmentCondition(name);
+				return condition === void 0 ? void 0 : scaleCondition(condition, factor);
+			};
+			case "listSegments": return async () => {
+				return (await value.call(target)).map(({ id, condition }) => ({
+					id,
+					condition: scaleCondition(condition, factor)
+				}));
+			};
+			case "findTriggers": return async (event) => {
+				const scaled = (route) => ({
+					...route,
+					filter: route.filter === null ? null : scaleCondition(route.filter, factor)
+				});
+				return (await value.call(target, event)).map(scaled);
+			};
+			default: return value.bind(target);
+		}
 	} });
 }
 exports.scaleCondition = scaleCondition;

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

@@ -1 +1 @@
-{"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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"}
+{"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 * and trigger routes live in the store rather than the workflow body;\n * `scaleSegmentWindows` scales them as they are read — one segment for an\n * event-driven evaluation, all of them for the scheduled sweep, a route's\n * profile gate at ingest — so a segment's `within` keeps pace everywhere.\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 the journey host leases\n * in fast-forward, so a segment's windows (`performed(e.login, { within: '7 days' })`) shrink\n * with the journeys that reference it, and with the segment triggers it routes. Every read that\n * hands out a stored condition is scaled: `getSegmentCondition` (event-driven evaluation),\n * `listSegments` (the scheduled sweep, which narrows candidates in SQL and evaluates with those\n * definitions) and `findTriggers` (the profile gate an event trigger checks before it starts a\n * journey, which `scaleDurations` scales inside the journey too). Every other method is the\n * 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      const value: unknown = Reflect.get(target, property, target);\n      if (typeof value !== 'function') return value;\n      switch (property) {\n        case 'getSegmentCondition':\n          return async (name: string) => {\n            const condition = await target.getSegmentCondition(name);\n            return condition === undefined ? undefined : scaleCondition(condition, factor);\n          };\n        case 'listSegments':\n          return async () => {\n            const segments = (await value.call(target)) as { id: string; condition: ConditionIR }[];\n            return segments.map(({ id, condition }) => ({\n              id,\n              condition: scaleCondition(condition, factor),\n            }));\n          };\n        case 'findTriggers':\n          return async (event: string) => {\n            // Only the profile gate: `where` is payload-only, so it holds no window to scale\n            const scaled = (route: { filter: ConditionIR | null }) => ({\n              ...route,\n              filter: route.filter === null ? null : scaleCondition(route.filter, factor),\n            });\n            return ((await value.call(target, event)) as { filter: ConditionIR | null }[]).map(\n              scaled\n            );\n          };\n        default:\n          return value.bind(target);\n      }\n    },\n  });\n}\n"],"mappings":"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"}

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

@@ -9,8 +9,10 @@ import { ConditionIR, WorkflowIR } from "../ir.cjs";
  * 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.
+ * and trigger routes live in the store rather than the workflow body;
+ * `scaleSegmentWindows` scales them as they are read — one segment for an
+ * event-driven evaluation, all of them for the scheduled sweep, a route's
+ * profile gate at ingest — so a segment's `within` keeps pace everywhere.
  *
  * 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
@@ -21,10 +23,14 @@ export declare function scaleDurations(ir: WorkflowIR, factor: number): Workflow
 /** 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' })`)
- * shrink with the journeys that reference it, and with the segment triggers it routes. Every
- * other method is the store's own.
+ * A store whose segment definitions come back scaled by `factor` — what the journey host leases
+ * 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 read that
+ * hands out a stored condition is scaled: `getSegmentCondition` (event-driven evaluation),
+ * `listSegments` (the scheduled sweep, which narrows candidates in SQL and evaluates with those
+ * definitions) and `findTriggers` (the profile gate an event trigger checks before it starts a
+ * journey, which `scaleDurations` scales inside the journey too). Every other method is the
+ * store's own.
  */
 export declare function scaleSegmentWindows<S extends {
   getSegmentCondition(name: string): Promise<ConditionIR | undefined>;

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

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

@@ -9,8 +9,10 @@ import { ConditionIR, WorkflowIR } from "../ir.mjs";
  * 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.
+ * and trigger routes live in the store rather than the workflow body;
+ * `scaleSegmentWindows` scales them as they are read — one segment for an
+ * event-driven evaluation, all of them for the scheduled sweep, a route's
+ * profile gate at ingest — so a segment's `within` keeps pace everywhere.
  *
  * 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
@@ -21,10 +23,14 @@ export declare function scaleDurations(ir: WorkflowIR, factor: number): Workflow
 /** 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' })`)
- * shrink with the journeys that reference it, and with the segment triggers it routes. Every
- * other method is the store's own.
+ * A store whose segment definitions come back scaled by `factor` — what the journey host leases
+ * 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 read that
+ * hands out a stored condition is scaled: `getSegmentCondition` (event-driven evaluation),
+ * `listSegments` (the scheduled sweep, which narrows candidates in SQL and evaluates with those
+ * definitions) and `findTriggers` (the profile gate an event trigger checks before it starts a
+ * journey, which `scaleDurations` scales inside the journey too). Every other method is the
+ * store's own.
  */
 export declare function scaleSegmentWindows<S extends {
   getSegmentCondition(name: string): Promise<ConditionIR | undefined>;

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

package/dist/engine/time-scale.mjs

@@ -9,8 +9,10 @@
 * 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.
+* and trigger routes live in the store rather than the workflow body;
+* `scaleSegmentWindows` scales them as they are read — one segment for an
+* event-driven evaluation, all of them for the scheduled sweep, a route's
+* profile gate at ingest — so a segment's `within` keeps pace everywhere.
 *
 * 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
@@ -104,20 +106,40 @@ function scale(duration, 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.
+* A store whose segment definitions come back scaled by `factor` — what the journey host leases
+* 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 read that
+* hands out a stored condition is scaled: `getSegmentCondition` (event-driven evaluation),
+* `listSegments` (the scheduled sweep, which narrows candidates in SQL and evaluates with those
+* definitions) and `findTriggers` (the profile gate an event trigger checks before it starts a
+* journey, which `scaleDurations` scales inside the journey too). 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) => {
-			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;
+		if (typeof value !== "function") return value;
+		switch (property) {
+			case "getSegmentCondition": return async (name) => {
+				const condition = await target.getSegmentCondition(name);
+				return condition === void 0 ? void 0 : scaleCondition(condition, factor);
+			};
+			case "listSegments": return async () => {
+				return (await value.call(target)).map(({ id, condition }) => ({
+					id,
+					condition: scaleCondition(condition, factor)
+				}));
+			};
+			case "findTriggers": return async (event) => {
+				const scaled = (route) => ({
+					...route,
+					filter: route.filter === null ? null : scaleCondition(route.filter, factor)
+				});
+				return (await value.call(target, event)).map(scaled);
+			};
+			default: return value.bind(target);
+		}
 	} });
 }
 export { scaleCondition, scaleDurations, scaleSegmentWindows };

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

@@ -1 +1 @@
-{"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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"}
+{"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 * and trigger routes live in the store rather than the workflow body;\n * `scaleSegmentWindows` scales them as they are read — one segment for an\n * event-driven evaluation, all of them for the scheduled sweep, a route's\n * profile gate at ingest — so a segment's `within` keeps pace everywhere.\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 the journey host leases\n * in fast-forward, so a segment's windows (`performed(e.login, { within: '7 days' })`) shrink\n * with the journeys that reference it, and with the segment triggers it routes. Every read that\n * hands out a stored condition is scaled: `getSegmentCondition` (event-driven evaluation),\n * `listSegments` (the scheduled sweep, which narrows candidates in SQL and evaluates with those\n * definitions) and `findTriggers` (the profile gate an event trigger checks before it starts a\n * journey, which `scaleDurations` scales inside the journey too). Every other method is the\n * 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      const value: unknown = Reflect.get(target, property, target);\n      if (typeof value !== 'function') return value;\n      switch (property) {\n        case 'getSegmentCondition':\n          return async (name: string) => {\n            const condition = await target.getSegmentCondition(name);\n            return condition === undefined ? undefined : scaleCondition(condition, factor);\n          };\n        case 'listSegments':\n          return async () => {\n            const segments = (await value.call(target)) as { id: string; condition: ConditionIR }[];\n            return segments.map(({ id, condition }) => ({\n              id,\n              condition: scaleCondition(condition, factor),\n            }));\n          };\n        case 'findTriggers':\n          return async (event: string) => {\n            // Only the profile gate: `where` is payload-only, so it holds no window to scale\n            const scaled = (route: { filter: ConditionIR | null }) => ({\n              ...route,\n              filter: route.filter === null ? null : scaleCondition(route.filter, factor),\n            });\n            return ((await value.call(target, event)) as { filter: ConditionIR | null }[]).map(\n              scaled\n            );\n          };\n        default:\n          return value.bind(target);\n      }\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/host/ingest.cjs

@@ -119,6 +119,24 @@ async function refreshSegmentTriggers(env, store, userId, ts) {
 * and act on each membership transition: entering records the membership and starts the
 * segment's routed workflows, leaving drops it. A segment trigger therefore starts journeys for
 * users who enter after it is deployed; a user already a member is not entered again.
+*
+* Why the membership writes and the starts are separate store calls, and why that is safe:
+* - Each segment's transition is one store operation. `addSegmentMember` writes the membership
+*   and the starts it owes (`segment_start`) in one locked transaction; `removeSegmentMember`
+*   drops both in one transaction. No failure leaves a segment half-entered or half-left.
+* - Starts come only from `pendingSegmentStarts`, which exists only once that transaction has
+*   committed, so a journey is never started for a membership that was not recorded. A start that
+*   fails stays pending and is retried by the next evaluation (the sweep, the user's next event);
+*   it is crossed off only once an instance is known to exist (`entryStarted`).
+* - A retried or concurrent start cannot run a journey twice: `startJourney` goes through the
+*   entry ledger, keyed by (workflow, user) under the once policy, and the membership insert is
+*   `ON CONFLICT DO NOTHING`.
+* - Segments are independent memberships. A failure on one leaves the others where they were;
+*   every evaluation recomputes each from facts and the stored membership, so the next one
+*   converges rather than building on a partial run.
+* Folding every segment's writes into one transaction would add nothing: the starts have to happen
+* after the commit anyway (a workflow instance cannot join a database transaction), which is what
+* the `segment_start` outbox already provides.
 */
 async function refreshSegments(env, store, userId, ts, routes, segments = [], definitions = /* @__PURE__ */ new Map()) {
 	if (require_store_identity.isVisitorSubject(userId)) return [];
@@ -199,6 +217,63 @@ async function failLostStarts(env, store, now) {
 	}
 	return failed;
 }
+/**
+* How long after its admission an entry is left out of the lost-instance sample. No age proves
+* anything about an admitted instance — it can end a moment after admitting itself, and a long
+* wait runs for weeks — so this is not a judgment, only a filter: the freshest entries are the
+* ones most likely to still be running, and the ones a platform status may not have settled
+* for yet. Correctness rests on the lookup and the conditional update, not on the window.
+*/
+const LOST_INSTANCE_AFTER_MS = 9e5;
+/**
+* Admitted entries one maintenance run looks up on the platform: a random sample (see
+* `JourneyStore.admittedEntries`), so every entry is reached eventually however many are
+* running, and the sweep's platform calls stay bounded.
+*/
+const LOST_INSTANCE_BATCH = 50;
+/**
+* Instances that ended on the platform without finalizing their entry: terminated from outside
+* (the dashboard, the API), errored for good because a finalize step kept failing, or no longer
+* known to the runtime at all. The entry stays `running`, and the once-policy would bar the user
+* from the workflow for good. Only admitted entries are looked at — an unadmitted one is
+* `failLostStarts`' — and only a terminal status, or not found, ends one: an admitted instance
+* did reach the runtime, so not found now means it finished and was evicted (as `stopInstance`
+* reads it). A lookup that fails otherwise proves nothing and leaves the entry alone. The update
+* is conditional on the entry still running under the instance id, so a run that finalized
+* between the read and the lookup keeps its own status.
+*
+* `complete` ends in `failed` too: the run's finalize step is what records the real outcome, and
+* an instance complete with its entry still running went without it, so what the journey would
+* have recorded is unknown. Platform-neutral: on AWS the adapter's own maintenance reconciles
+* these too (both writes are idempotent), and its `status` reads running through a stop's
+* drain, so nothing is failed here that the adapter would still wait for.
+*/
+async function failLostInstances(env, store, now) {
+	const failed = [];
+	for (const entry of await store.admittedEntries(now - LOST_INSTANCE_AFTER_MS, LOST_INSTANCE_BATCH)) {
+		let status;
+		try {
+			const reported = await (await env.JOURNEY.get(entry.instanceId)).status?.();
+			if (reported === void 0 || !STOPPED_STATUSES.has(reported.status)) continue;
+			status = reported.status;
+		} catch (error) {
+			if (!(error instanceof require_host_platform.InstanceNotFoundError)) continue;
+			status = "not found";
+		}
+		if (!await store.failAdmittedEntry(entry.instanceId)) continue;
+		failed.push(entry.instanceId);
+		await store.unsubscribe(entry.instanceId);
+		await store.reporting.instanceFinished({
+			workflow: entry.workflow,
+			instanceId: entry.instanceId,
+			userId: entry.userId,
+			status: "failed",
+			at: now
+		});
+		console.error(`[workflow] ${entry.instanceId} (${entry.workflow}) ended on the platform (${status}) without finishing: marked failed, the next trigger re-enters`);
+	}
+	return failed;
+}
 /** How long a visitor who never signs in is kept after they were last heard from. */
 const VISITOR_RETENTION_MS = 7776e6;
 /** Visitors one sweep prunes: the next sweep goes on. */
@@ -207,9 +282,10 @@ const VISITOR_PRUNE_BATCH = 100;
 const SWEEP_PAGE_SIZE = 500;
 /**
 * What the sweep does before it looks at any user: the runtime's own upkeep (AWS: unconfirmed
-* starts, executions that ended unseen) and the erasures left unfinished (an instance would not
-* stop). A failure of either is logged, never fatal: the pages still run. Users whose erasure is
-* still pending afterwards are skipped by every page (`sweepSegmentsPaged`).
+* starts, executions that ended unseen), the entries whose start or instance was lost, and the
+* erasures left unfinished (an instance would not stop). A failure of any is logged, never
+* fatal: the pages still run. Users whose erasure is still pending afterwards are skipped by
+* every page (`sweepSegmentsPaged`).
 */
 async function sweepMaintenance(env, store) {
 	try {
@@ -222,6 +298,11 @@ async function sweepMaintenance(env, store) {
 	} catch (error) {
 		console.error("[workflow] reclaiming lost starts failed", error);
 	}
+	try {
+		await failLostInstances(env, store, Date.now());
+	} catch (error) {
+		console.error("[workflow] reclaiming lost instances failed", error);
+	}
 	try {
 		await store.pruneVisitors(Date.now() - VISITOR_RETENTION_MS, VISITOR_PRUNE_BATCH);
 	} catch (error) {
@@ -803,11 +884,13 @@ async function setSubscriptionsByMessage(env, store, messageId, patch, topics, n
 	};
 }
 exports.BundleIntegrityError = BundleIntegrityError;
+exports.LOST_INSTANCE_AFTER_MS = LOST_INSTANCE_AFTER_MS;
 exports.LOST_START_AFTER_MS = LOST_START_AFTER_MS;
 exports.SUBSCRIPTION_CHANNELS = SUBSCRIPTION_CHANNELS;
 exports.SWEEP_PAGE_SIZE = SWEEP_PAGE_SIZE;
 exports.VISITOR_RETENTION_MS = VISITOR_RETENTION_MS;
 exports.deployBundle = deployBundle;
+exports.failLostInstances = failLostInstances;
 exports.failLostStarts = failLostStarts;
 exports.forgetUser = forgetUser;
 exports.getSubscriptions = getSubscriptions;