@shware/workflow 0.0.0-stage → 0.1.0

package/dist/ir.d.cts

@@ -0,0 +1,486 @@
+import * as z from "zod/mini";
+//#region src/ir.d.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).
+ */
+export declare const IR_VERSION = 2;
+export declare const ScalarIR: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniBoolean<boolean>]>;
+export type ScalarIR = z.infer<typeof ScalarIR>;
+/** Duration: `value` keeps the DSL literal ('23 hours', for display), `ms` is what the engine uses. */
+export declare const DurationIR: z.ZodMiniObject<{
+  value: z.ZodMiniString<string>;
+  ms: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type DurationIR = z.infer<typeof DurationIR>;
+/** User-property reference — isomorphic to the DSL's UserPropertyRef once serialized (phantom type dropped). */
+export declare const UserPropertyRefIR: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"user_property">;
+  path: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type UserPropertyRefIR = z.infer<typeof UserPropertyRefIR>;
+/** A message prop / event payload value: either a literal or a user-property reference. */
+export declare const PropValueIR: z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniBoolean<boolean>]>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"user_property">;
+  path: z.ZodMiniString<string>;
+}, z.core.$strip>]>;
+export type PropValueIR = z.infer<typeof PropValueIR>;
+export declare const ChannelIR: z.ZodMiniEnum<{
+  discord: "discord";
+  email: "email";
+  in_app: "in_app";
+  push: "push";
+  slack: "slack";
+  sms: "sms";
+  survey: "survey";
+}>;
+export type ChannelIR = z.infer<typeof ChannelIR>;
+export declare const WeekdayIR: z.ZodMiniEnum<{
+  fri: "fri";
+  mon: "mon";
+  sat: "sat";
+  sun: "sun";
+  thu: "thu";
+  tue: "tue";
+  wed: "wed";
+}>;
+export type WeekdayIR = z.infer<typeof WeekdayIR>;
+/**
+ * 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.
+ */
+export declare const SourceLocIR: z.ZodMiniObject<{
+  file: z.ZodMiniString<string>;
+  line: z.ZodMiniNumber<number>;
+  column: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export type SourceLocIR = z.infer<typeof SourceLocIR>;
+/** Node-level metadata: provenance only, for now. Excluded from contentHash. */
+export declare const NodeMetaIR: z.ZodMiniObject<{
+  loc: z.ZodMiniOptional<z.ZodMiniObject<{
+    file: z.ZodMiniString<string>;
+    line: z.ZodMiniNumber<number>;
+    column: z.ZodMiniNumber<number>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+export type NodeMetaIR = z.infer<typeof NodeMetaIR>;
+export declare const PropertyOperatorIR: z.ZodMiniEnum<{
+  between: "between";
+  contains: "contains";
+  eq: "eq";
+  exists: "exists";
+  gt: "gt";
+  gte: "gte";
+  in_array: "in_array";
+  lt: "lt";
+  lte: "lte";
+  ne: "ne";
+  not_between: "not_between";
+  not_contains: "not_contains";
+  not_exists: "not_exists";
+  not_in_array: "not_in_array";
+}>;
+export type PropertyOperatorIR = z.infer<typeof PropertyOperatorIR>;
+/**
+ * Condition expression tree. The shape of value/values follows `op`:
+ * eq/ne/gt/gte/lt/lte/contains/not_contains → value; in_array/not_in_array →
+ * values; between/not_between → values = [min, max]; exists/not_exists → neither.
+ *
+ * `payload` predicates test the payload of an event (dotted paths reach nested
+ * fields). They are only valid inside a `where` subtree — `performed.where`
+ * and the event trigger's `where` — where an event row is in scope; the
+ * compiler (compileBundle) and the evaluator both enforce the placement.
+ * TODO: runtime refinement narrowing by op.
+ */
+/**
+ * Provenance rides on conditions too, so the studio can point at the exact
+ * `eq(...)` / `and(...)` that produced a node — same rule as nodes: `meta` is
+ * dropped before hashing, so carrying it never affects execution identity.
+ */
+interface ConditionBaseIR {
+  meta?: NodeMetaIR | undefined;
+}
+export type ConditionIR = (ConditionBaseIR & {
+  type: 'and';
+  conditions: ConditionIR[];
+}) | (ConditionBaseIR & {
+  type: 'or';
+  conditions: ConditionIR[];
+}) | (ConditionBaseIR & {
+  type: 'not';
+  condition: ConditionIR;
+}) |
+/** Reference a segment by id (defined in SegmentIR, versioned separately). */
+(ConditionBaseIR & {
+  type: 'segment';
+  segment: string;
+}) | (ConditionBaseIR & {
+  type: 'property';
+  path: string;
+  op: PropertyOperatorIR;
+  value?: ScalarIR | undefined;
+  values?: ScalarIR[] | undefined;
+}) | (ConditionBaseIR & {
+  /** Event payload predicate; `path` is dotted for nested fields ('tags.utm_source'). */
+  type: 'payload';
+  path: string;
+  op: PropertyOperatorIR;
+  value?: ScalarIR | undefined;
+  values?: ScalarIR[] | undefined;
+}) | (ConditionBaseIR & {
+  type: 'performed';
+  event: string;
+  /** Payload filter: only events matching it count (a payload-only subtree). */
+  where?: ConditionIR | undefined;
+  within?: DurationIR | undefined;
+  count?: number | undefined;
+}) |
+/**
+ * The user can be reached on the channel right now: for push, the host's
+ * device directory lists at least one device; for the others, the channel's
+ * recipient property (email, phone, …) is set.
+ */
+(ConditionBaseIR & {
+  type: 'reachable';
+  channel: ChannelIR;
+});
+export declare const ConditionIR: z.ZodMiniType<ConditionIR>;
+/**
+ * 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.
+ */
+export declare const TriggerIR: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"event">;
+  event: z.ZodMiniString<string>;
+  where: z.ZodMiniOptional<z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>>;
+  filter: z.ZodMiniOptional<z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>>;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"segment">;
+  segment: z.ZodMiniString<string>;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"date">;
+  at: z.ZodMiniString<string>;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"webhook">;
+}, z.core.$strip>], "type">;
+export type TriggerIR = z.infer<typeof TriggerIR>;
+interface NodeBaseIR {
+  /** Stable id derived from the structural path (rules in the file header). */
+  id: string;
+  /** Optional node name: UI title / observability handle (branch's optional first argument lands here). */
+  label?: string | undefined;
+  /** Metadata (provenance); excluded from contentHash. */
+  meta?: NodeMetaIR | undefined;
+}
+export type NodeIR = (NodeBaseIR & {
+  type: 'message';
+  channel: ChannelIR;
+  template: string;
+  props: Record<string, PropValueIR>;
+  /**
+   * Push only: which of the user's devices get a copy. Absent means every
+   * device the directory lists; 'latest' only the most recently registered.
+   */
+  devices?: 'latest' | undefined;
+}) | (NodeBaseIR & {
+  type: 'delay';
+  duration: DurationIR;
+}) | (NodeBaseIR & {
+  type: 'random_delay';
+  min: DurationIR;
+  max: DurationIR;
+}) | (NodeBaseIR & {
+  type: 'time_window';
+  days: WeekdayIR[];
+  between: [string, string];
+  tz: string;
+}) | (NodeBaseIR & {
+  type: 'wait_until';
+  condition: ConditionIR;
+  timeout: DurationIR;
+  onTimeout: 'continue' | 'exit' | NodeIR[];
+}) | (NodeBaseIR & {
+  type: 'branch';
+  cases: {
+    label?: string | undefined;
+    condition: ConditionIR;
+    flow: NodeIR[];
+  }[];
+  /** Default arm (the DSL's bare tail argument). Absent = fall through to the main line. */
+  otherwise?: NodeIR[] | undefined;
+}) | (NodeBaseIR & {
+  type: 'filter';
+  /** Audit-log line for the users this gate drops. Metadata: excluded from contentHash. */
+  reason?: string | undefined;
+  condition: ConditionIR;
+}) | (NodeBaseIR & {
+  type: 'cohort';
+  /**
+   * Explicit experiment key: bucketing hashes `userId:key` instead of the
+   * structural node id, so the assignment survives node insertion/moves and
+   * the experiment keeps one identity across workflow versions. Absent →
+   * the node id is used (fine for one-off splits).
+   */
+  key?: string | undefined;
+  /**
+   * Arms in authoring order — the order the interpreter accumulates weights
+   * in, so it decides which bucket range each arm owns. The DSL keeps that
+   * promise by rejecting integer-like arm names, which JavaScript would
+   * hoist to the front of the object in numeric order. Weights sum to 100.
+   */
+  arms: {
+    name: string;
+    weight: number;
+    flow: NodeIR[];
+  }[];
+}) | (NodeBaseIR & {
+  /** `reason` is the audit-log line. Metadata: excluded from contentHash. */
+  type: 'exit';
+  reason?: string | undefined;
+}) | (NodeBaseIR & {
+  type: 'send_event';
+  event: string;
+  payload: Record<string, PropValueIR>;
+}) | (NodeBaseIR & {
+  type: 'action';
+  /** Registry name of the custom action; the code itself lives in the deployed Worker bundle. */
+  action: string;
+  /** Argument values; user_property references are resolved at run time, like message props. */
+  args: Record<string, PropValueIR>;
+  /**
+   * Hash of the action's source at compile time — the code-identity pin.
+   * IR carries identity only (dual-plane model): the runtime looks the
+   * action up by name and compares this hash against the registered
+   * implementation to detect version skew (warn by default).
+   */
+  codeHash?: string | undefined;
+});
+export declare const NodeIR: z.ZodMiniType<NodeIR>;
+export declare const GoalIR: z.ZodMiniObject<{
+  condition: z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>;
+  within: z.ZodMiniOptional<z.ZodMiniObject<{
+    value: z.ZodMiniString<string>;
+    ms: z.ZodMiniNumber<number>;
+  }, z.core.$strip>>;
+  exitOnMatch: z.ZodMiniBoolean<boolean>;
+}, z.core.$strip>;
+export type GoalIR = z.infer<typeof GoalIR>;
+/**
+ * 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.
+ */
+export declare const MetaIR: z.ZodMiniObject<{
+  name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  loc: z.ZodMiniOptional<z.ZodMiniObject<{
+    file: z.ZodMiniString<string>;
+    line: z.ZodMiniNumber<number>;
+    column: z.ZodMiniNumber<number>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MetaIR = z.infer<typeof MetaIR>;
+export declare const WorkflowIR: z.ZodMiniObject<{
+  irVersion: z.ZodMiniLiteral<2>;
+  id: z.ZodMiniString<string>;
+  contentHash: z.ZodMiniString<string>;
+  meta: z.ZodMiniOptional<z.ZodMiniObject<{
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    loc: z.ZodMiniOptional<z.ZodMiniObject<{
+      file: z.ZodMiniString<string>;
+      line: z.ZodMiniNumber<number>;
+      column: z.ZodMiniNumber<number>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  trigger: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+    type: z.ZodMiniLiteral<"event">;
+    event: z.ZodMiniString<string>;
+    where: z.ZodMiniOptional<z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>>;
+    filter: z.ZodMiniOptional<z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    type: z.ZodMiniLiteral<"segment">;
+    segment: z.ZodMiniString<string>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    type: z.ZodMiniLiteral<"date">;
+    at: z.ZodMiniString<string>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    type: z.ZodMiniLiteral<"webhook">;
+  }, z.core.$strip>], "type">;
+  goal: z.ZodMiniOptional<z.ZodMiniObject<{
+    condition: z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>;
+    within: z.ZodMiniOptional<z.ZodMiniObject<{
+      value: z.ZodMiniString<string>;
+      ms: z.ZodMiniNumber<number>;
+    }, z.core.$strip>>;
+    exitOnMatch: z.ZodMiniBoolean<boolean>;
+  }, z.core.$strip>>;
+  exitWhen: z.ZodMiniOptional<z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>>;
+  flow: z.ZodMiniArray<z.ZodMiniType<NodeIR, unknown, z.core.$ZodTypeInternals<NodeIR, unknown>>>;
+}, z.core.$strip>;
+export type WorkflowIR = z.infer<typeof WorkflowIR>;
+export declare const SegmentIR: z.ZodMiniObject<{
+  irVersion: z.ZodMiniLiteral<2>;
+  id: z.ZodMiniString<string>;
+  contentHash: z.ZodMiniString<string>;
+  meta: z.ZodMiniOptional<z.ZodMiniObject<{
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    loc: z.ZodMiniOptional<z.ZodMiniObject<{
+      file: z.ZodMiniString<string>;
+      line: z.ZodMiniNumber<number>;
+      column: z.ZodMiniNumber<number>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  condition: z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>;
+}, z.core.$strip>;
+export type SegmentIR = z.infer<typeof SegmentIR>;
+/** Template manifest entry: IR records only the reference; the body lives in the template system. */
+export declare const TemplateIR: z.ZodMiniObject<{
+  irVersion: z.ZodMiniLiteral<2>;
+  key: z.ZodMiniString<string>;
+  channel: z.ZodMiniEnum<{
+    discord: "discord";
+    email: "email";
+    in_app: "in_app";
+    push: "push";
+    slack: "slack";
+    sms: "sms";
+    survey: "survey";
+  }>;
+}, z.core.$strip>;
+export type TemplateIR = z.infer<typeof TemplateIR>;
+/**
+ * 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).
+ */
+export declare const ActionIR: z.ZodMiniObject<{
+  irVersion: z.ZodMiniLiteral<2>;
+  name: z.ZodMiniString<string>;
+  codeHash: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type ActionIR = z.infer<typeof ActionIR>;
+/**
+ * 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.
+ */
+export declare const BundleIR: z.ZodMiniObject<{
+  irVersion: z.ZodMiniLiteral<2>;
+  workflows: z.ZodMiniArray<z.ZodMiniObject<{
+    irVersion: z.ZodMiniLiteral<2>;
+    id: z.ZodMiniString<string>;
+    contentHash: z.ZodMiniString<string>;
+    meta: z.ZodMiniOptional<z.ZodMiniObject<{
+      name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      loc: z.ZodMiniOptional<z.ZodMiniObject<{
+        file: z.ZodMiniString<string>;
+        line: z.ZodMiniNumber<number>;
+        column: z.ZodMiniNumber<number>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    trigger: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+      type: z.ZodMiniLiteral<"event">;
+      event: z.ZodMiniString<string>;
+      where: z.ZodMiniOptional<z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>>;
+      filter: z.ZodMiniOptional<z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>>;
+    }, z.core.$strip>, z.ZodMiniObject<{
+      type: z.ZodMiniLiteral<"segment">;
+      segment: z.ZodMiniString<string>;
+    }, z.core.$strip>, z.ZodMiniObject<{
+      type: z.ZodMiniLiteral<"date">;
+      at: z.ZodMiniString<string>;
+    }, z.core.$strip>, z.ZodMiniObject<{
+      type: z.ZodMiniLiteral<"webhook">;
+    }, z.core.$strip>], "type">;
+    goal: z.ZodMiniOptional<z.ZodMiniObject<{
+      condition: z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>;
+      within: z.ZodMiniOptional<z.ZodMiniObject<{
+        value: z.ZodMiniString<string>;
+        ms: z.ZodMiniNumber<number>;
+      }, z.core.$strip>>;
+      exitOnMatch: z.ZodMiniBoolean<boolean>;
+    }, z.core.$strip>>;
+    exitWhen: z.ZodMiniOptional<z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>>;
+    flow: z.ZodMiniArray<z.ZodMiniType<NodeIR, unknown, z.core.$ZodTypeInternals<NodeIR, unknown>>>;
+  }, z.core.$strip>>;
+  segments: z.ZodMiniArray<z.ZodMiniObject<{
+    irVersion: z.ZodMiniLiteral<2>;
+    id: z.ZodMiniString<string>;
+    contentHash: z.ZodMiniString<string>;
+    meta: z.ZodMiniOptional<z.ZodMiniObject<{
+      name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      loc: z.ZodMiniOptional<z.ZodMiniObject<{
+        file: z.ZodMiniString<string>;
+        line: z.ZodMiniNumber<number>;
+        column: z.ZodMiniNumber<number>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    condition: z.ZodMiniType<ConditionIR, unknown, z.core.$ZodTypeInternals<ConditionIR, unknown>>;
+  }, z.core.$strip>>;
+  templates: z.ZodMiniArray<z.ZodMiniObject<{
+    irVersion: z.ZodMiniLiteral<2>;
+    key: z.ZodMiniString<string>;
+    channel: z.ZodMiniEnum<{
+      discord: "discord";
+      email: "email";
+      in_app: "in_app";
+      push: "push";
+      slack: "slack";
+      sms: "sms";
+      survey: "survey";
+    }>;
+  }, z.core.$strip>>;
+  actions: z.ZodMiniArray<z.ZodMiniObject<{
+    irVersion: z.ZodMiniLiteral<2>;
+    name: z.ZodMiniString<string>;
+    codeHash: z.ZodMiniString<string>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BundleIR = z.infer<typeof BundleIR>;
+//#endregion
+//# sourceMappingURL=ir.d.cts.map

package/dist/ir.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.cts","names":[],"sources":["../src/ir.ts"],"mappings":"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"}