@curviate/sdk 0.43.0 → 0.44.0

package/dist/index.js

@@ -281,10 +281,17 @@ var ERROR_CODES = [
   "IMPORT_QUEUE_FULL",
   // Sequences (`Sequence`, `validateSequence`). `SEQUENCE_INVALID` (422 from
   // the API, or thrown offline by `toDocument()` / `Sequence.fromDocument`):
-  // the Sequence document breaks one or more rules. `errors` lists every one as
-  // `{path, rule}` in step order, so one fix round covers them all. Nothing is
-  // saved. user_fixable, never retryable as sent.
+  // the Sequence document breaks one or more rules. `errors` lists every one
+  // (`path`, `rule`, `code`, `pointer`, `hint`, `docs_url`) in step order, so
+  // one fix round covers them all. Nothing is saved. user_fixable, never
+  // retryable as sent.
+  //
+  // `SEQUENCE_CONFLICT` (409): `motions.update` sent `if_sequence_revision`
+  // and someone saved the Sequence since; nothing is saved. `current` carries
+  // the stored document and its `sequence_revision`: merge, or send yours again
+  // with that revision to replace it.
   "SEQUENCE_INVALID",
+  "SEQUENCE_CONFLICT",
   // Motions and Enrollments (`motions`, `enrollments`).
   //
   // - `MOTION_NOT_STARTABLE` (422): `start` or `resume` found gaps; `errors`
@@ -294,15 +301,33 @@ var ERROR_CODES = [
   //   Motion's status; the message names it and the operations it allows.
   //   Only a draft can be deleted: archive instead.
   // - `ENROLLMENT_NOT_ACTIVE` (409): the Enrollment's status does not take
-  //   this operation (stop: pending, active or paused; signal: active or
-  //   paused; resume: active, paused or finished, not when the account or
-  //   Contact is gone).
+  //   this operation (stop and pause: pending, active or paused; events:
+  //   active or paused; resume: active, paused or finished, not when the
+  //   account or Contact is gone).
+  // - `STEP_IN_FLIGHT` (409): a Step of the Enrollment is being sent right
+  //   now; pause and reassign wait until it settles. Retry in a minute.
+  // - `NOTHING_TO_RETRY` (409, or thrown by `enrollments.retry`): Retry found no
+  //   Step whose latest outcome is `failed`; nothing was resumed or sent.
+  // - `ACCOUNT_ALREADY_ENGAGED` (409): reassign refused: the Enrollment's
+  //   account already did something the Contact can see.
+  // - `ALREADY_ENROLLED_ON_ACCOUNT` (409): reassign refused: the target
+  //   account already holds this Contact in the Motion, or is its own account.
+  // - `KNOWN_CHAT` (409): reassign refused: the Motion excludes known chats
+  //   and the Contact already has a chat with your team.
   // - `CONTACT_NOT_ENROLLABLE` (422): adding a Contact to a Motion from a chat
   //   was refused (already enrolled, excluded, in another Motion, filtered).
+  // - `CHAT_NOT_ONE_TO_ONE` (422): a Unibox Contact action on a group chat,
+  //   or a chat whose counterpart is not a person.
   "MOTION_NOT_STARTABLE",
   "MOTION_STATUS_CONFLICT",
   "ENROLLMENT_NOT_ACTIVE",
+  "STEP_IN_FLIGHT",
+  "NOTHING_TO_RETRY",
+  "ACCOUNT_ALREADY_ENGAGED",
+  "ALREADY_ENROLLED_ON_ACCOUNT",
+  "KNOWN_CHAT",
   "CONTACT_NOT_ENROLLABLE",
+  "CHAT_NOT_ONE_TO_ONE",
   // Client-side, never sent by the API. `CLIENT_TIMEOUT`: no response within
   // the client's `timeout` (default 30 s, per attempt). A read is retried
   // first; a write is not, and may still have reached the API, so read back
@@ -330,6 +355,7 @@ var CurviateError = class _CurviateError extends Error {
     this.blocked = init.blocked;
     this.connectionLocation = init.connectionLocation;
     this.errors = init.errors;
+    this.current = init.current;
     this.feature = init.feature;
     this.requiredTier = init.requiredTier;
     this.currentTier = init.currentTier;
@@ -360,6 +386,7 @@ var CurviateError = class _CurviateError extends Error {
     if (this.blocked !== void 0) json.blocked = this.blocked;
     if (this.connectionLocation !== void 0) json.connectionLocation = this.connectionLocation;
     if (this.errors !== void 0) json.errors = this.errors;
+    if (this.current !== void 0) json.current = this.current;
     if (this.feature !== void 0) json.feature = this.feature;
     if (this.requiredTier !== void 0) json.requiredTier = this.requiredTier;
     if (this.currentTier !== void 0) json.currentTier = this.currentTier;
@@ -403,11 +430,19 @@ function resolveConfig(config) {
 }
 
 // src/transport.ts
+var DETAIL_KEYS = ["code", "message", "pointer", "hint", "docs_url"];
 function toErrorDetails(errors) {
   if (!Array.isArray(errors)) return void 0;
   return errors.flatMap((e) => {
-    const { path, rule } = typeof e === "object" && e !== null ? e : {};
-    return typeof path === "string" && typeof rule === "string" ? [{ path, rule }] : [];
+    const entry2 = typeof e === "object" && e !== null ? e : {};
+    const { path, rule } = entry2;
+    if (typeof path !== "string" || typeof rule !== "string") return [];
+    const detail = { path, rule };
+    for (const k of DETAIL_KEYS) {
+      const v = entry2[k];
+      if (typeof v === "string") detail[k] = v;
+    }
+    return [detail];
   });
 }
 var BASE_DELAY_MS = 500;
@@ -497,6 +532,7 @@ async function errorFromResponse(res) {
     ...typeof env?.blocked === "boolean" ? { blocked: env.blocked } : {},
     ...env?.connection_location !== null && typeof env?.connection_location === "object" ? { connectionLocation: env.connection_location } : {},
     ...Array.isArray(env?.errors) ? { errors: toErrorDetails(env.errors) } : {},
+    ...env?.code === "SEQUENCE_CONFLICT" && env.current !== null && typeof env.current === "object" && !Array.isArray(env.current) ? { current: env.current } : {},
     // `TIER_REQUIRED` details. `required_tier` / `current_tier` are null-BEARING
     // (no Tier has it / the team has none), so null survives; a non-string
     // value (neither a name nor null) is dropped rather than mistyped.
@@ -2886,7 +2922,7 @@ var TagsResource = class {
 
 // src/sequence/order.ts
 var DOC = ["$schema", "on_reply", "steps"];
-var STEP = ["id", "do", "wait", "until", "if", "emit", "tag", "timeout", "variants", "with", "then", "else", "next", "note"];
+var STEP = ["id", "do", "wait", "until", "if", "emit", "tag", "timeout", "variants", "with", "event", "then", "else", "next", "note"];
 var WITH = ["post", "newer_than", "reaction", "subject", "text", "note", "note_fallback", "fallback", "withdraw_after"];
 var VARIANT = ["id", "subject", "text"];
 var FALLBACK = ["subject", "text"];
@@ -2921,7 +2957,7 @@ var schema_v1_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
   $id: "https://docs.curviate.com/schemas/sequence/v1.json",
   title: "Sequence document v1",
-  description: `A Motion's Sequence: a flat steps array run from the first step, ending explicitly in "end". Served documents use this key order: $schema, on_reply, steps; in a step id, the kind key, timeout, variants, with, then, else, next, note; in with post, newer_than, reaction, subject, text, note, note_fallback, fallback, withdraw_after; in a variant id, subject, text. A text holds at most 50 variables.`,
+  description: 'A Motion\'s Sequence: a flat steps array run from the first step, ending explicitly in "end". Served documents use this key order: $schema, on_reply, steps; in a step id, the kind key, timeout, variants, with, event, then, else, next, note; in with post, newer_than, reaction, subject, text, note, note_fallback, fallback, withdraw_after; in a variant id, subject, text. A text holds at most 50 variables. Variables: `{{first_name}}` (any standard Contact field), `{{my_first_name}}`, `{{my_last_name}}`, `{{my_full_name}}` (the sending Account), any other `{{<key>}}` is the custom field `contact.extra.<key>`; the long forms `{{contact.<field>}}`, `{{contact.extra.<key>}}` and `{{account.<name>}}` stay valid. Delays are about their duration: every wait and until timeout gets a small random spread that only ever adds time.',
   type: "object",
   additionalProperties: false,
   required: [
@@ -2966,6 +3002,11 @@ var schema_v1_default = {
                 additionalProperties: false,
                 properties: {}
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3005,6 +3046,11 @@ var schema_v1_default = {
                 additionalProperties: false,
                 properties: {}
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3044,6 +3090,11 @@ var schema_v1_default = {
                 additionalProperties: false,
                 properties: {}
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3106,7 +3157,7 @@ var schema_v1_default = {
                 type: "array",
                 minItems: 2,
                 maxItems: 5,
-                description: "A/B variants, split evenly and sticky per Enrollment. Exclusive with the text in with.",
+                description: "A/B variants: exactly 2, split evenly and sticky per Enrollment. Exclusive with the text in with. More than 2 (up to 5) is deprecated: accepted with warning W13 until 2027-01-19.",
                 items: {
                   type: "object",
                   additionalProperties: false,
@@ -3127,6 +3178,11 @@ var schema_v1_default = {
                   }
                 }
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3166,6 +3222,11 @@ var schema_v1_default = {
                 additionalProperties: false,
                 properties: {}
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3220,7 +3281,7 @@ var schema_v1_default = {
                 type: "array",
                 minItems: 2,
                 maxItems: 5,
-                description: "A/B variants, split evenly and sticky per Enrollment. Exclusive with the text in with.",
+                description: "A/B variants: exactly 2, split evenly and sticky per Enrollment. Exclusive with the text in with. More than 2 (up to 5) is deprecated: accepted with warning W13 until 2027-01-19.",
                 items: {
                   type: "object",
                   additionalProperties: false,
@@ -3241,6 +3302,11 @@ var schema_v1_default = {
                   }
                 }
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3314,7 +3380,7 @@ var schema_v1_default = {
                 type: "array",
                 minItems: 2,
                 maxItems: 5,
-                description: "A/B variants, split evenly and sticky per Enrollment. Exclusive with the text in with.",
+                description: "A/B variants: exactly 2, split evenly and sticky per Enrollment. Exclusive with the text in with. More than 2 (up to 5) is deprecated: accepted with warning W13 until 2027-01-19.",
                 items: {
                   type: "object",
                   additionalProperties: false,
@@ -3340,6 +3406,11 @@ var schema_v1_default = {
                   }
                 }
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3404,6 +3475,11 @@ var schema_v1_default = {
                   }
                 }
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3470,7 +3546,7 @@ var schema_v1_default = {
                 type: "array",
                 minItems: 2,
                 maxItems: 5,
-                description: "A/B variants, split evenly and sticky per Enrollment. Exclusive with the text in with.",
+                description: "A/B variants: exactly 2, split evenly and sticky per Enrollment. Exclusive with the text in with. More than 2 (up to 5) is deprecated: accepted with warning W13 until 2027-01-19.",
                 items: {
                   type: "object",
                   additionalProperties: false,
@@ -3491,6 +3567,11 @@ var schema_v1_default = {
                   }
                 }
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3530,6 +3611,11 @@ var schema_v1_default = {
                 additionalProperties: false,
                 properties: {}
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -3563,7 +3649,7 @@ var schema_v1_default = {
               wait: {
                 type: "string",
                 pattern: "^[1-9][0-9]*(m|h|d)$",
-                description: "Calendar time to wait (1m to 365d)."
+                description: "Calendar time to wait, about this long (1m to 365d; a small random spread is added, never subtracted)."
               },
               next: {
                 type: "string",
@@ -3604,15 +3690,15 @@ var schema_v1_default = {
                   },
                   {
                     type: "string",
-                    pattern: "^signal\\.[a-z][a-z0-9_]{0,39}$"
+                    pattern: "^(event|signal)\\.[a-z][a-z0-9_.]{0,63}$"
                   }
                 ],
-                description: "`invite.accepted`, `message.replied`, `message.read`, or `signal.<name>`."
+                description: "`invite.accepted`, `message.replied`, `message.read`, or `event.<name>` (a custom event an agent sends). `signal.<name>` is the deprecated spelling of `event.<name>`: accepted with warning W13 until 2027-01-19."
               },
               timeout: {
                 type: "string",
                 pattern: "^[1-9][0-9]*(m|h|d)$",
-                description: "Give up waiting after this long (1h to 180d)."
+                description: "Give up waiting after about this long (1h to 180d; a small random spread is added, never subtracted)."
               },
               then: {
                 type: "string",
@@ -4257,6 +4343,19 @@ var schema_v1_default = {
                       }
                     }
                   },
+                  {
+                    type: "object",
+                    additionalProperties: false,
+                    required: [
+                      "message.seen"
+                    ],
+                    properties: {
+                      "message.seen": {
+                        type: "boolean",
+                        description: "if only: the Enrollment's last message.send or inmail.send was seen (a read receipt, or a reply after it). False before any message."
+                      }
+                    }
+                  },
                   {
                     type: "object",
                     additionalProperties: false,
@@ -4874,6 +4973,19 @@ var schema_v1_default = {
                                 type: "boolean"
                               }
                             }
+                          },
+                          {
+                            type: "object",
+                            additionalProperties: false,
+                            required: [
+                              "message.seen"
+                            ],
+                            properties: {
+                              "message.seen": {
+                                type: "boolean",
+                                description: "if only: the Enrollment's last message.send or inmail.send was seen (a read receipt, or a reply after it). False before any message."
+                              }
+                            }
                           }
                         ]
                       }
@@ -4914,7 +5026,7 @@ var schema_v1_default = {
               emit: {
                 type: "string",
                 pattern: "^[a-z][a-z0-9_.]{0,63}$",
-                description: "Signal name for the motion.signal webhook."
+                description: "Legacy: a custom event name. New documents put event on the step that matters."
               },
               next: {
                 type: "string",
@@ -4948,6 +5060,11 @@ var schema_v1_default = {
                 pattern: "^[^,;]*[^,;\\s][^,;]*$",
                 description: "Tag added to the Contact."
               },
+              event: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9_.]{0,63}$",
+                description: "Custom event sent once each time this step runs (not when skipped or failed), for example invite_sent."
+              },
               next: {
                 type: "string",
                 pattern: "^(end|[a-z][a-z0-9_]{0,39})$",
@@ -4982,10 +5099,10 @@ var END = "end";
 var H = 60;
 var D = 24 * H;
 var DURATION_BOUNDS = {
-  wait: { min: 1, max: 365 * D, label: "1m and 365d" },
-  timeout: { min: 1 * H, max: 180 * D, label: "1h and 180d" },
-  withdraw_after: { min: 14 * D, max: 180 * D, label: "14d and 180d" },
-  newer_than: { min: 1 * H, max: 365 * D, label: "1h and 365d" }
+  wait: { min: 1, max: 365 * D, label: "1m and 365d", example: "1d" },
+  timeout: { min: 1 * H, max: 180 * D, label: "1h and 180d", example: "21d" },
+  withdraw_after: { min: 14 * D, max: 180 * D, label: "14d and 180d", example: "21d" },
+  newer_than: { min: 1 * H, max: 365 * D, label: "1h and 365d", example: "30d" }
 };
 var TEXT_LIMITS = {
   message: 8e3,
@@ -5001,6 +5118,53 @@ var MAX_QUOTED_TOKEN_CHARS = 64;
 var ACCOUNT_FIELDS = ["first_name", "last_name", "full_name"];
 var NAME_FIELDS = ["full_name", "first_name", "last_name"];
 var MOTION_KEY_PATTERN = "^[a-z][a-z0-9_]{0,39}$";
+var MAX_VARIANTS = 2;
+var DEPRECATED_ACCEPTED_UNTIL = "2027-01-19";
+var SHORT_VARIABLE_PATTERN = "^[a-z][a-z0-9_]{0,63}$";
+var MY_FIELDS = ["my_first_name", "my_last_name", "my_full_name"];
+
+// src/sequence/rules.ts
+var SEQUENCE_RULES_DOCS_URL = "https://docs.curviate.com/reference/sequence-rules";
+var HINTS = {
+  R1: () => "Keep only $schema, on_reply and steps at the top level; $schema, when present, is https://docs.curviate.com/schemas/sequence/v1.json.",
+  R2: () => "Keep the document to 1 to 100 steps and 256 KiB; split a longer flow into two Motions.",
+  R3: () => "Give each step a unique id: lowercase letters, digits and _, starting with a letter, at most 40 characters, not end.",
+  R4: () => "Give the step exactly one of do, wait, until, if, emit or tag.",
+  R5: () => "Remove the key: each step kind takes only its own keys, and the sending Account is chosen with settings.assign.",
+  R6: () => 'Point the exit at a step id of this document, or at "end".',
+  R7: () => "Add then: the step to go to when the event happens or the condition is true.",
+  R8: () => 'Break the loop: point one exit of the cycle at a later step or at "end".',
+  R9: () => "Lead an exit of another step here, or delete the step.",
+  R10: () => 'End the last step explicitly: set its exits to a step id or "end".',
+  R11: () => 'Set on_reply to a step id or "end".',
+  R12: (t) => `Use a duration between ${t}.`,
+  R13: () => "Use an action from the list and only the parameters it takes, with values of their type.",
+  R14: () => "Wait for invite.accepted, message.replied, message.read or event.<name>, and give a timeout.",
+  R15: () => "Use one predicate key per object with its typed operand; chain if steps instead of all or any. account.* and message.* work in if steps only.",
+  R16: () => "Write a variable as {{first_name}}, {{my_first_name}} or a custom field {{opener}}; the long forms {{contact.first_name}}, {{contact.extra.opener}} and {{account.first_name}} work too.",
+  R17: () => "Remove the part after | and add a variable-free fallback on the step instead.",
+  R18: () => "Write a variable with double braces, like {{first_name}}, or remove the braces.",
+  R19: () => 'Add a variable-free fallback: with.fallback, with.note_fallback (or "drop") on an invitation, "skip" on a comment.',
+  R20: () => "Use a Contact variable in the comment, for example a custom field {{comment}} your agent writes per Contact.",
+  R21: () => "Set withdraw_after between 14d and 180d, for example 21d.",
+  R22: () => "Shorten the text to the limit (variables are not counted) or use fewer variables.",
+  R23: () => "Give the step exactly 2 variants (A/B) with ids unique in the document, or one text in with.",
+  R24: () => "Name the event with lowercase letters, digits, _ and ., starting with a letter, like reply.received; a Tag is 1 to 64 characters without , or ;.",
+  W1: () => "If the merge is intended, keep it; otherwise give the jumping step its own continuation.",
+  W5: () => "Remove the follow step: the invitation already follows the person.",
+  W6: () => "Send an invitation on this path before waiting for its acceptance.",
+  W7: () => "Write the comment per Contact, for example in a custom field {{comment}}.",
+  W8: () => "Keep the link for a later message.",
+  W9: () => "Motion variables are deprecated: write the text in place, or use a custom field.",
+  W11: (t) => `Did you mean ${t}?`,
+  W12: () => "Send a message on this path before checking whether it was seen.",
+  W13: (t) => `Use ${t} instead.`
+};
+function ruleHelp(code, token = "") {
+  const hint = HINTS[code];
+  if (!hint) throw new Error(`no hint for ${code}`);
+  return { hint: hint(token), docs_url: `${SEQUENCE_RULES_DOCS_URL}#${code.toLowerCase()}` };
+}
 
 // src/sequence/vocab.ts
 var SUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
@@ -5143,7 +5307,7 @@ function vocabulary(schema) {
     maxNoteChars: num(obj(propsOf(alts[0])["note"], "note")["maxLength"], "note.maxLength"),
     durationPattern: str(obj(byKind("wait")["wait"], "wait")["pattern"], "wait.pattern"),
     events: arr(until[0]["enum"], "until.enum").map((e) => str(e, "until.enum[]")),
-    signalNamePattern: after(str(until[1]["pattern"], "until.pattern"), "^signal\\."),
+    eventNamePattern: after(str(until[1]["pattern"], "until.pattern"), "^(event|signal)\\."),
     emitPattern: str(obj(byKind("emit")["emit"], "emit")["pattern"], "emit.pattern"),
     tagPattern: str(tag["pattern"], "tag.pattern"),
     maxTagChars: num(tag["maxLength"], "tag.maxLength"),
@@ -5159,6 +5323,18 @@ function vocabulary(schema) {
 }
 
 // src/sequence/validate.ts
+var issue = (ctx, i) => ctx.issues.push(i);
+var warning = (ctx, i) => ctx.warnings.push(i);
+function jsonPointer(...tokens) {
+  return tokens.map((t) => "/" + String(t).replace(/~/g, "~0").replace(/\//g, "~1")).join("");
+}
+function entry(code, path, pointer, rule, token) {
+  return { path, rule, code, message: rule, pointer, ...ruleHelp(code, token) };
+}
+function entries(issues) {
+  return issues.sort((a, b) => a.order - b.order).map((i) => entry(i.code, i.path, i.pointer, i.rule, i.token));
+}
+var UNTIL = `; accepted until ${DEPRECATED_ACCEPTED_UNTIL}`;
 var VARIABLE_RE = /\{\{([^{}]*)\}\}/g;
 var SINGLE_BRACE_RE = /\{[A-Za-z_][A-Za-z0-9_.]*\}/g;
 function keysOf(o) {
@@ -5198,6 +5374,7 @@ function durationMinutes(v) {
 function durationRule(bounds) {
   return `must be a duration between ${bounds.label}: a number then m, h or d, like 30d`;
 }
+var durationHint = (bounds) => `${bounds.label}, for example ${bounds.example}`;
 function durationOk(ctx, v, bounds) {
   if (typeof v !== "string" || !ctx.re.duration.test(v)) return false;
   const m = durationMinutes(v);
@@ -5215,75 +5392,123 @@ function hasVariable(text) {
 function staticLength(text) {
   return [...text.replace(VARIABLE_RE, "")].length;
 }
+function longVariable(ctx, inner) {
+  if (inner.includes(".")) return inner;
+  if (!ctx.re.short.test(inner)) return null;
+  if (MY_FIELDS.includes(inner)) return `account.${inner.slice(3)}`;
+  if (inner.startsWith("my_")) return null;
+  if (ctx.v.standardFields.includes(inner)) return `contact.${inner}`;
+  return `contact.extra.${inner}`;
+}
 function isKnownVariable(ctx, inner) {
-  if (inner.startsWith("contact.extra.")) return ctx.re.extraKey.test(inner.slice("contact.extra.".length));
-  if (inner.startsWith("contact.")) return ctx.v.standardFields.includes(inner.slice(8));
-  if (inner.startsWith("account.")) return ACCOUNT_FIELDS.includes(inner.slice(8));
+  const long = longVariable(ctx, inner);
+  if (long === null) return false;
+  if (long.startsWith("contact.extra.")) return ctx.re.extraKey.test(long.slice("contact.extra.".length));
+  if (long.startsWith("contact.")) return ctx.v.standardFields.includes(long.slice(8));
+  if (long.startsWith("account.")) return ACCOUNT_FIELDS.includes(long.slice(8));
   return false;
 }
-function checkText(ctx, order, path, value, limit) {
+function distance(a, b, cap) {
+  if (Math.abs(a.length - b.length) > cap) return cap + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1; j <= b.length; j++) cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    prev = cur;
+  }
+  return prev[b.length];
+}
+function likelyTypoOf(ctx, key) {
+  let best = null;
+  let bestD = 3;
+  for (const n of [...ctx.v.standardFields, ...MY_FIELDS]) {
+    const d = distance(key, n, 2);
+    if (d < bestD) [best, bestD] = [n, d];
+  }
+  return best;
+}
+function checkText(ctx, order, path, pointer, parent, value, limit) {
   if (typeof value !== "string" || value.trim() === "") {
-    ctx.issues.push({ order, path, rule: "must be non-empty text" });
+    issue(ctx, { order, code: "R13", path, pointer: value === void 0 ? parent : pointer, rule: "must be non-empty text" });
     return null;
   }
+  const at = { order, path, pointer };
   const vars = variablesIn(value);
   if (vars.length > MAX_VARIABLE_REFS_PER_TEXT) {
-    ctx.issues.push({ order, path, rule: `${vars.length} variables; the limit is ${MAX_VARIABLE_REFS_PER_TEXT} per text` });
+    issue(ctx, { ...at, code: "R22", rule: `${vars.length} variables; the limit is ${MAX_VARIABLE_REFS_PER_TEXT} per text` });
   }
   for (const v of vars.length > MAX_VARIABLE_REFS_PER_TEXT ? [] : vars) {
     if (v.inner.includes("|")) {
-      ctx.issues.push({ order, path, rule: "variable defaults are not supported; add a fallback" });
+      issue(ctx, { ...at, code: "R17", rule: "variable defaults are not supported; add a fallback" });
       continue;
     }
     if (v.inner.startsWith("motion.") && ctx.re.motion.test(v.inner.slice(7))) {
-      ctx.warnings.push({ order, code: "W9", path, rule: `${quote(v.token)} is checked against settings.variables by the server only` });
+      const key = v.inner.slice(7);
+      warning(ctx, {
+        ...at,
+        code: "W13",
+        rule: `${quote(v.token)}: Motion variables were removed${UNTIL}; write the text in place or use a custom field`,
+        token: `text in place or a custom field such as {{${key}}}`
+      });
+      warning(ctx, { ...at, code: "W9", rule: `${quote(v.token)} is checked against settings.variables by the server only` });
+      continue;
+    }
+    if (!v.inner.includes(".") && v.inner.startsWith("my_") && !MY_FIELDS.includes(v.inner)) {
+      issue(ctx, { ...at, code: "R16", rule: `${quote(v.token)}: the my_ prefix is reserved for my_first_name, my_last_name and my_full_name` });
       continue;
     }
     if (!isKnownVariable(ctx, v.inner)) {
-      ctx.issues.push({
-        order,
-        path,
-        rule: `unknown variable ${quote(v.token)}; use contact.<field>, contact.extra.<key>, account.first_name, account.last_name, account.full_name or motion.<key>`
+      issue(ctx, {
+        ...at,
+        code: "R16",
+        rule: `unknown variable ${quote(v.token)}; use a field ({{first_name}}), your name ({{my_first_name}}), a custom field ({{opener}}), or contact.<field>, contact.extra.<key>, account.first_name, account.last_name, account.full_name`
       });
+      continue;
+    }
+    if (!v.inner.includes(".") && longVariable(ctx, v.inner).startsWith("contact.extra.")) {
+      const near = likelyTypoOf(ctx, v.inner);
+      if (near !== null) warning(ctx, { ...at, code: "W11", rule: `${quote(v.token)} is read as a custom field; did you mean ${near}?`, token: near });
     }
   }
   const rest = value.replace(VARIABLE_RE, " ");
   if (rest.includes("{{")) {
-    ctx.issues.push({ order, path, rule: "unclosed variable; write a variable as {{contact.first_name}}" });
+    issue(ctx, { ...at, code: "R16", rule: "unclosed variable; write a variable as {{contact.first_name}}" });
   } else {
     for (const m of rest.matchAll(SINGLE_BRACE_RE)) {
-      ctx.issues.push({ order, path, rule: `${quote(m[0])} is not a variable; write {{contact.<field>}} or remove the braces` });
+      issue(ctx, { ...at, code: "R18", rule: `${quote(m[0])} is not a variable; write {{contact.<field>}} or remove the braces` });
     }
   }
   const len = staticLength(value);
-  if (len > limit) ctx.issues.push({ order, path, rule: `${len} characters; the limit is ${limit}, variables not counted` });
+  if (len > limit) issue(ctx, { ...at, code: "R22", rule: `${len} characters; the limit is ${limit}, variables not counted` });
   return value;
 }
-function checkFallbackText(ctx, order, path, value, limit, keyword) {
+function checkFallbackText(ctx, order, path, pointer, parent, value, limit, keyword) {
   if (keyword !== void 0 && value === keyword) return;
+  const at = { order, code: "R19", path, pointer };
   if (typeof value !== "string") {
-    ctx.issues.push({ order, path, rule: keyword ? `must be text or "${keyword}"` : "must be text" });
+    issue(ctx, { ...at, pointer: value === void 0 ? parent : pointer, rule: keyword ? `must be text or "${keyword}"` : "must be text" });
     return;
   }
   if (value.trim() === "") {
-    ctx.issues.push({ order, path, rule: "a fallback must not be empty" });
+    issue(ctx, { ...at, rule: "a fallback must not be empty" });
     return;
   }
   if (hasVariable(value)) {
-    ctx.issues.push({ order, path, rule: "a fallback must not contain a variable" });
+    issue(ctx, { ...at, rule: "a fallback must not contain a variable" });
     return;
   }
-  checkText(ctx, order, path, value, limit);
+  checkText(ctx, order, path, pointer, parent, value, limit);
 }
 function createValidator(v) {
   const re = {
     id: new RegExp(v.idPattern),
     duration: new RegExp(v.durationPattern),
     emit: new RegExp(v.emitPattern),
-    signal: new RegExp(v.signalNamePattern),
+    event: new RegExp(v.eventNamePattern),
     extraKey: new RegExp(v.extraKeyPattern),
     tag: new RegExp(v.tagPattern),
-    motion: new RegExp(MOTION_KEY_PATTERN)
+    motion: new RegExp(MOTION_KEY_PATTERN),
+    short: new RegExp(SHORT_VARIABLE_PATTERN)
   };
   return (doc) => run(doc, { v, re, issues: [], warnings: [] });
 }
@@ -5310,9 +5535,9 @@ function firstUnstorable(doc) {
     } else if (Array.isArray(value)) {
       for (let i = value.length - 1; i >= 0; i--) stack.push(["value", value[i], `${path}[${i}]`]);
     } else if (typeof value === "object" && value !== null) {
-      const entries = Object.entries(value);
-      for (let i = entries.length - 1; i >= 0; i--) {
-        const [k, v] = entries[i];
+      const entries2 = Object.entries(value);
+      for (let i = entries2.length - 1; i >= 0; i--) {
+        const [k, v] = entries2[i];
         stack.push(["value", v, path ? `${path}.${k}` : k], ["key", k, path]);
       }
     }
@@ -5324,53 +5549,55 @@ function run(doc, ctx) {
   if (bad !== null) return { errors: [{ path: bad, rule: UNSTORABLE_RULE }], warnings: [] };
   const size = compactBytes(doc);
   if (size > MAX_SEQUENCE_BYTES) {
-    return { errors: [{ path: "$", rule: `the document is ${size} bytes; the limit is ${MAX_SEQUENCE_BYTES}, UTF-8 compact JSON` }], warnings: [] };
+    return { errors: [entry("R2", "$", "", `the document is ${size} bytes; the limit is ${MAX_SEQUENCE_BYTES}, UTF-8 compact JSON`)], warnings: [] };
   }
   return rules(doc, ctx);
 }
 function rules(doc, ctx) {
   const { v } = ctx;
   const DOC2 = -1;
-  if (!isObject(doc)) return { errors: [{ path: "$", rule: "a Sequence document is a JSON object" }], warnings: [] };
+  if (!isObject(doc)) return { errors: [entry("R1", "$", "", "a Sequence document is a JSON object")], warnings: [] };
   for (const k of keysOf(doc)) {
     if (k !== "$schema" && k !== "on_reply" && k !== "steps") {
-      ctx.issues.push({ order: DOC2, path: quote(k), rule: "unknown key; a Sequence document holds only $schema, on_reply and steps" });
+      issue(ctx, { order: DOC2, code: "R1", path: quote(k), pointer: jsonPointer(k), rule: "unknown key; a Sequence document holds only $schema, on_reply and steps" });
     }
   }
   if (has(doc, "$schema") && doc["$schema"] !== v.schemaUrl) {
-    ctx.issues.push({ order: DOC2, path: "$schema", rule: `must be ${v.schemaUrl}` });
+    issue(ctx, { order: DOC2, code: "R1", path: "$schema", pointer: "/$schema", rule: `must be ${v.schemaUrl}` });
   }
   const rawSteps = doc["steps"];
   const stepsArr = Array.isArray(rawSteps) ? rawSteps : [];
   if (!Array.isArray(rawSteps) || rawSteps.length < v.minSteps) {
-    ctx.issues.push({ order: DOC2, path: "steps", rule: `required: an array of ${v.minSteps} to ${v.maxSteps} steps` });
+    issue(ctx, { order: DOC2, code: "R2", path: "steps", pointer: has(doc, "steps") ? "/steps" : "", rule: `required: an array of ${v.minSteps} to ${v.maxSteps} steps` });
   } else if (rawSteps.length > v.maxSteps) {
-    ctx.issues.push({ order: DOC2, path: "steps", rule: `${rawSteps.length} steps; the limit is ${v.maxSteps}` });
+    issue(ctx, { order: DOC2, code: "R2", path: "steps", pointer: "/steps", rule: `${rawSteps.length} steps; the limit is ${v.maxSteps}` });
   }
   const infos = [];
   const firstIndex = /* @__PURE__ */ new Map();
   let structural = !Array.isArray(rawSteps) || rawSteps.length < v.minSteps || rawSteps.length > v.maxSteps;
   stepsArr.forEach((raw, index) => {
-    const info = { index, prefix: `steps[${index}]`, id: null, kind: null, raw: null };
+    const ptr = jsonPointer("steps", index);
+    const info = { index, prefix: `steps[${index}]`, ptr, id: null, kind: null, raw: null };
     infos.push(info);
     if (!isObject(raw)) {
-      ctx.issues.push({ order: index, path: info.prefix, rule: "a step is a JSON object" });
+      issue(ctx, { order: index, code: "R4", path: info.prefix, pointer: ptr, rule: "a step is a JSON object" });
       structural = true;
       return;
     }
     info.raw = raw;
     const id = raw["id"];
+    const idAt = { order: index, code: "R3", path: `${info.prefix}.id`, pointer: `${ptr}/id` };
     if (!has(raw, "id")) {
-      ctx.issues.push({ order: index, path: `${info.prefix}.id`, rule: `required: matching ${v.idPattern}` });
+      issue(ctx, { ...idAt, pointer: ptr, rule: `required: matching ${v.idPattern}` });
       structural = true;
     } else if (typeof id !== "string" || !ctx.re.id.test(id)) {
-      ctx.issues.push({ order: index, path: `${info.prefix}.id`, rule: `must match ${v.idPattern}` });
+      issue(ctx, { ...idAt, rule: `must match ${v.idPattern}` });
       structural = true;
     } else if (id === END) {
-      ctx.issues.push({ order: index, path: `${info.prefix}.id`, rule: '"end" is reserved' });
+      issue(ctx, { ...idAt, rule: '"end" is reserved' });
       structural = true;
     } else if (firstIndex.has(id)) {
-      ctx.issues.push({ order: index, path: `${info.prefix}.id`, rule: `duplicate step id ${id}` });
+      issue(ctx, { ...idAt, rule: `duplicate step id ${id}` });
       structural = true;
     } else {
       firstIndex.set(id, index);
@@ -5379,9 +5606,11 @@ function rules(doc, ctx) {
     }
     const kinds = v.stepKinds.filter((k) => has(raw, k));
     if (kinds.length !== 1) {
-      ctx.issues.push({
+      issue(ctx, {
         order: index,
+        code: "R4",
         path: info.prefix,
+        pointer: ptr,
         rule: kinds.length === 0 ? `a step needs exactly one of ${v.stepKinds.join(", ")}` : `a step has exactly one kind; found ${kinds.join(", ")}`
       });
       structural = true;
@@ -5391,93 +5620,115 @@ function rules(doc, ctx) {
   });
   const onReply = doc["on_reply"];
   const targetOk = (t) => t === END || typeof t === "string" && firstIndex.has(t);
+  const replyAt = { order: DOC2, code: "R11", path: "on_reply", pointer: "/on_reply" };
   if (!has(doc, "on_reply")) {
-    ctx.issues.push({ order: DOC2, path: "on_reply", rule: 'required: a step id or "end"' });
+    issue(ctx, { ...replyAt, pointer: "", rule: 'required: a step id or "end"' });
     structural = true;
   } else if (typeof onReply !== "string") {
-    ctx.issues.push({ order: DOC2, path: "on_reply", rule: 'must be a step id or "end"' });
+    issue(ctx, { ...replyAt, rule: 'must be a step id or "end"' });
     structural = true;
   } else if (!targetOk(onReply)) {
-    ctx.issues.push({ order: DOC2, path: "on_reply", rule: `unknown step ${quote(onReply)}` });
+    issue(ctx, { ...replyAt, rule: `unknown step ${quote(onReply)}` });
     structural = true;
   }
   const usedIds = new Set(firstIndex.keys());
   for (const info of infos) {
     if (!info.raw || !info.kind) continue;
-    const { raw, kind, index: order, prefix: p } = info;
+    const { raw, kind, index: order, prefix: p, ptr } = info;
     const keys = v.stepKeys[kind] ?? [];
     for (const k of keysOf(raw)) {
       if (keys.includes(k)) continue;
-      ctx.issues.push({
+      issue(ctx, {
         order,
+        code: "R5",
         path: `${p}.${quote(k)}`,
+        pointer: `${ptr}${jsonPointer(k)}`,
         rule: k === "by" ? "step-level by is not supported; use settings.assign" : `unknown key for a ${kind} step`
       });
     }
     if (has(raw, "note")) {
       const n = raw["note"];
       if (typeof n !== "string" || [...n].length > v.maxNoteChars) {
-        ctx.issues.push({ order, path: `${p}.note`, rule: `must be text of at most ${v.maxNoteChars} characters` });
+        issue(ctx, { order, code: "R22", path: `${p}.note`, pointer: `${ptr}/note`, rule: `must be text of at most ${v.maxNoteChars} characters` });
+      }
+    }
+    if (has(raw, "event") && keys.includes("event")) {
+      const e = raw["event"];
+      if (typeof e !== "string" || !ctx.re.event.test(e)) {
+        issue(ctx, { order, code: "R24", path: `${p}.event`, pointer: `${ptr}/event`, rule: `must match ${v.eventNamePattern}, like invite_sent` });
       }
     }
     switch (kind) {
       case "do":
-        checkDo(ctx, order, p, raw, usedIds);
+        checkDo(ctx, order, p, ptr, raw, usedIds);
         break;
       case "wait":
-        if (!durationOk(ctx, raw["wait"], DURATION_BOUNDS.wait)) ctx.issues.push({ order, path: `${p}.wait`, rule: durationRule(DURATION_BOUNDS.wait) });
+        if (!durationOk(ctx, raw["wait"], DURATION_BOUNDS.wait)) {
+          issue(ctx, { order, code: "R12", path: `${p}.wait`, pointer: `${ptr}/wait`, rule: durationRule(DURATION_BOUNDS.wait), token: durationHint(DURATION_BOUNDS.wait) });
+        }
         break;
       case "until":
-        checkUntil(ctx, order, p, raw);
+        checkUntil(ctx, order, p, ptr, raw);
         break;
       case "if":
-        checkPredicate(ctx, raw["if"], `${p}.if`, order);
+        checkPredicate(ctx, raw["if"], `${p}.if`, `${ptr}/if`, order);
         break;
       case "emit": {
         const e = raw["emit"];
         if (typeof e !== "string" || !ctx.re.emit.test(e)) {
-          ctx.issues.push({ order, path: `${p}.emit`, rule: `must match ${v.emitPattern}, like reply.received` });
+          issue(ctx, { order, code: "R24", path: `${p}.emit`, pointer: `${ptr}/emit`, rule: `must match ${v.emitPattern}, like reply.received` });
         }
         break;
       }
       case "tag":
-        if (!tagOk(ctx, raw["tag"])) ctx.issues.push({ order, path: `${p}.tag`, rule: "a Tag name is 1 to 64 characters, without , or ;" });
+        if (!tagOk(ctx, raw["tag"])) issue(ctx, { order, code: "R24", path: `${p}.tag`, pointer: `${ptr}/tag`, rule: "a Tag name is 1 to 64 characters, without , or ;" });
         break;
     }
     if ((kind === "until" || kind === "if") && !has(raw, "then")) {
-      ctx.issues.push({ order, path: `${p}.then`, rule: `required on an ${kind} step` });
+      issue(ctx, { order, code: "R7", path: `${p}.then`, pointer: ptr, rule: `required on an ${kind} step` });
       structural = true;
     }
     for (const f of ["then", "else", "next"]) {
       if (!has(raw, f) || !keys.includes(f)) continue;
       const t = raw[f];
+      const at = { order, code: "R6", path: `${p}.${f}`, pointer: `${ptr}/${f}` };
       if (typeof t !== "string") {
-        ctx.issues.push({ order, path: `${p}.${f}`, rule: 'must be a step id or "end"' });
+        issue(ctx, { ...at, rule: 'must be a step id or "end"' });
         structural = true;
       } else if (!targetOk(t)) {
-        ctx.issues.push({ order, path: `${p}.${f}`, rule: `unknown step ${quote(t)}` });
+        issue(ctx, { ...at, rule: `unknown step ${quote(t)}` });
         structural = true;
       }
     }
   }
   if (!structural) graph(ctx, infos, firstIndex, onReply);
-  const byOrder = (a, b) => a.order - b.order;
-  return {
-    errors: ctx.issues.sort(byOrder).map(({ path, rule }) => ({ path, rule })),
-    warnings: ctx.warnings.sort(byOrder).map(({ code, path, rule }) => ({ code, path, rule }))
-  };
+  return { errors: entries(ctx.issues), warnings: entries(ctx.warnings) };
 }
-function checkUntil(ctx, order, p, raw) {
+function checkUntil(ctx, order, p, ptr, raw) {
   const ev = raw["until"];
-  if (typeof ev === "string" && ev.startsWith("signal.")) {
-    if (!ctx.re.signal.test(ev.slice(7))) ctx.issues.push({ order, path: `${p}.until`, rule: `a signal name must match ${ctx.v.signalNamePattern}` });
+  const at = { order, code: "R14", path: `${p}.until`, pointer: `${ptr}/until` };
+  const custom = typeof ev === "string" ? /^(event|signal)\.(.*)$/s.exec(ev) : null;
+  if (custom) {
+    const [, ns, name] = custom;
+    if (!ctx.re.event.test(name)) {
+      issue(ctx, { ...at, rule: `an event name must match ${ctx.v.eventNamePattern}` });
+    } else if (ns === "signal") {
+      warning(ctx, { ...at, code: "W13", rule: `until signal.${quote(name)} is now until event.${quote(name)}${UNTIL}`, token: `event.${quote(name)}` });
+    }
   } else if (!ctx.v.events.includes(ev)) {
-    ctx.issues.push({ order, path: `${p}.until`, rule: `unknown event; use ${ctx.v.events.join(", ")} or signal.<name>` });
+    issue(ctx, { ...at, rule: `unknown event; use ${ctx.v.events.join(", ")} or event.<name>` });
   }
   if (!has(raw, "timeout")) {
-    ctx.issues.push({ order, path: `${p}.timeout`, rule: "required on an until step" });
+    issue(ctx, { order, code: "R14", path: `${p}.timeout`, pointer: ptr, rule: "required on an until step" });
   } else if (!durationOk(ctx, raw["timeout"], DURATION_BOUNDS.timeout)) {
-    ctx.issues.push({ order, path: `${p}.timeout`, rule: durationRule(DURATION_BOUNDS.timeout) });
+    issue(ctx, {
+      order,
+      code: "R12",
+      path: `${p}.timeout`,
+      pointer: `${ptr}/timeout`,
+      rule: durationRule(DURATION_BOUNDS.timeout),
+      token: durationHint(DURATION_BOUNDS.timeout)
+    });
   }
 }
 function limitOf(a, field) {
@@ -5486,110 +5737,135 @@ function limitOf(a, field) {
   if (a === "invite.send") return TEXT_LIMITS.invite_note;
   return field === "subject" ? TEXT_LIMITS.inmail_subject : TEXT_LIMITS.inmail_text;
 }
-function checkDo(ctx, order, p, raw, usedIds) {
+function checkDo(ctx, order, p, ptr, raw, usedIds) {
   const { v } = ctx;
   const a = raw["do"];
   if (typeof a !== "string" || !v.actions.includes(a)) {
-    ctx.issues.push({ order, path: `${p}.do`, rule: `unknown action; use ${v.actions.join(", ")}` });
+    issue(ctx, { order, code: "R13", path: `${p}.do`, pointer: `${ptr}/do`, rule: `unknown action; use ${v.actions.join(", ")}` });
     return;
   }
   const params = v.actionParams[a] ?? [];
+  const wp = `${ptr}/with`;
+  const withParent = isObject(raw["with"]) ? wp : ptr;
   let w = {};
   if (has(raw, "with")) {
     if (!isObject(raw["with"])) {
-      ctx.issues.push({ order, path: `${p}.with`, rule: "must be an object" });
+      issue(ctx, { order, code: "R13", path: `${p}.with`, pointer: wp, rule: "must be an object" });
     } else {
       w = raw["with"];
       for (const k of keysOf(w)) {
         if (!params.includes(k)) {
-          ctx.issues.push({ order, path: `${p}.with.${quote(k)}`, rule: `unknown parameter; ${a} takes ${params.length ? params.join(", ") : "no parameters"}` });
+          issue(ctx, {
+            order,
+            code: "R13",
+            path: `${p}.with.${quote(k)}`,
+            pointer: `${wp}${jsonPointer(k)}`,
+            rule: `unknown parameter; ${a} takes ${params.length ? params.join(", ") : "no parameters"}`
+          });
         }
       }
     }
   }
   const messaging = v.messagingActions.includes(a);
   const hasVariants = has(raw, "variants");
-  if (hasVariants && !messaging) ctx.issues.push({ order, path: `${p}.variants`, rule: "variants are allowed on messaging steps only" });
+  const vptr = `${ptr}/variants`;
+  if (hasVariants && !messaging) issue(ctx, { order, code: "R23", path: `${p}.variants`, pointer: vptr, rule: "variants are allowed on messaging steps only" });
   if (has(w, "post") && params.includes("post") && w["post"] !== v.post) {
-    ctx.issues.push({ order, path: `${p}.with.post`, rule: `only "${v.post}" is supported` });
+    issue(ctx, { order, code: "R13", path: `${p}.with.post`, pointer: `${wp}/post`, rule: `only "${v.post}" is supported` });
   }
   if (has(w, "newer_than") && params.includes("newer_than") && !durationOk(ctx, w["newer_than"], DURATION_BOUNDS.newer_than)) {
-    ctx.issues.push({ order, path: `${p}.with.newer_than`, rule: durationRule(DURATION_BOUNDS.newer_than) });
+    issue(ctx, {
+      order,
+      code: "R12",
+      path: `${p}.with.newer_than`,
+      pointer: `${wp}/newer_than`,
+      rule: durationRule(DURATION_BOUNDS.newer_than),
+      token: durationHint(DURATION_BOUNDS.newer_than)
+    });
   }
   if (has(w, "reaction") && params.includes("reaction") && !v.reactions.includes(w["reaction"])) {
-    ctx.issues.push({ order, path: `${p}.with.reaction`, rule: `must be one of ${v.reactions.join(", ")}` });
+    issue(ctx, { order, code: "R13", path: `${p}.with.reaction`, pointer: `${wp}/reaction`, rule: `must be one of ${v.reactions.join(", ")}` });
   }
   if (has(w, "withdraw_after") && params.includes("withdraw_after") && !durationOk(ctx, w["withdraw_after"], DURATION_BOUNDS.withdraw_after)) {
-    ctx.issues.push({ order, path: `${p}.with.withdraw_after`, rule: durationRule(DURATION_BOUNDS.withdraw_after) });
+    issue(ctx, { order, code: "R21", path: `${p}.with.withdraw_after`, pointer: `${wp}/withdraw_after`, rule: durationRule(DURATION_BOUNDS.withdraw_after) });
   }
   if (!messaging) return;
   const textKeys = a === "inmail.send" ? ["subject", "text"] : ["text"];
   const withTextKeys = a === "invite.send" ? ["note"] : textKeys;
   const variants = hasVariants ? raw["variants"] : void 0;
   if (hasVariants && withTextKeys.some((k) => has(w, k) && w[k] !== null)) {
-    ctx.issues.push({ order, path: `${p}.variants`, rule: `use either variants or with.${withTextKeys.join(" and with.")}, not both` });
+    issue(ctx, { order, code: "R23", path: `${p}.variants`, pointer: vptr, rule: `use either variants or with.${withTextKeys.join(" and with.")}, not both` });
   }
   const texts = [];
   if (hasVariants) {
-    if (!Array.isArray(variants) || variants.length < v.minVariants || variants.length > v.maxVariants) {
-      ctx.issues.push({
+    const n = Array.isArray(variants) ? variants.length : null;
+    if (n !== null && n > MAX_VARIANTS && n <= v.maxVariants) {
+      warning(ctx, { order, code: "W13", path: `${p}.variants`, pointer: vptr, rule: `${n} variants; A/B takes exactly ${MAX_VARIANTS}${UNTIL}`, token: `${MAX_VARIANTS} variants` });
+    } else if (n === null || n < v.minVariants || n > MAX_VARIANTS) {
+      issue(ctx, {
         order,
+        code: "R23",
         path: `${p}.variants`,
-        rule: `needs ${v.minVariants} to ${v.maxVariants} variants${Array.isArray(variants) ? `; found ${variants.length}` : ""}`
+        pointer: vptr,
+        rule: `needs exactly ${MAX_VARIANTS} variants (A/B)${n === null ? "" : `; found ${n}`}`
       });
     }
     (Array.isArray(variants) ? variants : []).forEach((variant, j) => {
       let vp = `${p}.variants[${j}]`;
+      const vptrJ = `${vptr}/${j}`;
       if (!isObject(variant)) {
-        ctx.issues.push({ order, path: vp, rule: "a variant is a JSON object" });
+        issue(ctx, { order, code: "R23", path: vp, pointer: vptrJ, rule: "a variant is a JSON object" });
         return;
       }
       const vid = variant["id"];
+      const idAt = { order, code: "R23", path: `${vp}.id`, pointer: has(variant, "id") ? `${vptrJ}/id` : vptrJ };
       if (typeof vid !== "string" || !ctx.re.id.test(vid)) {
-        ctx.issues.push({ order, path: `${vp}.id`, rule: `must match ${v.idPattern}` });
+        issue(ctx, { ...idAt, rule: `must match ${v.idPattern}` });
       } else if (vid === END) {
-        ctx.issues.push({ order, path: `${vp}.id`, rule: '"end" is reserved' });
+        issue(ctx, { ...idAt, rule: '"end" is reserved' });
       } else if (usedIds.has(vid)) {
-        ctx.issues.push({ order, path: `${vp}.id`, rule: `${vid} is already a step or variant id` });
+        issue(ctx, { ...idAt, rule: `${vid} is already a step or variant id` });
       } else {
         usedIds.add(vid);
         vp = `${p}.variants.${vid}`;
       }
       for (const k of keysOf(variant)) {
         if (k !== "id" && !textKeys.includes(k)) {
-          ctx.issues.push({ order, path: `${vp}.${quote(k)}`, rule: `unknown key; a variant holds id and ${textKeys.join(" and ")}` });
+          issue(ctx, { order, code: "R23", path: `${vp}.${quote(k)}`, pointer: `${vptrJ}${jsonPointer(k)}`, rule: `unknown key; a variant holds id and ${textKeys.join(" and ")}` });
         }
       }
       for (const field of textKeys) {
-        const value = checkText(ctx, order, `${vp}.${field}`, variant[field], limitOf(a, field));
-        if (value !== null) texts.push({ path: `${vp}.${field}`, value });
+        const value = checkText(ctx, order, `${vp}.${field}`, `${vptrJ}/${field}`, vptrJ, variant[field], limitOf(a, field));
+        if (value !== null) texts.push({ path: `${vp}.${field}`, pointer: `${vptrJ}/${field}`, value });
       }
     });
   } else {
     for (const field of withTextKeys) {
+      const fp = `${wp}/${field}`;
       if (a === "invite.send") {
         if (has(w, "note") && w["note"] !== null) {
-          const value = checkText(ctx, order, `${p}.with.note`, w["note"], limitOf(a, field));
-          if (value !== null) texts.push({ path: `${p}.with.note`, value });
+          const value = checkText(ctx, order, `${p}.with.note`, fp, withParent, w["note"], limitOf(a, field));
+          if (value !== null) texts.push({ path: `${p}.with.note`, pointer: fp, value });
         }
       } else if (!has(w, field)) {
-        ctx.issues.push({ order, path: `${p}.with.${field}`, rule: "required, or use variants" });
+        issue(ctx, { order, code: "R13", path: `${p}.with.${field}`, pointer: withParent, rule: "required, or use variants" });
       } else {
-        const value = checkText(ctx, order, `${p}.with.${field}`, w[field], limitOf(a, field));
-        if (value !== null) texts.push({ path: `${p}.with.${field}`, value });
+        const value = checkText(ctx, order, `${p}.with.${field}`, fp, withParent, w[field], limitOf(a, field));
+        if (value !== null) texts.push({ path: `${p}.with.${field}`, pointer: fp, value });
       }
     }
   }
   if (a === "post.comment") {
     for (const t of texts) {
-      const contactVars = variablesIn(t.value).map((x) => x.inner).filter((i) => i.startsWith("contact.") && isKnownVariable(ctx, i));
+      const contactVars = variablesIn(t.value).filter((x) => isKnownVariable(ctx, x.inner)).map((x) => longVariable(ctx, x.inner)).filter((l) => l.startsWith("contact."));
       if (contactVars.length === 0) {
-        ctx.issues.push({ order, path: t.path, rule: "a comment must use a contact variable, such as {{contact.extra.comment}}" });
-      } else if (contactVars.every((i) => NAME_FIELDS.includes(i.slice(8)))) {
-        ctx.warnings.push({
+        issue(ctx, { order, code: "R20", path: t.path, pointer: t.pointer, rule: "a comment must use a contact variable, such as {{contact.extra.comment}}" });
+      } else if (contactVars.every((l) => NAME_FIELDS.includes(l.slice(8)))) {
+        warning(ctx, {
           order,
           code: "W7",
           path: t.path,
+          pointer: t.pointer,
           rule: "the comment's only per-Contact variables are name fields; write it per Contact, for example in contact.extra"
         });
       }
@@ -5598,35 +5874,38 @@ function checkDo(ctx, order, p, raw, usedIds) {
   const usesVariable = texts.some((t) => hasVariable(t.value));
   if (a === "invite.send") {
     const fp = `${p}.with.note_fallback`;
-    if (has(w, "note_fallback")) checkFallbackText(ctx, order, fp, w["note_fallback"], TEXT_LIMITS.invite_note, "drop");
-    else if (usesVariable) ctx.issues.push({ order, path: fp, rule: 'required because the note uses a variable: text, or "drop"' });
+    if (has(w, "note_fallback")) checkFallbackText(ctx, order, fp, `${wp}/note_fallback`, withParent, w["note_fallback"], TEXT_LIMITS.invite_note, "drop");
+    else if (usesVariable) issue(ctx, { order, code: "R19", path: fp, pointer: withParent, rule: 'required because the note uses a variable: text, or "drop"' });
   } else if (a === "inmail.send") {
     const fp = `${p}.with.fallback`;
+    const fptr = `${wp}/fallback`;
     if (has(w, "fallback")) {
       const f = w["fallback"];
       if (!isObject(f)) {
-        ctx.issues.push({ order, path: fp, rule: "must be an object with subject and text" });
+        issue(ctx, { order, code: "R19", path: fp, pointer: fptr, rule: "must be an object with subject and text" });
       } else {
         for (const k of keysOf(f)) {
-          if (k !== "subject" && k !== "text") ctx.issues.push({ order, path: `${fp}.${quote(k)}`, rule: "unknown key; a fallback holds subject and text" });
+          if (k !== "subject" && k !== "text") {
+            issue(ctx, { order, code: "R19", path: `${fp}.${quote(k)}`, pointer: `${fptr}${jsonPointer(k)}`, rule: "unknown key; a fallback holds subject and text" });
+          }
         }
-        checkFallbackText(ctx, order, `${fp}.subject`, f["subject"], TEXT_LIMITS.inmail_subject);
-        checkFallbackText(ctx, order, `${fp}.text`, f["text"], TEXT_LIMITS.inmail_text);
+        checkFallbackText(ctx, order, `${fp}.subject`, `${fptr}/subject`, fptr, f["subject"], TEXT_LIMITS.inmail_subject);
+        checkFallbackText(ctx, order, `${fp}.text`, `${fptr}/text`, fptr, f["text"], TEXT_LIMITS.inmail_text);
       }
     } else if (usesVariable) {
-      ctx.issues.push({ order, path: fp, rule: "required because the subject or text uses a variable: an object with subject and text" });
+      issue(ctx, { order, code: "R19", path: fp, pointer: withParent, rule: "required because the subject or text uses a variable: an object with subject and text" });
     }
   } else {
     const fp = `${p}.with.fallback`;
     const comment = a === "post.comment";
-    if (has(w, "fallback")) checkFallbackText(ctx, order, fp, w["fallback"], limitOf(a, "text"), comment ? "skip" : void 0);
-    else if (comment) ctx.issues.push({ order, path: fp, rule: 'required on a comment: text, or "skip"' });
-    else if (usesVariable) ctx.issues.push({ order, path: fp, rule: "required because the text uses a variable" });
+    if (has(w, "fallback")) checkFallbackText(ctx, order, fp, `${wp}/fallback`, withParent, w["fallback"], limitOf(a, "text"), comment ? "skip" : void 0);
+    else if (comment) issue(ctx, { order, code: "R19", path: fp, pointer: withParent, rule: 'required on a comment: text, or "skip"' });
+    else if (usesVariable) issue(ctx, { order, code: "R19", path: fp, pointer: withParent, rule: "required because the text uses a variable" });
   }
 }
-function checkPredicate(ctx, pred, path, order, nested = false) {
+function checkPredicate(ctx, pred, path, pointer, order, nested = false) {
   const { v } = ctx;
-  const push = (rule) => ctx.issues.push({ order, path, rule });
+  const push = (rule) => issue(ctx, { order, code: "R15", path, pointer, rule });
   if (!nested && deeperThan(pred, MAX_PREDICATE_DEPTH)) {
     push(`a predicate nests at most ${MAX_PREDICATE_DEPTH} levels`);
     return;
@@ -5639,7 +5918,7 @@ function checkPredicate(ctx, pred, path, order, nested = false) {
   const val = pred[key];
   if (key === "not") {
     if (nested) push("not cannot wrap another not");
-    else checkPredicate(ctx, val, `${path}.not`, order, true);
+    else checkPredicate(ctx, val, `${path}.not`, `${pointer}/not`, order, true);
     return;
   }
   if (key.startsWith("account.")) {
@@ -5647,6 +5926,11 @@ function checkPredicate(ctx, pred, path, order, nested = false) {
     else if (typeof val !== "boolean") push("account.premium takes true or false");
     return;
   }
+  if (key.startsWith("message.")) {
+    if (key !== "message.seen") push(`unknown predicate ${quote(key)}`);
+    else if (typeof val !== "boolean") push("message.seen takes true or false");
+    return;
+  }
   if (v.booleanPredicates.includes(key)) {
     if (typeof val !== "boolean") push(`${key} takes true or false`);
     return;
@@ -5700,11 +5984,18 @@ function graph(ctx, infos, ids, onReply) {
         return [pick("next")];
     }
   });
+  const exitPtr = (i, e) => e.fallThrough ? infos[i].ptr : `${infos[i].ptr}/${e.field}`;
   const graphIssues = [];
   infos.forEach((info, i) => {
     for (const e of edges[i]) {
       if (e.to === "off") {
-        graphIssues.push({ order: i, path: `${info.prefix}.${e.field}`, rule: `the last step must end explicitly; set ${e.field} to a step id or "end"` });
+        graphIssues.push({
+          order: i,
+          code: "R10",
+          path: `${info.prefix}.${e.field}`,
+          pointer: exitPtr(i, e),
+          rule: `the last step must end explicitly; set ${e.field} to a step id or "end"`
+        });
       }
     }
   });
@@ -5718,7 +6009,7 @@ function graph(ctx, infos, ids, onReply) {
     for (const e of edges[i]) if (typeof e.to === "number") queue.push(e.to);
   }
   infos.forEach((info, i) => {
-    if (!seen.has(i)) graphIssues.push({ order: i, path: info.prefix, rule: "unreachable: no path leads here from the first step or from on_reply" });
+    if (!seen.has(i)) graphIssues.push({ order: i, code: "R9", path: info.prefix, pointer: info.ptr, rule: "unreachable: no path leads here from the first step or from on_reply" });
   });
   const state = new Array(n).fill(0);
   const stack = [];
@@ -5729,7 +6020,7 @@ function graph(ctx, infos, ids, onReply) {
       if (typeof e.to !== "number") continue;
       if (state[e.to] === 1) {
         const rule = `cycle: ${[...stack.slice(stack.indexOf(e.to)), e.to].map((k) => infos[k].prefix).join(" -> ")}`;
-        if (!graphIssues.some((x) => x.rule === rule)) graphIssues.push({ order: i, path: `${infos[i].prefix}.${e.field}`, rule });
+        if (!graphIssues.some((x) => x.rule === rule)) graphIssues.push({ order: i, code: "R8", path: `${infos[i].prefix}.${e.field}`, pointer: exitPtr(i, e), rule });
       } else if (state[e.to] === 0) {
         dfs(e.to);
       }
@@ -5748,10 +6039,11 @@ function graph(ctx, infos, ids, onReply) {
     const jumpFrom = preds[i].filter((x) => !x.edge.fallThrough && x.from !== i - 1).map((x) => x.from);
     if (fallFrom.length && jumpFrom.length) {
       const names = (xs) => [...new Set(xs)].map((k) => infos[k].prefix).join(", ");
-      ctx.warnings.push({
+      warning(ctx, {
         order: i,
         code: "W1",
         path: info.prefix,
+        pointer: info.ptr,
         rule: `merge point: reached by fall-through from ${names(fallFrom)} and by a jump from ${names(jumpFrom)}`
       });
     }
@@ -5759,22 +6051,36 @@ function graph(ctx, infos, ids, onReply) {
   const order = topo(n, edges, roots);
   const afterInvite = new Array(n).fill(false);
   const withoutInvite = new Array(n).fill(false);
+  const withoutMessage = new Array(n).fill(false);
   const fromFirst = new Set(topo(n, edges, [0]));
-  for (const r of roots) if (r === 0 || !fromFirst.has(r)) withoutInvite[r] = true;
+  for (const r of roots) if (r === 0 || !fromFirst.has(r)) withoutInvite[r] = withoutMessage[r] = true;
   for (const i of order) {
     for (const { from, edge } of preds[i]) {
       const invited = action(from) === "invite.send" && edge.field === "next";
       if (afterInvite[from] || invited) afterInvite[i] = true;
       if (withoutInvite[from] && !invited) withoutInvite[i] = true;
+      const messaged = (action(from) === "message.send" || action(from) === "inmail.send") && edge.field === "next";
+      if (withoutMessage[from] && !messaged) withoutMessage[i] = true;
     }
   }
   infos.forEach((info, i) => {
     if (!seen.has(i)) return;
     if (action(i) === "profile.follow" && afterInvite[i]) {
-      ctx.warnings.push({ order: i, code: "W5", path: `${info.prefix}.do`, rule: "profile.follow after invite.send on the same path; an invitation already follows" });
+      warning(ctx, { order: i, code: "W5", path: `${info.prefix}.do`, pointer: `${info.ptr}/do`, rule: "profile.follow after invite.send on the same path; an invitation already follows" });
+    }
+    const cond = info.raw["if"];
+    const seenPred = isObject(cond) && (has(cond, "message.seen") || isObject(cond["not"]) && has(cond["not"], "message.seen"));
+    if (seenPred && withoutMessage[i]) {
+      warning(ctx, {
+        order: i,
+        code: "W12",
+        path: `${info.prefix}.if`,
+        pointer: `${info.ptr}/if`,
+        rule: "if message.seen on a path with no message.send or inmail.send before it; it is always false there"
+      });
     }
     if (info.raw["until"] === "invite.accepted" && withoutInvite[i]) {
-      ctx.warnings.push({ order: i, code: "W6", path: `${info.prefix}.until`, rule: "until invite.accepted on a path with no invite.send before it" });
+      warning(ctx, { order: i, code: "W6", path: `${info.prefix}.until`, pointer: `${info.ptr}/until`, rule: "until invite.accepted on a path with no invite.send before it" });
     }
   });
   const flagged = /* @__PURE__ */ new Set();
@@ -5791,7 +6097,7 @@ function graph(ctx, infos, ids, onReply) {
         if (!flagged.has(k)) {
           flagged.add(k);
           const link = messageTexts(infos[k]).find((t) => t.value.includes("http"));
-          if (link) ctx.warnings.push({ order: k, code: "W8", path: link.path, rule: "a link in the first message after the invitation is accepted" });
+          if (link) warning(ctx, { order: k, code: "W8", path: link.path, pointer: link.pointer, rule: "a link in the first message after the invitation is accepted" });
         }
         continue;
       }
@@ -5807,12 +6113,12 @@ function messageTexts(info) {
     raw["variants"].forEach((variant, j) => {
       if (isObject(variant) && typeof variant["text"] === "string") {
         const id = typeof variant["id"] === "string" ? `variants.${variant["id"]}` : `variants[${j}]`;
-        out.push({ path: `${info.prefix}.${id}.text`, value: variant["text"] });
+        out.push({ path: `${info.prefix}.${id}.text`, pointer: `${info.ptr}/variants/${j}/text`, value: variant["text"] });
       }
     });
   }
-  if (typeof w["text"] === "string") out.push({ path: `${info.prefix}.with.text`, value: w["text"] });
-  if (typeof w["fallback"] === "string") out.push({ path: `${info.prefix}.with.fallback`, value: w["fallback"] });
+  if (typeof w["text"] === "string") out.push({ path: `${info.prefix}.with.text`, pointer: `${info.ptr}/with/text`, value: w["text"] });
+  if (typeof w["fallback"] === "string") out.push({ path: `${info.prefix}.with.fallback`, pointer: `${info.ptr}/with/fallback`, value: w["fallback"] });
   return out;
 }
 function topo(n, edges, roots) {
@@ -5880,7 +6186,7 @@ var _Sequence = class _Sequence {
    * Appends steps in order: constructor output or object literals.
    *
    * @example
-   * const next = seq.add(step.wait("pause", "2d"), step.emit("done", "sequence.done", { next: "end" }));
+   * const next = seq.add(step.wait("pause", "2d"), step.tag("done", "sequence-done", { event: "sequence_done", next: "end" }));
    */
   add(...steps) {
     return __privateMethod(this, _Sequence_instances, with_fn).call(this, [...__privateGet(this, _doc).steps, ...clone(steps)]);
@@ -6029,7 +6335,10 @@ var MotionsResource = class {
    * Change a Motion. Objects (`schedule`, `settings`) merge by key; arrays,
    * `where` and `sequence` replace whole; `null` clears. `sequence` takes a
    * builder or a document, as in `create`. After start, a structural Sequence
-   * change makes a new version; running Enrollments keep theirs.
+   * change makes a new version; running Enrollments keep theirs. Send
+   * `if_sequence_revision` (the `sequence_revision` you read) to refuse the
+   * save when someone saved the Sequence since: `SEQUENCE_CONFLICT`, nothing
+   * saved, the stored document in `err.current`. Omitted: the last write wins.
    * `PATCH /v1/motions/{id}`
    *
    * Needs Automate: a Team below that Tier is refused with `TIER_REQUIRED`.
@@ -6038,6 +6347,7 @@ var MotionsResource = class {
    * const motion = await curviate.motions.get("mot_123");
    * await curviate.motions.update("mot_123", {
    *   sequence: Sequence.fromDocument(motion.sequence).replace("pause", step.wait("pause", "3d", { next: "end" })),
+   *   if_sequence_revision: motion.sequence_revision,
    * });
    */
   async update(motionId, body) {
@@ -6172,15 +6482,22 @@ var EnrollmentsResource = class {
   }
   /**
    * List Enrollments, newest first. Filters: `motion_id`, `contact_id`,
-   * `account_id`, `status` (any of them), `step_id`. Pages with an opaque
-   * `cursor` until it is `null`.
+   * `account_id`, `status` (any of them), `step_id` (at that Step now),
+   * `version`; by Step outcome: `done_step` with `outcome` (how that Step
+   * ended), `reason` (catalogue codes, any of them), `variant_id`,
+   * `relationship_at_enrollment` (any of them). Pages with an opaque `cursor`
+   * until it is `null`.
    * `GET /v1/enrollments`
    *
    * @example
-   * const { items } = await curviate.enrollments.list({ motion_id: "mot_123", status: ["active"] });
+   * const { items } = await curviate.enrollments.list({ motion_id: "mot_123", done_step: "opener", outcome: "failed" });
    */
   list(params) {
-    return this.ctx.request({ method: "GET", path: "/v1/enrollments", query: commaLists(params, "status") });
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/enrollments",
+      query: commaLists(params, "status", "reason", "relationship_at_enrollment")
+    });
   }
   /**
    * One Enrollment with its `history` of Steps (metadata only, no rendered
@@ -6205,29 +6522,131 @@ var EnrollmentsResource = class {
     return this.ctx.request({ method: "POST", path: apiPath`/v1/enrollments/${enrollmentId}/stop` });
   }
   /**
-   * Continue an Enrollment at Step `at` of its Sequence version, `on_reply`
-   * re-armed: the out-of-office path. Works on `active`, `paused` and most
-   * `finished` Enrollments; else `ENROLLMENT_NOT_ACTIVE`.
+   * Hold one `pending`, `active` or `paused` Enrollment until you `resume` it
+   * (`waiting.kind: "paused_by_user"`); its waits freeze. A Step being sent
+   * right now is `STEP_IN_FLIGHT`: retry in a minute. Works on every plan.
+   * `POST /v1/enrollments/{id}/pause`
+   *
+   * @example
+   * await curviate.enrollments.pause("enr_123");
+   */
+  pause(enrollmentId) {
+    return this.ctx.request({ method: "POST", path: apiPath`/v1/enrollments/${enrollmentId}/pause` });
+  }
+  /**
+   * Without `at`: lift your own pause; the Enrollment continues where it was,
+   * with the time its wait had left. With `at`: an explicit jump to that Step
+   * of its Sequence version, `on_reply` re-armed (the out-of-office path).
+   * The jump is not guarded: it re-enters the Step you name even when that
+   * Step already sent, so a message can go out again. To retry a failed Step,
+   * use `enrollments.retry(id)`, which acts only on a failure. Works on
+   * `active`, `paused` and most `finished` Enrollments; else
+   * `ENROLLMENT_NOT_ACTIVE`.
    * `POST /v1/enrollments/{id}/resume`
    *
    * Needs Automate: a Team below that Tier is refused with `TIER_REQUIRED`.
    *
    * @example
-   * await curviate.enrollments.resume("enr_123", { at: "bump" });
+   * await curviate.enrollments.resume("enr_123"); // lift your pause
+   * await curviate.enrollments.resume("enr_123", { at: "bump" }); // jump to a Step after an out-of-office reply
    */
   resume(enrollmentId, body) {
     return this.ctx.request({ method: "POST", path: apiPath`/v1/enrollments/${enrollmentId}/resume`, body });
   }
   /**
-   * Send the signal a Step waits for (`until signal.<name>`), on an `active`
-   * or `paused` Enrollment. A name no Step of its version awaits is
-   * `INVALID_REQUEST`, listing the awaited names.
+   * Send a custom event to an `active` or `paused` Enrollment whose Sequence
+   * waits for it (`until event.<name>`), for example once your agent wrote
+   * the researched text to the Contact's custom fields. Input only: fires no
+   * webhook. A name no Step of its version awaits is `INVALID_REQUEST`,
+   * listing the awaited names.
+   * `POST /v1/enrollments/{id}/events`
+   *
+   * Needs Automate: a Team below that Tier is refused with `TIER_REQUIRED`.
+   *
+   * @example
+   * await curviate.enrollments.events("enr_123", { name: "research_ready" });
+   */
+  events(enrollmentId, body) {
+    return this.ctx.request({ method: "POST", path: apiPath`/v1/enrollments/${enrollmentId}/events`, body });
+  }
+  /**
+   * Move an Enrollment to another sending account of its Motion; it restarts
+   * there at the first Step of its Sequence version (one you paused stays
+   * paused until you resume it). `warnings` names each Step that will be
+   * skipped. Refused, nothing changed, with `ACCOUNT_ALREADY_ENGAGED` (its
+   * account already contacted the person beyond a profile view),
+   * `ALREADY_ENROLLED_ON_ACCOUNT`, `KNOWN_CHAT` or `STEP_IN_FLIGHT`.
+   * `POST /v1/enrollments/{id}/reassign`
+   *
+   * Needs Automate: a Team below that Tier is refused with `TIER_REQUIRED`.
+   *
+   * @example
+   * const { warnings } = await curviate.enrollments.reassign("enr_123", { account_id: "acc_456" });
+   */
+  reassign(enrollmentId, body) {
+    return this.ctx.request({ method: "POST", path: apiPath`/v1/enrollments/${enrollmentId}/reassign`, body });
+  }
+  /**
+   * Pause, resume, stop, retry, send an event to or reassign up to 1,000
+   * Enrollments, by `ids` or by a `filter` of the list's fields (`motion_id`
+   * required). Each is decided alone, as its single call would be, with its
+   * own result (`ok`, or `error` with that call's code; a server error on one
+   * is `INTERNAL` for it); not atomic. List with the same filter to see the
+   * matches first. Below Automate only `pause` and `stop` run.
+   * `POST /v1/enrollments/bulk`
+   *
+   * @example
+   * const { results } = await curviate.enrollments.bulk({
+   *   action: "retry",
+   *   filter: { motion_id: "mot_123", done_step: "opener", outcome: "failed" },
+   * });
+   */
+  bulk(body) {
+    return this.ctx.request({ method: "POST", path: "/v1/enrollments/bulk", body });
+  }
+  /**
+   * Retry the failed Step of one Enrollment: the guarded Retry. It acts only
+   * while that Step's latest outcome is `failed`, so a repeated or looped
+   * call never sends a delivered message again. Resolves with the
+   * Enrollment's result when it was resumed; otherwise throws its refusal as
+   * a `CurviateError` (`NOTHING_TO_RETRY` when nothing failed,
+   * `STEP_IN_FLIGHT`, `ENROLLMENT_NOT_ACTIVE`, `RESOURCE_NOT_FOUND`, ...),
+   * with no `httpStatus`. Sent as `bulk` with this one id.
+   * `POST /v1/enrollments/bulk`
+   *
+   * Needs Automate: a Team below that Tier is refused with `TIER_REQUIRED`.
+   *
+   * @example
+   * try {
+   *   await curviate.enrollments.retry("enr_123");
+   * } catch (err) {
+   *   if (isCurviateError(err) && err.code === "NOTHING_TO_RETRY") console.log("nothing failed");
+   * }
+   */
+  async retry(enrollmentId) {
+    const res = await this.bulk({ action: "retry", ids: [enrollmentId] });
+    const item = res.results[0];
+    if (item?.outcome === "ok") return item;
+    const known = item?.error && KNOWN_ERROR_CODES.has(item.error.code);
+    const code = known ? item.error.code : "INTERNAL";
+    throw new CurviateError({
+      code,
+      message: item?.error?.message ?? `No retry result for ${enrollmentId}.`,
+      userFixable: false,
+      retryLikelyToSucceed: code === "STEP_IN_FLIGHT"
+    });
+  }
+  /**
+   * Deprecated alias of {@link EnrollmentsResource.events}, answered the same
+   * plus a `Deprecation` header and warning W13; accepted until 2027-01-19.
    * `POST /v1/enrollments/{id}/signal`
    *
    * Needs Automate: a Team below that Tier is refused with `TIER_REQUIRED`.
    *
+   * @deprecated Use `enrollments.events`; `signal` stops working on 2027-01-19.
+   *
    * @example
-   * await curviate.enrollments.signal("enr_123", { name: "demo_booked" });
+   * await curviate.enrollments.events("enr_123", { name: "demo_booked" }); // instead of signal
    */
   signal(enrollmentId, body) {
     return this.ctx.request({ method: "POST", path: apiPath`/v1/enrollments/${enrollmentId}/signal`, body });
@@ -7868,6 +8287,42 @@ var step = {
   tag: (id, name, fields) => build(id, "tag", name, fields)
 };
 
+// src/sequence/ids.ts
+var ID_BASE = {
+  "profile.view": "visit",
+  "profile.follow": "follow",
+  "profile.unfollow": "unfollow",
+  "invite.send": "invite",
+  "invite.withdraw": "withdraw",
+  "message.send": "message",
+  "inmail.send": "inmail",
+  "post.react": "like",
+  "post.comment": "comment",
+  "skill.endorse": "endorse",
+  wait: "wait",
+  until: "accepted",
+  if: "check",
+  emit: "event",
+  tag: "tag"
+};
+var MAX_ID = 40;
+var idOf = (v) => isObject(v) && typeof v["id"] === "string" ? v["id"] : null;
+var fit = (stem, suffix) => stem.slice(0, MAX_ID - suffix.length) + suffix;
+function newStepId(doc, kind, beforeId) {
+  const taken = /* @__PURE__ */ new Set();
+  for (const s of isObject(doc) && Array.isArray(doc["steps"]) ? doc["steps"] : []) {
+    const id = idOf(s);
+    if (id) taken.add(id);
+    const vs = isObject(s) ? s["variants"] : void 0;
+    if (Array.isArray(vs)) {
+      for (const v of vs) if (idOf(v)) taken.add(idOf(v));
+    }
+  }
+  const base = kind === "wait" && beforeId !== void 0 ? `w_${beforeId}` : ID_BASE[kind];
+  if (!taken.has(fit(base, ""))) return fit(base, "");
+  for (let n = 2; ; n++) if (!taken.has(fit(base, `_${n}`))) return fit(base, `_${n}`);
+}
+
 // src/webhooks.ts
 var WebhookSignatureError = class _WebhookSignatureError extends Error {
   constructor(reason, message) {
@@ -8012,6 +8467,7 @@ export {
   WebhookSignatureError,
   constructEvent,
   isCurviateError,
+  newStepId,
   step,
   validateSequence
 };