@shware/workflow 0.0.0-stage → 0.1.0

package/dist/engine/ports.d.cts

@@ -0,0 +1,252 @@
+import { ChannelIR, ConditionIR, ScalarIR } from "../ir.cjs";
+//#region src/engine/ports.d.ts
+/**
+ * Engine ports: the only shape of the outside world the interpreter depends on.
+ *
+ * Design constraints (AWS-proof, see the engine design notes):
+ * - A wake-up is only a hint — "**at least one wake-up, re-evaluate after
+ *   waking**". No event buffering or de-duplication is promised (Cloudflare
+ *   buffers, AWS callback tokens do not — the port takes the intersection).
+ *   The truth of a condition is always re-read by the caller once awake.
+ * - subscribe / waitForWake / unsubscribe are split so the caller can register
+ *   interest *before* its first condition check — an event landing between the
+ *   check and the registration would otherwise be missed until the timeout.
+ * - Every source of non-determinism (randomness, current time, external IO)
+ *   must happen inside step.do, so its result is persisted and replay lines up.
+ */
+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. */
+  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
+   * complete before the caller's condition check for that attempt.
+   *
+   * Contract: one subscribe arms **at least one** wake-up — adapters whose
+   * wake handle is one-shot (AWS durable-function callbacks are consumed on
+   * delivery) satisfy it with exactly one. Callers therefore re-subscribe on
+   * every wait attempt; adapters where registrations persist (Cloudflare rows)
+   * make the repeat call idempotent.
+   */
+  subscribe(name: string, events: readonly string[]): Promise<void>;
+  /** Durable: drop every registration this instance holds. */
+  unsubscribe(name: string): Promise<void>;
+  /**
+   * Wait for a wake-up or a timeout. A registration from `subscribe` must
+   * already exist — this call only parks the instance.
+   */
+  waitForWake(name: string, timeoutMs: 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 {
+  token: string;
+  platform: string;
+}
+/** Facts from a single user's point of view: the read interface condition evaluation uses (D1 and in-memory share one evaluator). */
+export interface FactSource {
+  /**
+   * How many times an event occurred. `sinceMs` bounds the window (within /
+   * anchoring); `where` is a payload-only condition tree — count only events
+   * whose payload matches (evaluate with matchesWhere from engine/condition).
+   */
+  countEvents(event: string, opts?: {
+    sinceMs?: number;
+    untilMs?: number;
+    where?: ConditionIR;
+  }): Promise<number>;
+  getProperty(path: string): Promise<ScalarIR | undefined>;
+  /** Resolve a segment definition by id (stored with the bundle at deploy time). */
+  getSegmentCondition(name: string): Promise<ConditionIR | undefined>;
+  /** The user's push devices, most recently registered first (empty when the user registered none). */
+  listDevices(): Promise<PushDevice[]>;
+  /** The user opted out of the channel (an email unsubscribe): nothing is sent there. */
+  isSuppressed?(channel: ChannelIR): Promise<boolean>;
+}
+export interface OutboundMessage {
+  /** Where the copy comes from: the workflow, its instance and the message node. */
+  workflow: string;
+  instanceId: string;
+  nodeId: string;
+  channel: ChannelIR;
+  template: string;
+  /** Already resolved: user_property references have been replaced by actual values. */
+  props: Record<string, ScalarIR | undefined>;
+  userId: string;
+  /**
+   * The channel's recipient address, resolved by the engine — so senders never
+   * read the database: a profile property for most channels, the device token
+   * for push (one message per device).
+   */
+  recipient?: string | undefined;
+  /** Push only: the device this copy goes to — its platform picks the provider. */
+  device?: PushDevice | undefined;
+  /**
+   * `${instanceId}:${nodeId}` (plus `:${token}` for a push copy) — one per copy. Senders
+   * de-duplicate on it, making replays and retries safe, and it is the copy's identity for
+   * tracking: a push carries it in its payload, so the app can report the tap against it.
+   */
+  idempotencyKey: string;
+  /** What the host's observer asked the sender to add for measuring this copy (see `MessageTracking`). */
+  tracking?: MessageTracking | undefined;
+}
+/**
+ * Measuring a copy, as the built-in senders apply it: an email's links are routed through
+ * `link` and `pixel` is appended as a 1×1 image; a push carries `data` in its payload.
+ * Each is optional, and a sender ignores what its channel has no use for.
+ */
+export interface MessageTracking {
+  /** The original `http(s)` URL in, the URL that records the click and redirects out. */
+  link?: (url: string) => string;
+  /** Loaded when the email is opened. */
+  pixel?: string;
+  /** Extra string keys in the push payload. */
+  data?: Record<string, string>;
+  /**
+   * Called by the sender once the links are rewritten and before the transport takes the copy:
+   * what the tracking URLs resolve to is stored before anyone can click one. A throw stops the
+   * send, and the step retries it.
+   */
+  commit?: () => Promise<void>;
+}
+/**
+ * How a copy ended at the transport. A sender returns nothing when the transport accepted it;
+ * `{ delivered: false }` when it settled the copy without delivering — a dead push token, which
+ * is not retried. A transient failure throws instead, and the step retries.
+ */
+export interface SendResult {
+  delivered: false;
+  reason: string;
+}
+export interface MessageSender {
+  send(message: OutboundMessage): Promise<void | SendResult>;
+}
+/**
+ * What the host learns about each journey as it runs, for reporting: where every instance
+ * stands, every copy it sends and how the transport took it, and how it ended. Storage is the
+ * host's — the engine only reports. Every method is optional and must be idempotent: a step
+ * that fails after its report ran is retried and reports again (keyed by the instance and node,
+ * or the copy's idempotency key).
+ */
+export interface JourneyObserver {
+  /** The instance entered, before its entry guards: `at` is the trigger's time, the entry anchor. */
+  started?(event: {
+    workflow: string;
+    instanceId: string;
+    userId: string;
+    at: number;
+  }): Promise<void>;
+  /** The instance reached a node: it sits there until the next one (a delay, a wait), or passes through. */
+  nodeReached?(event: {
+    workflow: string;
+    instanceId: string;
+    userId: string;
+    nodeId: string;
+    at: number;
+  }): Promise<void>;
+  /** A copy is about to go out; the tracking returned travels with it to the sender. */
+  messagePrepared?(message: OutboundMessage): Promise<MessageTracking | undefined>;
+  /** The transport took the copy (`delivered: true`), or settled it undelivered; a thrown send is not reported. */
+  messageSent?(message: OutboundMessage, result: {
+    delivered: true;
+  } | SendResult): Promise<void>;
+  /** The instance ended: its outcome (`goal` is a conversion), or `failed` when an error ended it. */
+  finished?(event: {
+    workflow: string;
+    instanceId: string;
+    userId: string;
+    status: JourneyOutcome['status'] | 'failed';
+    at: number;
+    /** When it converted, if it did — set whatever the status (see JourneyOutcome). */
+    convertedAt?: number;
+  }): Promise<void>;
+}
+/**
+ * Message preparation: checks a message's resolved props against its template
+ * before any sender sees it (and, for a push, before the first device), and
+ * returns the props to send — the parsed value. Throwing stops the send; the
+ * interpreter adds the instance and node to the error. The Cloudflare host
+ * assembles one from the template registries (`registryValidator`).
+ */
+export interface MessageValidator {
+  validate(message: {
+    channel: ChannelIR;
+    template: string;
+    props: Record<string, ScalarIR | undefined>;
+  }): Record<string, ScalarIR | undefined>;
+}
+/** send_event's outlet: feeds back into ingest (the event edge between workflows). */
+export interface EventSink {
+  /**
+   * `id` identifies the occurrence, and sending the same one twice must record
+   * it once. The interpreter passes `${instanceId}:${nodeId}` — the same
+   * identity senders and actions de-duplicate on — because the emit is wrapped
+   * in a step, and a step body is retried after a failure that may have
+   * happened *after* the event was already written.
+   */
+  emit(event: string, payload: Record<string, ScalarIR | undefined>, id: string): Promise<void>;
+}
+/** One action node's resolved call, ready for the registry. */
+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;
+  /** `${instanceId}:${nodeId}` — handlers with external side effects de-duplicate on it, like senders do. */
+  idempotencyKey: string;
+}
+/**
+ * Custom-action outlet. The interpreter already wraps the call in step.do, so
+ * an implementation may just look up and run the handler — a throw is retried
+ * by the runtime, a success is checkpointed.
+ */
+export interface ActionInvoker {
+  invoke(invocation: ActionInvocation): Promise<void>;
+}
+export interface JourneyContext {
+  userId: string;
+  /** Instance identity: feeds the idempotency key and the logs. */
+  instanceId: string;
+  /**
+   * When the user entered the workflow (ms epoch) — the baseline for the
+   * goal's attribution window (`goal.within`). Must be replay-stable: the
+   * adapter derives it from the trigger event's timestamp, never from
+   * Date.now() at run time.
+   */
+  enteredAtMs: number;
+  step: EngineStep;
+  facts: FactSource;
+  messages: MessageSender;
+  events: EventSink;
+  /** Optional: only journeys whose IR contains action nodes need one; running such a node without it is a runtime error. */
+  actions?: ActionInvoker | undefined;
+  /** Template props validation before every send; without one, props go out as resolved. */
+  validator?: MessageValidator | undefined;
+  /** Reporting hooks (positions and copies); without one, nothing is reported. */
+  observer?: JourneyObserver | undefined;
+}
+/**
+ * How an instance ended, and — apart from that — whether and when it converted: `goal` ends it
+ * at the conversion, while with `exitOnMatch: false` a converted instance ends like any other
+ * and only `convertedAt` tells.
+ */
+export type JourneyOutcome = ({
+  status: 'completed';
+} | {
+  status: 'exited';
+  reason?: string;
+} | {
+  status: 'goal';
+} | {
+  status: 'exit_when';
+}) & {
+  convertedAt?: number;
+};
+//#endregion
+//# sourceMappingURL=ports.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.cts","names":[],"sources":["../../src/engine/ports.ts"],"mappings":";;;;;;;;;;;;;;;;iBAiBiB;;EAEf,GAAG,GAAG,cAAc,UAAU,QAAQ,KAAK,QAAQ;;EAGnD,MAAM,cAAc,aAAa;;EAGjC,WAAW,cAAc,sBAAsB;;;;;;;;;;;;EAa/C,UAAU,cAAc,4BAA4B;;EAGpD,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;;;;;;;iBAQI;;EAEf,QAAQ;;EAER;;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"}

package/dist/engine/ports.d.mts

@@ -0,0 +1,252 @@
+import { ChannelIR, ConditionIR, ScalarIR } from "../ir.mjs";
+//#region src/engine/ports.d.ts
+/**
+ * Engine ports: the only shape of the outside world the interpreter depends on.
+ *
+ * Design constraints (AWS-proof, see the engine design notes):
+ * - A wake-up is only a hint — "**at least one wake-up, re-evaluate after
+ *   waking**". No event buffering or de-duplication is promised (Cloudflare
+ *   buffers, AWS callback tokens do not — the port takes the intersection).
+ *   The truth of a condition is always re-read by the caller once awake.
+ * - subscribe / waitForWake / unsubscribe are split so the caller can register
+ *   interest *before* its first condition check — an event landing between the
+ *   check and the registration would otherwise be missed until the timeout.
+ * - Every source of non-determinism (randomness, current time, external IO)
+ *   must happen inside step.do, so its result is persisted and replay lines up.
+ */
+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. */
+  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
+   * complete before the caller's condition check for that attempt.
+   *
+   * Contract: one subscribe arms **at least one** wake-up — adapters whose
+   * wake handle is one-shot (AWS durable-function callbacks are consumed on
+   * delivery) satisfy it with exactly one. Callers therefore re-subscribe on
+   * every wait attempt; adapters where registrations persist (Cloudflare rows)
+   * make the repeat call idempotent.
+   */
+  subscribe(name: string, events: readonly string[]): Promise<void>;
+  /** Durable: drop every registration this instance holds. */
+  unsubscribe(name: string): Promise<void>;
+  /**
+   * Wait for a wake-up or a timeout. A registration from `subscribe` must
+   * already exist — this call only parks the instance.
+   */
+  waitForWake(name: string, timeoutMs: 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 {
+  token: string;
+  platform: string;
+}
+/** Facts from a single user's point of view: the read interface condition evaluation uses (D1 and in-memory share one evaluator). */
+export interface FactSource {
+  /**
+   * How many times an event occurred. `sinceMs` bounds the window (within /
+   * anchoring); `where` is a payload-only condition tree — count only events
+   * whose payload matches (evaluate with matchesWhere from engine/condition).
+   */
+  countEvents(event: string, opts?: {
+    sinceMs?: number;
+    untilMs?: number;
+    where?: ConditionIR;
+  }): Promise<number>;
+  getProperty(path: string): Promise<ScalarIR | undefined>;
+  /** Resolve a segment definition by id (stored with the bundle at deploy time). */
+  getSegmentCondition(name: string): Promise<ConditionIR | undefined>;
+  /** The user's push devices, most recently registered first (empty when the user registered none). */
+  listDevices(): Promise<PushDevice[]>;
+  /** The user opted out of the channel (an email unsubscribe): nothing is sent there. */
+  isSuppressed?(channel: ChannelIR): Promise<boolean>;
+}
+export interface OutboundMessage {
+  /** Where the copy comes from: the workflow, its instance and the message node. */
+  workflow: string;
+  instanceId: string;
+  nodeId: string;
+  channel: ChannelIR;
+  template: string;
+  /** Already resolved: user_property references have been replaced by actual values. */
+  props: Record<string, ScalarIR | undefined>;
+  userId: string;
+  /**
+   * The channel's recipient address, resolved by the engine — so senders never
+   * read the database: a profile property for most channels, the device token
+   * for push (one message per device).
+   */
+  recipient?: string | undefined;
+  /** Push only: the device this copy goes to — its platform picks the provider. */
+  device?: PushDevice | undefined;
+  /**
+   * `${instanceId}:${nodeId}` (plus `:${token}` for a push copy) — one per copy. Senders
+   * de-duplicate on it, making replays and retries safe, and it is the copy's identity for
+   * tracking: a push carries it in its payload, so the app can report the tap against it.
+   */
+  idempotencyKey: string;
+  /** What the host's observer asked the sender to add for measuring this copy (see `MessageTracking`). */
+  tracking?: MessageTracking | undefined;
+}
+/**
+ * Measuring a copy, as the built-in senders apply it: an email's links are routed through
+ * `link` and `pixel` is appended as a 1×1 image; a push carries `data` in its payload.
+ * Each is optional, and a sender ignores what its channel has no use for.
+ */
+export interface MessageTracking {
+  /** The original `http(s)` URL in, the URL that records the click and redirects out. */
+  link?: (url: string) => string;
+  /** Loaded when the email is opened. */
+  pixel?: string;
+  /** Extra string keys in the push payload. */
+  data?: Record<string, string>;
+  /**
+   * Called by the sender once the links are rewritten and before the transport takes the copy:
+   * what the tracking URLs resolve to is stored before anyone can click one. A throw stops the
+   * send, and the step retries it.
+   */
+  commit?: () => Promise<void>;
+}
+/**
+ * How a copy ended at the transport. A sender returns nothing when the transport accepted it;
+ * `{ delivered: false }` when it settled the copy without delivering — a dead push token, which
+ * is not retried. A transient failure throws instead, and the step retries.
+ */
+export interface SendResult {
+  delivered: false;
+  reason: string;
+}
+export interface MessageSender {
+  send(message: OutboundMessage): Promise<void | SendResult>;
+}
+/**
+ * What the host learns about each journey as it runs, for reporting: where every instance
+ * stands, every copy it sends and how the transport took it, and how it ended. Storage is the
+ * host's — the engine only reports. Every method is optional and must be idempotent: a step
+ * that fails after its report ran is retried and reports again (keyed by the instance and node,
+ * or the copy's idempotency key).
+ */
+export interface JourneyObserver {
+  /** The instance entered, before its entry guards: `at` is the trigger's time, the entry anchor. */
+  started?(event: {
+    workflow: string;
+    instanceId: string;
+    userId: string;
+    at: number;
+  }): Promise<void>;
+  /** The instance reached a node: it sits there until the next one (a delay, a wait), or passes through. */
+  nodeReached?(event: {
+    workflow: string;
+    instanceId: string;
+    userId: string;
+    nodeId: string;
+    at: number;
+  }): Promise<void>;
+  /** A copy is about to go out; the tracking returned travels with it to the sender. */
+  messagePrepared?(message: OutboundMessage): Promise<MessageTracking | undefined>;
+  /** The transport took the copy (`delivered: true`), or settled it undelivered; a thrown send is not reported. */
+  messageSent?(message: OutboundMessage, result: {
+    delivered: true;
+  } | SendResult): Promise<void>;
+  /** The instance ended: its outcome (`goal` is a conversion), or `failed` when an error ended it. */
+  finished?(event: {
+    workflow: string;
+    instanceId: string;
+    userId: string;
+    status: JourneyOutcome['status'] | 'failed';
+    at: number;
+    /** When it converted, if it did — set whatever the status (see JourneyOutcome). */
+    convertedAt?: number;
+  }): Promise<void>;
+}
+/**
+ * Message preparation: checks a message's resolved props against its template
+ * before any sender sees it (and, for a push, before the first device), and
+ * returns the props to send — the parsed value. Throwing stops the send; the
+ * interpreter adds the instance and node to the error. The Cloudflare host
+ * assembles one from the template registries (`registryValidator`).
+ */
+export interface MessageValidator {
+  validate(message: {
+    channel: ChannelIR;
+    template: string;
+    props: Record<string, ScalarIR | undefined>;
+  }): Record<string, ScalarIR | undefined>;
+}
+/** send_event's outlet: feeds back into ingest (the event edge between workflows). */
+export interface EventSink {
+  /**
+   * `id` identifies the occurrence, and sending the same one twice must record
+   * it once. The interpreter passes `${instanceId}:${nodeId}` — the same
+   * identity senders and actions de-duplicate on — because the emit is wrapped
+   * in a step, and a step body is retried after a failure that may have
+   * happened *after* the event was already written.
+   */
+  emit(event: string, payload: Record<string, ScalarIR | undefined>, id: string): Promise<void>;
+}
+/** One action node's resolved call, ready for the registry. */
+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;
+  /** `${instanceId}:${nodeId}` — handlers with external side effects de-duplicate on it, like senders do. */
+  idempotencyKey: string;
+}
+/**
+ * Custom-action outlet. The interpreter already wraps the call in step.do, so
+ * an implementation may just look up and run the handler — a throw is retried
+ * by the runtime, a success is checkpointed.
+ */
+export interface ActionInvoker {
+  invoke(invocation: ActionInvocation): Promise<void>;
+}
+export interface JourneyContext {
+  userId: string;
+  /** Instance identity: feeds the idempotency key and the logs. */
+  instanceId: string;
+  /**
+   * When the user entered the workflow (ms epoch) — the baseline for the
+   * goal's attribution window (`goal.within`). Must be replay-stable: the
+   * adapter derives it from the trigger event's timestamp, never from
+   * Date.now() at run time.
+   */
+  enteredAtMs: number;
+  step: EngineStep;
+  facts: FactSource;
+  messages: MessageSender;
+  events: EventSink;
+  /** Optional: only journeys whose IR contains action nodes need one; running such a node without it is a runtime error. */
+  actions?: ActionInvoker | undefined;
+  /** Template props validation before every send; without one, props go out as resolved. */
+  validator?: MessageValidator | undefined;
+  /** Reporting hooks (positions and copies); without one, nothing is reported. */
+  observer?: JourneyObserver | undefined;
+}
+/**
+ * How an instance ended, and — apart from that — whether and when it converted: `goal` ends it
+ * at the conversion, while with `exitOnMatch: false` a converted instance ends like any other
+ * and only `convertedAt` tells.
+ */
+export type JourneyOutcome = ({
+  status: 'completed';
+} | {
+  status: 'exited';
+  reason?: string;
+} | {
+  status: 'goal';
+} | {
+  status: 'exit_when';
+}) & {
+  convertedAt?: number;
+};
+//#endregion
+//# sourceMappingURL=ports.d.mts.map

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

@@ -0,0 +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;;;;;;;;;;;;EAa/C,UAAU,cAAc,4BAA4B;;EAGpD,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;;;;;;;iBAQI;;EAEf,QAAQ;;EAER;;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"}

package/dist/engine/ports.mjs

@@ -0,0 +1 @@
+export {};

package/dist/engine/recipient.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/engine/recipient.ts
+/**
+* Channel → the user property holding its recipient address. The engine
+* resolves it before sending, which keeps senders stateless. Push is absent on
+* purpose: its recipients are devices, kept in the store. Slack and Discord post to a team
+* channel through the template's webhook, so they have no per-user address either.
+* TODO: let the app override this table (today it is a convention, with
+* UserPropertyBase guaranteeing `email` exists).
+*/
+const RECIPIENT_PROPERTY = {
+	email: "email",
+	sms: "phone",
+	push: void 0,
+	slack: void 0,
+	discord: void 0,
+	survey: "email",
+	in_app: void 0
+};
+//#endregion
+exports.RECIPIENT_PROPERTY = RECIPIENT_PROPERTY;
+
+//# sourceMappingURL=recipient.cjs.map

package/dist/engine/recipient.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipient.cjs","names":[],"sources":["../../src/engine/recipient.ts"],"sourcesContent":["import type { ChannelIR } from '../ir';\n\n/**\n * Channel → the user property holding its recipient address. The engine\n * resolves it before sending, which keeps senders stateless. Push is absent on\n * purpose: its recipients are devices, kept in the store. Slack and Discord post to a team\n * channel through the template's webhook, so they have no per-user address either.\n * TODO: let the app override this table (today it is a convention, with\n * UserPropertyBase guaranteeing `email` exists).\n */\nexport const RECIPIENT_PROPERTY: Record<ChannelIR, string | undefined> = {\n  email: 'email',\n  sms: 'phone',\n  push: undefined,\n  slack: undefined,\n  discord: undefined,\n  survey: 'email',\n  in_app: undefined,\n};\n"],"mappings":";;;;;;;;;;AAUA,MAAa,qBAA4D;CACvE,OAAO;CACP,KAAK;CACL,MAAM,KAAA;CACN,OAAO,KAAA;CACP,SAAS,KAAA;CACT,QAAQ;CACR,QAAQ,KAAA;AACV"}

package/dist/engine/recipient.d.cts

@@ -0,0 +1,13 @@
+import { ChannelIR } from "../ir.cjs";
+//#region src/engine/recipient.d.ts
+/**
+ * Channel → the user property holding its recipient address. The engine
+ * resolves it before sending, which keeps senders stateless. Push is absent on
+ * purpose: its recipients are devices, kept in the store. Slack and Discord post to a team
+ * channel through the template's webhook, so they have no per-user address either.
+ * TODO: let the app override this table (today it is a convention, with
+ * UserPropertyBase guaranteeing `email` exists).
+ */
+export declare const RECIPIENT_PROPERTY: Record<ChannelIR, string | undefined>;
+//#endregion
+//# sourceMappingURL=recipient.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recipient.d.cts","names":[],"sources":["../../src/engine/recipient.ts"],"mappings":";;;;;;;;;;qBAUa,oBAAoB,OAAO"}

package/dist/engine/recipient.d.mts

@@ -0,0 +1,13 @@
+import { ChannelIR } from "../ir.mjs";
+//#region src/engine/recipient.d.ts
+/**
+ * Channel → the user property holding its recipient address. The engine
+ * resolves it before sending, which keeps senders stateless. Push is absent on
+ * purpose: its recipients are devices, kept in the store. Slack and Discord post to a team
+ * channel through the template's webhook, so they have no per-user address either.
+ * TODO: let the app override this table (today it is a convention, with
+ * UserPropertyBase guaranteeing `email` exists).
+ */
+export declare const RECIPIENT_PROPERTY: Record<ChannelIR, string | undefined>;
+//#endregion
+//# sourceMappingURL=recipient.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recipient.d.mts","names":[],"sources":["../../src/engine/recipient.ts"],"mappings":";;;;;;;;;;qBAUa,oBAAoB,OAAO"}

package/dist/engine/recipient.mjs

@@ -0,0 +1,22 @@
+//#region src/engine/recipient.ts
+/**
+* Channel → the user property holding its recipient address. The engine
+* resolves it before sending, which keeps senders stateless. Push is absent on
+* purpose: its recipients are devices, kept in the store. Slack and Discord post to a team
+* channel through the template's webhook, so they have no per-user address either.
+* TODO: let the app override this table (today it is a convention, with
+* UserPropertyBase guaranteeing `email` exists).
+*/
+const RECIPIENT_PROPERTY = {
+	email: "email",
+	sms: "phone",
+	push: void 0,
+	slack: void 0,
+	discord: void 0,
+	survey: "email",
+	in_app: void 0
+};
+//#endregion
+export { RECIPIENT_PROPERTY };
+
+//# sourceMappingURL=recipient.mjs.map

package/dist/engine/recipient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipient.mjs","names":[],"sources":["../../src/engine/recipient.ts"],"sourcesContent":["import type { ChannelIR } from '../ir';\n\n/**\n * Channel → the user property holding its recipient address. The engine\n * resolves it before sending, which keeps senders stateless. Push is absent on\n * purpose: its recipients are devices, kept in the store. Slack and Discord post to a team\n * channel through the template's webhook, so they have no per-user address either.\n * TODO: let the app override this table (today it is a convention, with\n * UserPropertyBase guaranteeing `email` exists).\n */\nexport const RECIPIENT_PROPERTY: Record<ChannelIR, string | undefined> = {\n  email: 'email',\n  sms: 'phone',\n  push: undefined,\n  slack: undefined,\n  discord: undefined,\n  survey: 'email',\n  in_app: undefined,\n};\n"],"mappings":";;;;;;;;;AAUA,MAAa,qBAA4D;CACvE,OAAO;CACP,KAAK;CACL,MAAM,KAAA;CACN,OAAO,KAAA;CACP,SAAS,KAAA;CACT,QAAQ;CACR,QAAQ,KAAA;AACV"}

package/dist/engine/time-scale.cjs

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