@shware/workflow 0.0.0-stage → 0.1.0

package/dist/dsl/workflow.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.mjs","names":["WorkflowIRSchema"],"sources":["../../src/dsl/workflow.ts"],"sourcesContent":["import { semanticHash } from '../hash';\nimport {\n  type GoalIR,\n  IR_VERSION,\n  type MetaIR,\n  type NodeIR,\n  type SourceLocIR,\n  type WorkflowIR,\n  WorkflowIR as WorkflowIRSchema,\n} from '../ir';\nimport { captureLoc } from '../provenance';\nimport { type Duration, durationIR } from './base';\nimport { type Condition, condIR } from './condition';\nimport { type FlowBuilder, FlowBuilderImpl } from './flow';\nimport type { TriggerInternal, TriggerRef } from './trigger';\n\n/**\n * The workflow — a named flow chain plus its configuration (options =\n * configuration, the chain = steps), and the compiler back half: `toIR()`\n * deep-clones the collected nodes, assigns structural-path ids, computes the\n * contentHash (metadata stripped, see hash.ts) and self-checks the result\n * against the authoritative IR schema.\n */\n\n/** Full conversion-goal configuration (customer.io's Goal & Exit semantics). */\nexport interface GoalOptions {\n  condition: Condition;\n  /** Attribution window: how long after entry a match still counts as a conversion. Unbounded by default. */\n  within?: Duration;\n  /** Exit on conversion. Defaults to true — this is what absorbs all those True→Exit arms in a UI canvas. */\n  exitOnMatch?: boolean;\n}\n\nexport interface WorkflowDefinition {\n  /**\n   * Wire identity — engine instances, the entry ledger and stats keys are all\n   * built on it (`WorkflowIR.id`), so it is not something to rename for\n   * readability; `name` is.\n   */\n  id: string;\n\n  /** Trigger: a trigger.xxx() asset. TODO: multiple triggers, entry frequency / re-entry policy. */\n  trigger: TriggerRef;\n\n  /**\n   * Conversion goal: feeds reporting (conversion rate / attribution) and by\n   * default exits on match. Checked before each node runs. Pass a condition\n   * for the shorthand, or GoalOptions for the full form.\n   */\n  goal?: Condition | GoalOptions;\n\n  /** Plain exit condition: leaving without counting as a conversion (unsubscribed, no longer eligible). Coexists with goal. */\n  exitWhen?: Condition;\n\n  /*\n   * Everything below is human-facing metadata: it lands in IR's `meta` field\n   * and is **excluded from contentHash**. Editing it neither invalidates the\n   * version in-flight users are pinned to nor shows up as a change in plan.\n   */\n\n  /** Human label: what the studio shows instead of the id. */\n  name?: string;\n\n  /** One line on what this flow does (UI lists, plan output). */\n  description?: string;\n}\n\nexport interface WorkflowBuilder extends FlowBuilder {\n  toIR(): WorkflowIR;\n}\n\n/**\n * Assign node ids from the structural path (rules in ir.ts's header). Written\n * in place into the tree toIR deep-cloned, never into the builder's own nodes.\n */\nfunction assignIds(nodes: NodeIR[], prefix: string): void {\n  nodes.forEach((node, i) => {\n    const id = prefix === '' ? String(i) : `${prefix}.${i}`;\n    node.id = id;\n    switch (node.type) {\n      case 'branch':\n        node.cases.forEach((c, ci) => assignIds(c.flow, `${id}.c${ci}`));\n        if (node.otherwise) assignIds(node.otherwise, `${id}.o`);\n        break;\n      case 'cohort':\n        node.arms.forEach((arm) => assignIds(arm.flow, `${id}.${arm.name}`));\n        break;\n      case 'wait_until':\n        if (Array.isArray(node.onTimeout)) assignIds(node.onTimeout, `${id}.t`);\n        break;\n      default:\n        break;\n    }\n  });\n}\n\n/**\n * Ids are derived, never authored, so a duplicate is always a compiler bug —\n * and a silent one: assignIds writes in place, so the second write simply wins\n * and two nodes ship as one. What that costs is concrete, because an id is the\n * durable step name (`step.do('{id}:send')`), the message idempotency key\n * (`{instanceId}:{id}`) and the cohort bucket seed: the twins share a\n * checkpoint, and the second send is suppressed as a duplicate of the first.\n * Cheap to check once at the end of the compile, so it is checked.\n */\nfunction assertUniqueIds(nodes: readonly NodeIR[], seen = new Set<string>()): void {\n  for (const node of nodes) {\n    if (seen.has(node.id)) {\n      throw new Error(\n        `toIR(): node id '${node.id}' is used twice — ids are durable step names and message idempotency keys, so they must be unique`\n      );\n    }\n    seen.add(node.id);\n    switch (node.type) {\n      case 'branch':\n        for (const branchCase of node.cases) assertUniqueIds(branchCase.flow, seen);\n        if (node.otherwise) assertUniqueIds(node.otherwise, seen);\n        break;\n      case 'cohort':\n        for (const arm of node.arms) assertUniqueIds(arm.flow, seen);\n        break;\n      case 'wait_until':\n        if (Array.isArray(node.onTimeout)) assertUniqueIds(node.onTimeout, seen);\n        break;\n      default:\n        break;\n    }\n  }\n}\n\nclass WorkflowBuilderImpl extends FlowBuilderImpl implements WorkflowBuilder {\n  constructor(\n    private readonly options: WorkflowDefinition,\n    /** Callsite of the workflow() call (provenance; lands in meta.loc). */\n    private readonly loc: SourceLocIR | undefined\n  ) {\n    super();\n  }\n\n  private goalIR(): GoalIR | undefined {\n    const goal = this.options.goal;\n    if (goal === undefined) return undefined;\n    if ('__condition' in goal) {\n      return { condition: condIR(goal), exitOnMatch: true };\n    }\n    return {\n      condition: condIR(goal.condition),\n      ...(goal.within !== undefined ? { within: durationIR(goal.within) } : {}),\n      exitOnMatch: goal.exitOnMatch ?? true,\n    };\n  }\n\n  private metaIR(): MetaIR | undefined {\n    const { name, description } = this.options;\n    if (name === undefined && description === undefined && this.loc === undefined) {\n      return undefined;\n    }\n    return {\n      ...(name !== undefined ? { name } : {}),\n      ...(description !== undefined ? { description } : {}),\n      ...(this.loc !== undefined ? { loc: this.loc } : {}),\n    };\n  }\n\n  toIR(): WorkflowIR {\n    const flowNodes = structuredClone(this.nodes);\n    assignIds(flowNodes, '');\n    assertUniqueIds(flowNodes);\n    const goal = this.goalIR();\n    const meta = this.metaIR();\n    const body = {\n      irVersion: IR_VERSION,\n      id: this.options.id,\n      ...(meta !== undefined ? { meta } : {}),\n      trigger: (this.options.trigger as TriggerInternal).ir,\n      ...(goal !== undefined ? { goal } : {}),\n      ...(this.options.exitWhen !== undefined ? { exitWhen: condIR(this.options.exitWhen) } : {}),\n      flow: flowNodes,\n    };\n    // semanticHash strips meta / label / reason, so metadata edits leave contentHash alone\n    // Self-check: the compiler's output must pass IR's authoritative schema\n    return WorkflowIRSchema.parse({ ...body, contentHash: semanticHash(body) });\n  }\n}\n\n/**\n * Workflow definition: an id, configuration (trigger / goal / exitWhen),\n * optional labels, and chained steps.\n *\n *   export const onboarding = workflow({\n *     id: 'onboarding',\n *     name: 'Onboarding',\n *     trigger: trigger.event(e.sign_up),\n *   }).email(t.email.welcome);\n */\nexport function workflow(definition: WorkflowDefinition): WorkflowBuilder {\n  return new WorkflowBuilderImpl(definition, captureLoc(workflow));\n}\n"],"mappings":"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"}

package/dist/engine/actions.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/engine/actions.ts
+var RegistryActionInvoker = class {
+	policy;
+	registry;
+	constructor(actions, policy = "warn") {
+		this.policy = policy;
+		this.registry = new Map(actions.map((a) => [a.name, a]));
+	}
+	async invoke(invocation) {
+		const registered = this.registry.get(invocation.action);
+		if (registered === void 0) throw new Error(`action '${invocation.action}' is not registered in this runtime — was it removed from the deployed bundle while workflows still reference it?`);
+		if (this.policy !== "rolling" && invocation.codeHash !== void 0 && invocation.codeHash !== registered.codeHash) {
+			const skew = `action '${invocation.action}': deployed code (${registered.codeHash}) differs from the version pinned in this journey's IR (${invocation.codeHash})`;
+			if (this.policy === "strict") throw new Error(skew);
+			console.warn(`${skew} — running the deployed version`);
+		}
+		await registered.handler(invocation.args, {
+			userId: invocation.userId,
+			idempotencyKey: invocation.idempotencyKey
+		});
+	}
+};
+//#endregion
+exports.RegistryActionInvoker = RegistryActionInvoker;
+
+//# sourceMappingURL=actions.cjs.map

package/dist/engine/actions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.cjs","names":[],"sources":["../../src/engine/actions.ts"],"sourcesContent":["import type { ScalarIR } from '../ir';\nimport type { ActionInvocation, ActionInvoker } from './ports';\n\n/**\n * The default ActionInvoker: a name → handler registry (the runtime half of\n * the dual-plane model — IR carries identity, the deployed bundle carries\n * code). Adapter-agnostic: the Cloudflare runner uses it and an AWS adapter\n * would too.\n */\n\n/**\n * What the registry stores — structurally satisfied by the DSL's ActionRef,\n * so the same `action(...)` objects the workflows reference are registered\n * directly, exactly like createMessageSender overrides plug in senders.\n */\nexport interface RegisteredAction {\n  readonly name: string;\n  readonly codeHash: string;\n  /** Method syntax on purpose: accepts ActionRef handlers with narrower arg types. */\n  handler(\n    args: Record<string, ScalarIR | undefined>,\n    ctx: { userId: string; idempotencyKey: string }\n  ): Promise<void> | void;\n}\n\n/**\n * Version-consistency tiers for the codeHash pinned in IR vs the code actually\n * registered. Deploys are rolling — Worker code and IR never flip in the same\n * instant, and different build pipelines can print the same function\n * differently — so 'warn' is the default: run the current code, log the skew.\n * 'strict' is for actions where running the wrong version is worse than\n * failing the step; 'rolling' silences the log entirely.\n */\nexport type ActionVersionPolicy = 'rolling' | 'warn' | 'strict';\n\nexport class RegistryActionInvoker implements ActionInvoker {\n  private readonly registry: ReadonlyMap<string, RegisteredAction>;\n\n  constructor(\n    actions: readonly RegisteredAction[],\n    private readonly policy: ActionVersionPolicy = 'warn'\n  ) {\n    this.registry = new Map(actions.map((a) => [a.name, a]));\n  }\n\n  async invoke(invocation: ActionInvocation): Promise<void> {\n    const registered = this.registry.get(invocation.action);\n    if (registered === undefined) {\n      throw new Error(\n        `action '${invocation.action}' is not registered in this runtime — was it removed from the deployed bundle while workflows still reference it?`\n      );\n    }\n    if (\n      this.policy !== 'rolling' &&\n      invocation.codeHash !== undefined &&\n      invocation.codeHash !== registered.codeHash\n    ) {\n      const skew = `action '${invocation.action}': deployed code (${registered.codeHash}) differs from the version pinned in this journey's IR (${invocation.codeHash})`;\n      if (this.policy === 'strict') throw new Error(skew);\n      console.warn(`${skew} — running the deployed version`);\n    }\n    // The key is forwarded, not consumed here: this invoker has no state to\n    // de-duplicate against, and the step body it runs inside is replayed — the\n    // handler is the only place that can collapse the duplicate side effect.\n    await registered.handler(invocation.args, {\n      userId: invocation.userId,\n      idempotencyKey: invocation.idempotencyKey,\n    });\n  }\n}\n"],"mappings":";;AAmCA,IAAa,wBAAb,MAA4D;CAKvC;CAJnB;CAEA,YACE,SACA,SAA+C,QAC/C;EADiB,KAAA,SAAA;EAEjB,KAAK,WAAW,IAAI,IAAI,QAAQ,KAAK,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;CACzD;CAEA,MAAM,OAAO,YAA6C;EACxD,MAAM,aAAa,KAAK,SAAS,IAAI,WAAW,MAAM;EACtD,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,WAAW,WAAW,OAAO,kHAC/B;EAEF,IACE,KAAK,WAAW,aAChB,WAAW,aAAa,KAAA,KACxB,WAAW,aAAa,WAAW,UACnC;GACA,MAAM,OAAO,WAAW,WAAW,OAAO,oBAAoB,WAAW,SAAS,0DAA0D,WAAW,SAAS;GAChK,IAAI,KAAK,WAAW,UAAU,MAAM,IAAI,MAAM,IAAI;GAClD,QAAQ,KAAK,GAAG,KAAK,gCAAgC;EACvD;EAIA,MAAM,WAAW,QAAQ,WAAW,MAAM;GACxC,QAAQ,WAAW;GACnB,gBAAgB,WAAW;EAC7B,CAAC;CACH;AACF"}

package/dist/engine/actions.d.cts

@@ -0,0 +1,40 @@
+import { ScalarIR } from "../ir.cjs";
+import { ActionInvocation, ActionInvoker } from "./ports.cjs";
+//#region src/engine/actions.d.ts
+/**
+ * The default ActionInvoker: a name → handler registry (the runtime half of
+ * the dual-plane model — IR carries identity, the deployed bundle carries
+ * code). Adapter-agnostic: the Cloudflare runner uses it and an AWS adapter
+ * would too.
+ */
+/**
+ * What the registry stores — structurally satisfied by the DSL's ActionRef,
+ * so the same `action(...)` objects the workflows reference are registered
+ * directly, exactly like createMessageSender overrides plug in senders.
+ */
+export interface RegisteredAction {
+  readonly name: string;
+  readonly codeHash: string;
+  /** Method syntax on purpose: accepts ActionRef handlers with narrower arg types. */
+  handler(args: Record<string, ScalarIR | undefined>, ctx: {
+    userId: string;
+    idempotencyKey: string;
+  }): Promise<void> | void;
+}
+/**
+ * Version-consistency tiers for the codeHash pinned in IR vs the code actually
+ * registered. Deploys are rolling — Worker code and IR never flip in the same
+ * instant, and different build pipelines can print the same function
+ * differently — so 'warn' is the default: run the current code, log the skew.
+ * 'strict' is for actions where running the wrong version is worse than
+ * failing the step; 'rolling' silences the log entirely.
+ */
+export type ActionVersionPolicy = 'rolling' | 'warn' | 'strict';
+export declare class RegistryActionInvoker implements ActionInvoker {
+  private readonly policy;
+  private readonly registry;
+  constructor(actions: readonly RegisteredAction[], policy?: ActionVersionPolicy);
+  invoke(invocation: ActionInvocation): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=actions.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.cts","names":[],"sources":["../../src/engine/actions.ts"],"mappings":";;;;;;;;;;;;;;iBAeiB;WACN;WACA;;EAET,QACE,MAAM,eAAe,uBACrB;IAAO;IAAgB;MACtB;;;;;;;;;;YAWO;qBAEC,iCAAiC;mBAKzB;mBAJF;EAEjB,YACE,kBAAkB,oBACD,SAAQ;EAKrB,OAAO,YAAY,mBAAmB"}

package/dist/engine/actions.d.mts

@@ -0,0 +1,40 @@
+import { ScalarIR } from "../ir.mjs";
+import { ActionInvocation, ActionInvoker } from "./ports.mjs";
+//#region src/engine/actions.d.ts
+/**
+ * The default ActionInvoker: a name → handler registry (the runtime half of
+ * the dual-plane model — IR carries identity, the deployed bundle carries
+ * code). Adapter-agnostic: the Cloudflare runner uses it and an AWS adapter
+ * would too.
+ */
+/**
+ * What the registry stores — structurally satisfied by the DSL's ActionRef,
+ * so the same `action(...)` objects the workflows reference are registered
+ * directly, exactly like createMessageSender overrides plug in senders.
+ */
+export interface RegisteredAction {
+  readonly name: string;
+  readonly codeHash: string;
+  /** Method syntax on purpose: accepts ActionRef handlers with narrower arg types. */
+  handler(args: Record<string, ScalarIR | undefined>, ctx: {
+    userId: string;
+    idempotencyKey: string;
+  }): Promise<void> | void;
+}
+/**
+ * Version-consistency tiers for the codeHash pinned in IR vs the code actually
+ * registered. Deploys are rolling — Worker code and IR never flip in the same
+ * instant, and different build pipelines can print the same function
+ * differently — so 'warn' is the default: run the current code, log the skew.
+ * 'strict' is for actions where running the wrong version is worse than
+ * failing the step; 'rolling' silences the log entirely.
+ */
+export type ActionVersionPolicy = 'rolling' | 'warn' | 'strict';
+export declare class RegistryActionInvoker implements ActionInvoker {
+  private readonly policy;
+  private readonly registry;
+  constructor(actions: readonly RegisteredAction[], policy?: ActionVersionPolicy);
+  invoke(invocation: ActionInvocation): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=actions.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.mts","names":[],"sources":["../../src/engine/actions.ts"],"mappings":";;;;;;;;;;;;;;iBAeiB;WACN;WACA;;EAET,QACE,MAAM,eAAe,uBACrB;IAAO;IAAgB;MACtB;;;;;;;;;;YAWO;qBAEC,iCAAiC;mBAKzB;mBAJF;EAEjB,YACE,kBAAkB,oBACD,SAAQ;EAKrB,OAAO,YAAY,mBAAmB"}

package/dist/engine/actions.mjs

@@ -0,0 +1,26 @@
+//#region src/engine/actions.ts
+var RegistryActionInvoker = class {
+	policy;
+	registry;
+	constructor(actions, policy = "warn") {
+		this.policy = policy;
+		this.registry = new Map(actions.map((a) => [a.name, a]));
+	}
+	async invoke(invocation) {
+		const registered = this.registry.get(invocation.action);
+		if (registered === void 0) throw new Error(`action '${invocation.action}' is not registered in this runtime — was it removed from the deployed bundle while workflows still reference it?`);
+		if (this.policy !== "rolling" && invocation.codeHash !== void 0 && invocation.codeHash !== registered.codeHash) {
+			const skew = `action '${invocation.action}': deployed code (${registered.codeHash}) differs from the version pinned in this journey's IR (${invocation.codeHash})`;
+			if (this.policy === "strict") throw new Error(skew);
+			console.warn(`${skew} — running the deployed version`);
+		}
+		await registered.handler(invocation.args, {
+			userId: invocation.userId,
+			idempotencyKey: invocation.idempotencyKey
+		});
+	}
+};
+//#endregion
+export { RegistryActionInvoker };
+
+//# sourceMappingURL=actions.mjs.map

package/dist/engine/actions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.mjs","names":[],"sources":["../../src/engine/actions.ts"],"sourcesContent":["import type { ScalarIR } from '../ir';\nimport type { ActionInvocation, ActionInvoker } from './ports';\n\n/**\n * The default ActionInvoker: a name → handler registry (the runtime half of\n * the dual-plane model — IR carries identity, the deployed bundle carries\n * code). Adapter-agnostic: the Cloudflare runner uses it and an AWS adapter\n * would too.\n */\n\n/**\n * What the registry stores — structurally satisfied by the DSL's ActionRef,\n * so the same `action(...)` objects the workflows reference are registered\n * directly, exactly like createMessageSender overrides plug in senders.\n */\nexport interface RegisteredAction {\n  readonly name: string;\n  readonly codeHash: string;\n  /** Method syntax on purpose: accepts ActionRef handlers with narrower arg types. */\n  handler(\n    args: Record<string, ScalarIR | undefined>,\n    ctx: { userId: string; idempotencyKey: string }\n  ): Promise<void> | void;\n}\n\n/**\n * Version-consistency tiers for the codeHash pinned in IR vs the code actually\n * registered. Deploys are rolling — Worker code and IR never flip in the same\n * instant, and different build pipelines can print the same function\n * differently — so 'warn' is the default: run the current code, log the skew.\n * 'strict' is for actions where running the wrong version is worse than\n * failing the step; 'rolling' silences the log entirely.\n */\nexport type ActionVersionPolicy = 'rolling' | 'warn' | 'strict';\n\nexport class RegistryActionInvoker implements ActionInvoker {\n  private readonly registry: ReadonlyMap<string, RegisteredAction>;\n\n  constructor(\n    actions: readonly RegisteredAction[],\n    private readonly policy: ActionVersionPolicy = 'warn'\n  ) {\n    this.registry = new Map(actions.map((a) => [a.name, a]));\n  }\n\n  async invoke(invocation: ActionInvocation): Promise<void> {\n    const registered = this.registry.get(invocation.action);\n    if (registered === undefined) {\n      throw new Error(\n        `action '${invocation.action}' is not registered in this runtime — was it removed from the deployed bundle while workflows still reference it?`\n      );\n    }\n    if (\n      this.policy !== 'rolling' &&\n      invocation.codeHash !== undefined &&\n      invocation.codeHash !== registered.codeHash\n    ) {\n      const skew = `action '${invocation.action}': deployed code (${registered.codeHash}) differs from the version pinned in this journey's IR (${invocation.codeHash})`;\n      if (this.policy === 'strict') throw new Error(skew);\n      console.warn(`${skew} — running the deployed version`);\n    }\n    // The key is forwarded, not consumed here: this invoker has no state to\n    // de-duplicate against, and the step body it runs inside is replayed — the\n    // handler is the only place that can collapse the duplicate side effect.\n    await registered.handler(invocation.args, {\n      userId: invocation.userId,\n      idempotencyKey: invocation.idempotencyKey,\n    });\n  }\n}\n"],"mappings":";AAmCA,IAAa,wBAAb,MAA4D;CAKvC;CAJnB;CAEA,YACE,SACA,SAA+C,QAC/C;EADiB,KAAA,SAAA;EAEjB,KAAK,WAAW,IAAI,IAAI,QAAQ,KAAK,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;CACzD;CAEA,MAAM,OAAO,YAA6C;EACxD,MAAM,aAAa,KAAK,SAAS,IAAI,WAAW,MAAM;EACtD,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,WAAW,WAAW,OAAO,kHAC/B;EAEF,IACE,KAAK,WAAW,aAChB,WAAW,aAAa,KAAA,KACxB,WAAW,aAAa,WAAW,UACnC;GACA,MAAM,OAAO,WAAW,WAAW,OAAO,oBAAoB,WAAW,SAAS,0DAA0D,WAAW,SAAS;GAChK,IAAI,KAAK,WAAW,UAAU,MAAM,IAAI,MAAM,IAAI;GAClD,QAAQ,KAAK,GAAG,KAAK,gCAAgC;EACvD;EAIA,MAAM,WAAW,QAAQ,WAAW,MAAM;GACxC,QAAQ,WAAW;GACnB,gBAAgB,WAAW;EAC7B,CAAC;CACH;AACF"}

package/dist/engine/bucket.cjs

@@ -0,0 +1,72 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/engine/bucket.ts
+/**
+* Cohort bucketing — deterministic assignment of a user to an A/B arm.
+*
+* MurmurHash3 (x86, 32-bit, seed 0) over the UTF-8 bytes of the key, the same
+* construction A/B systems like Unleash use: excellent avalanche behaviour
+* (sequential user ids spread evenly, where FNV-1a showed low-bit bias) and a
+* frozen, widely cross-checked algorithm. Hand-written on purpose: the engine
+* core stays dependency-free, and the known-answer tests pin this
+* implementation against the reference vectors — a stronger guarantee than
+* trusting an npm package's variant.
+*
+* The bucket function is a permanent contract: changing it reshuffles every
+* in-flight cohort, so it must never change once production traffic exists.
+*/
+/** MurmurHash3 x86 32-bit over raw bytes; seed 0. Returns an unsigned 32-bit integer. */
+function murmur3(bytes, seed = 0) {
+	const c1 = 3432918353;
+	const c2 = 461845907;
+	let h = seed >>> 0;
+	const tail = bytes.length & -4;
+	for (let i = 0; i < tail; i += 4) {
+		let k = bytes[i] | bytes[i + 1] << 8 | bytes[i + 2] << 16 | bytes[i + 3] << 24;
+		k = Math.imul(k, c1);
+		k = k << 15 | k >>> 17;
+		k = Math.imul(k, c2);
+		h ^= k;
+		h = h << 13 | h >>> 19;
+		h = Math.imul(h, 5) + 3864292196 >>> 0;
+	}
+	let k = 0;
+	const remainder = bytes.length & 3;
+	if (remainder === 3) k ^= bytes[tail + 2] << 16;
+	if (remainder >= 2) k ^= bytes[tail + 1] << 8;
+	if (remainder >= 1) {
+		k ^= bytes[tail];
+		k = Math.imul(k, c1);
+		k = k << 15 | k >>> 17;
+		k = Math.imul(k, c2);
+		h ^= k;
+	}
+	h ^= bytes.length;
+	h ^= h >>> 16;
+	h = Math.imul(h, 2246822507);
+	h ^= h >>> 13;
+	h = Math.imul(h, 3266489909);
+	h ^= h >>> 16;
+	return h >>> 0;
+}
+const utf8 = new TextEncoder();
+/**
+* Bucket resolution: basis points, i.e. hundredths of a percent. Weights are
+* compared on the same integer grid (weight% × 100), so fractional splits like
+* 33.3/33.3/33.4 are honoured exactly and the whole path stays float-free —
+* the Optimizely/Statsig construction.
+*/
+const BUCKET_RESOLUTION = 1e4;
+/**
+* Map a bucketing key (`${userId}:${cohortKey}`) to [0, 10000). Keys hash
+* their UTF-8 bytes, so results agree with any standard Murmur3 implementation
+* regardless of the user id's alphabet.
+*/
+function hashToBucket(input) {
+	return murmur3(utf8.encode(input)) % BUCKET_RESOLUTION;
+}
+//#endregion
+exports.BUCKET_RESOLUTION = BUCKET_RESOLUTION;
+exports.hashToBucket = hashToBucket;
+exports.murmur3 = murmur3;
+
+//# sourceMappingURL=bucket.cjs.map

package/dist/engine/bucket.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bucket.cjs","names":[],"sources":["../../src/engine/bucket.ts"],"sourcesContent":["/**\n * Cohort bucketing — deterministic assignment of a user to an A/B arm.\n *\n * MurmurHash3 (x86, 32-bit, seed 0) over the UTF-8 bytes of the key, the same\n * construction A/B systems like Unleash use: excellent avalanche behaviour\n * (sequential user ids spread evenly, where FNV-1a showed low-bit bias) and a\n * frozen, widely cross-checked algorithm. Hand-written on purpose: the engine\n * core stays dependency-free, and the known-answer tests pin this\n * implementation against the reference vectors — a stronger guarantee than\n * trusting an npm package's variant.\n *\n * The bucket function is a permanent contract: changing it reshuffles every\n * in-flight cohort, so it must never change once production traffic exists.\n */\n\n/** MurmurHash3 x86 32-bit over raw bytes; seed 0. Returns an unsigned 32-bit integer. */\nexport function murmur3(bytes: Uint8Array, seed = 0): number {\n  const c1 = 0xcc9e2d51;\n  const c2 = 0x1b873593;\n  let h = seed >>> 0;\n\n  const tail = bytes.length & ~3;\n  for (let i = 0; i < tail; i += 4) {\n    let k = bytes[i] | (bytes[i + 1] << 8) | (bytes[i + 2] << 16) | (bytes[i + 3] << 24);\n    k = Math.imul(k, c1);\n    k = (k << 15) | (k >>> 17);\n    k = Math.imul(k, c2);\n    h ^= k;\n    h = (h << 13) | (h >>> 19);\n    h = (Math.imul(h, 5) + 0xe6546b64) >>> 0;\n  }\n\n  let k = 0;\n  const remainder = bytes.length & 3;\n  if (remainder === 3) k ^= bytes[tail + 2] << 16;\n  if (remainder >= 2) k ^= bytes[tail + 1] << 8;\n  if (remainder >= 1) {\n    k ^= bytes[tail];\n    k = Math.imul(k, c1);\n    k = (k << 15) | (k >>> 17);\n    k = Math.imul(k, c2);\n    h ^= k;\n  }\n\n  h ^= bytes.length;\n  h ^= h >>> 16;\n  h = Math.imul(h, 0x85ebca6b);\n  h ^= h >>> 13;\n  h = Math.imul(h, 0xc2b2ae35);\n  h ^= h >>> 16;\n  return h >>> 0;\n}\n\nconst utf8 = new TextEncoder();\n\n/**\n * Bucket resolution: basis points, i.e. hundredths of a percent. Weights are\n * compared on the same integer grid (weight% × 100), so fractional splits like\n * 33.3/33.3/33.4 are honoured exactly and the whole path stays float-free —\n * the Optimizely/Statsig construction.\n */\nexport const BUCKET_RESOLUTION = 10_000;\n\n/**\n * Map a bucketing key (`${userId}:${cohortKey}`) to [0, 10000). Keys hash\n * their UTF-8 bytes, so results agree with any standard Murmur3 implementation\n * regardless of the user id's alphabet.\n */\nexport function hashToBucket(input: string): number {\n  return murmur3(utf8.encode(input)) % BUCKET_RESOLUTION;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAgB,QAAQ,OAAmB,OAAO,GAAW;CAC3D,MAAM,KAAK;CACX,MAAM,KAAK;CACX,IAAI,IAAI,SAAS;CAEjB,MAAM,OAAO,MAAM,SAAS;CAC5B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,KAAK,GAAG;EAChC,IAAI,IAAI,MAAM,KAAM,MAAM,IAAI,MAAM,IAAM,MAAM,IAAI,MAAM,KAAO,MAAM,IAAI,MAAM;EACjF,IAAI,KAAK,KAAK,GAAG,EAAE;EACnB,IAAK,KAAK,KAAO,MAAM;EACvB,IAAI,KAAK,KAAK,GAAG,EAAE;EACnB,KAAK;EACL,IAAK,KAAK,KAAO,MAAM;EACvB,IAAK,KAAK,KAAK,GAAG,CAAC,IAAI,eAAgB;CACzC;CAEA,IAAI,IAAI;CACR,MAAM,YAAY,MAAM,SAAS;CACjC,IAAI,cAAc,GAAG,KAAK,MAAM,OAAO,MAAM;CAC7C,IAAI,aAAa,GAAG,KAAK,MAAM,OAAO,MAAM;CAC5C,IAAI,aAAa,GAAG;EAClB,KAAK,MAAM;EACX,IAAI,KAAK,KAAK,GAAG,EAAE;EACnB,IAAK,KAAK,KAAO,MAAM;EACvB,IAAI,KAAK,KAAK,GAAG,EAAE;EACnB,KAAK;CACP;CAEA,KAAK,MAAM;CACX,KAAK,MAAM;CACX,IAAI,KAAK,KAAK,GAAG,UAAU;CAC3B,KAAK,MAAM;CACX,IAAI,KAAK,KAAK,GAAG,UAAU;CAC3B,KAAK,MAAM;CACX,OAAO,MAAM;AACf;AAEA,MAAM,OAAO,IAAI,YAAY;;;;;;;AAQ7B,MAAa,oBAAoB;;;;;;AAOjC,SAAgB,aAAa,OAAuB;CAClD,OAAO,QAAQ,KAAK,OAAO,KAAK,CAAC,IAAI;AACvC"}

package/dist/engine/bucket.d.cts

@@ -0,0 +1,32 @@
+//#region src/engine/bucket.d.ts
+/**
+ * Cohort bucketing — deterministic assignment of a user to an A/B arm.
+ *
+ * MurmurHash3 (x86, 32-bit, seed 0) over the UTF-8 bytes of the key, the same
+ * construction A/B systems like Unleash use: excellent avalanche behaviour
+ * (sequential user ids spread evenly, where FNV-1a showed low-bit bias) and a
+ * frozen, widely cross-checked algorithm. Hand-written on purpose: the engine
+ * core stays dependency-free, and the known-answer tests pin this
+ * implementation against the reference vectors — a stronger guarantee than
+ * trusting an npm package's variant.
+ *
+ * The bucket function is a permanent contract: changing it reshuffles every
+ * in-flight cohort, so it must never change once production traffic exists.
+ */
+/** MurmurHash3 x86 32-bit over raw bytes; seed 0. Returns an unsigned 32-bit integer. */
+export declare function murmur3(bytes: Uint8Array, seed?: number): number;
+/**
+ * Bucket resolution: basis points, i.e. hundredths of a percent. Weights are
+ * compared on the same integer grid (weight% × 100), so fractional splits like
+ * 33.3/33.3/33.4 are honoured exactly and the whole path stays float-free —
+ * the Optimizely/Statsig construction.
+ */
+export declare const BUCKET_RESOLUTION = 10000;
+/**
+ * Map a bucketing key (`${userId}:${cohortKey}`) to [0, 10000). Keys hash
+ * their UTF-8 bytes, so results agree with any standard Murmur3 implementation
+ * regardless of the user id's alphabet.
+ */
+export declare function hashToBucket(input: string): number;
+//#endregion
+//# sourceMappingURL=bucket.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bucket.d.cts","names":[],"sources":["../../src/engine/bucket.ts"],"mappings":";;;;;;;;;;;;;;;;wBAgBgB,QAAQ,OAAO,YAAY;;;;;;;qBA6C9B;;;;;;wBAOG,aAAa"}

package/dist/engine/bucket.d.mts

@@ -0,0 +1,32 @@
+//#region src/engine/bucket.d.ts
+/**
+ * Cohort bucketing — deterministic assignment of a user to an A/B arm.
+ *
+ * MurmurHash3 (x86, 32-bit, seed 0) over the UTF-8 bytes of the key, the same
+ * construction A/B systems like Unleash use: excellent avalanche behaviour
+ * (sequential user ids spread evenly, where FNV-1a showed low-bit bias) and a
+ * frozen, widely cross-checked algorithm. Hand-written on purpose: the engine
+ * core stays dependency-free, and the known-answer tests pin this
+ * implementation against the reference vectors — a stronger guarantee than
+ * trusting an npm package's variant.
+ *
+ * The bucket function is a permanent contract: changing it reshuffles every
+ * in-flight cohort, so it must never change once production traffic exists.
+ */
+/** MurmurHash3 x86 32-bit over raw bytes; seed 0. Returns an unsigned 32-bit integer. */
+export declare function murmur3(bytes: Uint8Array, seed?: number): number;
+/**
+ * Bucket resolution: basis points, i.e. hundredths of a percent. Weights are
+ * compared on the same integer grid (weight% × 100), so fractional splits like
+ * 33.3/33.3/33.4 are honoured exactly and the whole path stays float-free —
+ * the Optimizely/Statsig construction.
+ */
+export declare const BUCKET_RESOLUTION = 10000;
+/**
+ * Map a bucketing key (`${userId}:${cohortKey}`) to [0, 10000). Keys hash
+ * their UTF-8 bytes, so results agree with any standard Murmur3 implementation
+ * regardless of the user id's alphabet.
+ */
+export declare function hashToBucket(input: string): number;
+//#endregion
+//# sourceMappingURL=bucket.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bucket.d.mts","names":[],"sources":["../../src/engine/bucket.ts"],"mappings":";;;;;;;;;;;;;;;;wBAgBgB,QAAQ,OAAO,YAAY;;;;;;;qBA6C9B;;;;;;wBAOG,aAAa"}

package/dist/engine/bucket.mjs

@@ -0,0 +1,69 @@
+//#region src/engine/bucket.ts
+/**
+* Cohort bucketing — deterministic assignment of a user to an A/B arm.
+*
+* MurmurHash3 (x86, 32-bit, seed 0) over the UTF-8 bytes of the key, the same
+* construction A/B systems like Unleash use: excellent avalanche behaviour
+* (sequential user ids spread evenly, where FNV-1a showed low-bit bias) and a
+* frozen, widely cross-checked algorithm. Hand-written on purpose: the engine
+* core stays dependency-free, and the known-answer tests pin this
+* implementation against the reference vectors — a stronger guarantee than
+* trusting an npm package's variant.
+*
+* The bucket function is a permanent contract: changing it reshuffles every
+* in-flight cohort, so it must never change once production traffic exists.
+*/
+/** MurmurHash3 x86 32-bit over raw bytes; seed 0. Returns an unsigned 32-bit integer. */
+function murmur3(bytes, seed = 0) {
+	const c1 = 3432918353;
+	const c2 = 461845907;
+	let h = seed >>> 0;
+	const tail = bytes.length & -4;
+	for (let i = 0; i < tail; i += 4) {
+		let k = bytes[i] | bytes[i + 1] << 8 | bytes[i + 2] << 16 | bytes[i + 3] << 24;
+		k = Math.imul(k, c1);
+		k = k << 15 | k >>> 17;
+		k = Math.imul(k, c2);
+		h ^= k;
+		h = h << 13 | h >>> 19;
+		h = Math.imul(h, 5) + 3864292196 >>> 0;
+	}
+	let k = 0;
+	const remainder = bytes.length & 3;
+	if (remainder === 3) k ^= bytes[tail + 2] << 16;
+	if (remainder >= 2) k ^= bytes[tail + 1] << 8;
+	if (remainder >= 1) {
+		k ^= bytes[tail];
+		k = Math.imul(k, c1);
+		k = k << 15 | k >>> 17;
+		k = Math.imul(k, c2);
+		h ^= k;
+	}
+	h ^= bytes.length;
+	h ^= h >>> 16;
+	h = Math.imul(h, 2246822507);
+	h ^= h >>> 13;
+	h = Math.imul(h, 3266489909);
+	h ^= h >>> 16;
+	return h >>> 0;
+}
+const utf8 = new TextEncoder();
+/**
+* Bucket resolution: basis points, i.e. hundredths of a percent. Weights are
+* compared on the same integer grid (weight% × 100), so fractional splits like
+* 33.3/33.3/33.4 are honoured exactly and the whole path stays float-free —
+* the Optimizely/Statsig construction.
+*/
+const BUCKET_RESOLUTION = 1e4;
+/**
+* Map a bucketing key (`${userId}:${cohortKey}`) to [0, 10000). Keys hash
+* their UTF-8 bytes, so results agree with any standard Murmur3 implementation
+* regardless of the user id's alphabet.
+*/
+function hashToBucket(input) {
+	return murmur3(utf8.encode(input)) % BUCKET_RESOLUTION;
+}
+//#endregion
+export { BUCKET_RESOLUTION, hashToBucket, murmur3 };
+
+//# sourceMappingURL=bucket.mjs.map

package/dist/engine/bucket.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bucket.mjs","names":[],"sources":["../../src/engine/bucket.ts"],"sourcesContent":["/**\n * Cohort bucketing — deterministic assignment of a user to an A/B arm.\n *\n * MurmurHash3 (x86, 32-bit, seed 0) over the UTF-8 bytes of the key, the same\n * construction A/B systems like Unleash use: excellent avalanche behaviour\n * (sequential user ids spread evenly, where FNV-1a showed low-bit bias) and a\n * frozen, widely cross-checked algorithm. Hand-written on purpose: the engine\n * core stays dependency-free, and the known-answer tests pin this\n * implementation against the reference vectors — a stronger guarantee than\n * trusting an npm package's variant.\n *\n * The bucket function is a permanent contract: changing it reshuffles every\n * in-flight cohort, so it must never change once production traffic exists.\n */\n\n/** MurmurHash3 x86 32-bit over raw bytes; seed 0. Returns an unsigned 32-bit integer. */\nexport function murmur3(bytes: Uint8Array, seed = 0): number {\n  const c1 = 0xcc9e2d51;\n  const c2 = 0x1b873593;\n  let h = seed >>> 0;\n\n  const tail = bytes.length & ~3;\n  for (let i = 0; i < tail; i += 4) {\n    let k = bytes[i] | (bytes[i + 1] << 8) | (bytes[i + 2] << 16) | (bytes[i + 3] << 24);\n    k = Math.imul(k, c1);\n    k = (k << 15) | (k >>> 17);\n    k = Math.imul(k, c2);\n    h ^= k;\n    h = (h << 13) | (h >>> 19);\n    h = (Math.imul(h, 5) + 0xe6546b64) >>> 0;\n  }\n\n  let k = 0;\n  const remainder = bytes.length & 3;\n  if (remainder === 3) k ^= bytes[tail + 2] << 16;\n  if (remainder >= 2) k ^= bytes[tail + 1] << 8;\n  if (remainder >= 1) {\n    k ^= bytes[tail];\n    k = Math.imul(k, c1);\n    k = (k << 15) | (k >>> 17);\n    k = Math.imul(k, c2);\n    h ^= k;\n  }\n\n  h ^= bytes.length;\n  h ^= h >>> 16;\n  h = Math.imul(h, 0x85ebca6b);\n  h ^= h >>> 13;\n  h = Math.imul(h, 0xc2b2ae35);\n  h ^= h >>> 16;\n  return h >>> 0;\n}\n\nconst utf8 = new TextEncoder();\n\n/**\n * Bucket resolution: basis points, i.e. hundredths of a percent. Weights are\n * compared on the same integer grid (weight% × 100), so fractional splits like\n * 33.3/33.3/33.4 are honoured exactly and the whole path stays float-free —\n * the Optimizely/Statsig construction.\n */\nexport const BUCKET_RESOLUTION = 10_000;\n\n/**\n * Map a bucketing key (`${userId}:${cohortKey}`) to [0, 10000). Keys hash\n * their UTF-8 bytes, so results agree with any standard Murmur3 implementation\n * regardless of the user id's alphabet.\n */\nexport function hashToBucket(input: string): number {\n  return murmur3(utf8.encode(input)) % BUCKET_RESOLUTION;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAgB,QAAQ,OAAmB,OAAO,GAAW;CAC3D,MAAM,KAAK;CACX,MAAM,KAAK;CACX,IAAI,IAAI,SAAS;CAEjB,MAAM,OAAO,MAAM,SAAS;CAC5B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,KAAK,GAAG;EAChC,IAAI,IAAI,MAAM,KAAM,MAAM,IAAI,MAAM,IAAM,MAAM,IAAI,MAAM,KAAO,MAAM,IAAI,MAAM;EACjF,IAAI,KAAK,KAAK,GAAG,EAAE;EACnB,IAAK,KAAK,KAAO,MAAM;EACvB,IAAI,KAAK,KAAK,GAAG,EAAE;EACnB,KAAK;EACL,IAAK,KAAK,KAAO,MAAM;EACvB,IAAK,KAAK,KAAK,GAAG,CAAC,IAAI,eAAgB;CACzC;CAEA,IAAI,IAAI;CACR,MAAM,YAAY,MAAM,SAAS;CACjC,IAAI,cAAc,GAAG,KAAK,MAAM,OAAO,MAAM;CAC7C,IAAI,aAAa,GAAG,KAAK,MAAM,OAAO,MAAM;CAC5C,IAAI,aAAa,GAAG;EAClB,KAAK,MAAM;EACX,IAAI,KAAK,KAAK,GAAG,EAAE;EACnB,IAAK,KAAK,KAAO,MAAM;EACvB,IAAI,KAAK,KAAK,GAAG,EAAE;EACnB,KAAK;CACP;CAEA,KAAK,MAAM;CACX,KAAK,MAAM;CACX,IAAI,KAAK,KAAK,GAAG,UAAU;CAC3B,KAAK,MAAM;CACX,IAAI,KAAK,KAAK,GAAG,UAAU;CAC3B,KAAK,MAAM;CACX,OAAO,MAAM;AACf;AAEA,MAAM,OAAO,IAAI,YAAY;;;;;;;AAQ7B,MAAa,oBAAoB;;;;;;AAOjC,SAAgB,aAAa,OAAuB;CAClD,OAAO,QAAQ,KAAK,OAAO,KAAK,CAAC,IAAI;AACvC"}

package/dist/engine/condition.cjs

@@ -0,0 +1,166 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_engine_recipient = require("./recipient.cjs");
+//#region src/engine/condition.ts
+/**
+* ConditionIR evaluation: pure logic, with facts injected through FactSource,
+* so the D1 implementation and the in-memory test one share a single set of
+* semantics and cannot drift into two evaluators.
+*/
+async function evaluateCondition(condition, facts, nowMs, opts) {
+	return evaluate(condition, facts, nowMs, opts, []);
+}
+/**
+* `enclosing` is the chain of segment names currently being expanded. A
+* segment that reaches itself has no truth value to converge on, and left
+* unchecked the recursion runs until memory gives out, one D1 round trip per
+* level — inside a step, so Workflows retries it and the instance never gets
+* out. Failing immediately keeps it bounded, and the message names the cycle
+* because only a deployed bundle can fix it. Only the *path* is tracked, so a
+* diamond (two branches referencing one segment) still evaluates twice.
+*/
+async function evaluate(condition, facts, nowMs, opts, enclosing) {
+	switch (condition.type) {
+		case "and":
+			for (const child of condition.conditions) if (!await evaluate(child, facts, nowMs, opts, enclosing)) return false;
+			return true;
+		case "or":
+			for (const child of condition.conditions) if (await evaluate(child, facts, nowMs, opts, enclosing)) return true;
+			return false;
+		case "not": return !await evaluate(condition.condition, facts, nowMs, opts, enclosing);
+		case "segment": {
+			if (enclosing.includes(condition.segment)) throw new Error(`segment '${condition.segment}' references itself: ${[...enclosing, condition.segment].join(" -> ")}`);
+			const def = await facts.getSegmentCondition(condition.segment);
+			if (def === void 0) throw new Error(`Unknown segment: '${condition.segment}' (bundle not deployed?)`);
+			return evaluate(def, facts, nowMs, opts, [...enclosing, condition.segment]);
+		}
+		case "performed": {
+			const bounds = [];
+			if (condition.within !== void 0) bounds.push(nowMs - condition.within.ms);
+			if (opts?.anchorMs !== void 0) bounds.push(opts.anchorMs);
+			const sinceMs = bounds.length > 0 ? Math.max(...bounds) : void 0;
+			return await facts.countEvents(condition.event, {
+				...sinceMs !== void 0 ? { sinceMs } : {},
+				...opts?.untilMs !== void 0 ? { untilMs: opts.untilMs } : {},
+				...condition.where !== void 0 ? { where: condition.where } : {}
+			}) >= (condition.count ?? 1);
+		}
+		case "property": return compareProperty(condition, await facts.getProperty(condition.path));
+		case "reachable": {
+			if (await facts.isSuppressed?.(condition.channel)) return false;
+			if (condition.channel === "push") return (await facts.listDevices()).length > 0;
+			const path = require_engine_recipient.RECIPIENT_PROPERTY[condition.channel];
+			return path === void 0 || await facts.getProperty(path) !== void 0;
+		}
+		case "payload": throw new Error("payload conditions are only valid inside performed({ where }) or a trigger where clause");
+	}
+}
+/**
+* Evaluate a where tree against one event's payload. Shared by performed
+* counting (FactSource implementations) and the ingest router's trigger gate.
+* Dotted paths descend nested objects; a missing or non-scalar leaf behaves
+* like a missing property (exists sees objects, comparisons do not).
+*/
+function matchesWhere(payload, where) {
+	switch (where.type) {
+		case "and": return where.conditions.every((child) => matchesWhere(payload, child));
+		case "or": return where.conditions.some((child) => matchesWhere(payload, child));
+		case "not": return !matchesWhere(payload, where.condition);
+		case "payload": {
+			const raw = valueAtPath(payload, where.path);
+			if (where.op === "exists") return raw !== void 0 && raw !== null;
+			if (where.op === "not_exists") return raw === void 0 || raw === null;
+			return compareProperty(where, typeof raw === "string" || typeof raw === "number" || typeof raw === "boolean" ? raw : void 0);
+		}
+		default: throw new Error(`where clause may not contain a '${where.type}' condition`);
+	}
+}
+function valueAtPath(payload, path) {
+	let current = payload;
+	for (const key of path.split(".")) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[key];
+	}
+	return current;
+}
+function compareProperty(condition, actual) {
+	const { op, value, values } = condition;
+	switch (op) {
+		case "exists": return actual !== void 0;
+		case "not_exists": return actual === void 0;
+		case "eq": return actual === value;
+		case "ne": return actual !== value;
+		case "gt": return actual !== void 0 && value !== void 0 && actual > value;
+		case "gte": return actual !== void 0 && value !== void 0 && actual >= value;
+		case "lt": return actual !== void 0 && value !== void 0 && actual < value;
+		case "lte": return actual !== void 0 && value !== void 0 && actual <= value;
+		case "between": return isBetween(actual, values);
+		case "not_between": return !isBetween(actual, values);
+		case "in_array": return actual !== void 0 && (values ?? []).includes(actual);
+		case "not_in_array": return actual === void 0 || !(values ?? []).includes(actual);
+		case "contains": return typeof actual === "string" && typeof value === "string" && actual.includes(value);
+		case "not_contains": return !(typeof actual === "string" && typeof value === "string" && actual.includes(value));
+	}
+}
+function isBetween(actual, values) {
+	if (actual === void 0 || values === void 0 || values.length < 2) return false;
+	const [min, max] = values;
+	return actual >= min && actual <= max;
+}
+/**
+* Wake-up channel for profile changes: a property predicate has no event name
+* of its own, so subscriptions use this reserved name and the ingest router
+* fires it on every /identify. The '$' prefix marks internal names — real
+* events may never use it (the router rejects them).
+*/
+const PROFILE_UPDATED_EVENT = "$profile_updated";
+/**
+* Wake-up channel for device changes: a device registered for the user, moved to another account
+* or was unbound or removed (`POST /devices`, `/devices/unbind`, `/devices/remove`). `reachable('push')` subscribes to it.
+*/
+const DEVICES_UPDATED_EVENT = "$devices_updated";
+/**
+* The set of event names a condition cares about — what wait_until subscribes
+* to for wake-ups. `performed` contributes its event; a property predicate
+* contributes PROFILE_UPDATED_EVENT (so /identify wakes the wait). Segment
+* references are expanded, which is why a FactSource is needed to resolve
+* their definitions.
+*/
+async function relevantEvents(condition, facts) {
+	const found = /* @__PURE__ */ new Set();
+	const expanded = /* @__PURE__ */ new Set();
+	async function walk(c) {
+		switch (c.type) {
+			case "and":
+			case "or":
+				for (const child of c.conditions) await walk(child);
+				break;
+			case "not":
+				await walk(c.condition);
+				break;
+			case "performed":
+				found.add(c.event);
+				break;
+			case "segment": {
+				if (expanded.has(c.segment)) break;
+				expanded.add(c.segment);
+				const def = await facts.getSegmentCondition(c.segment);
+				if (def) await walk(def);
+				break;
+			}
+			case "property":
+				found.add(PROFILE_UPDATED_EVENT);
+				break;
+			case "reachable": found.add(c.channel === "push" ? DEVICES_UPDATED_EVENT : PROFILE_UPDATED_EVENT);
+		}
+	}
+	await walk(condition);
+	return [...found];
+}
+//#endregion
+exports.DEVICES_UPDATED_EVENT = DEVICES_UPDATED_EVENT;
+exports.PROFILE_UPDATED_EVENT = PROFILE_UPDATED_EVENT;
+exports.evaluateCondition = evaluateCondition;
+exports.matchesWhere = matchesWhere;
+exports.relevantEvents = relevantEvents;
+
+//# sourceMappingURL=condition.cjs.map

package/dist/engine/condition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition.cjs","names":["RECIPIENT_PROPERTY"],"sources":["../../src/engine/condition.ts"],"sourcesContent":["import type { ConditionIR, PropertyOperatorIR, ScalarIR } from '../ir';\nimport type { FactSource } from './ports';\nimport { RECIPIENT_PROPERTY } from './recipient';\n\n/**\n * Evaluation options.\n * - anchorMs: the earliest instant `performed` counts events from — the goal\n *   guard anchors at workflow entry (a conversion must happen *after* entry),\n *   waitUntil at the moment the wait began (a wake must not be satisfied by\n *   pre-existing history). Combined with `within` by taking the later bound.\n * - untilMs: the latest instant `performed` counts events up to — the goal's\n *   attribution window ends there, so an event after it is no conversion even\n *   when the check runs later (a resumed instance, a delayed wake).\n */\nexport interface EvaluateOptions {\n  anchorMs?: number;\n  untilMs?: number;\n}\n\n/**\n * ConditionIR evaluation: pure logic, with facts injected through FactSource,\n * so the D1 implementation and the in-memory test one share a single set of\n * semantics and cannot drift into two evaluators.\n */\nexport async function evaluateCondition(\n  condition: ConditionIR,\n  facts: FactSource,\n  nowMs: number,\n  opts?: EvaluateOptions\n): Promise<boolean> {\n  return evaluate(condition, facts, nowMs, opts, []);\n}\n\n/**\n * `enclosing` is the chain of segment names currently being expanded. A\n * segment that reaches itself has no truth value to converge on, and left\n * unchecked the recursion runs until memory gives out, one D1 round trip per\n * level — inside a step, so Workflows retries it and the instance never gets\n * out. Failing immediately keeps it bounded, and the message names the cycle\n * because only a deployed bundle can fix it. Only the *path* is tracked, so a\n * diamond (two branches referencing one segment) still evaluates twice.\n */\nasync function evaluate(\n  condition: ConditionIR,\n  facts: FactSource,\n  nowMs: number,\n  opts: EvaluateOptions | undefined,\n  enclosing: readonly string[]\n): Promise<boolean> {\n  switch (condition.type) {\n    case 'and': {\n      for (const child of condition.conditions) {\n        if (!(await evaluate(child, facts, nowMs, opts, enclosing))) return false;\n      }\n      return true;\n    }\n    case 'or': {\n      for (const child of condition.conditions) {\n        if (await evaluate(child, facts, nowMs, opts, enclosing)) return true;\n      }\n      return false;\n    }\n    case 'not':\n      return !(await evaluate(condition.condition, facts, nowMs, opts, enclosing));\n    case 'segment': {\n      if (enclosing.includes(condition.segment)) {\n        throw new Error(\n          `segment '${condition.segment}' references itself: ${[...enclosing, condition.segment].join(' -> ')}`\n        );\n      }\n      const def = await facts.getSegmentCondition(condition.segment);\n      if (def === undefined) {\n        throw new Error(`Unknown segment: '${condition.segment}' (bundle not deployed?)`);\n      }\n      return evaluate(def, facts, nowMs, opts, [...enclosing, condition.segment]);\n    }\n    case 'performed': {\n      const bounds: number[] = [];\n      if (condition.within !== undefined) bounds.push(nowMs - condition.within.ms);\n      if (opts?.anchorMs !== undefined) bounds.push(opts.anchorMs);\n      const sinceMs = bounds.length > 0 ? Math.max(...bounds) : undefined;\n      const count = await facts.countEvents(condition.event, {\n        ...(sinceMs !== undefined ? { sinceMs } : {}),\n        ...(opts?.untilMs !== undefined ? { untilMs: opts.untilMs } : {}),\n        ...(condition.where !== undefined ? { where: condition.where } : {}),\n      });\n      return count >= (condition.count ?? 1);\n    }\n    case 'property': {\n      const actual = await facts.getProperty(condition.path);\n      return compareProperty(condition, actual);\n    }\n    case 'reachable': {\n      if (await facts.isSuppressed?.(condition.channel)) return false;\n      if (condition.channel === 'push') return (await facts.listDevices()).length > 0;\n      const path = RECIPIENT_PROPERTY[condition.channel];\n      // in_app, slack and discord need no address: a signed-in user is reachable in the app, and\n      // the webhook channels post to a team channel, not to the user\n      return path === undefined || (await facts.getProperty(path)) !== undefined;\n    }\n    case 'payload':\n      // Placement is validated at compile; reaching here means hand-built IR\n      throw new Error(\n        'payload conditions are only valid inside performed({ where }) or a trigger where clause'\n      );\n  }\n}\n\n/**\n * Evaluate a where tree against one event's payload. Shared by performed\n * counting (FactSource implementations) and the ingest router's trigger gate.\n * Dotted paths descend nested objects; a missing or non-scalar leaf behaves\n * like a missing property (exists sees objects, comparisons do not).\n */\nexport function matchesWhere(payload: unknown, where: ConditionIR): boolean {\n  switch (where.type) {\n    case 'and':\n      return where.conditions.every((child) => matchesWhere(payload, child));\n    case 'or':\n      return where.conditions.some((child) => matchesWhere(payload, child));\n    case 'not':\n      return !matchesWhere(payload, where.condition);\n    case 'payload': {\n      const raw = valueAtPath(payload, where.path);\n      if (where.op === 'exists') return raw !== undefined && raw !== null;\n      if (where.op === 'not_exists') return raw === undefined || raw === null;\n      const actual =\n        typeof raw === 'string' || typeof raw === 'number' || typeof raw === 'boolean'\n          ? raw\n          : undefined;\n      return compareProperty(where, actual);\n    }\n    default:\n      // compileBundle rejects these; defend against hand-built IR\n      throw new Error(`where clause may not contain a '${where.type}' condition`);\n  }\n}\n\nfunction valueAtPath(payload: unknown, path: string): unknown {\n  let current: unknown = payload;\n  for (const key of path.split('.')) {\n    if (current === null || typeof current !== 'object') return undefined;\n    current = (current as Record<string, unknown>)[key];\n  }\n  return current;\n}\n\nfunction compareProperty(\n  condition: {\n    op: PropertyOperatorIR;\n    value?: ScalarIR | undefined;\n    values?: ScalarIR[] | undefined;\n  },\n  actual: ScalarIR | undefined\n): boolean {\n  const { op, value, values } = condition;\n  switch (op) {\n    case 'exists':\n      return actual !== undefined;\n    case 'not_exists':\n      return actual === undefined;\n    case 'eq':\n      return actual === value;\n    case 'ne':\n      return actual !== value;\n    case 'gt':\n      return actual !== undefined && value !== undefined && actual > value;\n    case 'gte':\n      return actual !== undefined && value !== undefined && actual >= value;\n    case 'lt':\n      return actual !== undefined && value !== undefined && actual < value;\n    case 'lte':\n      return actual !== undefined && value !== undefined && actual <= value;\n    case 'between':\n      return isBetween(actual, values);\n    case 'not_between':\n      // A missing property is outside any range, mirroring not_in_array.\n      return !isBetween(actual, values);\n    case 'in_array':\n      return actual !== undefined && (values ?? []).includes(actual);\n    case 'not_in_array':\n      return actual === undefined || !(values ?? []).includes(actual);\n    case 'contains':\n      return typeof actual === 'string' && typeof value === 'string' && actual.includes(value);\n    case 'not_contains':\n      return !(typeof actual === 'string' && typeof value === 'string' && actual.includes(value));\n  }\n}\n\nfunction isBetween(actual: ScalarIR | undefined, values: ScalarIR[] | undefined): boolean {\n  if (actual === undefined || values === undefined || values.length < 2) return false;\n  const [min, max] = values;\n  return actual >= min && actual <= max;\n}\n\n/**\n * Wake-up channel for profile changes: a property predicate has no event name\n * of its own, so subscriptions use this reserved name and the ingest router\n * fires it on every /identify. The '$' prefix marks internal names — real\n * events may never use it (the router rejects them).\n */\nexport const PROFILE_UPDATED_EVENT = '$profile_updated';\n\n/**\n * Wake-up channel for device changes: a device registered for the user, moved to another account\n * or was unbound or removed (`POST /devices`, `/devices/unbind`, `/devices/remove`). `reachable('push')` subscribes to it.\n */\nexport const DEVICES_UPDATED_EVENT = '$devices_updated';\n\n/**\n * The set of event names a condition cares about — what wait_until subscribes\n * to for wake-ups. `performed` contributes its event; a property predicate\n * contributes PROFILE_UPDATED_EVENT (so /identify wakes the wait). Segment\n * references are expanded, which is why a FactSource is needed to resolve\n * their definitions.\n */\nexport async function relevantEvents(condition: ConditionIR, facts: FactSource): Promise<string[]> {\n  const found = new Set<string>();\n  // Names already expanded. The result is a union, so re-walking a segment can\n  // only add what is already there — and a segment that reaches itself would\n  // otherwise recurse until the stack blows, taking a D1 read per level.\n  const expanded = new Set<string>();\n  async function walk(c: ConditionIR): Promise<void> {\n    switch (c.type) {\n      case 'and':\n      case 'or':\n        for (const child of c.conditions) await walk(child);\n        break;\n      case 'not':\n        await walk(c.condition);\n        break;\n      case 'performed':\n        found.add(c.event);\n        break;\n      case 'segment': {\n        if (expanded.has(c.segment)) break;\n        expanded.add(c.segment);\n        const def = await facts.getSegmentCondition(c.segment);\n        if (def) await walk(def);\n        break;\n      }\n      case 'property':\n        found.add(PROFILE_UPDATED_EVENT);\n        break;\n      case 'reachable':\n        found.add(c.channel === 'push' ? DEVICES_UPDATED_EVENT : PROFILE_UPDATED_EVENT);\n        break;\n      case 'payload':\n        break; // only appears inside performed.where, which is not walked\n    }\n  }\n  await walk(condition);\n  return [...found];\n}\n"],"mappings":"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"}