@shware/workflow 0.0.0-stage → 0.0.0

package/dist/dsl/condition.cjs

@@ -0,0 +1,177 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_dsl_refs = require("./refs.cjs");
+const require_provenance = require("../provenance.cjs");
+const require_dsl_base = require("./base.cjs");
+//#region src/dsl/condition.ts
+const cond = (ir, loc) => {
+	return {
+		__condition: true,
+		ir: loc === void 0 ? ir : {
+			...ir,
+			meta: { loc }
+		}
+	};
+};
+/** @internal unwrap a condition to its IR — used by flow/trigger/workflow builders */
+const condIR = (c) => {
+	const ir = c.ir;
+	if (ir === void 0) throw new Error("Condition was not created by this DSL — use the predicates (eq/gt/…), combinators (and/or/not) or segment()");
+	return ir;
+};
+/**
+* A payload ref identifies itself by a symbol key, and a user-property ref by
+* the absence of one. Nothing here reads a *string* key off the reference: a
+* payload ref hands out sub-refs for every string key, so a field named `type`
+* or `path` would otherwise answer in place of the ref itself.
+*/
+const payloadPathOf = (ref) => ref[require_dsl_refs.PAYLOAD_PATH];
+function prop(ref, op, value, values, loc) {
+	const payloadPath = payloadPathOf(ref);
+	return cond({
+		type: payloadPath !== void 0 ? "payload" : "property",
+		path: payloadPath ?? ref.path,
+		op,
+		...value !== void 0 ? { value } : {},
+		...values !== void 0 ? { values: [...values] } : {}
+	}, loc);
+}
+function eq(ref, value) {
+	return prop(ref, "eq", value, void 0, require_provenance.captureLoc(eq));
+}
+function ne(ref, value) {
+	return prop(ref, "ne", value, void 0, require_provenance.captureLoc(ne));
+}
+function gt(ref, value) {
+	return prop(ref, "gt", value, void 0, require_provenance.captureLoc(gt));
+}
+function gte(ref, value) {
+	return prop(ref, "gte", value, void 0, require_provenance.captureLoc(gte));
+}
+function lt(ref, value) {
+	return prop(ref, "lt", value, void 0, require_provenance.captureLoc(lt));
+}
+function lte(ref, value) {
+	return prop(ref, "lte", value, void 0, require_provenance.captureLoc(lte));
+}
+function between(ref, min, max) {
+	return prop(ref, "between", void 0, [min, max], require_provenance.captureLoc(between));
+}
+function notBetween(ref, min, max) {
+	return prop(ref, "not_between", void 0, [min, max], require_provenance.captureLoc(notBetween));
+}
+function inArray(ref, values) {
+	return prop(ref, "in_array", void 0, values, require_provenance.captureLoc(inArray));
+}
+function notInArray(ref, values) {
+	return prop(ref, "not_in_array", void 0, values, require_provenance.captureLoc(notInArray));
+}
+function exists(ref) {
+	return prop(ref, "exists", void 0, void 0, require_provenance.captureLoc(exists));
+}
+function notExists(ref) {
+	return prop(ref, "not_exists", void 0, void 0, require_provenance.captureLoc(notExists));
+}
+function contains(ref, value) {
+	return prop(ref, "contains", value, void 0, require_provenance.captureLoc(contains));
+}
+function notContains(ref, value) {
+	return prop(ref, "not_contains", value, void 0, require_provenance.captureLoc(notContains));
+}
+function performed(event, whereOrOpts, maybeOpts) {
+	const where = typeof whereOrOpts === "function" ? whereOrOpts : void 0;
+	const opts = typeof whereOrOpts === "function" ? maybeOpts : whereOrOpts;
+	return cond({
+		type: "performed",
+		event: event.name,
+		...where !== void 0 ? { where: condIR(where(require_dsl_refs.payloadRefs())) } : {},
+		...opts?.within !== void 0 ? { within: require_dsl_base.durationIR(opts.within) } : {},
+		...opts?.count !== void 0 ? { count: opts.count } : {}
+	}, require_provenance.captureLoc(performed));
+}
+/**
+* The user can be reached on a channel right now. For push it asks the host's
+* device directory (at least one device listed) — the engine keeps no device
+* state, so this is the way to branch on "has the app on a device that allowed
+* notifications"; for the other channels it checks the recipient property
+* (`email`, `phone`, …). Inside `waitUntil` it wakes on device changes
+* (`POST /devices/changed`) or profile updates respectively.
+*
+*   .branch([reachable('push'), (w) => w.push(tip)], (w) => w.email(tip))
+*/
+function reachable(channel) {
+	return cond({
+		type: "reachable",
+		channel
+	}, require_provenance.captureLoc(reachable));
+}
+/** Condition combinators: nest freely. */
+function and(...conditions) {
+	return cond({
+		type: "and",
+		conditions: conditions.map(condIR)
+	}, require_provenance.captureLoc(and));
+}
+function or(...conditions) {
+	return cond({
+		type: "or",
+		conditions: conditions.map(condIR)
+	}, require_provenance.captureLoc(or));
+}
+function not(condition) {
+	return cond({
+		type: "not",
+		condition: condIR(condition)
+	}, require_provenance.captureLoc(not));
+}
+/**
+* Segment definition. `name` and `description` are optional labels: metadata,
+* dropped before hashing, and what the studio shows.
+*
+*   export const purchaser = segment({
+*     id: 'purchaser',
+*     name: 'Purchased (last 30d)',
+*     condition: performed(e.purchase, { within: '30 days' }),
+*   });
+*/
+function segment({ id, condition, name, description }) {
+	const meta = {
+		...name === void 0 ? {} : { name },
+		...description === void 0 ? {} : { description }
+	};
+	return {
+		__condition: true,
+		__segment: true,
+		id,
+		ir: {
+			type: "segment",
+			segment: id
+		},
+		definition: condIR(condition),
+		loc: require_provenance.captureLoc(segment),
+		meta: Object.keys(meta).length === 0 ? void 0 : meta
+	};
+}
+//#endregion
+exports.and = and;
+exports.between = between;
+exports.condIR = condIR;
+exports.contains = contains;
+exports.eq = eq;
+exports.exists = exists;
+exports.gt = gt;
+exports.gte = gte;
+exports.inArray = inArray;
+exports.lt = lt;
+exports.lte = lte;
+exports.ne = ne;
+exports.not = not;
+exports.notBetween = notBetween;
+exports.notContains = notContains;
+exports.notExists = notExists;
+exports.notInArray = notInArray;
+exports.or = or;
+exports.performed = performed;
+exports.reachable = reachable;
+exports.segment = segment;
+
+//# sourceMappingURL=condition.cjs.map

package/dist/dsl/condition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition.cjs","names":["PAYLOAD_PATH","captureLoc","payloadRefs","durationIR"],"sources":["../../src/dsl/condition.ts"],"sourcesContent":["import type { ConditionIR, SourceLocIR } from '../ir';\nimport { captureLoc } from '../provenance';\nimport { type Duration, durationIR } from './base';\nimport {\n  type EventRef,\n  PAYLOAD_PATH,\n  type PayloadRef,\n  type PayloadRefs,\n  type UserPropertyRef,\n  payloadRefs,\n} from './refs';\nimport type { Channel } from './template';\n\n/**\n * Conditions — drizzle-style predicate expressions: free functions (eq/gt/…)\n * composed with and/or/not, plus `segment` for naming an expression as a\n * top-level asset. A condition is an opaque handle wrapping its ConditionIR.\n *\n * Type techniques:\n * - Types flow in from the reference's phantom type; operator applicability is\n *   a signature constraint (gt only takes string|number refs, contains only\n *   string ones), mirroring customer.io's condition panel.\n * - Value parameters are always NoInfer: types come from the reference only,\n *   which stops eq(ref, 'typo') from widening T to include the bad value.\n *\n * TODO: JSON array 'where at least one'、JSON object 'has the property'。\n */\n\n/** Opaque condition handle — what predicates, combinators and segments all produce. */\nexport interface Condition {\n  readonly __condition: true;\n}\n\ninterface ConditionInternal extends Condition {\n  readonly ir: ConditionIR;\n}\n\nconst cond = (ir: ConditionIR, loc?: SourceLocIR): Condition => {\n  const impl: ConditionInternal = {\n    __condition: true,\n    ir: loc === undefined ? ir : { ...ir, meta: { loc } },\n  };\n  return impl;\n};\n\n/** @internal unwrap a condition to its IR — used by flow/trigger/workflow builders */\nexport const condIR = (c: Condition): ConditionIR => {\n  // Partial: the cast is unsound for hand-rolled objects — exactly what this checks\n  const ir = (c as Partial<ConditionInternal>).ir;\n  if (ir === undefined) {\n    // A hand-rolled `{ __condition: true }` would otherwise surface as a\n    // baffling zod error at toIR() time, far away from the actual mistake.\n    throw new Error(\n      'Condition was not created by this DSL — use the predicates (eq/gt/…), combinators (and/or/not) or segment()'\n    );\n  }\n  return ir;\n};\n\ntype Scalar = string | number | boolean;\n\n/**\n * Predicates accept either kind of reference: a user property (profile\n * condition) or an event payload field (only valid inside a `where` — the\n * bundle compiler enforces the placement, since both produce `Condition`).\n */\ntype CondRef<T> = UserPropertyRef<T> | PayloadRef<T>;\n\n/**\n * A payload ref identifies itself by a symbol key, and a user-property ref by\n * the absence of one. Nothing here reads a *string* key off the reference: a\n * payload ref hands out sub-refs for every string key, so a field named `type`\n * or `path` would otherwise answer in place of the ref itself.\n */\nconst payloadPathOf = (ref: CondRef<unknown>): string | undefined =>\n  (ref as Partial<PayloadRef<unknown>>)[PAYLOAD_PATH];\n\nfunction prop(\n  ref: CondRef<unknown>,\n  op:\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  value?: Scalar,\n  values?: readonly Scalar[],\n  loc?: SourceLocIR\n): Condition {\n  const payloadPath = payloadPathOf(ref);\n  return cond(\n    {\n      type: payloadPath !== undefined ? 'payload' : 'property',\n      path: payloadPath ?? (ref as UserPropertyRef<unknown>).path,\n      op,\n      ...(value !== undefined ? { value } : {}),\n      ...(values !== undefined ? { values: [...values] } : {}),\n    },\n    loc\n  );\n}\n\nexport function eq<T>(ref: CondRef<T>, value: NoInfer<T>): Condition {\n  return prop(ref, 'eq', value as Scalar, undefined, captureLoc(eq));\n}\nexport function ne<T>(ref: CondRef<T>, value: NoInfer<T>): Condition {\n  return prop(ref, 'ne', value as Scalar, undefined, captureLoc(ne));\n}\nexport function gt<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition {\n  return prop(ref, 'gt', value, undefined, captureLoc(gt));\n}\nexport function gte<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition {\n  return prop(ref, 'gte', value, undefined, captureLoc(gte));\n}\nexport function lt<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition {\n  return prop(ref, 'lt', value, undefined, captureLoc(lt));\n}\nexport function lte<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition {\n  return prop(ref, 'lte', value, undefined, captureLoc(lte));\n}\nexport function between<T extends string | number>(\n  ref: CondRef<T>,\n  min: NoInfer<T>,\n  max: NoInfer<T>\n): Condition {\n  return prop(ref, 'between', undefined, [min, max], captureLoc(between));\n}\nexport function notBetween<T extends string | number>(\n  ref: CondRef<T>,\n  min: NoInfer<T>,\n  max: NoInfer<T>\n): Condition {\n  return prop(ref, 'not_between', undefined, [min, max], captureLoc(notBetween));\n}\nexport function inArray<T>(ref: CondRef<T>, values: readonly NoInfer<T>[]): Condition {\n  return prop(ref, 'in_array', undefined, values as readonly Scalar[], captureLoc(inArray));\n}\nexport function notInArray<T>(ref: CondRef<T>, values: readonly NoInfer<T>[]): Condition {\n  return prop(ref, 'not_in_array', undefined, values as readonly Scalar[], captureLoc(notInArray));\n}\nexport function exists(ref: CondRef<unknown>): Condition {\n  return prop(ref, 'exists', undefined, undefined, captureLoc(exists));\n}\nexport function notExists(ref: CondRef<unknown>): Condition {\n  return prop(ref, 'not_exists', undefined, undefined, captureLoc(notExists));\n}\nexport function contains<T extends string>(ref: CondRef<T>, value: string): Condition {\n  return prop(ref, 'contains', value, undefined, captureLoc(contains));\n}\nexport function notContains<T extends string>(ref: CondRef<T>, value: string): Condition {\n  return prop(ref, 'not_contains', value, undefined, captureLoc(notContains));\n}\n\nexport interface PerformedOptions {\n  within?: Duration;\n  count?: number;\n}\n\n/** A payload where clause: an arrow taking the typed payload-ref table. Runs once at construction — the result is a serializable condition tree in IR, never a closure. */\nexport type PayloadWhere<P> = (p: PayloadRefs<P>) => Condition;\n\n/**\n * Event predicate: performed an event (optionally within a window / at least N\n * times). \"Did not perform\" is `not(performed(...))` — expressed by the\n * combinator, so there is no separate notPerformed.\n *\n * The optional second argument narrows which events count by their payload —\n * an arrow receiving a typed payload reference table, with the ordinary\n * predicates applying. It compiles to a `where` subtree in IR (data the UI\n * renders), not a runtime closure:\n *\n *   performed(e.login)\n *   performed(e.login, (p) => and(eq(p.platform, 'web'), eq(p.tags.utm_source, 'meta')))\n *   performed(e.purchase, (p) => gt(p.value, 100), { within: '30 days', count: 2 })\n *   performed(e.purchase, { within: '30 days' })                 // options without a where\n *\n * Time anchoring: evaluated inside a `goal` the count starts at workflow\n * entry, inside `waitUntil` at the moment the wait began (the engine anchors\n * them — a conversion or a wake must not be satisfied by pre-existing\n * history). Everywhere else (branch/filter/exitWhen/segments) it looks over\n * full history, bounded only by `within`.\n */\nexport function performed<P>(event: EventRef<P>, opts?: PerformedOptions): Condition;\nexport function performed<P>(\n  event: EventRef<P>,\n  where: PayloadWhere<P>,\n  opts?: PerformedOptions\n): Condition;\nexport function performed<P>(\n  event: EventRef<P>,\n  whereOrOpts?: PayloadWhere<P> | PerformedOptions,\n  maybeOpts?: PerformedOptions\n): Condition {\n  const where = typeof whereOrOpts === 'function' ? whereOrOpts : undefined;\n  const opts = typeof whereOrOpts === 'function' ? maybeOpts : whereOrOpts;\n  return cond(\n    {\n      type: 'performed',\n      event: event.name,\n      ...(where !== undefined ? { where: condIR(where(payloadRefs<P>())) } : {}),\n      ...(opts?.within !== undefined ? { within: durationIR(opts.within) } : {}),\n      ...(opts?.count !== undefined ? { count: opts.count } : {}),\n    },\n    captureLoc(performed)\n  );\n}\n\n/**\n * The user can be reached on a channel right now. For push it asks the host's\n * device directory (at least one device listed) — the engine keeps no device\n * state, so this is the way to branch on \"has the app on a device that allowed\n * notifications\"; for the other channels it checks the recipient property\n * (`email`, `phone`, …). Inside `waitUntil` it wakes on device changes\n * (`POST /devices/changed`) or profile updates respectively.\n *\n *   .branch([reachable('push'), (w) => w.push(tip)], (w) => w.email(tip))\n */\nexport function reachable(channel: Channel): Condition {\n  return cond({ type: 'reachable', channel }, captureLoc(reachable));\n}\n\n/** Condition combinators: nest freely. */\nexport function and(...conditions: readonly Condition[]): Condition {\n  return cond({ type: 'and', conditions: conditions.map(condIR) }, captureLoc(and));\n}\nexport function or(...conditions: readonly Condition[]): Condition {\n  return cond({ type: 'or', conditions: conditions.map(condIR) }, captureLoc(or));\n}\nexport function not(condition: Condition): Condition {\n  return cond({ type: 'not', condition: condIR(condition) }, captureLoc(not));\n}\n\n/**\n * Segment: a named condition expression and a top-level asset — it shows up in\n * the UI sidebar, is reusable across workflows, is referenced by id in IR,\n * and has a continuously materialized membership count (the prerequisite for\n * segment triggers). Anonymous reuse is just a const expression; a one-off\n * check is an inline expression at the use site.\n * TODO, to match customer.io's panel: form / page / device / screen /\n * opt-out / message data（email opened、sms clicked、webhook …）\n */\nexport interface SegmentRef extends Condition {\n  readonly __segment: true;\n  /** Wire identity: segment references and the membership store are keyed on it (`SegmentIR.id`). */\n  readonly id: string;\n}\n\n/** @internal the compiled shape behind a SegmentRef — compileBundle reads definition/loc off it */\nexport interface SegmentInternal extends SegmentRef {\n  readonly ir: ConditionIR;\n  /** Human label / description; metadata, so never part of the hash. */\n  readonly meta: SegmentMeta | undefined;\n  /** The segment's own definition (SegmentIR.condition), as opposed to a reference by id. */\n  readonly definition: ConditionIR;\n  /** Callsite of the segment() call (provenance; lands in SegmentIR.meta.loc). */\n  readonly loc: SourceLocIR | undefined;\n}\n\n/** Labels for a segment: what the studio shows instead of the wire key. */\nexport interface SegmentMeta {\n  name?: string;\n  description?: string;\n}\n\nexport interface SegmentDefinition extends SegmentMeta {\n  /**\n   * Wire identity — by-name references and the membership store are keyed on\n   * it, so it is not something to rename for readability.\n   */\n  id: string;\n  /** Who is in the segment; the predicates already checked its types. */\n  condition: Condition;\n}\n\n/**\n * Segment definition. `name` and `description` are optional labels: metadata,\n * dropped before hashing, and what the studio shows.\n *\n *   export const purchaser = segment({\n *     id: 'purchaser',\n *     name: 'Purchased (last 30d)',\n *     condition: performed(e.purchase, { within: '30 days' }),\n *   });\n */\nexport function segment({ id, condition, name, description }: SegmentDefinition): SegmentRef {\n  const meta: SegmentMeta = {\n    ...(name === undefined ? {} : { name }),\n    ...(description === undefined ? {} : { description }),\n  };\n  const impl: SegmentInternal = {\n    __condition: true,\n    __segment: true,\n    id,\n    ir: { type: 'segment', segment: id },\n    definition: condIR(condition),\n    loc: captureLoc(segment),\n    meta: Object.keys(meta).length === 0 ? undefined : meta,\n  };\n  return impl;\n}\n"],"mappings":"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"}

package/dist/dsl/condition.d.cts

@@ -0,0 +1,140 @@
+import { ConditionIR, SourceLocIR } from "../ir.cjs";
+import { Duration } from "./base.cjs";
+import { EventRef, PayloadRef, PayloadRefs, UserPropertyRef } from "./refs.cjs";
+import { Channel } from "./template.cjs";
+//#region src/dsl/condition.d.ts
+/**
+ * Conditions — drizzle-style predicate expressions: free functions (eq/gt/…)
+ * composed with and/or/not, plus `segment` for naming an expression as a
+ * top-level asset. A condition is an opaque handle wrapping its ConditionIR.
+ *
+ * Type techniques:
+ * - Types flow in from the reference's phantom type; operator applicability is
+ *   a signature constraint (gt only takes string|number refs, contains only
+ *   string ones), mirroring customer.io's condition panel.
+ * - Value parameters are always NoInfer: types come from the reference only,
+ *   which stops eq(ref, 'typo') from widening T to include the bad value.
+ *
+ * TODO: JSON array 'where at least one'、JSON object 'has the property'。
+ */
+/** Opaque condition handle — what predicates, combinators and segments all produce. */
+export interface Condition {
+  readonly __condition: true;
+}
+/** @internal unwrap a condition to its IR — used by flow/trigger/workflow builders */
+export declare const condIR: (c: Condition) => ConditionIR;
+/**
+ * Predicates accept either kind of reference: a user property (profile
+ * condition) or an event payload field (only valid inside a `where` — the
+ * bundle compiler enforces the placement, since both produce `Condition`).
+ */
+type CondRef<T> = UserPropertyRef<T> | PayloadRef<T>;
+export declare function eq<T>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function ne<T>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function gt<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function gte<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function lt<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function lte<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function between<T extends string | number>(ref: CondRef<T>, min: NoInfer<T>, max: NoInfer<T>): Condition;
+export declare function notBetween<T extends string | number>(ref: CondRef<T>, min: NoInfer<T>, max: NoInfer<T>): Condition;
+export declare function inArray<T>(ref: CondRef<T>, values: readonly NoInfer<T>[]): Condition;
+export declare function notInArray<T>(ref: CondRef<T>, values: readonly NoInfer<T>[]): Condition;
+export declare function exists(ref: CondRef<unknown>): Condition;
+export declare function notExists(ref: CondRef<unknown>): Condition;
+export declare function contains<T extends string>(ref: CondRef<T>, value: string): Condition;
+export declare function notContains<T extends string>(ref: CondRef<T>, value: string): Condition;
+export interface PerformedOptions {
+  within?: Duration;
+  count?: number;
+}
+/** A payload where clause: an arrow taking the typed payload-ref table. Runs once at construction — the result is a serializable condition tree in IR, never a closure. */
+export type PayloadWhere<P> = (p: PayloadRefs<P>) => Condition;
+/**
+ * Event predicate: performed an event (optionally within a window / at least N
+ * times). "Did not perform" is `not(performed(...))` — expressed by the
+ * combinator, so there is no separate notPerformed.
+ *
+ * The optional second argument narrows which events count by their payload —
+ * an arrow receiving a typed payload reference table, with the ordinary
+ * predicates applying. It compiles to a `where` subtree in IR (data the UI
+ * renders), not a runtime closure:
+ *
+ *   performed(e.login)
+ *   performed(e.login, (p) => and(eq(p.platform, 'web'), eq(p.tags.utm_source, 'meta')))
+ *   performed(e.purchase, (p) => gt(p.value, 100), { within: '30 days', count: 2 })
+ *   performed(e.purchase, { within: '30 days' })                 // options without a where
+ *
+ * Time anchoring: evaluated inside a `goal` the count starts at workflow
+ * entry, inside `waitUntil` at the moment the wait began (the engine anchors
+ * them — a conversion or a wake must not be satisfied by pre-existing
+ * history). Everywhere else (branch/filter/exitWhen/segments) it looks over
+ * full history, bounded only by `within`.
+ */
+export declare function performed<P>(event: EventRef<P>, opts?: PerformedOptions): Condition;
+export declare function performed<P>(event: EventRef<P>, where: PayloadWhere<P>, opts?: PerformedOptions): Condition;
+/**
+ * The user can be reached on a channel right now. For push it asks the host's
+ * device directory (at least one device listed) — the engine keeps no device
+ * state, so this is the way to branch on "has the app on a device that allowed
+ * notifications"; for the other channels it checks the recipient property
+ * (`email`, `phone`, …). Inside `waitUntil` it wakes on device changes
+ * (`POST /devices/changed`) or profile updates respectively.
+ *
+ *   .branch([reachable('push'), (w) => w.push(tip)], (w) => w.email(tip))
+ */
+export declare function reachable(channel: Channel): Condition;
+/** Condition combinators: nest freely. */
+export declare function and(...conditions: readonly Condition[]): Condition;
+export declare function or(...conditions: readonly Condition[]): Condition;
+export declare function not(condition: Condition): Condition;
+/**
+ * Segment: a named condition expression and a top-level asset — it shows up in
+ * the UI sidebar, is reusable across workflows, is referenced by id in IR,
+ * and has a continuously materialized membership count (the prerequisite for
+ * segment triggers). Anonymous reuse is just a const expression; a one-off
+ * check is an inline expression at the use site.
+ * TODO, to match customer.io's panel: form / page / device / screen /
+ * opt-out / message data（email opened、sms clicked、webhook …）
+ */
+export interface SegmentRef extends Condition {
+  readonly __segment: true;
+  /** Wire identity: segment references and the membership store are keyed on it (`SegmentIR.id`). */
+  readonly id: string;
+}
+/** @internal the compiled shape behind a SegmentRef — compileBundle reads definition/loc off it */
+export interface SegmentInternal extends SegmentRef {
+  readonly ir: ConditionIR;
+  /** Human label / description; metadata, so never part of the hash. */
+  readonly meta: SegmentMeta | undefined;
+  /** The segment's own definition (SegmentIR.condition), as opposed to a reference by id. */
+  readonly definition: ConditionIR;
+  /** Callsite of the segment() call (provenance; lands in SegmentIR.meta.loc). */
+  readonly loc: SourceLocIR | undefined;
+}
+/** Labels for a segment: what the studio shows instead of the wire key. */
+export interface SegmentMeta {
+  name?: string;
+  description?: string;
+}
+export interface SegmentDefinition extends SegmentMeta {
+  /**
+   * Wire identity — by-name references and the membership store are keyed on
+   * it, so it is not something to rename for readability.
+   */
+  id: string;
+  /** Who is in the segment; the predicates already checked its types. */
+  condition: Condition;
+}
+/**
+ * Segment definition. `name` and `description` are optional labels: metadata,
+ * dropped before hashing, and what the studio shows.
+ *
+ *   export const purchaser = segment({
+ *     id: 'purchaser',
+ *     name: 'Purchased (last 30d)',
+ *     condition: performed(e.purchase, { within: '30 days' }),
+ *   });
+ */
+export declare function segment({ id, condition, name, description }: SegmentDefinition): SegmentRef;
+//#endregion
+//# sourceMappingURL=condition.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"condition.d.cts","names":[],"sources":["../../src/dsl/condition.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBA6BiB;WACN;;;qBAgBE,SAAM,GAAO,cAAY;;;;;;KAoBjC,QAAQ,KAAK,gBAAgB,KAAK,WAAW;wBA6ClC,GAAG,GAAG,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAG3C,GAAG,GAAG,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAG3C,GAAG,2BAA2B,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAGnE,IAAI,2BAA2B,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAGpE,GAAG,2BAA2B,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAGnE,IAAI,2BAA2B,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAGpE,QAAQ,2BACtB,KAAK,QAAQ,IACb,KAAK,QAAQ,IACb,KAAK,QAAQ,KACZ;wBAGa,WAAW,2BACzB,KAAK,QAAQ,IACb,KAAK,QAAQ,IACb,KAAK,QAAQ,KACZ;wBAGa,QAAQ,GAAG,KAAK,QAAQ,IAAI,iBAAiB,QAAQ,OAAO;wBAG5D,WAAW,GAAG,KAAK,QAAQ,IAAI,iBAAiB,QAAQ,OAAO;wBAG/D,OAAO,KAAK,mBAAmB;wBAG/B,UAAU,KAAK,mBAAmB;wBAGlC,SAAS,kBAAkB,KAAK,QAAQ,IAAI,gBAAgB;wBAG5D,YAAY,kBAAkB,KAAK,QAAQ,IAAI,gBAAgB;iBAI9D;EACf,SAAS;EACT;;;YAIU,aAAa,MAAM,GAAG,YAAY,OAAO;;;;;;;;;;;;;;;;;;;;;;wBAuBrC,UAAU,GAAG,OAAO,SAAS,IAAI,OAAO,mBAAmB;wBAC3D,UAAU,GACxB,OAAO,SAAS,IAChB,OAAO,aAAa,IACpB,OAAO,mBACN;;;;;;;;;;;wBA8Ba,UAAU,SAAS,UAAU;;wBAK7B,OAAO,qBAAqB,cAAc;wBAG1C,MAAM,qBAAqB,cAAc;wBAGzC,IAAI,WAAW,YAAY;;;;;;;;;;iBAa1B,mBAAmB;WACzB;;WAEA;;;iBAIM,wBAAwB;WAC9B,IAAI;;WAEJ,MAAM;;WAEN,YAAY;;WAEZ,KAAK;;;iBAIC;EACf;EACA;;iBAGe,0BAA0B;;;;;EAKzC;;EAEA,WAAW;;;;;;;;;;;;wBAaG,UAAU,IAAI,WAAW,MAAM,eAAe,oBAAoB"}

package/dist/dsl/condition.d.mts

@@ -0,0 +1,140 @@
+import { ConditionIR, SourceLocIR } from "../ir.mjs";
+import { Duration } from "./base.mjs";
+import { EventRef, PayloadRef, PayloadRefs, UserPropertyRef } from "./refs.mjs";
+import { Channel } from "./template.mjs";
+//#region src/dsl/condition.d.ts
+/**
+ * Conditions — drizzle-style predicate expressions: free functions (eq/gt/…)
+ * composed with and/or/not, plus `segment` for naming an expression as a
+ * top-level asset. A condition is an opaque handle wrapping its ConditionIR.
+ *
+ * Type techniques:
+ * - Types flow in from the reference's phantom type; operator applicability is
+ *   a signature constraint (gt only takes string|number refs, contains only
+ *   string ones), mirroring customer.io's condition panel.
+ * - Value parameters are always NoInfer: types come from the reference only,
+ *   which stops eq(ref, 'typo') from widening T to include the bad value.
+ *
+ * TODO: JSON array 'where at least one'、JSON object 'has the property'。
+ */
+/** Opaque condition handle — what predicates, combinators and segments all produce. */
+export interface Condition {
+  readonly __condition: true;
+}
+/** @internal unwrap a condition to its IR — used by flow/trigger/workflow builders */
+export declare const condIR: (c: Condition) => ConditionIR;
+/**
+ * Predicates accept either kind of reference: a user property (profile
+ * condition) or an event payload field (only valid inside a `where` — the
+ * bundle compiler enforces the placement, since both produce `Condition`).
+ */
+type CondRef<T> = UserPropertyRef<T> | PayloadRef<T>;
+export declare function eq<T>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function ne<T>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function gt<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function gte<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function lt<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function lte<T extends string | number>(ref: CondRef<T>, value: NoInfer<T>): Condition;
+export declare function between<T extends string | number>(ref: CondRef<T>, min: NoInfer<T>, max: NoInfer<T>): Condition;
+export declare function notBetween<T extends string | number>(ref: CondRef<T>, min: NoInfer<T>, max: NoInfer<T>): Condition;
+export declare function inArray<T>(ref: CondRef<T>, values: readonly NoInfer<T>[]): Condition;
+export declare function notInArray<T>(ref: CondRef<T>, values: readonly NoInfer<T>[]): Condition;
+export declare function exists(ref: CondRef<unknown>): Condition;
+export declare function notExists(ref: CondRef<unknown>): Condition;
+export declare function contains<T extends string>(ref: CondRef<T>, value: string): Condition;
+export declare function notContains<T extends string>(ref: CondRef<T>, value: string): Condition;
+export interface PerformedOptions {
+  within?: Duration;
+  count?: number;
+}
+/** A payload where clause: an arrow taking the typed payload-ref table. Runs once at construction — the result is a serializable condition tree in IR, never a closure. */
+export type PayloadWhere<P> = (p: PayloadRefs<P>) => Condition;
+/**
+ * Event predicate: performed an event (optionally within a window / at least N
+ * times). "Did not perform" is `not(performed(...))` — expressed by the
+ * combinator, so there is no separate notPerformed.
+ *
+ * The optional second argument narrows which events count by their payload —
+ * an arrow receiving a typed payload reference table, with the ordinary
+ * predicates applying. It compiles to a `where` subtree in IR (data the UI
+ * renders), not a runtime closure:
+ *
+ *   performed(e.login)
+ *   performed(e.login, (p) => and(eq(p.platform, 'web'), eq(p.tags.utm_source, 'meta')))
+ *   performed(e.purchase, (p) => gt(p.value, 100), { within: '30 days', count: 2 })
+ *   performed(e.purchase, { within: '30 days' })                 // options without a where
+ *
+ * Time anchoring: evaluated inside a `goal` the count starts at workflow
+ * entry, inside `waitUntil` at the moment the wait began (the engine anchors
+ * them — a conversion or a wake must not be satisfied by pre-existing
+ * history). Everywhere else (branch/filter/exitWhen/segments) it looks over
+ * full history, bounded only by `within`.
+ */
+export declare function performed<P>(event: EventRef<P>, opts?: PerformedOptions): Condition;
+export declare function performed<P>(event: EventRef<P>, where: PayloadWhere<P>, opts?: PerformedOptions): Condition;
+/**
+ * The user can be reached on a channel right now. For push it asks the host's
+ * device directory (at least one device listed) — the engine keeps no device
+ * state, so this is the way to branch on "has the app on a device that allowed
+ * notifications"; for the other channels it checks the recipient property
+ * (`email`, `phone`, …). Inside `waitUntil` it wakes on device changes
+ * (`POST /devices/changed`) or profile updates respectively.
+ *
+ *   .branch([reachable('push'), (w) => w.push(tip)], (w) => w.email(tip))
+ */
+export declare function reachable(channel: Channel): Condition;
+/** Condition combinators: nest freely. */
+export declare function and(...conditions: readonly Condition[]): Condition;
+export declare function or(...conditions: readonly Condition[]): Condition;
+export declare function not(condition: Condition): Condition;
+/**
+ * Segment: a named condition expression and a top-level asset — it shows up in
+ * the UI sidebar, is reusable across workflows, is referenced by id in IR,
+ * and has a continuously materialized membership count (the prerequisite for
+ * segment triggers). Anonymous reuse is just a const expression; a one-off
+ * check is an inline expression at the use site.
+ * TODO, to match customer.io's panel: form / page / device / screen /
+ * opt-out / message data（email opened、sms clicked、webhook …）
+ */
+export interface SegmentRef extends Condition {
+  readonly __segment: true;
+  /** Wire identity: segment references and the membership store are keyed on it (`SegmentIR.id`). */
+  readonly id: string;
+}
+/** @internal the compiled shape behind a SegmentRef — compileBundle reads definition/loc off it */
+export interface SegmentInternal extends SegmentRef {
+  readonly ir: ConditionIR;
+  /** Human label / description; metadata, so never part of the hash. */
+  readonly meta: SegmentMeta | undefined;
+  /** The segment's own definition (SegmentIR.condition), as opposed to a reference by id. */
+  readonly definition: ConditionIR;
+  /** Callsite of the segment() call (provenance; lands in SegmentIR.meta.loc). */
+  readonly loc: SourceLocIR | undefined;
+}
+/** Labels for a segment: what the studio shows instead of the wire key. */
+export interface SegmentMeta {
+  name?: string;
+  description?: string;
+}
+export interface SegmentDefinition extends SegmentMeta {
+  /**
+   * Wire identity — by-name references and the membership store are keyed on
+   * it, so it is not something to rename for readability.
+   */
+  id: string;
+  /** Who is in the segment; the predicates already checked its types. */
+  condition: Condition;
+}
+/**
+ * Segment definition. `name` and `description` are optional labels: metadata,
+ * dropped before hashing, and what the studio shows.
+ *
+ *   export const purchaser = segment({
+ *     id: 'purchaser',
+ *     name: 'Purchased (last 30d)',
+ *     condition: performed(e.purchase, { within: '30 days' }),
+ *   });
+ */
+export declare function segment({ id, condition, name, description }: SegmentDefinition): SegmentRef;
+//#endregion
+//# sourceMappingURL=condition.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"condition.d.mts","names":[],"sources":["../../src/dsl/condition.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBA6BiB;WACN;;;qBAgBE,SAAM,GAAO,cAAY;;;;;;KAoBjC,QAAQ,KAAK,gBAAgB,KAAK,WAAW;wBA6ClC,GAAG,GAAG,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAG3C,GAAG,GAAG,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAG3C,GAAG,2BAA2B,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAGnE,IAAI,2BAA2B,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAGpE,GAAG,2BAA2B,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAGnE,IAAI,2BAA2B,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;wBAGpE,QAAQ,2BACtB,KAAK,QAAQ,IACb,KAAK,QAAQ,IACb,KAAK,QAAQ,KACZ;wBAGa,WAAW,2BACzB,KAAK,QAAQ,IACb,KAAK,QAAQ,IACb,KAAK,QAAQ,KACZ;wBAGa,QAAQ,GAAG,KAAK,QAAQ,IAAI,iBAAiB,QAAQ,OAAO;wBAG5D,WAAW,GAAG,KAAK,QAAQ,IAAI,iBAAiB,QAAQ,OAAO;wBAG/D,OAAO,KAAK,mBAAmB;wBAG/B,UAAU,KAAK,mBAAmB;wBAGlC,SAAS,kBAAkB,KAAK,QAAQ,IAAI,gBAAgB;wBAG5D,YAAY,kBAAkB,KAAK,QAAQ,IAAI,gBAAgB;iBAI9D;EACf,SAAS;EACT;;;YAIU,aAAa,MAAM,GAAG,YAAY,OAAO;;;;;;;;;;;;;;;;;;;;;;wBAuBrC,UAAU,GAAG,OAAO,SAAS,IAAI,OAAO,mBAAmB;wBAC3D,UAAU,GACxB,OAAO,SAAS,IAChB,OAAO,aAAa,IACpB,OAAO,mBACN;;;;;;;;;;;wBA8Ba,UAAU,SAAS,UAAU;;wBAK7B,OAAO,qBAAqB,cAAc;wBAG1C,MAAM,qBAAqB,cAAc;wBAGzC,IAAI,WAAW,YAAY;;;;;;;;;;iBAa1B,mBAAmB;WACzB;;WAEA;;;iBAIM,wBAAwB;WAC9B,IAAI;;WAEJ,MAAM;;WAEN,YAAY;;WAEZ,KAAK;;;iBAIC;EACf;EACA;;iBAGe,0BAA0B;;;;;EAKzC;;EAEA,WAAW;;;;;;;;;;;;wBAaG,UAAU,IAAI,WAAW,MAAM,eAAe,oBAAoB"}

package/dist/dsl/condition.mjs

@@ -0,0 +1,156 @@
+import { PAYLOAD_PATH, payloadRefs } from "./refs.mjs";
+import { captureLoc } from "../provenance.mjs";
+import { durationIR } from "./base.mjs";
+//#region src/dsl/condition.ts
+const cond = (ir, loc) => {
+	return {
+		__condition: true,
+		ir: loc === void 0 ? ir : {
+			...ir,
+			meta: { loc }
+		}
+	};
+};
+/** @internal unwrap a condition to its IR — used by flow/trigger/workflow builders */
+const condIR = (c) => {
+	const ir = c.ir;
+	if (ir === void 0) throw new Error("Condition was not created by this DSL — use the predicates (eq/gt/…), combinators (and/or/not) or segment()");
+	return ir;
+};
+/**
+* A payload ref identifies itself by a symbol key, and a user-property ref by
+* the absence of one. Nothing here reads a *string* key off the reference: a
+* payload ref hands out sub-refs for every string key, so a field named `type`
+* or `path` would otherwise answer in place of the ref itself.
+*/
+const payloadPathOf = (ref) => ref[PAYLOAD_PATH];
+function prop(ref, op, value, values, loc) {
+	const payloadPath = payloadPathOf(ref);
+	return cond({
+		type: payloadPath !== void 0 ? "payload" : "property",
+		path: payloadPath ?? ref.path,
+		op,
+		...value !== void 0 ? { value } : {},
+		...values !== void 0 ? { values: [...values] } : {}
+	}, loc);
+}
+function eq(ref, value) {
+	return prop(ref, "eq", value, void 0, captureLoc(eq));
+}
+function ne(ref, value) {
+	return prop(ref, "ne", value, void 0, captureLoc(ne));
+}
+function gt(ref, value) {
+	return prop(ref, "gt", value, void 0, captureLoc(gt));
+}
+function gte(ref, value) {
+	return prop(ref, "gte", value, void 0, captureLoc(gte));
+}
+function lt(ref, value) {
+	return prop(ref, "lt", value, void 0, captureLoc(lt));
+}
+function lte(ref, value) {
+	return prop(ref, "lte", value, void 0, captureLoc(lte));
+}
+function between(ref, min, max) {
+	return prop(ref, "between", void 0, [min, max], captureLoc(between));
+}
+function notBetween(ref, min, max) {
+	return prop(ref, "not_between", void 0, [min, max], captureLoc(notBetween));
+}
+function inArray(ref, values) {
+	return prop(ref, "in_array", void 0, values, captureLoc(inArray));
+}
+function notInArray(ref, values) {
+	return prop(ref, "not_in_array", void 0, values, captureLoc(notInArray));
+}
+function exists(ref) {
+	return prop(ref, "exists", void 0, void 0, captureLoc(exists));
+}
+function notExists(ref) {
+	return prop(ref, "not_exists", void 0, void 0, captureLoc(notExists));
+}
+function contains(ref, value) {
+	return prop(ref, "contains", value, void 0, captureLoc(contains));
+}
+function notContains(ref, value) {
+	return prop(ref, "not_contains", value, void 0, captureLoc(notContains));
+}
+function performed(event, whereOrOpts, maybeOpts) {
+	const where = typeof whereOrOpts === "function" ? whereOrOpts : void 0;
+	const opts = typeof whereOrOpts === "function" ? maybeOpts : whereOrOpts;
+	return cond({
+		type: "performed",
+		event: event.name,
+		...where !== void 0 ? { where: condIR(where(payloadRefs())) } : {},
+		...opts?.within !== void 0 ? { within: durationIR(opts.within) } : {},
+		...opts?.count !== void 0 ? { count: opts.count } : {}
+	}, captureLoc(performed));
+}
+/**
+* The user can be reached on a channel right now. For push it asks the host's
+* device directory (at least one device listed) — the engine keeps no device
+* state, so this is the way to branch on "has the app on a device that allowed
+* notifications"; for the other channels it checks the recipient property
+* (`email`, `phone`, …). Inside `waitUntil` it wakes on device changes
+* (`POST /devices/changed`) or profile updates respectively.
+*
+*   .branch([reachable('push'), (w) => w.push(tip)], (w) => w.email(tip))
+*/
+function reachable(channel) {
+	return cond({
+		type: "reachable",
+		channel
+	}, captureLoc(reachable));
+}
+/** Condition combinators: nest freely. */
+function and(...conditions) {
+	return cond({
+		type: "and",
+		conditions: conditions.map(condIR)
+	}, captureLoc(and));
+}
+function or(...conditions) {
+	return cond({
+		type: "or",
+		conditions: conditions.map(condIR)
+	}, captureLoc(or));
+}
+function not(condition) {
+	return cond({
+		type: "not",
+		condition: condIR(condition)
+	}, captureLoc(not));
+}
+/**
+* Segment definition. `name` and `description` are optional labels: metadata,
+* dropped before hashing, and what the studio shows.
+*
+*   export const purchaser = segment({
+*     id: 'purchaser',
+*     name: 'Purchased (last 30d)',
+*     condition: performed(e.purchase, { within: '30 days' }),
+*   });
+*/
+function segment({ id, condition, name, description }) {
+	const meta = {
+		...name === void 0 ? {} : { name },
+		...description === void 0 ? {} : { description }
+	};
+	return {
+		__condition: true,
+		__segment: true,
+		id,
+		ir: {
+			type: "segment",
+			segment: id
+		},
+		definition: condIR(condition),
+		loc: captureLoc(segment),
+		meta: Object.keys(meta).length === 0 ? void 0 : meta
+	};
+}
+//#endregion
+export { and, between, condIR, contains, eq, exists, gt, gte, inArray, lt, lte, ne, not, notBetween, notContains, notExists, notInArray, or, performed, reachable, segment };
+
+//# sourceMappingURL=condition.mjs.map