@shware/workflow 0.0.0-stage → 0.1.0

package/dist/ir.cjs

@@ -0,0 +1,366 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let zod_mini = require("zod/mini");
+zod_mini = require_runtime.__toESM(zod_mini, 1);
+//#region src/ir.ts
+/**
+* IR (Intermediate Representation) — what the DSL compiles to: serializable
+* JSON. It is the three-way contract between the engine that interprets it,
+* the UI (react-flow) that renders it, and diff / audit tooling.
+*
+* Validation strategy: the zod/mini schemas are the authoritative definition.
+* TS types are either inferred from a schema or hand-written under the same
+* name (zod cannot infer recursive types; the hand-written type is anchored
+* with a ZodMiniType<T> annotation, so any drift fails to compile). IR crosses
+* process boundaries (database, network, UI), so runtime validation is a must.
+*
+* ## Versioning (two independent axes)
+*
+* 1. IR format version (irVersion): evolution of the IR schema itself. Adding
+*    optional fields does not bump it; only structurally incompatible changes
+*    do (changing a discriminant, dropping a field, altering semantics).
+*    Readers dispatch on irVersion to the matching schema/migrator; writers
+*    always write the current version.
+* 2. Content version (contentHash): a content-addressed id for a single
+*    definition's **execution semantics** — the canonical-JSON hash after
+*    metadata (meta / label / reason) is stripped, see hash.ts. It is used to:
+*    - pin a version when a user enters, so an in-flight journey runs the
+*      pinned version to completion (the default policy; compatible hot
+*      updates are a future explicit-migration topic). Known exception:
+*      segment conditions are resolved **by id at evaluation time** — a
+*      segment redeploy changes behaviour of in-flight journeys that
+*      reference it. Pinning covers the workflow's own structure; per-hash
+*      segment snapshots are future work;
+*    - diff on deploy: same hash means unchanged, skip publishing;
+*    - audit: answer "which version was this user on" at any point.
+*
+* ## Node ids
+*
+* Derived from the structural path at compile time — stable and deterministic:
+* root level '0', '1', …; the j-th child of a branch's i-th case is
+* '{branchId}.c{i}.{j}', the default arm '{branchId}.o.{j}'; cohort arms use
+* the arm name '{cohortId}.{armName}.{j}'; a waitUntil timeout flow '{id}.t.{j}'.
+* Editing a node's parameters keeps its id; inserting a node shifts the ids of
+* its later siblings (a known trade-off — locating in-flight users relies on
+* the pinned version rather than cross-version id alignment, and cross-version
+* mapping is an explicit migrator's job).
+*/
+const IR_VERSION = 2;
+const ScalarIR = zod_mini.union([
+	zod_mini.string(),
+	zod_mini.number(),
+	zod_mini.boolean()
+]);
+/** Duration: `value` keeps the DSL literal ('23 hours', for display), `ms` is what the engine uses. */
+const DurationIR = zod_mini.object({
+	value: zod_mini.string(),
+	ms: zod_mini.number()
+});
+/** User-property reference — isomorphic to the DSL's UserPropertyRef once serialized (phantom type dropped). */
+const UserPropertyRefIR = zod_mini.object({
+	type: zod_mini.literal("user_property"),
+	path: zod_mini.string()
+});
+/** A message prop / event payload value: either a literal or a user-property reference. */
+const PropValueIR = zod_mini.union([ScalarIR, UserPropertyRefIR]);
+const ChannelIR = zod_mini.enum([
+	"email",
+	"sms",
+	"push",
+	"in_app",
+	"slack",
+	"discord",
+	"survey"
+]);
+const WeekdayIR = zod_mini.enum([
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat",
+	"sun"
+]);
+/**
+* Source location of the builder call that produced a definition — the IR's
+* source map. Lives under `meta`, so it is **excluded from contentHash**
+* (see hash.ts): provenance never affects execution identity or plan.
+* `file` is cwd-relative when compiled under Node, a URL under Vite dev.
+*/
+const SourceLocIR = zod_mini.object({
+	file: zod_mini.string(),
+	line: zod_mini.number(),
+	column: zod_mini.number()
+});
+/** Node-level metadata: provenance only, for now. Excluded from contentHash. */
+const NodeMetaIR = zod_mini.object({ loc: zod_mini.optional(SourceLocIR) });
+const PropertyOperatorIR = zod_mini.enum([
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"between",
+	"not_between",
+	"in_array",
+	"not_in_array",
+	"exists",
+	"not_exists",
+	"contains",
+	"not_contains"
+]);
+const conditionBase = { meta: zod_mini.optional(NodeMetaIR) };
+const ConditionIR = zod_mini.lazy(() => zod_mini.discriminatedUnion("type", [
+	zod_mini.object({
+		...conditionBase,
+		type: zod_mini.literal("and"),
+		conditions: zod_mini.array(ConditionIR)
+	}),
+	zod_mini.object({
+		...conditionBase,
+		type: zod_mini.literal("or"),
+		conditions: zod_mini.array(ConditionIR)
+	}),
+	zod_mini.object({
+		...conditionBase,
+		type: zod_mini.literal("not"),
+		condition: ConditionIR
+	}),
+	zod_mini.object({
+		...conditionBase,
+		type: zod_mini.literal("segment"),
+		segment: zod_mini.string()
+	}),
+	zod_mini.object({
+		...conditionBase,
+		type: zod_mini.literal("property"),
+		path: zod_mini.string(),
+		op: PropertyOperatorIR,
+		value: zod_mini.optional(ScalarIR),
+		values: zod_mini.optional(zod_mini.array(ScalarIR))
+	}),
+	zod_mini.object({
+		...conditionBase,
+		type: zod_mini.literal("payload"),
+		path: zod_mini.string(),
+		op: PropertyOperatorIR,
+		value: zod_mini.optional(ScalarIR),
+		values: zod_mini.optional(zod_mini.array(ScalarIR))
+	}),
+	zod_mini.object({
+		...conditionBase,
+		type: zod_mini.literal("performed"),
+		event: zod_mini.string(),
+		where: zod_mini.optional(ConditionIR),
+		within: zod_mini.optional(DurationIR),
+		count: zod_mini.optional(zod_mini.number())
+	}),
+	zod_mini.object({
+		...conditionBase,
+		type: zod_mini.literal("reachable"),
+		channel: ChannelIR
+	})
+]));
+/**
+* Trigger shapes. The event trigger has two independent gates: `where` tests
+* the triggering event's payload (payload-only subtree, evaluated against the
+* incoming event before anything else), `filter` tests the user's profile.
+*/
+const TriggerIR = zod_mini.discriminatedUnion("type", [
+	zod_mini.object({
+		type: zod_mini.literal("event"),
+		event: zod_mini.string(),
+		where: zod_mini.optional(ConditionIR),
+		filter: zod_mini.optional(ConditionIR)
+	}),
+	zod_mini.object({
+		type: zod_mini.literal("segment"),
+		segment: zod_mini.string()
+	}),
+	zod_mini.object({
+		type: zod_mini.literal("date"),
+		at: zod_mini.string()
+	}),
+	zod_mini.object({ type: zod_mini.literal("webhook") })
+]);
+const nodeBase = {
+	id: zod_mini.string(),
+	label: zod_mini.optional(zod_mini.string()),
+	meta: zod_mini.optional(NodeMetaIR)
+};
+const NodeIR = zod_mini.lazy(() => zod_mini.discriminatedUnion("type", [
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("message"),
+		channel: ChannelIR,
+		template: zod_mini.string(),
+		props: zod_mini.record(zod_mini.string(), PropValueIR),
+		devices: zod_mini.optional(zod_mini.literal("latest"))
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("delay"),
+		duration: DurationIR
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("random_delay"),
+		min: DurationIR,
+		max: DurationIR
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("time_window"),
+		days: zod_mini.array(WeekdayIR),
+		between: zod_mini.tuple([zod_mini.string(), zod_mini.string()]),
+		tz: zod_mini.string()
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("wait_until"),
+		condition: ConditionIR,
+		timeout: DurationIR,
+		onTimeout: zod_mini.union([
+			zod_mini.literal("continue"),
+			zod_mini.literal("exit"),
+			zod_mini.array(NodeIR)
+		])
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("branch"),
+		cases: zod_mini.array(zod_mini.object({
+			label: zod_mini.optional(zod_mini.string()),
+			condition: ConditionIR,
+			flow: zod_mini.array(NodeIR)
+		})),
+		otherwise: zod_mini.optional(zod_mini.array(NodeIR))
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("filter"),
+		condition: ConditionIR,
+		reason: zod_mini.optional(zod_mini.string())
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("cohort"),
+		key: zod_mini.optional(zod_mini.string()),
+		arms: zod_mini.array(zod_mini.object({
+			name: zod_mini.string(),
+			weight: zod_mini.number(),
+			flow: zod_mini.array(NodeIR)
+		}))
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("exit"),
+		reason: zod_mini.optional(zod_mini.string())
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("send_event"),
+		event: zod_mini.string(),
+		payload: zod_mini.record(zod_mini.string(), PropValueIR)
+	}),
+	zod_mini.object({
+		...nodeBase,
+		type: zod_mini.literal("action"),
+		action: zod_mini.string(),
+		args: zod_mini.record(zod_mini.string(), PropValueIR),
+		codeHash: zod_mini.optional(zod_mini.string())
+	})
+]));
+const GoalIR = zod_mini.object({
+	condition: ConditionIR,
+	within: zod_mini.optional(DurationIR),
+	exitOnMatch: zod_mini.boolean()
+});
+/**
+* Human-facing metadata: **excluded from contentHash** (see hash.ts).
+* Editing a name or description does not touch execution semantics, so it never
+* invalidates the version in-flight users are pinned to, nor shows up in plan.
+*/
+const MetaIR = zod_mini.object({
+	/**
+	* Human label. The asset's `id` is its identity — a wire key that routing
+	* tables and the entry ledger are built on — so it is not something to
+	* rename for readability. This is: it is metadata, dropped before hashing,
+	* and the studio shows it in place of the key wherever it is set.
+	*/
+	name: zod_mini.optional(zod_mini.string()),
+	description: zod_mini.optional(zod_mini.string()),
+	loc: zod_mini.optional(SourceLocIR)
+});
+const WorkflowIR = zod_mini.object({
+	irVersion: zod_mini.literal(2),
+	/** Wire identity (`workflow({ id })`): routing tables, the entry ledger and reporting are keyed on it. */
+	id: zod_mini.string(),
+	contentHash: zod_mini.string(),
+	meta: zod_mini.optional(MetaIR),
+	trigger: TriggerIR,
+	goal: zod_mini.optional(GoalIR),
+	exitWhen: zod_mini.optional(ConditionIR),
+	flow: zod_mini.array(NodeIR)
+});
+const SegmentIR = zod_mini.object({
+	irVersion: zod_mini.literal(2),
+	/** Wire identity (`segment({ id })`): segment references and the membership store are keyed on it. */
+	id: zod_mini.string(),
+	contentHash: zod_mini.string(),
+	/** Provenance plus the human label — MetaIR, same as a workflow's. */
+	meta: zod_mini.optional(MetaIR),
+	condition: ConditionIR
+});
+/** Template manifest entry: IR records only the reference; the body lives in the template system. */
+const TemplateIR = zod_mini.object({
+	irVersion: zod_mini.literal(2),
+	key: zod_mini.string(),
+	channel: ChannelIR
+});
+/**
+* Action manifest entry: IR records the name and the code-identity hash; the
+* implementation solidifies into the Worker bundle at deploy time, never into
+* IR (custom code stays out of the data plane by design).
+*/
+const ActionIR = zod_mini.object({
+	irVersion: zod_mini.literal(2),
+	name: zod_mini.string(),
+	codeHash: zod_mini.string()
+});
+/**
+* Deployment unit: the complete snapshot one `deploy` produces (terraform
+* apply, same mental model). The server diffs each definition's contentHash to
+* decide publish / skip / retire.
+*/
+const BundleIR = zod_mini.object({
+	irVersion: zod_mini.literal(2),
+	workflows: zod_mini.array(WorkflowIR),
+	segments: zod_mini.array(SegmentIR),
+	templates: zod_mini.array(TemplateIR),
+	actions: zod_mini.array(ActionIR)
+});
+//#endregion
+exports.ActionIR = ActionIR;
+exports.BundleIR = BundleIR;
+exports.ChannelIR = ChannelIR;
+exports.ConditionIR = ConditionIR;
+exports.DurationIR = DurationIR;
+exports.GoalIR = GoalIR;
+exports.IR_VERSION = IR_VERSION;
+exports.MetaIR = MetaIR;
+exports.NodeIR = NodeIR;
+exports.NodeMetaIR = NodeMetaIR;
+exports.PropValueIR = PropValueIR;
+exports.PropertyOperatorIR = PropertyOperatorIR;
+exports.ScalarIR = ScalarIR;
+exports.SegmentIR = SegmentIR;
+exports.SourceLocIR = SourceLocIR;
+exports.TemplateIR = TemplateIR;
+exports.TriggerIR = TriggerIR;
+exports.UserPropertyRefIR = UserPropertyRefIR;
+exports.WeekdayIR = WeekdayIR;
+exports.WorkflowIR = WorkflowIR;
+
+//# sourceMappingURL=ir.cjs.map

package/dist/ir.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.cjs","names":["z"],"sources":["../src/ir.ts"],"sourcesContent":["import * as z from 'zod/mini';\n\n/**\n * IR (Intermediate Representation) — what the DSL compiles to: serializable\n * JSON. It is the three-way contract between the engine that interprets it,\n * the UI (react-flow) that renders it, and diff / audit tooling.\n *\n * Validation strategy: the zod/mini schemas are the authoritative definition.\n * TS types are either inferred from a schema or hand-written under the same\n * name (zod cannot infer recursive types; the hand-written type is anchored\n * with a ZodMiniType<T> annotation, so any drift fails to compile). IR crosses\n * process boundaries (database, network, UI), so runtime validation is a must.\n *\n * ## Versioning (two independent axes)\n *\n * 1. IR format version (irVersion): evolution of the IR schema itself. Adding\n *    optional fields does not bump it; only structurally incompatible changes\n *    do (changing a discriminant, dropping a field, altering semantics).\n *    Readers dispatch on irVersion to the matching schema/migrator; writers\n *    always write the current version.\n * 2. Content version (contentHash): a content-addressed id for a single\n *    definition's **execution semantics** — the canonical-JSON hash after\n *    metadata (meta / label / reason) is stripped, see hash.ts. It is used to:\n *    - pin a version when a user enters, so an in-flight journey runs the\n *      pinned version to completion (the default policy; compatible hot\n *      updates are a future explicit-migration topic). Known exception:\n *      segment conditions are resolved **by id at evaluation time** — a\n *      segment redeploy changes behaviour of in-flight journeys that\n *      reference it. Pinning covers the workflow's own structure; per-hash\n *      segment snapshots are future work;\n *    - diff on deploy: same hash means unchanged, skip publishing;\n *    - audit: answer \"which version was this user on\" at any point.\n *\n * ## Node ids\n *\n * Derived from the structural path at compile time — stable and deterministic:\n * root level '0', '1', …; the j-th child of a branch's i-th case is\n * '{branchId}.c{i}.{j}', the default arm '{branchId}.o.{j}'; cohort arms use\n * the arm name '{cohortId}.{armName}.{j}'; a waitUntil timeout flow '{id}.t.{j}'.\n * Editing a node's parameters keeps its id; inserting a node shifts the ids of\n * its later siblings (a known trade-off — locating in-flight users relies on\n * the pinned version rather than cross-version id alignment, and cross-version\n * mapping is an explicit migrator's job).\n */\n\nexport const IR_VERSION = 2;\n\n/* -------------------------------- Base values ------------------------------- */\n\nexport const ScalarIR = z.union([z.string(), z.number(), z.boolean()]);\nexport type ScalarIR = z.infer<typeof ScalarIR>;\n\n/** Duration: `value` keeps the DSL literal ('23 hours', for display), `ms` is what the engine uses. */\n/*\n * TODO: `value` is hashed alongside `ms`, so '7 days' / '1 week' / '168 hours'\n * — identical to the engine, which only reads ms — produce three different\n * contentHashes. Rewording a duration therefore reports as a semantic change in\n * plan and repins in-flight users. Moving `value` out of the hash (it is a\n * display string) would fix it; deferred because it changes existing hashes.\n */\nexport const DurationIR = z.object({ value: z.string(), ms: z.number() });\nexport type DurationIR = z.infer<typeof DurationIR>;\n\n/** User-property reference — isomorphic to the DSL's UserPropertyRef once serialized (phantom type dropped). */\nexport const UserPropertyRefIR = z.object({\n  type: z.literal('user_property'),\n  path: z.string(),\n});\nexport type UserPropertyRefIR = z.infer<typeof UserPropertyRefIR>;\n\n/** A message prop / event payload value: either a literal or a user-property reference. */\nexport const PropValueIR = z.union([ScalarIR, UserPropertyRefIR]);\nexport type PropValueIR = z.infer<typeof PropValueIR>;\n\nexport const ChannelIR = z.enum(['email', 'sms', 'push', 'in_app', 'slack', 'discord', 'survey']);\nexport type ChannelIR = z.infer<typeof ChannelIR>;\n\nexport const WeekdayIR = z.enum(['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']);\nexport type WeekdayIR = z.infer<typeof WeekdayIR>;\n\n/* --------------------------------- Provenance -------------------------------- */\n\n/**\n * Source location of the builder call that produced a definition — the IR's\n * source map. Lives under `meta`, so it is **excluded from contentHash**\n * (see hash.ts): provenance never affects execution identity or plan.\n * `file` is cwd-relative when compiled under Node, a URL under Vite dev.\n */\nexport const SourceLocIR = z.object({\n  file: z.string(),\n  line: z.number(),\n  column: z.number(),\n});\nexport type SourceLocIR = z.infer<typeof SourceLocIR>;\n\n/** Node-level metadata: provenance only, for now. Excluded from contentHash. */\nexport const NodeMetaIR = z.object({\n  loc: z.optional(SourceLocIR),\n});\nexport type NodeMetaIR = z.infer<typeof NodeMetaIR>;\n\n/* -------------------------------- Conditions -------------------------------- */\n\nexport const PropertyOperatorIR = z.enum([\n  'eq',\n  'ne',\n  'gt',\n  'gte',\n  'lt',\n  'lte',\n  'between',\n  'not_between',\n  'in_array',\n  'not_in_array',\n  'exists',\n  'not_exists',\n  'contains',\n  'not_contains',\n]);\nexport type PropertyOperatorIR = z.infer<typeof PropertyOperatorIR>;\n\n/**\n * Condition expression tree. The shape of value/values follows `op`:\n * eq/ne/gt/gte/lt/lte/contains/not_contains → value; in_array/not_in_array →\n * values; between/not_between → values = [min, max]; exists/not_exists → neither.\n *\n * `payload` predicates test the payload of an event (dotted paths reach nested\n * fields). They are only valid inside a `where` subtree — `performed.where`\n * and the event trigger's `where` — where an event row is in scope; the\n * compiler (compileBundle) and the evaluator both enforce the placement.\n * TODO: runtime refinement narrowing by op.\n */\n/**\n * Provenance rides on conditions too, so the studio can point at the exact\n * `eq(...)` / `and(...)` that produced a node — same rule as nodes: `meta` is\n * dropped before hashing, so carrying it never affects execution identity.\n */\ninterface ConditionBaseIR {\n  meta?: NodeMetaIR | undefined;\n}\n\nexport type ConditionIR =\n  | (ConditionBaseIR & { type: 'and'; conditions: ConditionIR[] })\n  | (ConditionBaseIR & { type: 'or'; conditions: ConditionIR[] })\n  | (ConditionBaseIR & { type: 'not'; condition: ConditionIR })\n  /** Reference a segment by id (defined in SegmentIR, versioned separately). */\n  | (ConditionBaseIR & { type: 'segment'; segment: string })\n  | (ConditionBaseIR & {\n      type: 'property';\n      path: string;\n      op: PropertyOperatorIR;\n      value?: ScalarIR | undefined;\n      values?: ScalarIR[] | undefined;\n    })\n  | (ConditionBaseIR & {\n      /** Event payload predicate; `path` is dotted for nested fields ('tags.utm_source'). */\n      type: 'payload';\n      path: string;\n      op: PropertyOperatorIR;\n      value?: ScalarIR | undefined;\n      values?: ScalarIR[] | undefined;\n    })\n  | (ConditionBaseIR & {\n      type: 'performed';\n      event: string;\n      /** Payload filter: only events matching it count (a payload-only subtree). */\n      where?: ConditionIR | undefined;\n      within?: DurationIR | undefined;\n      count?: number | undefined;\n    })\n  /**\n   * The user can be reached on the channel right now: for push, the host's\n   * device directory lists at least one device; for the others, the channel's\n   * recipient property (email, phone, …) is set.\n   */\n  | (ConditionBaseIR & { type: 'reachable'; channel: ChannelIR });\n\nconst conditionBase = { meta: z.optional(NodeMetaIR) };\n\nexport const ConditionIR: z.ZodMiniType<ConditionIR> = z.lazy(() =>\n  z.discriminatedUnion('type', [\n    z.object({ ...conditionBase, type: z.literal('and'), conditions: z.array(ConditionIR) }),\n    z.object({ ...conditionBase, type: z.literal('or'), conditions: z.array(ConditionIR) }),\n    z.object({ ...conditionBase, type: z.literal('not'), condition: ConditionIR }),\n    z.object({ ...conditionBase, type: z.literal('segment'), segment: z.string() }),\n    z.object({\n      ...conditionBase,\n      type: z.literal('property'),\n      path: z.string(),\n      op: PropertyOperatorIR,\n      value: z.optional(ScalarIR),\n      values: z.optional(z.array(ScalarIR)),\n    }),\n    z.object({\n      ...conditionBase,\n      type: z.literal('payload'),\n      path: z.string(),\n      op: PropertyOperatorIR,\n      value: z.optional(ScalarIR),\n      values: z.optional(z.array(ScalarIR)),\n    }),\n    z.object({\n      ...conditionBase,\n      type: z.literal('performed'),\n      event: z.string(),\n      where: z.optional(ConditionIR),\n      within: z.optional(DurationIR),\n      count: z.optional(z.number()),\n    }),\n    z.object({ ...conditionBase, type: z.literal('reachable'), channel: ChannelIR }),\n  ])\n);\n\n/* --------------------------------- Triggers --------------------------------- */\n\n/**\n * Trigger shapes. The event trigger has two independent gates: `where` tests\n * the triggering event's payload (payload-only subtree, evaluated against the\n * incoming event before anything else), `filter` tests the user's profile.\n */\nexport const TriggerIR = z.discriminatedUnion('type', [\n  z.object({\n    type: z.literal('event'),\n    event: z.string(),\n    where: z.optional(ConditionIR),\n    filter: z.optional(ConditionIR),\n  }),\n  z.object({ type: z.literal('segment'), segment: z.string() }),\n  z.object({ type: z.literal('date'), at: z.string() }),\n  z.object({ type: z.literal('webhook') }),\n]);\nexport type TriggerIR = z.infer<typeof TriggerIR>;\n\n/* ----------------------------------- Nodes ---------------------------------- */\n\ninterface NodeBaseIR {\n  /** Stable id derived from the structural path (rules in the file header). */\n  id: string;\n  /** Optional node name: UI title / observability handle (branch's optional first argument lands here). */\n  label?: string | undefined;\n  /** Metadata (provenance); excluded from contentHash. */\n  meta?: NodeMetaIR | undefined;\n}\n\nexport type NodeIR =\n  | (NodeBaseIR & {\n      type: 'message';\n      channel: ChannelIR;\n      template: string;\n      props: Record<string, PropValueIR>;\n      /**\n       * Push only: which of the user's devices get a copy. Absent means every\n       * device the directory lists; 'latest' only the most recently registered.\n       */\n      devices?: 'latest' | undefined;\n    })\n  | (NodeBaseIR & { type: 'delay'; duration: DurationIR })\n  | (NodeBaseIR & { type: 'random_delay'; min: DurationIR; max: DurationIR })\n  | (NodeBaseIR & {\n      type: 'time_window';\n      days: WeekdayIR[];\n      between: [string, string];\n      tz: string;\n    })\n  | (NodeBaseIR & {\n      type: 'wait_until';\n      condition: ConditionIR;\n      timeout: DurationIR;\n      onTimeout: 'continue' | 'exit' | NodeIR[];\n    })\n  | (NodeBaseIR & {\n      type: 'branch';\n      cases: { label?: string | undefined; condition: ConditionIR; flow: NodeIR[] }[];\n      /** Default arm (the DSL's bare tail argument). Absent = fall through to the main line. */\n      otherwise?: NodeIR[] | undefined;\n    })\n  | (NodeBaseIR & {\n      type: 'filter';\n      /** Audit-log line for the users this gate drops. Metadata: excluded from contentHash. */\n      reason?: string | undefined;\n      condition: ConditionIR;\n    })\n  | (NodeBaseIR & {\n      type: 'cohort';\n      /**\n       * Explicit experiment key: bucketing hashes `userId:key` instead of the\n       * structural node id, so the assignment survives node insertion/moves and\n       * the experiment keeps one identity across workflow versions. Absent →\n       * the node id is used (fine for one-off splits).\n       */\n      key?: string | undefined;\n      /**\n       * Arms in authoring order — the order the interpreter accumulates weights\n       * in, so it decides which bucket range each arm owns. The DSL keeps that\n       * promise by rejecting integer-like arm names, which JavaScript would\n       * hoist to the front of the object in numeric order. Weights sum to 100.\n       */\n      arms: { name: string; weight: number; flow: NodeIR[] }[];\n    })\n  | (NodeBaseIR & {\n      /** `reason` is the audit-log line. Metadata: excluded from contentHash. */\n      type: 'exit';\n      reason?: string | undefined;\n    })\n  | (NodeBaseIR & { type: 'send_event'; event: string; payload: Record<string, PropValueIR> })\n  | (NodeBaseIR & {\n      type: 'action';\n      /** Registry name of the custom action; the code itself lives in the deployed Worker bundle. */\n      action: string;\n      /** Argument values; user_property references are resolved at run time, like message props. */\n      args: Record<string, PropValueIR>;\n      /**\n       * Hash of the action's source at compile time — the code-identity pin.\n       * IR carries identity only (dual-plane model): the runtime looks the\n       * action up by name and compares this hash against the registered\n       * implementation to detect version skew (warn by default).\n       */\n      codeHash?: string | undefined;\n    });\n\nconst nodeBase = { id: z.string(), label: z.optional(z.string()), meta: z.optional(NodeMetaIR) };\n\nexport const NodeIR: z.ZodMiniType<NodeIR> = z.lazy(() =>\n  z.discriminatedUnion('type', [\n    z.object({\n      ...nodeBase,\n      type: z.literal('message'),\n      channel: ChannelIR,\n      template: z.string(),\n      props: z.record(z.string(), PropValueIR),\n      devices: z.optional(z.literal('latest')),\n    }),\n    z.object({ ...nodeBase, type: z.literal('delay'), duration: DurationIR }),\n    z.object({ ...nodeBase, type: z.literal('random_delay'), min: DurationIR, max: DurationIR }),\n    z.object({\n      ...nodeBase,\n      type: z.literal('time_window'),\n      days: z.array(WeekdayIR),\n      between: z.tuple([z.string(), z.string()]),\n      tz: z.string(),\n    }),\n    z.object({\n      ...nodeBase,\n      type: z.literal('wait_until'),\n      condition: ConditionIR,\n      timeout: DurationIR,\n      onTimeout: z.union([z.literal('continue'), z.literal('exit'), z.array(NodeIR)]),\n    }),\n    z.object({\n      ...nodeBase,\n      type: z.literal('branch'),\n      cases: z.array(\n        z.object({\n          label: z.optional(z.string()),\n          condition: ConditionIR,\n          flow: z.array(NodeIR),\n        })\n      ),\n      otherwise: z.optional(z.array(NodeIR)),\n    }),\n    z.object({\n      ...nodeBase,\n      type: z.literal('filter'),\n      condition: ConditionIR,\n      reason: z.optional(z.string()),\n    }),\n    z.object({\n      ...nodeBase,\n      type: z.literal('cohort'),\n      key: z.optional(z.string()),\n      arms: z.array(z.object({ name: z.string(), weight: z.number(), flow: z.array(NodeIR) })),\n    }),\n    z.object({ ...nodeBase, type: z.literal('exit'), reason: z.optional(z.string()) }),\n    z.object({\n      ...nodeBase,\n      type: z.literal('send_event'),\n      event: z.string(),\n      payload: z.record(z.string(), PropValueIR),\n    }),\n    z.object({\n      ...nodeBase,\n      type: z.literal('action'),\n      action: z.string(),\n      args: z.record(z.string(), PropValueIR),\n      codeHash: z.optional(z.string()),\n    }),\n  ])\n);\n\n/* ---------------------- Top-level definitions and bundle --------------------- */\n\nexport const GoalIR = z.object({\n  condition: ConditionIR,\n  within: z.optional(DurationIR),\n  exitOnMatch: z.boolean(),\n});\nexport type GoalIR = z.infer<typeof GoalIR>;\n\n/**\n * Human-facing metadata: **excluded from contentHash** (see hash.ts).\n * Editing a name or description does not touch execution semantics, so it never\n * invalidates the version in-flight users are pinned to, nor shows up in plan.\n */\nexport const MetaIR = z.object({\n  /**\n   * Human label. The asset's `id` is its identity — a wire key that routing\n   * tables and the entry ledger are built on — so it is not something to\n   * rename for readability. This is: it is metadata, dropped before hashing,\n   * and the studio shows it in place of the key wherever it is set.\n   */\n  name: z.optional(z.string()),\n  description: z.optional(z.string()),\n  loc: z.optional(SourceLocIR),\n});\nexport type MetaIR = z.infer<typeof MetaIR>;\n\nexport const WorkflowIR = z.object({\n  irVersion: z.literal(IR_VERSION),\n  /** Wire identity (`workflow({ id })`): routing tables, the entry ledger and reporting are keyed on it. */\n  id: z.string(),\n  contentHash: z.string(),\n  meta: z.optional(MetaIR),\n  trigger: TriggerIR,\n  goal: z.optional(GoalIR),\n  exitWhen: z.optional(ConditionIR),\n  flow: z.array(NodeIR),\n});\nexport type WorkflowIR = z.infer<typeof WorkflowIR>;\n\nexport const SegmentIR = z.object({\n  irVersion: z.literal(IR_VERSION),\n  /** Wire identity (`segment({ id })`): segment references and the membership store are keyed on it. */\n  id: z.string(),\n  contentHash: z.string(),\n  /** Provenance plus the human label — MetaIR, same as a workflow's. */\n  meta: z.optional(MetaIR),\n  condition: ConditionIR,\n});\nexport type SegmentIR = z.infer<typeof SegmentIR>;\n\n/** Template manifest entry: IR records only the reference; the body lives in the template system. */\nexport const TemplateIR = z.object({\n  irVersion: z.literal(IR_VERSION),\n  key: z.string(),\n  channel: ChannelIR,\n});\nexport type TemplateIR = z.infer<typeof TemplateIR>;\n\n/**\n * Action manifest entry: IR records the name and the code-identity hash; the\n * implementation solidifies into the Worker bundle at deploy time, never into\n * IR (custom code stays out of the data plane by design).\n */\nexport const ActionIR = z.object({\n  irVersion: z.literal(IR_VERSION),\n  name: z.string(),\n  codeHash: z.string(),\n});\nexport type ActionIR = z.infer<typeof ActionIR>;\n\n/**\n * Deployment unit: the complete snapshot one `deploy` produces (terraform\n * apply, same mental model). The server diffs each definition's contentHash to\n * decide publish / skip / retire.\n */\nexport const BundleIR = z.object({\n  irVersion: z.literal(IR_VERSION),\n  workflows: z.array(WorkflowIR),\n  segments: z.array(SegmentIR),\n  templates: z.array(TemplateIR),\n  actions: z.array(ActionIR),\n});\nexport type BundleIR = z.infer<typeof BundleIR>;\n"],"mappings":"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"}