@shware/workflow 0.0.0-stage → 0.1.0

package/dist/dsl/trigger.cjs

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_dsl_refs = require("./refs.cjs");
+const require_dsl_condition = require("./condition.cjs");
+//#region src/dsl/trigger.ts
+const makeTrigger = (ir) => {
+	return {
+		type: ir.type,
+		ir
+	};
+};
+/**
+* Trigger definition: a plain object — event names come from e.xxx references.
+*
+*   const login = trigger.event(e.login, { filter: newUsers7d });
+*/
+const trigger = {
+	event: (ev, whereOrOpts, maybeOpts) => {
+		const where = typeof whereOrOpts === "function" ? whereOrOpts : void 0;
+		const opts = typeof whereOrOpts === "function" ? maybeOpts : whereOrOpts;
+		return makeTrigger({
+			type: "event",
+			event: ev.name,
+			...where !== void 0 ? { where: require_dsl_condition.condIR(where(require_dsl_refs.payloadRefs())) } : {},
+			...opts?.filter !== void 0 ? { filter: require_dsl_condition.condIR(opts.filter) } : {}
+		});
+	},
+	segment: (seg) => makeTrigger({
+		type: "segment",
+		segment: seg.id
+	}),
+	date: (at) => makeTrigger({
+		type: "date",
+		at
+	}),
+	webhook: () => makeTrigger({ type: "webhook" })
+};
+//#endregion
+exports.trigger = trigger;
+
+//# sourceMappingURL=trigger.cjs.map

package/dist/dsl/trigger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.cjs","names":["condIR","payloadRefs"],"sources":["../../src/dsl/trigger.ts"],"sourcesContent":["import type { TriggerIR } from '../ir';\nimport { type Condition, type PayloadWhere, type SegmentRef, condIR } from './condition';\nimport { type EventRef, payloadRefs } from './refs';\n\n/**\n * Triggers — the four ways into a workflow, mirroring customer.io's campaign\n * trigger types. A trigger is a plain reusable object; the event name and\n * payload types flow in from an e.xxx reference, so the factory itself needs\n * no generics.\n */\n\n/** 'YYYY-MM-DD HH:mm:ss'. TODO: validate at runtime — template literals cannot express leading zeros. */\nexport type DateTime = string;\n\n/** Trigger reference: what trigger.xxx() returns, reusable across workflows. */\nexport interface TriggerRef {\n  readonly type: 'event' | 'segment' | 'date' | 'webhook';\n}\n\n/** @internal the compiled shape behind a TriggerRef — workflow.toIR reads .ir off it */\nexport interface TriggerInternal extends TriggerRef {\n  readonly ir: TriggerIR;\n}\n\nconst makeTrigger = (ir: TriggerIR): TriggerRef => {\n  const impl: TriggerInternal = { type: ir.type, ir };\n  return impl;\n};\n\nexport interface EventTriggerOptions {\n  filter?: Condition;\n}\n\n/** Trigger factory: four ways in, mirroring customer.io's campaign trigger types. */\nexport interface TriggerFactory {\n  /**\n   * Event trigger: the event name comes from an e.xxx reference (types flow in\n   * from it, so the factory itself needs no generics). Two independent gates:\n   * - the optional second argument is a payload where clause (typed refs, the\n   *   ordinary predicates — compiles to IR data the UI renders):\n   *   trigger.event(e.login, (p) => eq(p.platform, 'web'))\n   * - `filter` tests the user's profile (customer.io's trigger Filters).\n   * The user enters only if the event fired *and* both gates hold.\n   */\n  event<P>(event: EventRef<P>, opts?: EventTriggerOptions): TriggerRef;\n  event<P>(event: EventRef<P>, where: PayloadWhere<P>, opts?: EventTriggerOptions): TriggerRef;\n\n  /**\n   * Segment-entry trigger: the user enters the moment they go from not\n   * matching to matching. Only a named segment is accepted — entry semantics\n   * need a membership table, which an anonymous expression cannot provide.\n   * Runtime note: membership is maintained lazily (re-evaluated on the user's\n   * ingest/identify activity), so purely time-driven drift — e.g. an\n   * inactivity segment becoming true by clock alone — is only observed on the\n   * user's next activity. TODO: a cron sweep for time-driven segments.\n   */\n  segment(segment: SegmentRef): TriggerRef;\n\n  /**\n   * Scheduled trigger (one-shot, e.g. '2026-12-25 09:00:00', interpreted as\n   * UTC). TODO: not routed by the runtime yet — deployBundle reports it in\n   * `unrouted`; the implementation goes through cron + Queues (instance\n   * creation is rate-limited, a date trigger fans out to the whole audience at\n   * once). TODO: cron/recurring form.\n   */\n  date(at: DateTime): TriggerRef;\n\n  /** Webhook trigger: third-party or external code fires it via a URL; the runtime allocates the endpoint. */\n  webhook(): TriggerRef;\n}\n\n/**\n * Trigger definition: a plain object — event names come from e.xxx references.\n *\n *   const login = trigger.event(e.login, { filter: newUsers7d });\n */\nexport const trigger: TriggerFactory = {\n  event: <P>(\n    ev: EventRef<P>,\n    whereOrOpts?: PayloadWhere<P> | EventTriggerOptions,\n    maybeOpts?: EventTriggerOptions\n  ) => {\n    const where = typeof whereOrOpts === 'function' ? whereOrOpts : undefined;\n    const opts = typeof whereOrOpts === 'function' ? maybeOpts : whereOrOpts;\n    return makeTrigger({\n      type: 'event',\n      event: ev.name,\n      ...(where !== undefined ? { where: condIR(where(payloadRefs<P>())) } : {}),\n      ...(opts?.filter !== undefined ? { filter: condIR(opts.filter) } : {}),\n    });\n  },\n  segment: (seg) => makeTrigger({ type: 'segment', segment: seg.id }),\n  date: (at) => makeTrigger({ type: 'date', at }),\n  webhook: () => makeTrigger({ type: 'webhook' }),\n};\n"],"mappings":";;;;AAwBA,MAAM,eAAe,OAA8B;CAEjD,OAAO;EADyB,MAAM,GAAG;EAAM;CACrC;AACZ;;;;;;AAiDA,MAAa,UAA0B;CACrC,QACE,IACA,aACA,cACG;EACH,MAAM,QAAQ,OAAO,gBAAgB,aAAa,cAAc,KAAA;EAChE,MAAM,OAAO,OAAO,gBAAgB,aAAa,YAAY;EAC7D,OAAO,YAAY;GACjB,MAAM;GACN,OAAO,GAAG;GACV,GAAI,UAAU,KAAA,IAAY,EAAE,OAAOA,sBAAAA,OAAO,MAAMC,iBAAAA,YAAe,CAAC,CAAC,EAAE,IAAI,CAAC;GACxE,GAAI,MAAM,WAAW,KAAA,IAAY,EAAE,QAAQD,sBAAAA,OAAO,KAAK,MAAM,EAAE,IAAI,CAAC;EACtE,CAAC;CACH;CACA,UAAU,QAAQ,YAAY;EAAE,MAAM;EAAW,SAAS,IAAI;CAAG,CAAC;CAClE,OAAO,OAAO,YAAY;EAAE,MAAM;EAAQ;CAAG,CAAC;CAC9C,eAAe,YAAY,EAAE,MAAM,UAAU,CAAC;AAChD"}

package/dist/dsl/trigger.d.cts

@@ -0,0 +1,65 @@
+import { TriggerIR } from "../ir.cjs";
+import { EventRef } from "./refs.cjs";
+import { Condition, PayloadWhere, SegmentRef } from "./condition.cjs";
+//#region src/dsl/trigger.d.ts
+/**
+ * Triggers — the four ways into a workflow, mirroring customer.io's campaign
+ * trigger types. A trigger is a plain reusable object; the event name and
+ * payload types flow in from an e.xxx reference, so the factory itself needs
+ * no generics.
+ */
+/** 'YYYY-MM-DD HH:mm:ss'. TODO: validate at runtime — template literals cannot express leading zeros. */
+export type DateTime = string;
+/** Trigger reference: what trigger.xxx() returns, reusable across workflows. */
+export interface TriggerRef {
+  readonly type: 'event' | 'segment' | 'date' | 'webhook';
+}
+/** @internal the compiled shape behind a TriggerRef — workflow.toIR reads .ir off it */
+export interface TriggerInternal extends TriggerRef {
+  readonly ir: TriggerIR;
+}
+export interface EventTriggerOptions {
+  filter?: Condition;
+}
+/** Trigger factory: four ways in, mirroring customer.io's campaign trigger types. */
+export interface TriggerFactory {
+  /**
+   * Event trigger: the event name comes from an e.xxx reference (types flow in
+   * from it, so the factory itself needs no generics). Two independent gates:
+   * - the optional second argument is a payload where clause (typed refs, the
+   *   ordinary predicates — compiles to IR data the UI renders):
+   *   trigger.event(e.login, (p) => eq(p.platform, 'web'))
+   * - `filter` tests the user's profile (customer.io's trigger Filters).
+   * The user enters only if the event fired *and* both gates hold.
+   */
+  event<P>(event: EventRef<P>, opts?: EventTriggerOptions): TriggerRef;
+  event<P>(event: EventRef<P>, where: PayloadWhere<P>, opts?: EventTriggerOptions): TriggerRef;
+  /**
+   * Segment-entry trigger: the user enters the moment they go from not
+   * matching to matching. Only a named segment is accepted — entry semantics
+   * need a membership table, which an anonymous expression cannot provide.
+   * Runtime note: membership is maintained lazily (re-evaluated on the user's
+   * ingest/identify activity), so purely time-driven drift — e.g. an
+   * inactivity segment becoming true by clock alone — is only observed on the
+   * user's next activity. TODO: a cron sweep for time-driven segments.
+   */
+  segment(segment: SegmentRef): TriggerRef;
+  /**
+   * Scheduled trigger (one-shot, e.g. '2026-12-25 09:00:00', interpreted as
+   * UTC). TODO: not routed by the runtime yet — deployBundle reports it in
+   * `unrouted`; the implementation goes through cron + Queues (instance
+   * creation is rate-limited, a date trigger fans out to the whole audience at
+   * once). TODO: cron/recurring form.
+   */
+  date(at: DateTime): TriggerRef;
+  /** Webhook trigger: third-party or external code fires it via a URL; the runtime allocates the endpoint. */
+  webhook(): TriggerRef;
+}
+/**
+ * Trigger definition: a plain object — event names come from e.xxx references.
+ *
+ *   const login = trigger.event(e.login, { filter: newUsers7d });
+ */
+export declare const trigger: TriggerFactory;
+//#endregion
+//# sourceMappingURL=trigger.d.cts.map

package/dist/dsl/trigger.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.d.cts","names":[],"sources":["../../src/dsl/trigger.ts"],"mappings":";;;;;;;;;;;YAYY;;iBAGK;WACN;;;iBAIM,wBAAwB;WAC9B,IAAI;;iBAQE;EACf,SAAS;;;iBAIM;;;;;;;;;;EAUf,MAAM,GAAG,OAAO,SAAS,IAAI,OAAO,sBAAsB;EAC1D,MAAM,GAAG,OAAO,SAAS,IAAI,OAAO,aAAa,IAAI,OAAO,sBAAsB;;;;;;;;;;EAWlF,QAAQ,SAAS,aAAa;;;;;;;;EAS9B,KAAK,IAAI,WAAW;;EAGpB,WAAW;;;;;;;qBAQA,SAAS"}

package/dist/dsl/trigger.d.mts

@@ -0,0 +1,65 @@
+import { TriggerIR } from "../ir.mjs";
+import { EventRef } from "./refs.mjs";
+import { Condition, PayloadWhere, SegmentRef } from "./condition.mjs";
+//#region src/dsl/trigger.d.ts
+/**
+ * Triggers — the four ways into a workflow, mirroring customer.io's campaign
+ * trigger types. A trigger is a plain reusable object; the event name and
+ * payload types flow in from an e.xxx reference, so the factory itself needs
+ * no generics.
+ */
+/** 'YYYY-MM-DD HH:mm:ss'. TODO: validate at runtime — template literals cannot express leading zeros. */
+export type DateTime = string;
+/** Trigger reference: what trigger.xxx() returns, reusable across workflows. */
+export interface TriggerRef {
+  readonly type: 'event' | 'segment' | 'date' | 'webhook';
+}
+/** @internal the compiled shape behind a TriggerRef — workflow.toIR reads .ir off it */
+export interface TriggerInternal extends TriggerRef {
+  readonly ir: TriggerIR;
+}
+export interface EventTriggerOptions {
+  filter?: Condition;
+}
+/** Trigger factory: four ways in, mirroring customer.io's campaign trigger types. */
+export interface TriggerFactory {
+  /**
+   * Event trigger: the event name comes from an e.xxx reference (types flow in
+   * from it, so the factory itself needs no generics). Two independent gates:
+   * - the optional second argument is a payload where clause (typed refs, the
+   *   ordinary predicates — compiles to IR data the UI renders):
+   *   trigger.event(e.login, (p) => eq(p.platform, 'web'))
+   * - `filter` tests the user's profile (customer.io's trigger Filters).
+   * The user enters only if the event fired *and* both gates hold.
+   */
+  event<P>(event: EventRef<P>, opts?: EventTriggerOptions): TriggerRef;
+  event<P>(event: EventRef<P>, where: PayloadWhere<P>, opts?: EventTriggerOptions): TriggerRef;
+  /**
+   * Segment-entry trigger: the user enters the moment they go from not
+   * matching to matching. Only a named segment is accepted — entry semantics
+   * need a membership table, which an anonymous expression cannot provide.
+   * Runtime note: membership is maintained lazily (re-evaluated on the user's
+   * ingest/identify activity), so purely time-driven drift — e.g. an
+   * inactivity segment becoming true by clock alone — is only observed on the
+   * user's next activity. TODO: a cron sweep for time-driven segments.
+   */
+  segment(segment: SegmentRef): TriggerRef;
+  /**
+   * Scheduled trigger (one-shot, e.g. '2026-12-25 09:00:00', interpreted as
+   * UTC). TODO: not routed by the runtime yet — deployBundle reports it in
+   * `unrouted`; the implementation goes through cron + Queues (instance
+   * creation is rate-limited, a date trigger fans out to the whole audience at
+   * once). TODO: cron/recurring form.
+   */
+  date(at: DateTime): TriggerRef;
+  /** Webhook trigger: third-party or external code fires it via a URL; the runtime allocates the endpoint. */
+  webhook(): TriggerRef;
+}
+/**
+ * Trigger definition: a plain object — event names come from e.xxx references.
+ *
+ *   const login = trigger.event(e.login, { filter: newUsers7d });
+ */
+export declare const trigger: TriggerFactory;
+//#endregion
+//# sourceMappingURL=trigger.d.mts.map

package/dist/dsl/trigger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.d.mts","names":[],"sources":["../../src/dsl/trigger.ts"],"mappings":";;;;;;;;;;;YAYY;;iBAGK;WACN;;;iBAIM,wBAAwB;WAC9B,IAAI;;iBAQE;EACf,SAAS;;;iBAIM;;;;;;;;;;EAUf,MAAM,GAAG,OAAO,SAAS,IAAI,OAAO,sBAAsB;EAC1D,MAAM,GAAG,OAAO,SAAS,IAAI,OAAO,aAAa,IAAI,OAAO,sBAAsB;;;;;;;;;;EAWlF,QAAQ,SAAS,aAAa;;;;;;;;EAS9B,KAAK,IAAI,WAAW;;EAGpB,WAAW;;;;;;;qBAQA,SAAS"}

package/dist/dsl/trigger.mjs

@@ -0,0 +1,39 @@
+import { payloadRefs } from "./refs.mjs";
+import { condIR } from "./condition.mjs";
+//#region src/dsl/trigger.ts
+const makeTrigger = (ir) => {
+	return {
+		type: ir.type,
+		ir
+	};
+};
+/**
+* Trigger definition: a plain object — event names come from e.xxx references.
+*
+*   const login = trigger.event(e.login, { filter: newUsers7d });
+*/
+const trigger = {
+	event: (ev, whereOrOpts, maybeOpts) => {
+		const where = typeof whereOrOpts === "function" ? whereOrOpts : void 0;
+		const opts = typeof whereOrOpts === "function" ? maybeOpts : whereOrOpts;
+		return makeTrigger({
+			type: "event",
+			event: ev.name,
+			...where !== void 0 ? { where: condIR(where(payloadRefs())) } : {},
+			...opts?.filter !== void 0 ? { filter: condIR(opts.filter) } : {}
+		});
+	},
+	segment: (seg) => makeTrigger({
+		type: "segment",
+		segment: seg.id
+	}),
+	date: (at) => makeTrigger({
+		type: "date",
+		at
+	}),
+	webhook: () => makeTrigger({ type: "webhook" })
+};
+//#endregion
+export { trigger };
+
+//# sourceMappingURL=trigger.mjs.map

package/dist/dsl/trigger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.mjs","names":[],"sources":["../../src/dsl/trigger.ts"],"sourcesContent":["import type { TriggerIR } from '../ir';\nimport { type Condition, type PayloadWhere, type SegmentRef, condIR } from './condition';\nimport { type EventRef, payloadRefs } from './refs';\n\n/**\n * Triggers — the four ways into a workflow, mirroring customer.io's campaign\n * trigger types. A trigger is a plain reusable object; the event name and\n * payload types flow in from an e.xxx reference, so the factory itself needs\n * no generics.\n */\n\n/** 'YYYY-MM-DD HH:mm:ss'. TODO: validate at runtime — template literals cannot express leading zeros. */\nexport type DateTime = string;\n\n/** Trigger reference: what trigger.xxx() returns, reusable across workflows. */\nexport interface TriggerRef {\n  readonly type: 'event' | 'segment' | 'date' | 'webhook';\n}\n\n/** @internal the compiled shape behind a TriggerRef — workflow.toIR reads .ir off it */\nexport interface TriggerInternal extends TriggerRef {\n  readonly ir: TriggerIR;\n}\n\nconst makeTrigger = (ir: TriggerIR): TriggerRef => {\n  const impl: TriggerInternal = { type: ir.type, ir };\n  return impl;\n};\n\nexport interface EventTriggerOptions {\n  filter?: Condition;\n}\n\n/** Trigger factory: four ways in, mirroring customer.io's campaign trigger types. */\nexport interface TriggerFactory {\n  /**\n   * Event trigger: the event name comes from an e.xxx reference (types flow in\n   * from it, so the factory itself needs no generics). Two independent gates:\n   * - the optional second argument is a payload where clause (typed refs, the\n   *   ordinary predicates — compiles to IR data the UI renders):\n   *   trigger.event(e.login, (p) => eq(p.platform, 'web'))\n   * - `filter` tests the user's profile (customer.io's trigger Filters).\n   * The user enters only if the event fired *and* both gates hold.\n   */\n  event<P>(event: EventRef<P>, opts?: EventTriggerOptions): TriggerRef;\n  event<P>(event: EventRef<P>, where: PayloadWhere<P>, opts?: EventTriggerOptions): TriggerRef;\n\n  /**\n   * Segment-entry trigger: the user enters the moment they go from not\n   * matching to matching. Only a named segment is accepted — entry semantics\n   * need a membership table, which an anonymous expression cannot provide.\n   * Runtime note: membership is maintained lazily (re-evaluated on the user's\n   * ingest/identify activity), so purely time-driven drift — e.g. an\n   * inactivity segment becoming true by clock alone — is only observed on the\n   * user's next activity. TODO: a cron sweep for time-driven segments.\n   */\n  segment(segment: SegmentRef): TriggerRef;\n\n  /**\n   * Scheduled trigger (one-shot, e.g. '2026-12-25 09:00:00', interpreted as\n   * UTC). TODO: not routed by the runtime yet — deployBundle reports it in\n   * `unrouted`; the implementation goes through cron + Queues (instance\n   * creation is rate-limited, a date trigger fans out to the whole audience at\n   * once). TODO: cron/recurring form.\n   */\n  date(at: DateTime): TriggerRef;\n\n  /** Webhook trigger: third-party or external code fires it via a URL; the runtime allocates the endpoint. */\n  webhook(): TriggerRef;\n}\n\n/**\n * Trigger definition: a plain object — event names come from e.xxx references.\n *\n *   const login = trigger.event(e.login, { filter: newUsers7d });\n */\nexport const trigger: TriggerFactory = {\n  event: <P>(\n    ev: EventRef<P>,\n    whereOrOpts?: PayloadWhere<P> | EventTriggerOptions,\n    maybeOpts?: EventTriggerOptions\n  ) => {\n    const where = typeof whereOrOpts === 'function' ? whereOrOpts : undefined;\n    const opts = typeof whereOrOpts === 'function' ? maybeOpts : whereOrOpts;\n    return makeTrigger({\n      type: 'event',\n      event: ev.name,\n      ...(where !== undefined ? { where: condIR(where(payloadRefs<P>())) } : {}),\n      ...(opts?.filter !== undefined ? { filter: condIR(opts.filter) } : {}),\n    });\n  },\n  segment: (seg) => makeTrigger({ type: 'segment', segment: seg.id }),\n  date: (at) => makeTrigger({ type: 'date', at }),\n  webhook: () => makeTrigger({ type: 'webhook' }),\n};\n"],"mappings":";;;AAwBA,MAAM,eAAe,OAA8B;CAEjD,OAAO;EADyB,MAAM,GAAG;EAAM;CACrC;AACZ;;;;;;AAiDA,MAAa,UAA0B;CACrC,QACE,IACA,aACA,cACG;EACH,MAAM,QAAQ,OAAO,gBAAgB,aAAa,cAAc,KAAA;EAChE,MAAM,OAAO,OAAO,gBAAgB,aAAa,YAAY;EAC7D,OAAO,YAAY;GACjB,MAAM;GACN,OAAO,GAAG;GACV,GAAI,UAAU,KAAA,IAAY,EAAE,OAAO,OAAO,MAAM,YAAe,CAAC,CAAC,EAAE,IAAI,CAAC;GACxE,GAAI,MAAM,WAAW,KAAA,IAAY,EAAE,QAAQ,OAAO,KAAK,MAAM,EAAE,IAAI,CAAC;EACtE,CAAC;CACH;CACA,UAAU,QAAQ,YAAY;EAAE,MAAM;EAAW,SAAS,IAAI;CAAG,CAAC;CAClE,OAAO,OAAO,YAAY;EAAE,MAAM;EAAQ;CAAG,CAAC;CAC9C,eAAe,YAAY,EAAE,MAAM,UAAU,CAAC;AAChD"}

package/dist/dsl/workflow.cjs

@@ -0,0 +1,121 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_hash = require("../hash.cjs");
+const require_provenance = require("../provenance.cjs");
+const require_dsl_base = require("./base.cjs");
+const require_dsl_condition = require("./condition.cjs");
+const require_dsl_flow = require("./flow.cjs");
+const require_ir = require("../ir.cjs");
+//#region src/dsl/workflow.ts
+/**
+* Assign node ids from the structural path (rules in ir.ts's header). Written
+* in place into the tree toIR deep-cloned, never into the builder's own nodes.
+*/
+function assignIds(nodes, prefix) {
+	nodes.forEach((node, i) => {
+		const id = prefix === "" ? String(i) : `${prefix}.${i}`;
+		node.id = id;
+		switch (node.type) {
+			case "branch":
+				node.cases.forEach((c, ci) => assignIds(c.flow, `${id}.c${ci}`));
+				if (node.otherwise) assignIds(node.otherwise, `${id}.o`);
+				break;
+			case "cohort":
+				node.arms.forEach((arm) => assignIds(arm.flow, `${id}.${arm.name}`));
+				break;
+			case "wait_until": if (Array.isArray(node.onTimeout)) assignIds(node.onTimeout, `${id}.t`);
+		}
+	});
+}
+/**
+* Ids are derived, never authored, so a duplicate is always a compiler bug —
+* and a silent one: assignIds writes in place, so the second write simply wins
+* and two nodes ship as one. What that costs is concrete, because an id is the
+* durable step name (`step.do('{id}:send')`), the message idempotency key
+* (`{instanceId}:{id}`) and the cohort bucket seed: the twins share a
+* checkpoint, and the second send is suppressed as a duplicate of the first.
+* Cheap to check once at the end of the compile, so it is checked.
+*/
+function assertUniqueIds(nodes, seen = /* @__PURE__ */ new Set()) {
+	for (const node of nodes) {
+		if (seen.has(node.id)) throw new Error(`toIR(): node id '${node.id}' is used twice — ids are durable step names and message idempotency keys, so they must be unique`);
+		seen.add(node.id);
+		switch (node.type) {
+			case "branch":
+				for (const branchCase of node.cases) assertUniqueIds(branchCase.flow, seen);
+				if (node.otherwise) assertUniqueIds(node.otherwise, seen);
+				break;
+			case "cohort":
+				for (const arm of node.arms) assertUniqueIds(arm.flow, seen);
+				break;
+			case "wait_until": if (Array.isArray(node.onTimeout)) assertUniqueIds(node.onTimeout, seen);
+		}
+	}
+}
+var WorkflowBuilderImpl = class extends require_dsl_flow.FlowBuilderImpl {
+	options;
+	loc;
+	constructor(options, loc) {
+		super();
+		this.options = options;
+		this.loc = loc;
+	}
+	goalIR() {
+		const goal = this.options.goal;
+		if (goal === void 0) return void 0;
+		if ("__condition" in goal) return {
+			condition: require_dsl_condition.condIR(goal),
+			exitOnMatch: true
+		};
+		return {
+			condition: require_dsl_condition.condIR(goal.condition),
+			...goal.within !== void 0 ? { within: require_dsl_base.durationIR(goal.within) } : {},
+			exitOnMatch: goal.exitOnMatch ?? true
+		};
+	}
+	metaIR() {
+		const { name, description } = this.options;
+		if (name === void 0 && description === void 0 && this.loc === void 0) return;
+		return {
+			...name !== void 0 ? { name } : {},
+			...description !== void 0 ? { description } : {},
+			...this.loc !== void 0 ? { loc: this.loc } : {}
+		};
+	}
+	toIR() {
+		const flowNodes = structuredClone(this.nodes);
+		assignIds(flowNodes, "");
+		assertUniqueIds(flowNodes);
+		const goal = this.goalIR();
+		const meta = this.metaIR();
+		const body = {
+			irVersion: 2,
+			id: this.options.id,
+			...meta !== void 0 ? { meta } : {},
+			trigger: this.options.trigger.ir,
+			...goal !== void 0 ? { goal } : {},
+			...this.options.exitWhen !== void 0 ? { exitWhen: require_dsl_condition.condIR(this.options.exitWhen) } : {},
+			flow: flowNodes
+		};
+		return require_ir.WorkflowIR.parse({
+			...body,
+			contentHash: require_hash.semanticHash(body)
+		});
+	}
+};
+/**
+* Workflow definition: an id, configuration (trigger / goal / exitWhen),
+* optional labels, and chained steps.
+*
+*   export const onboarding = workflow({
+*     id: 'onboarding',
+*     name: 'Onboarding',
+*     trigger: trigger.event(e.sign_up),
+*   }).email(t.email.welcome);
+*/
+function workflow(definition) {
+	return new WorkflowBuilderImpl(definition, require_provenance.captureLoc(workflow));
+}
+//#endregion
+exports.workflow = workflow;
+
+//# sourceMappingURL=workflow.cjs.map

package/dist/dsl/workflow.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.cjs","names":["FlowBuilderImpl","condIR","durationIR","WorkflowIRSchema","semanticHash","captureLoc"],"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/dsl/workflow.d.cts

@@ -0,0 +1,59 @@
+import { WorkflowIR } from "../ir.cjs";
+import { Duration } from "./base.cjs";
+import { Condition } from "./condition.cjs";
+import { FlowBuilder } from "./flow.cjs";
+import { TriggerRef } from "./trigger.cjs";
+//#region src/dsl/workflow.d.ts
+/**
+ * The workflow — a named flow chain plus its configuration (options =
+ * configuration, the chain = steps), and the compiler back half: `toIR()`
+ * deep-clones the collected nodes, assigns structural-path ids, computes the
+ * contentHash (metadata stripped, see hash.ts) and self-checks the result
+ * against the authoritative IR schema.
+ */
+/** Full conversion-goal configuration (customer.io's Goal & Exit semantics). */
+export interface GoalOptions {
+  condition: Condition;
+  /** Attribution window: how long after entry a match still counts as a conversion. Unbounded by default. */
+  within?: Duration;
+  /** Exit on conversion. Defaults to true — this is what absorbs all those True→Exit arms in a UI canvas. */
+  exitOnMatch?: boolean;
+}
+export interface WorkflowDefinition {
+  /**
+   * Wire identity — engine instances, the entry ledger and stats keys are all
+   * built on it (`WorkflowIR.id`), so it is not something to rename for
+   * readability; `name` is.
+   */
+  id: string;
+  /** Trigger: a trigger.xxx() asset. TODO: multiple triggers, entry frequency / re-entry policy. */
+  trigger: TriggerRef;
+  /**
+   * Conversion goal: feeds reporting (conversion rate / attribution) and by
+   * default exits on match. Checked before each node runs. Pass a condition
+   * for the shorthand, or GoalOptions for the full form.
+   */
+  goal?: Condition | GoalOptions;
+  /** Plain exit condition: leaving without counting as a conversion (unsubscribed, no longer eligible). Coexists with goal. */
+  exitWhen?: Condition;
+  /** Human label: what the studio shows instead of the id. */
+  name?: string;
+  /** One line on what this flow does (UI lists, plan output). */
+  description?: string;
+}
+export interface WorkflowBuilder extends FlowBuilder {
+  toIR(): WorkflowIR;
+}
+/**
+ * Workflow definition: an id, configuration (trigger / goal / exitWhen),
+ * optional labels, and chained steps.
+ *
+ *   export const onboarding = workflow({
+ *     id: 'onboarding',
+ *     name: 'Onboarding',
+ *     trigger: trigger.event(e.sign_up),
+ *   }).email(t.email.welcome);
+ */
+export declare function workflow(definition: WorkflowDefinition): WorkflowBuilder;
+//#endregion
+//# sourceMappingURL=workflow.d.cts.map

package/dist/dsl/workflow.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.cts","names":[],"sources":["../../src/dsl/workflow.ts"],"mappings":";;;;;;;;;;;;;;iBAyBiB;EACf,WAAW;;EAEX,SAAS;;EAET;;iBAGe;;;;;;EAMf;;EAGA,SAAS;;;;;;EAOT,OAAO,YAAY;;EAGnB,WAAW;;EASX;;EAGA;;iBAGe,wBAAwB;EACvC,QAAQ;;;;;;;;;;;;wBA+HM,SAAS,YAAY,qBAAqB"}

package/dist/dsl/workflow.d.mts

@@ -0,0 +1,59 @@
+import { WorkflowIR } from "../ir.mjs";
+import { Duration } from "./base.mjs";
+import { Condition } from "./condition.mjs";
+import { FlowBuilder } from "./flow.mjs";
+import { TriggerRef } from "./trigger.mjs";
+//#region src/dsl/workflow.d.ts
+/**
+ * The workflow — a named flow chain plus its configuration (options =
+ * configuration, the chain = steps), and the compiler back half: `toIR()`
+ * deep-clones the collected nodes, assigns structural-path ids, computes the
+ * contentHash (metadata stripped, see hash.ts) and self-checks the result
+ * against the authoritative IR schema.
+ */
+/** Full conversion-goal configuration (customer.io's Goal & Exit semantics). */
+export interface GoalOptions {
+  condition: Condition;
+  /** Attribution window: how long after entry a match still counts as a conversion. Unbounded by default. */
+  within?: Duration;
+  /** Exit on conversion. Defaults to true — this is what absorbs all those True→Exit arms in a UI canvas. */
+  exitOnMatch?: boolean;
+}
+export interface WorkflowDefinition {
+  /**
+   * Wire identity — engine instances, the entry ledger and stats keys are all
+   * built on it (`WorkflowIR.id`), so it is not something to rename for
+   * readability; `name` is.
+   */
+  id: string;
+  /** Trigger: a trigger.xxx() asset. TODO: multiple triggers, entry frequency / re-entry policy. */
+  trigger: TriggerRef;
+  /**
+   * Conversion goal: feeds reporting (conversion rate / attribution) and by
+   * default exits on match. Checked before each node runs. Pass a condition
+   * for the shorthand, or GoalOptions for the full form.
+   */
+  goal?: Condition | GoalOptions;
+  /** Plain exit condition: leaving without counting as a conversion (unsubscribed, no longer eligible). Coexists with goal. */
+  exitWhen?: Condition;
+  /** Human label: what the studio shows instead of the id. */
+  name?: string;
+  /** One line on what this flow does (UI lists, plan output). */
+  description?: string;
+}
+export interface WorkflowBuilder extends FlowBuilder {
+  toIR(): WorkflowIR;
+}
+/**
+ * Workflow definition: an id, configuration (trigger / goal / exitWhen),
+ * optional labels, and chained steps.
+ *
+ *   export const onboarding = workflow({
+ *     id: 'onboarding',
+ *     name: 'Onboarding',
+ *     trigger: trigger.event(e.sign_up),
+ *   }).email(t.email.welcome);
+ */
+export declare function workflow(definition: WorkflowDefinition): WorkflowBuilder;
+//#endregion
+//# sourceMappingURL=workflow.d.mts.map

package/dist/dsl/workflow.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.mts","names":[],"sources":["../../src/dsl/workflow.ts"],"mappings":";;;;;;;;;;;;;;iBAyBiB;EACf,WAAW;;EAEX,SAAS;;EAET;;iBAGe;;;;;;EAMf;;EAGA,SAAS;;;;;;EAOT,OAAO,YAAY;;EAGnB,WAAW;;EASX;;EAGA;;iBAGe,wBAAwB;EACvC,QAAQ;;;;;;;;;;;;wBA+HM,SAAS,YAAY,qBAAqB"}

package/dist/dsl/workflow.mjs

@@ -0,0 +1,120 @@
+import { semanticHash } from "../hash.mjs";
+import { captureLoc } from "../provenance.mjs";
+import { durationIR } from "./base.mjs";
+import { condIR } from "./condition.mjs";
+import { FlowBuilderImpl } from "./flow.mjs";
+import { WorkflowIR } from "../ir.mjs";
+//#region src/dsl/workflow.ts
+/**
+* Assign node ids from the structural path (rules in ir.ts's header). Written
+* in place into the tree toIR deep-cloned, never into the builder's own nodes.
+*/
+function assignIds(nodes, prefix) {
+	nodes.forEach((node, i) => {
+		const id = prefix === "" ? String(i) : `${prefix}.${i}`;
+		node.id = id;
+		switch (node.type) {
+			case "branch":
+				node.cases.forEach((c, ci) => assignIds(c.flow, `${id}.c${ci}`));
+				if (node.otherwise) assignIds(node.otherwise, `${id}.o`);
+				break;
+			case "cohort":
+				node.arms.forEach((arm) => assignIds(arm.flow, `${id}.${arm.name}`));
+				break;
+			case "wait_until": if (Array.isArray(node.onTimeout)) assignIds(node.onTimeout, `${id}.t`);
+		}
+	});
+}
+/**
+* Ids are derived, never authored, so a duplicate is always a compiler bug —
+* and a silent one: assignIds writes in place, so the second write simply wins
+* and two nodes ship as one. What that costs is concrete, because an id is the
+* durable step name (`step.do('{id}:send')`), the message idempotency key
+* (`{instanceId}:{id}`) and the cohort bucket seed: the twins share a
+* checkpoint, and the second send is suppressed as a duplicate of the first.
+* Cheap to check once at the end of the compile, so it is checked.
+*/
+function assertUniqueIds(nodes, seen = /* @__PURE__ */ new Set()) {
+	for (const node of nodes) {
+		if (seen.has(node.id)) throw new Error(`toIR(): node id '${node.id}' is used twice — ids are durable step names and message idempotency keys, so they must be unique`);
+		seen.add(node.id);
+		switch (node.type) {
+			case "branch":
+				for (const branchCase of node.cases) assertUniqueIds(branchCase.flow, seen);
+				if (node.otherwise) assertUniqueIds(node.otherwise, seen);
+				break;
+			case "cohort":
+				for (const arm of node.arms) assertUniqueIds(arm.flow, seen);
+				break;
+			case "wait_until": if (Array.isArray(node.onTimeout)) assertUniqueIds(node.onTimeout, seen);
+		}
+	}
+}
+var WorkflowBuilderImpl = class extends FlowBuilderImpl {
+	options;
+	loc;
+	constructor(options, loc) {
+		super();
+		this.options = options;
+		this.loc = loc;
+	}
+	goalIR() {
+		const goal = this.options.goal;
+		if (goal === void 0) return void 0;
+		if ("__condition" in goal) return {
+			condition: condIR(goal),
+			exitOnMatch: true
+		};
+		return {
+			condition: condIR(goal.condition),
+			...goal.within !== void 0 ? { within: durationIR(goal.within) } : {},
+			exitOnMatch: goal.exitOnMatch ?? true
+		};
+	}
+	metaIR() {
+		const { name, description } = this.options;
+		if (name === void 0 && description === void 0 && this.loc === void 0) return;
+		return {
+			...name !== void 0 ? { name } : {},
+			...description !== void 0 ? { description } : {},
+			...this.loc !== void 0 ? { loc: this.loc } : {}
+		};
+	}
+	toIR() {
+		const flowNodes = structuredClone(this.nodes);
+		assignIds(flowNodes, "");
+		assertUniqueIds(flowNodes);
+		const goal = this.goalIR();
+		const meta = this.metaIR();
+		const body = {
+			irVersion: 2,
+			id: this.options.id,
+			...meta !== void 0 ? { meta } : {},
+			trigger: this.options.trigger.ir,
+			...goal !== void 0 ? { goal } : {},
+			...this.options.exitWhen !== void 0 ? { exitWhen: condIR(this.options.exitWhen) } : {},
+			flow: flowNodes
+		};
+		return WorkflowIR.parse({
+			...body,
+			contentHash: semanticHash(body)
+		});
+	}
+};
+/**
+* Workflow definition: an id, configuration (trigger / goal / exitWhen),
+* optional labels, and chained steps.
+*
+*   export const onboarding = workflow({
+*     id: 'onboarding',
+*     name: 'Onboarding',
+*     trigger: trigger.event(e.sign_up),
+*   }).email(t.email.welcome);
+*/
+function workflow(definition) {
+	return new WorkflowBuilderImpl(definition, captureLoc(workflow));
+}
+//#endregion
+export { workflow };
+
+//# sourceMappingURL=workflow.mjs.map