@ykurilov/agent-chat-flows 0.0.0-stage → 0.55.0

package/dist/chunk-BOV6FJGU.js

@@ -0,0 +1,1288 @@
+// src/format/flow-format.ts
+var AGENT_FLOW_FORMAT = "agent-flow";
+var AGENT_FLOW_FORMAT_VERSION = 2;
+var RETURN_TARGET = "@return";
+var ANY_STATE_LAYOUT_KEY = "@any";
+var FLOW_FIELD_TYPES = ["text", "number", "choice", "boolean"];
+var FLOW_DATA_OPS = ["filled", "eq", "ne", "gt", "lt", "contains"];
+var FLOW_OPS_BY_FIELD_TYPE = {
+  text: ["filled", "contains"],
+  number: ["filled", "eq", "gt", "lt"],
+  choice: ["filled", "eq"],
+  boolean: ["filled", "eq", "ne"]
+};
+var FLOW_EVENT_TYPES = ["message", "button", "tool", "app"];
+var FLOW_TIMER_UNITS = ["min", "h", "d"];
+var FLOW_TIMER_SPANS = ["in_state", "silence", "since_start"];
+var DEFAULT_LATE_START_HOURS = 3;
+var DEFAULT_SIDE_TASK_MAX_ATTEMPTS = 2;
+var FLOW_AFTER_END_MODES = ["reply", "silent"];
+
+// src/format/flow-schema.ts
+import { z } from "zod";
+var id = z.string().min(1);
+var names = z.array(z.string()).default([]);
+var clock = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "\u0412\u0440\u0435\u043C\u044F \u0441\u0443\u0442\u043E\u043A \u043F\u0438\u0448\u0435\u0442\u0441\u044F \u043A\u0430\u043A \xAB\u0427\u0427:\u041C\u041C\xBB, \u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440 \xAB10:00\xBB.");
+var fieldShape = {
+  id,
+  name: z.string(),
+  about: z.string().default(""),
+  type: z.enum(FLOW_FIELD_TYPES).default("text"),
+  options: names
+};
+var flowField = z.strictObject(fieldShape);
+var clientCardField = z.strictObject({
+  ...fieldShape,
+  refreshAfterMonths: z.int().positive().nullable().default(null)
+});
+var judgeCondition = z.strictObject({ type: z.literal("judge"), text: z.string() });
+var dataCondition = z.strictObject({
+  type: z.literal("data"),
+  field: id,
+  op: z.enum(FLOW_DATA_OPS).default("filled"),
+  value: z.union([z.string(), z.number(), z.boolean()]).optional()
+}).superRefine((condition, context) => {
+  if (condition.op !== "filled" && condition.value === void 0) {
+    context.addIssue({ code: "custom", path: ["value"], message: "\u0414\u043B\u044F \u0441\u0440\u0430\u0432\u043D\u0435\u043D\u0438\u044F \u043D\u0443\u0436\u043D\u043E \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 `value`." });
+  }
+});
+var eventCondition = z.strictObject({
+  type: z.literal("event"),
+  event: z.enum(FLOW_EVENT_TYPES),
+  name: z.string().optional()
+});
+var timerCondition = z.discriminatedUnion("from", [
+  z.strictObject({
+    type: z.literal("timer"),
+    from: z.enum(FLOW_TIMER_SPANS),
+    amount: z.number().positive(),
+    unit: z.enum(FLOW_TIMER_UNITS)
+  }),
+  z.strictObject({ type: z.literal("timer"), from: z.literal("time_of_day"), at: clock }),
+  // `days` < 1 — не ошибка формы: недописанный сценарий сохраняется, находку показывает `checkFlow`.
+  z.strictObject({ type: z.literal("timer"), from: z.literal("state_days"), days: z.int() }),
+  // Дробный и меньше 1 — тоже находка `checkFlow`.
+  z.strictObject({ type: z.literal("timer"), from: z.literal("program_day"), day: z.number() })
+]);
+var duration = z.strictObject({ amount: z.number().positive(), unit: z.enum(FLOW_TIMER_UNITS) });
+var nudges = z.strictObject({
+  afterSilence: z.array(duration),
+  dailyAt: z.array(clock).optional(),
+  giveUpAfter: duration.optional()
+});
+var schedule = z.strictObject({
+  dayStart: clock,
+  nightFrom: clock.optional(),
+  lateStartHours: z.number().min(0).max(24).default(DEFAULT_LATE_START_HOURS),
+  lengthDays: z.int().min(1).max(60).optional(),
+  deadlineState: z.string().optional(),
+  farewellOnDeadline: z.boolean().default(false),
+  farewellText: z.string().optional(),
+  firstMessages: z.strictObject({
+    maxPerDay: z.int().min(0).optional(),
+    morning: z.boolean().optional(),
+    skipMorningIfHumanWithinMin: z.int().min(0).optional()
+  }).optional(),
+  nudges: nudges.optional(),
+  dayFrame: z.strictObject({ softFrom: z.int().positive().optional(), hardAt: z.int().positive().optional(), hardText: z.string().optional() }).optional()
+});
+var sideTask = z.strictObject({
+  id,
+  text: z.string(),
+  when: z.string().optional(),
+  field: z.string().optional(),
+  maxAttempts: z.int().positive().default(DEFAULT_SIDE_TASK_MAX_ATTEMPTS),
+  perConversation: z.boolean().default(false)
+});
+var flowCondition = z.discriminatedUnion("type", [judgeCondition, dataCondition, eventCondition, timerCondition]);
+var flowExit = z.strictObject({ id, when: flowCondition, to: z.string().nullable().default(null) });
+var exits = z.array(flowExit).default([]);
+var flowState = z.strictObject({
+  id,
+  kind: z.literal("state").default("state"),
+  title: z.string().default(""),
+  instructions: z.string().default(""),
+  firstMessage: z.string().nullable().default(null),
+  learn: names,
+  noSideQuestions: z.boolean().default(false),
+  tools: names,
+  tags: names,
+  exits,
+  nudges: z.union([nudges.extend({ days: z.number().optional() }), z.literal("off")]).optional()
+});
+var DEFAULT_SIDE_QUESTION_EVERY_MESSAGES = 5;
+var agentFlowSchema = z.strictObject({
+  $schema: z.string().optional(),
+  format: z.literal(AGENT_FLOW_FORMAT),
+  version: z.literal(AGENT_FLOW_FORMAT_VERSION),
+  id,
+  name: z.string(),
+  start: z.string().nullable().default(null),
+  common: z.string().default(""),
+  pace: z.strictObject({ sideQuestionEveryMessages: z.int().positive().default(DEFAULT_SIDE_QUESTION_EVERY_MESSAGES) }).default({ sideQuestionEveryMessages: DEFAULT_SIDE_QUESTION_EVERY_MESSAGES }),
+  clientCard: z.array(clientCardField).default([]),
+  chatNotes: z.array(flowField).default([]),
+  tools: names,
+  anyState: z.strictObject({ except: names, exits }).default({ except: [], exits: [] }),
+  states: z.array(flowState),
+  layout: z.record(z.string(), z.strictObject({ x: z.number(), y: z.number() })).default({}),
+  schedule: schedule.optional(),
+  nudges: nudges.optional(),
+  sideTasks: z.array(sideTask).optional(),
+  afterEnd: z.enum(FLOW_AFTER_END_MODES).optional()
+}).transform(({ $schema: _schema, ...flow }) => flow);
+
+// src/format/migrate-flow.ts
+var FORMAT_STEPS = {
+  // 1 → 2: новые поля («Дни и время», касания, «нода длится», «да/нет», попутные задачи) необязательные,
+  // без них сценарий ведёт себя как в версии 1. Меняется только номер версии.
+  1: (flow) => flow
+};
+function migrateFlow(flow, from) {
+  let current = flow;
+  for (let version = from; version < AGENT_FLOW_FORMAT_VERSION; version += 1) {
+    const step = FORMAT_STEPS[version];
+    if (!step) throw new Error(`\u041D\u0435\u0442 \u0448\u0430\u0433\u0430 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u0430 \u0444\u043E\u0440\u043C\u0430\u0442\u0430 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u0441 \u0432\u0435\u0440\u0441\u0438\u0438 ${version}.`);
+    current = { ...step(current), version: version + 1 };
+  }
+  return current;
+}
+
+// src/format/parse-flow.ts
+import { z as z2 } from "zod";
+var russianMessages = z2.locales.ru().localeError;
+var OTHERWISE_REMOVED = "\u0423\u0441\u043B\u043E\u0432\u0438\u044F \xAB\u0438\u043D\u0430\u0447\u0435\xBB \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435\u0442 (\u043F\u043E\u043B\u0435 `otherwise`): \u0435\u0441\u043B\u0438 \u043D\u0438 \u043E\u0434\u043D\u043E \u0443\u0441\u043B\u043E\u0432\u0438\u0435 \u043D\u0435 \u0441\u0440\u0430\u0431\u043E\u0442\u0430\u043B\u043E, \u0430\u0433\u0435\u043D\u0442 \u043E\u0441\u0442\u0430\u0451\u0442\u0441\u044F \u0432 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0438. \u041E\u0431\u0449\u0435\u0435 \u0434\u043B\u044F \u0432\u0441\u0435\u0445 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0439 \u2014 \u0446\u0435\u043D\u044B, \u0443\u0441\u043B\u043E\u0432\u0438\u044F, \u0442\u043E\u043D \u2014 \u043F\u0438\u0448\u0435\u0442\u0441\u044F \u0432 `common`.";
+function parseFlow(input) {
+  let json = input;
+  if (typeof input === "string") {
+    try {
+      json = JSON.parse(input);
+    } catch (error) {
+      return failure("", `\u042D\u0442\u043E \u043D\u0435 JSON: ${error.message}`);
+    }
+  }
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    return failure("", "\u0421\u0446\u0435\u043D\u0430\u0440\u0438\u0439 \u2014 \u044D\u0442\u043E \u043E\u0431\u044A\u0435\u043A\u0442 JSON.");
+  }
+  const raw = json;
+  if (raw.format !== AGENT_FLOW_FORMAT) {
+    return failure("format", `\u042D\u0442\u043E \u043D\u0435 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439 agent-flow: \u0443 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043F\u043E\u043B\u0435 "format": "${AGENT_FLOW_FORMAT}".`);
+  }
+  const version = raw.version;
+  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) {
+    return failure("version", "\u041D\u043E\u043C\u0435\u0440 \u0432\u0435\u0440\u0441\u0438\u0438 \u0444\u043E\u0440\u043C\u0430\u0442\u0430 (`version`) \u2014 \u0446\u0435\u043B\u043E\u0435 \u0447\u0438\u0441\u043B\u043E \u043E\u0442 1.");
+  }
+  if (version > AGENT_FLOW_FORMAT_VERSION) {
+    return failure(
+      "version",
+      `\u0421\u0446\u0435\u043D\u0430\u0440\u0438\u0439 \u0437\u0430\u043F\u0438\u0441\u0430\u043D \u0432 \u0432\u0435\u0440\u0441\u0438\u0438 \u0444\u043E\u0440\u043C\u0430\u0442\u0430 ${version}, \u0430 \u044D\u0442\u043E\u0442 SDK \u0437\u043D\u0430\u0435\u0442 \u0432\u0435\u0440\u0441\u0438\u0438 \u0434\u043E ${AGENT_FLOW_FORMAT_VERSION}: \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u0435 SDK.`
+    );
+  }
+  const parsed = agentFlowSchema.safeParse(migrateFlow(raw, version), { error: russianMessages });
+  if (parsed.success) return { ok: true, flow: parsed.data };
+  return { ok: false, errors: parsed.error.issues.flatMap(formatIssue) };
+}
+function formatIssue(issue) {
+  if (issue.code === "unrecognized_keys") {
+    return issue.keys.map((key) => ({
+      path: formatPath([...issue.path, key]),
+      message: key === "otherwise" ? OTHERWISE_REMOVED : `\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u043E\u0435 \u043F\u043E\u043B\u0435 \xAB${key}\xBB.`
+    }));
+  }
+  if (issue.code === "invalid_union" && issue.discriminator) {
+    const options = issue.options ?? [];
+    const known = options.map((option) => `\xAB${String(option)}\xBB`).join(", ");
+    return [{ path: formatPath(issue.path), message: `\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u043F\u043E\u043B\u044F \xAB${issue.discriminator}\xBB. \u041C\u043E\u0436\u043D\u043E: ${known}.` }];
+  }
+  return [{ path: formatPath(issue.path), message: issue.message }];
+}
+function formatPath(path) {
+  return path.reduce((text, key) => {
+    if (typeof key === "number") return `${text}[${key}]`;
+    return text ? `${text}.${String(key)}` : String(key);
+  }, "");
+}
+function failure(path, message) {
+  return { ok: false, errors: [{ path, message }] };
+}
+
+// src/format/catalog-events.ts
+function catalogEventNames(catalog) {
+  return catalog.events.map((event) => typeof event === "string" ? event : event.name);
+}
+function catalogEventLabel(catalog, name) {
+  const found = catalog?.events.find((event) => typeof event !== "string" && event.name === name);
+  return typeof found === "object" ? found.label?.trim() || void 0 : void 0;
+}
+
+// src/format/compact-flow.ts
+function compactFlow(flow) {
+  return withoutEmpty({
+    format: flow.format,
+    version: flow.version,
+    id: flow.id,
+    name: flow.name,
+    start: flow.start,
+    common: flow.common,
+    pace: flow.pace.sideQuestionEveryMessages === DEFAULT_SIDE_QUESTION_EVERY_MESSAGES ? void 0 : { sideQuestionEveryMessages: flow.pace.sideQuestionEveryMessages },
+    clientCard: flow.clientCard.map(compactField),
+    chatNotes: flow.chatNotes.map(compactField),
+    tools: flow.tools,
+    anyState: flow.anyState.except.length || flow.anyState.exits.length ? withoutEmpty({ except: flow.anyState.except, exits: flow.anyState.exits.map(compactExit) }) : void 0,
+    states: flow.states.map(compactState),
+    layout: Object.keys(flow.layout).length ? flow.layout : void 0,
+    schedule: flow.schedule && compactSchedule(flow.schedule),
+    nudges: flow.nudges,
+    sideTasks: flow.sideTasks?.map(compactSideTask),
+    afterEnd: flow.afterEnd
+  }, ["states"]);
+}
+function compactSchedule(schedule2) {
+  return withoutEmpty({
+    ...schedule2,
+    lateStartHours: schedule2.lateStartHours === DEFAULT_LATE_START_HOURS ? void 0 : schedule2.lateStartHours,
+    farewellOnDeadline: schedule2.farewellOnDeadline || void 0
+  });
+}
+function compactSideTask(task) {
+  return withoutEmpty({
+    ...task,
+    maxAttempts: task.maxAttempts === DEFAULT_SIDE_TASK_MAX_ATTEMPTS ? void 0 : task.maxAttempts,
+    perConversation: task.perConversation || void 0
+  });
+}
+function compactField(field) {
+  return withoutEmpty({ ...field, type: field.type === "text" ? void 0 : field.type });
+}
+function compactState(state) {
+  return withoutEmpty({
+    ...state,
+    kind: state.kind === "state" ? void 0 : state.kind,
+    noSideQuestions: state.noSideQuestions || void 0,
+    exits: state.exits.map(compactExit)
+  });
+}
+function compactExit(exit) {
+  const when = exit.when.type === "data" && exit.when.op === "filled" ? { ...exit.when, op: void 0 } : exit.when;
+  return withoutEmpty({ id: exit.id, when: withoutEmpty(when), to: exit.to });
+}
+function withoutEmpty(object, keep = []) {
+  return Object.fromEntries(
+    Object.entries(object).filter(([key, value]) => {
+      if (keep.includes(key)) return true;
+      if (value === void 0 || value === null || value === "") return false;
+      return !(Array.isArray(value) && value.length === 0);
+    })
+  );
+}
+
+// src/engine/flow-run.ts
+var FLOW_STATE_KEY = "flow";
+var FLOW_PATH_LIMIT = 50;
+var FLOW_CHAIN_LIMIT = 5;
+var DEFAULT_FIRST_MESSAGES = {
+  quietHours: { from: "21:00", to: "09:00" },
+  maxPerDay: 3
+};
+
+// src/engine/flow-graph.ts
+function stateById(flow, id2) {
+  return id2 === null ? void 0 : flow.states.find((state) => state.id === id2);
+}
+function isFinal(state) {
+  return state.exits.length === 0;
+}
+function isTouch(state) {
+  return state.exits.some((exit) => exit.to === RETURN_TARGET);
+}
+function commonApplies(flow, state) {
+  return !isFinal(state) && !flow.anyState.except.includes(state.id);
+}
+function activeExits(flow, state) {
+  const own = state.exits.map((exit) => ({ exit, own: true }));
+  if (!commonApplies(flow, state)) return own;
+  const common = flow.anyState.exits.filter((exit) => exit.to !== state.id).map((exit) => ({ exit, own: false }));
+  return [...own, ...common];
+}
+function fieldById(flow, id2) {
+  const card = flow.clientCard.find((field) => field.id === id2);
+  if (card) return { field: card, place: "card" };
+  const note = flow.chatNotes.find((field) => field.id === id2);
+  return note ? { field: note, place: "notes" } : void 0;
+}
+function sameText(left, right) {
+  return left.trim().toLocaleLowerCase() === right.trim().toLocaleLowerCase();
+}
+
+// src/engine/data-conditions.ts
+function fitsType(type, value) {
+  if (type === "number") return typeof value === "number" && Number.isFinite(value);
+  if (type === "boolean") return typeof value === "boolean";
+  return typeof value === "string" && value.trim() !== "";
+}
+var YES_WORDS = /* @__PURE__ */ new Set(["\u0434\u0430", "yes", "true"]);
+var NO_WORDS = /* @__PURE__ */ new Set(["\u043D\u0435\u0442", "no", "false"]);
+function parseBooleanAnswer(raw) {
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw !== "string") return void 0;
+  const word = raw.trim().toLocaleLowerCase().replace(/[.!\s]+$/u, "");
+  if (YES_WORDS.has(word)) return true;
+  return NO_WORDS.has(word) ? false : void 0;
+}
+function fieldValueFits(field, value) {
+  if (!fitsType(field.type, value)) return false;
+  if (field.type !== "choice" || field.options.length === 0) return true;
+  return field.options.some((option) => sameText(option, value));
+}
+function dataConditionHolds(condition, fieldType, value) {
+  if (!FLOW_OPS_BY_FIELD_TYPE[fieldType].includes(condition.op)) return false;
+  if (!fitsType(fieldType, value)) return false;
+  const expected = condition.value;
+  switch (condition.op) {
+    case "filled":
+      return true;
+    case "eq":
+      if (fieldType === "number" || fieldType === "boolean") return value === expected;
+      return typeof expected === "string" && sameText(value, expected);
+    case "ne":
+      return typeof expected === "boolean" && value !== expected;
+    case "gt":
+      return typeof expected === "number" && value > expected;
+    case "lt":
+      return typeof expected === "number" && value < expected;
+    case "contains":
+      return typeof expected === "string" && expected.trim() !== "" && value.toLocaleLowerCase().includes(expected.trim().toLocaleLowerCase());
+  }
+}
+
+// src/engine/targets.ts
+function returnTarget(flow, run) {
+  for (let index = run.path.length - 1; index >= 0; index -= 1) {
+    const id2 = run.path[index].state;
+    if (id2 === run.state) continue;
+    const state = stateById(flow, id2);
+    if (state && !isTouch(state)) return state;
+  }
+  return stateById(flow, flow.start);
+}
+function exitTarget(flow, run, to) {
+  if (to === null) return void 0;
+  if (to !== RETURN_TARGET) {
+    const state2 = stateById(flow, to);
+    return state2 ? { state: state2, returned: false } : void 0;
+  }
+  const state = returnTarget(flow, run);
+  return state && state.id !== run.state ? { state, returned: true } : void 0;
+}
+
+// src/engine/zoned-time.ts
+var formatters = /* @__PURE__ */ new Map();
+function formatterFor(timeZone) {
+  let formatter = formatters.get(timeZone);
+  if (!formatter) {
+    const options = {
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric",
+      hourCycle: "h23"
+    };
+    try {
+      formatter = new Intl.DateTimeFormat("en-US", { ...options, timeZone });
+    } catch {
+      formatter = new Intl.DateTimeFormat("en-US", { ...options, timeZone: "UTC" });
+    }
+    formatters.set(timeZone, formatter);
+  }
+  return formatter;
+}
+function zonedParts(at, timeZone) {
+  const parts = {};
+  for (const part of formatterFor(timeZone).formatToParts(at)) {
+    if (part.type !== "literal") parts[part.type] = Number(part.value);
+  }
+  return {
+    year: parts.year,
+    month: parts.month,
+    day: parts.day,
+    hour: parts.hour % 24,
+    minute: parts.minute,
+    second: parts.second
+  };
+}
+function offsetAt(at, timeZone) {
+  const parts = zonedParts(at, timeZone);
+  const wall = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+  return wall - Math.floor(at / 1e3) * 1e3;
+}
+function zonedTime(date, minutes, timeZone) {
+  const wall = Date.UTC(date.year, date.month - 1, date.day, 0, minutes);
+  const first = wall - offsetAt(wall, timeZone);
+  const second = wall - offsetAt(first, timeZone);
+  return second;
+}
+function nextDate(date, days = 1) {
+  const moved = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+  return { year: moved.getUTCFullYear(), month: moved.getUTCMonth() + 1, day: moved.getUTCDate() };
+}
+function parseClock(clock2) {
+  const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(clock2);
+  return match ? Number(match[1]) * 60 + Number(match[2]) : null;
+}
+function clockMinutes(at, timeZone) {
+  const parts = zonedParts(at, timeZone);
+  return parts.hour * 60 + parts.minute;
+}
+function nextClockTime(after, minutes, timeZone) {
+  let date = zonedParts(after, timeZone);
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const candidate = zonedTime(date, minutes, timeZone);
+    if (candidate > after) return candidate;
+    date = nextDate(date);
+  }
+  return zonedTime(date, minutes, timeZone);
+}
+function startOfNextDay(at, timeZone) {
+  return zonedTime(nextDate(zonedParts(at, timeZone)), 0, timeZone);
+}
+function localDay(at, timeZone) {
+  const { year, month, day } = zonedParts(at, timeZone);
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+
+// src/engine/flow-days.ts
+var DAY_MINUTES = 24 * 60;
+var DAY_MS = 864e5;
+var dayStartMinutes = (schedule2) => parseClock(schedule2.dayStart) ?? 0;
+var nightMinutes = (schedule2) => parseClock(schedule2.nightFrom ?? DEFAULT_FIRST_MESSAGES.quietHours.from) ?? 0;
+var dateKey = ({ year, month, day }) => `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+var dateOf = (key) => {
+  const [year, month, day] = key.split("-").map(Number);
+  return { year, month, day };
+};
+var shiftDate = (key, days) => dateKey(nextDate(dateOf(key), days));
+var daysBetween = (from, to) => {
+  const [a, b] = [dateOf(from), dateOf(to)];
+  return Math.round((Date.UTC(b.year, b.month - 1, b.day) - Date.UTC(a.year, a.month - 1, a.day)) / DAY_MS);
+};
+var later = (a, b) => a > b ? a : b;
+var eveningNight = (schedule2) => nightMinutes(schedule2) > dayStartMinutes(schedule2);
+function dayOf(at, timeZone, schedule2) {
+  const today = localDay(at, timeZone);
+  return eveningNight(schedule2) && clockMinutes(at, timeZone) >= nightMinutes(schedule2) ? shiftDate(today, 1) : today;
+}
+function dayInProgress(at, timeZone, schedule2) {
+  const today = localDay(at, timeZone);
+  return clockMinutes(at, timeZone) < dayStartMinutes(schedule2) ? shiftDate(today, -1) : today;
+}
+function dayStartAt(localDate, timeZone, schedule2) {
+  return zonedTime(dateOf(localDate), dayStartMinutes(schedule2), timeZone);
+}
+function nextDayStartAfter(at, timeZone, schedule2) {
+  return dayStartAt(shiftDate(dayInProgress(at, timeZone, schedule2), 1), timeZone, schedule2);
+}
+function firstDayOf(startedAt, timeZone, schedule2) {
+  const first = dayOf(startedAt, timeZone, schedule2);
+  const threshold = (schedule2.lateStartHours ?? DEFAULT_LATE_START_HOURS) * 60;
+  const clock2 = clockMinutes(startedAt, timeZone);
+  if (threshold <= 0 || clock2 < dayStartMinutes(schedule2) || first !== localDay(startedAt, timeZone)) return first;
+  const untilNight = (nightMinutes(schedule2) - clock2 + DAY_MINUTES) % DAY_MINUTES;
+  return untilNight < threshold ? shiftDate(first, 1) : first;
+}
+var lastActivity = (run) => Math.max(run.startedAt, run.enteredAt, run.lastHumanAt ?? 0, run.lastAgentAt ?? 0);
+function dayAnchor(run, timeZone, schedule2) {
+  const fresh = () => dayStartAt(firstDayOf(run.startedAt, timeZone, schedule2), timeZone, schedule2);
+  const stored = run.dayAnchorAt;
+  if (stored === void 0) return fresh();
+  if (clockMinutes(stored, timeZone) === dayStartMinutes(schedule2)) return stored;
+  const around = localDay(stored, timeZone);
+  const moved = [-1, 0, 1].map((shift) => dayStartAt(shiftDate(around, shift), timeZone, schedule2)).reduce((best, candidate) => Math.abs(candidate - stored) < Math.abs(best - stored) ? candidate : best);
+  const dayNow = daysBetween(localDay(moved, timeZone), dayInProgress(lastActivity(run), timeZone, schedule2)) + 1;
+  return dayNow <= 1 ? fresh() : moved;
+}
+var anchorDate = (run, timeZone, schedule2) => localDay(dayAnchor(run, timeZone, schedule2), timeZone);
+function stateDaysDue(run, days, timeZone, schedule2) {
+  const entered = later(dayOf(run.enteredAt, timeZone, schedule2), anchorDate(run, timeZone, schedule2));
+  return dayStartAt(shiftDate(entered, days), timeZone, schedule2);
+}
+function programDayDue(run, day, timeZone, schedule2) {
+  return dayStartAt(shiftDate(anchorDate(run, timeZone, schedule2), day - 1), timeZone, schedule2);
+}
+function flowDay(run, now, timeZone, schedule2) {
+  const first = anchorDate(run, timeZone, schedule2);
+  const current = later(dayInProgress(now, timeZone, schedule2), shiftDate(first, -1));
+  const day = Math.max(0, daysBetween(first, current) + 1);
+  const today = day === 0 ? shiftDate(first, -1) : current;
+  return {
+    day,
+    ...schedule2.lengthDays !== void 0 && { totalDays: schedule2.lengthDays },
+    isLastDay: schedule2.lengthDays !== void 0 && day === schedule2.lengthDays,
+    dayStartedAt: dayStartAt(today, timeZone, schedule2),
+    nextDayStartAt: dayStartAt(shiftDate(today, 1), timeZone, schedule2)
+  };
+}
+function deadlineAt(run, timeZone, schedule2) {
+  if (schedule2.lengthDays === void 0) return null;
+  return dayStartAt(shiftDate(anchorDate(run, timeZone, schedule2), schedule2.lengthDays), timeZone, schedule2);
+}
+function beforeFirstNight(run, now, timeZone, schedule2) {
+  const first = anchorDate(run, timeZone, schedule2);
+  const nightDate = eveningNight(schedule2) ? first : shiftDate(first, 1);
+  return now < zonedTime(dateOf(nightDate), nightMinutes(schedule2), timeZone);
+}
+function withDayAnchor(run, timeZone, schedule2) {
+  if (!schedule2) return run;
+  const dayAnchorAt = dayAnchor(run, timeZone, schedule2);
+  return run.dayAnchorAt === dayAnchorAt ? run : { ...run, dayAnchorAt };
+}
+function clockText(at, timeZone) {
+  const { hour, minute } = zonedParts(at, timeZone);
+  return `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+}
+
+// src/engine/nudges.ts
+function stateNudges(flow, stateId) {
+  const own = stateById(flow, stateId)?.nudges;
+  if (own === "off") return null;
+  return own ?? flow.schedule?.nudges ?? flow.nudges ?? null;
+}
+var CALENDAR_DAYS = { dayStart: "00:00", lateStartHours: 0, farewellOnDeadline: false };
+function nudgeRings(flow, run, timeZone) {
+  const own = stateById(flow, run.state)?.nudges;
+  if (own === "off") return null;
+  const common = flow.schedule?.nudges ?? flow.nudges ?? null;
+  if (!own) return common && { ring: common };
+  if (own.days === void 0) return { ring: own };
+  const schedule2 = flow.schedule ?? CALENDAR_DAYS;
+  const entryDay = flowDay(run, run.enteredAt, timeZone, schedule2).day;
+  return { ring: own, until: programDayDue(run, entryDay + own.days, timeZone, schedule2), after: common };
+}
+var UNIT_MS = { min: 6e4, h: 36e5, d: 864e5 };
+var durationMs = (duration2) => duration2.amount * UNIT_MS[duration2.unit];
+var DEFAULT_SKIP_MORNING_MIN = 180;
+function nextNudge(flow, run, now, timeZone, context = {}) {
+  const rings = nudgesRunning(flow, run, timeZone, context);
+  if (!rings || run.lastAgentAt === null) return null;
+  const base = Math.max(run.lastAgentAt, context.pausedUntil ?? 0, context.undeliveredAt ?? 0);
+  const step = run.nudgeStep ?? 0;
+  let nudge = null;
+  if (rings.until === void 0) nudge = ringNudge(rings.ring, base, step, timeZone);
+  else {
+    const own = base < rings.until ? ringNudge(rings.ring, base, step, timeZone) : null;
+    if (own && own.at < rings.until) nudge = { ...own, own: true };
+    else if (rings.after) nudge = ringNudge(rings.after, Math.max(base, rings.until), run.nudgeStepOwn || base < rings.until ? 0 : step, timeZone);
+  }
+  const giveUp = giveUpAt(flow, run, timeZone, context);
+  if (giveUp !== null && (!nudge || giveUp <= nudge.at || giveUp <= now)) return { at: giveUp, reason: { kind: "give_up" } };
+  return nudge;
+}
+function ringNudge(ring, base, step, timeZone) {
+  const silence = ring.afterSilence[step];
+  if (silence) return { at: base + durationMs(silence), reason: { kind: "silence", step: step + 1 } };
+  let nudge = null;
+  for (const clock2 of ring.dailyAt ?? []) {
+    const minutes = parseClock(clock2);
+    if (minutes === null) continue;
+    const at = nextClockTime(base, minutes, timeZone);
+    if (!nudge || at < nudge.at) nudge = { at, reason: { kind: "daily", at: clock2 } };
+  }
+  return nudge;
+}
+function nudgesRunning(flow, run, timeZone, context) {
+  const rings = nudgeRings(flow, run, timeZone);
+  if (!rings || run.endedAt !== void 0 || run.lastAgentAt === null) return null;
+  if (run.lastHumanAt !== null && run.lastHumanAt > run.lastAgentAt || (context.unanswered ?? 0) > 0) return null;
+  return rings;
+}
+function giveUpAt(flow, run, timeZone, context = {}) {
+  const rings = nudgesRunning(flow, run, timeZone, context);
+  const giveUpAfter = rings && (rings.ring.giveUpAfter ?? (rings.until !== void 0 ? rings.after?.giveUpAfter : void 0));
+  return giveUpAfter ? Math.max(run.lastHumanAt ?? run.startedAt, context.pausedUntil ?? 0) + durationMs(giveUpAfter) : null;
+}
+var morningOn = (schedule2) => schedule2.firstMessages?.morning ?? schedule2.lengthDays !== void 0;
+function nextMorning(flow, run, timeZone, context = {}) {
+  const schedule2 = flow.schedule;
+  if (!schedule2 || !morningOn(schedule2) || run.endedAt !== void 0) return null;
+  const skipMs = (schedule2.firstMessages?.skipMorningIfHumanWithinMin ?? DEFAULT_SKIP_MORNING_MIN) * 6e4;
+  const since = Math.max(run.lastAgentAt ?? run.startedAt, context.undeliveredAt ?? 0);
+  let morning = flowDay(run, since, timeZone, schedule2).nextDayStartAt;
+  for (let day = 0; day < 3; day += 1) {
+    const humanJustWrote = run.lastHumanAt !== null && run.lastHumanAt < morning && morning - run.lastHumanAt < skipMs;
+    const paused = (context.pausedUntil ?? 0) > morning;
+    if (!humanJustWrote && !paused) return morning;
+    morning = flowDay(run, morning, timeZone, schedule2).nextDayStartAt;
+  }
+  return morning;
+}
+var HELD_AT_DAY_START = /* @__PURE__ */ new Set(["morning", "silence", "daily"]);
+function dayStartHoldUntil(flow, run, now, timeZone, reasons) {
+  const schedule2 = flow.schedule;
+  if (!schedule2 || run.lastHumanAt === null || !reasons.every((reason) => HELD_AT_DAY_START.has(reason.kind))) return null;
+  const until = run.lastHumanAt + (schedule2.firstMessages?.skipMorningIfHumanWithinMin ?? DEFAULT_SKIP_MORNING_MIN) * 6e4;
+  if (until <= now) return null;
+  return run.lastHumanAt < flowDay(run, now, timeZone, schedule2).dayStartedAt ? until : null;
+}
+function nextNightReply(flow, run, timeZone, context = {}) {
+  if (!(context.unanswered ?? 0) || run.endedAt !== void 0) return null;
+  const last = Math.max(run.lastAgentAt ?? 0, run.lastHumanAt ?? 0, run.startedAt, context.undeliveredAt ?? 0);
+  return flow.schedule ? flowDay(run, last, timeZone, flow.schedule).nextDayStartAt : last;
+}
+
+// src/engine/timers.ts
+var FLOW_DEADLINE_EXIT = "@deadline";
+var UNIT_MS2 = { min: 6e4, h: 36e5, d: 864e5 };
+function actualEntry(run) {
+  const last = run.path.at(-1);
+  return last && last.state === run.state ? last.at : run.enteredAt;
+}
+function timerDueAt(condition, run, timeZone, schedule2) {
+  switch (condition.from) {
+    case "in_state":
+      return run.enteredAt + condition.amount * UNIT_MS2[condition.unit];
+    case "since_start":
+      return run.startedAt + condition.amount * UNIT_MS2[condition.unit];
+    case "silence":
+      if (run.lastAgentAt === null) return null;
+      if (run.lastHumanAt !== null && run.lastHumanAt > run.lastAgentAt) return null;
+      return run.lastAgentAt + condition.amount * UNIT_MS2[condition.unit];
+    case "time_of_day": {
+      const minutes = parseClock(condition.at);
+      return minutes === null ? null : nextClockTime(actualEntry(run), minutes, timeZone);
+    }
+    case "state_days":
+      return schedule2 ? stateDaysDue(run, condition.days, timeZone, schedule2) : null;
+    case "program_day":
+      return schedule2 ? programDayDue(run, condition.day, timeZone, schedule2) : null;
+  }
+}
+var ENTRY_FREE_TIMERS = /* @__PURE__ */ new Set(["since_start", "program_day"]);
+function overdueOnEntry(flow, run, now, timeZone) {
+  const state = stateById(flow, run.state);
+  if (!state) return null;
+  let best = null;
+  for (const { exit } of activeExits(flow, state)) {
+    if (exit.when.type !== "timer" || !ENTRY_FREE_TIMERS.has(exit.when.from) || !exitTarget(flow, run, exit.to)) continue;
+    const at = timerDueAt(exit.when, run, timeZone, flow.schedule);
+    if (at !== null && at <= now && (best === null || at < best.at)) best = { at, exitId: exit.id };
+  }
+  return best?.exitId ?? null;
+}
+function nextDue(flow, run, _now, timeZone) {
+  if (run.endedAt !== void 0) return null;
+  const state = stateById(flow, run.state);
+  if (!state) return null;
+  let best = null;
+  for (const { exit } of activeExits(flow, state)) {
+    if (exit.when.type !== "timer" || !exitTarget(flow, run, exit.to)) continue;
+    const at = timerDueAt(exit.when, run, timeZone, flow.schedule);
+    if (at !== null && (best === null || at < best.at)) best = { at, exitId: exit.id };
+  }
+  const deadline = flow.schedule ? deadlineAt(run, timeZone, flow.schedule) : null;
+  if (deadline !== null && (best === null || deadline <= best.at)) best = { at: deadline, exitId: FLOW_DEADLINE_EXIT };
+  return best;
+}
+var FLOW_FIRST_EXIT = "@first";
+var FLOW_GIVE_UP_EXIT = "@give_up";
+function firstMessageDues(flow, run, now, timeZone, context) {
+  const nudge = nextNudge(flow, run, now, timeZone, context);
+  const morning = nextMorning(flow, run, timeZone, context);
+  const night = nextNightReply(flow, run, timeZone, context);
+  const dues = [];
+  if (morning !== null) dues.push({ at: morning, reason: { kind: "morning" } });
+  if (night !== null) dues.push({ at: night, reason: { kind: "night_messages", count: context.unanswered ?? 0 } });
+  if (nudge && nudge.reason.kind !== "give_up") dues.push({ at: nudge.at, reason: nudge.reason });
+  return { dues, giveUp: nudge?.reason.kind === "give_up" ? nudge.at : null, ownNudge: nudge?.own === true };
+}
+function nextWake(flow, run, now, timeZone, context = {}) {
+  if (run.endedAt !== void 0) return null;
+  let best = nextDue(flow, run, now, timeZone);
+  const { dues, giveUp } = firstMessageDues(flow, run, now, timeZone, context);
+  const deadlineFirst = best?.exitId === FLOW_DEADLINE_EXIT;
+  if (giveUp !== null && (best === null || giveUp < best.at || giveUp === best.at && !deadlineFirst)) best = { at: giveUp, exitId: FLOW_GIVE_UP_EXIT };
+  for (const due of dues) if (best === null || due.at < best.at) best = { at: due.at, exitId: FLOW_FIRST_EXIT };
+  return best;
+}
+function dueReasons(flow, run, now, timeZone, context = {}) {
+  const none = { deadline: false, giveUp: false, exitId: null, reasons: [] };
+  if (run.endedAt !== void 0) return none;
+  const exit = nextDue(flow, run, now, timeZone);
+  const deadline = flow.schedule ? deadlineAt(run, timeZone, flow.schedule) : null;
+  if (deadline !== null && deadline <= now) return { ...none, deadline: true };
+  const { dues, giveUp, ownNudge } = firstMessageDues(flow, run, now, timeZone, context);
+  if (giveUp !== null && giveUp <= now) return { ...none, giveUp: true };
+  const exitId = exit && exit.at <= now ? exit.exitId : null;
+  const morning = dues.some((due) => due.at <= now && due.reason.kind === "morning");
+  const reasons = dues.filter((due) => due.at <= now && !((exitId || morning) && (due.reason.kind === "silence" || due.reason.kind === "daily"))).map((due) => due.reason);
+  const nudged = reasons.some((reason) => reason.kind === "silence" || reason.kind === "daily");
+  return { ...none, exitId, reasons, ...ownNudge && nudged && { ownNudge: true } };
+}
+function nextFirstMessageAfter(flow, run, now, timeZone, context = {}) {
+  if (run.endedAt !== void 0) return null;
+  const ahead = firstMessageDues(flow, run, now, timeZone, context).dues.filter((due) => due.at > now);
+  return ahead.length === 0 ? null : Math.min(...ahead.map((due) => due.at));
+}
+function endingWake(flow, run, now, timeZone, context) {
+  if (run.endedAt !== void 0) return null;
+  const deadline = flow.schedule ? deadlineAt(run, timeZone, flow.schedule) : null;
+  const giveUp = giveUpAt(flow, run, timeZone, context);
+  const candidates = [
+    ...deadline !== null && deadline > now ? [{ at: deadline, exitId: FLOW_DEADLINE_EXIT }] : [],
+    ...giveUp !== null && giveUp > now ? [{ at: giveUp, exitId: FLOW_GIVE_UP_EXIT }] : []
+  ];
+  return earliest(candidates);
+}
+var earliest = (dues) => dues.reduce((best, due) => best === null || due.at < best.at ? due : best, null);
+function deferredWake(flow, run, now, timeZone, context, retry) {
+  if (run.endedAt !== void 0) return null;
+  const exit = nextDue(flow, run, now, timeZone);
+  const ending = endingWake(flow, run, now, timeZone, context);
+  return earliest([
+    ...exit && exit.at > now && exit.exitId !== FLOW_DEADLINE_EXIT ? [exit] : [],
+    ...ending ? [ending] : [],
+    ...retry.at !== null ? [{ at: Math.max(retry.at, now), exitId: retry.exitId }] : []
+  ]);
+}
+
+// src/engine/next-transition.ts
+function matches(flow, run, exitId, when, event, now) {
+  switch (event.type) {
+    case "event":
+      if (when.type !== "event" || when.event !== event.event) return false;
+      return when.event === "message" || when.name === void 0 || when.name === event.name;
+    case "data": {
+      if (when.type !== "data" || event.field !== void 0 && when.field !== event.field) return false;
+      const found = fieldById(flow, when.field);
+      if (!found) return false;
+      const value = found.place === "notes" ? run.notes[when.field] : event.card?.[when.field];
+      return dataConditionHolds(when, found.field.type, value);
+    }
+    case "verdict":
+      return exitId === event.exitId && when.type === "judge";
+    case "timer": {
+      if (exitId !== event.exitId || when.type !== "timer") return false;
+      const due = timerDueAt(when, run, event.timeZone, flow.schedule);
+      return due !== null && due <= now;
+    }
+  }
+}
+var UNITS = { min: "\u043C\u0438\u043D", h: "\u0447", d: "\u0434" };
+var DATA_SIGNS = { eq: "=", ne: "\u2260", gt: ">", lt: "<", contains: "\u0441\u043E\u0434\u0435\u0440\u0436\u0438\u0442" };
+function daysText(days) {
+  const last = days % 10;
+  const tens = days % 100;
+  const word = last === 1 && tens !== 11 ? "\u0434\u0435\u043D\u044C" : last >= 2 && last <= 4 && (tens < 12 || tens > 14) ? "\u0434\u043D\u044F" : "\u0434\u043D\u0435\u0439";
+  return `${days} ${word}`;
+}
+var valueText = (value) => value === true ? "\u0434\u0430" : value === false ? "\u043D\u0435\u0442" : String(value);
+function describeCondition(flow, when, catalog) {
+  switch (when.type) {
+    case "judge":
+      return when.text;
+    case "data": {
+      const field = flow.clientCard.find((item) => item.id === when.field) ?? flow.chatNotes.find((item) => item.id === when.field);
+      const name = `\xAB${field?.name ?? when.field}\xBB`;
+      return when.op === "filled" ? `\u0443\u0437\u043D\u0430\u043B\u0438 ${name}` : `${name} ${DATA_SIGNS[when.op]} ${valueText(when.value)}`;
+    }
+    case "event": {
+      if (when.event === "message") return "\u0447\u0435\u043B\u043E\u0432\u0435\u043A \u043D\u0430\u043F\u0438\u0441\u0430\u043B";
+      if (when.event === "tool") return `\u0432\u044B\u0437\u0432\u0430\u043D \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442 \xAB${when.name ?? ""}\xBB`;
+      const name = (when.name && catalogEventLabel(catalog, when.name)) ?? when.name ?? "";
+      return when.event === "button" ? `\u043D\u0430\u0436\u0430\u0442\u0430 \u043A\u043D\u043E\u043F\u043A\u0430 \xAB${name}\xBB` : `\u0441\u043E\u0431\u044B\u0442\u0438\u0435 \xAB${name}\xBB`;
+    }
+    case "timer":
+      if (when.from === "time_of_day") return `\u043D\u0430\u0441\u0442\u0443\u043F\u0438\u043B\u043E ${when.at}`;
+      if (when.from === "state_days") return `\u043D\u043E\u0434\u0430 \u0434\u043B\u0438\u0442\u0441\u044F ${daysText(when.days)}`;
+      if (when.from === "program_day") return `\u043D\u0430\u0441\u0442\u0443\u043F\u0438\u043B \u0434\u0435\u043D\u044C ${when.day}`;
+      if (when.from === "silence") return `\u0442\u0438\u0448\u0438\u043D\u0430 ${when.amount} ${UNITS[when.unit]}`;
+      if (when.from === "in_state") return `\u0432 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0438 ${when.amount} ${UNITS[when.unit]}`;
+      return `\u0441 \u043D\u0430\u0447\u0430\u043B\u0430 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440\u0430 ${when.amount} ${UNITS[when.unit]}`;
+  }
+}
+function reasonOf(flow, event, when) {
+  const claimed = event.type === "verdict" ? event.why?.trim() : void 0;
+  return { kind: deciderOf(event), text: claimed || describeCondition(flow, when) };
+}
+var deciderOf = (event) => event.type === "verdict" ? event.decidedBy : event.type;
+function nextTransition(flow, run, event, now) {
+  if (run.chain >= FLOW_CHAIN_LIMIT) return null;
+  const state = stateById(flow, run.state);
+  if (!state) return null;
+  for (const { exit } of activeExits(flow, state)) {
+    if (!matches(flow, run, exit.id, exit.when, event, now)) continue;
+    const target = exitTarget(flow, run, exit.to);
+    if (!target) continue;
+    return {
+      from: run.state,
+      to: target.state.id,
+      exitId: exit.id,
+      decidedBy: deciderOf(event),
+      ...event.type === "verdict" ? { probability: event.probability } : {},
+      tags: target.state.tags,
+      at: now,
+      ...target.returned ? { returned: true } : {},
+      reason: reasonOf(flow, event, exit.when)
+    };
+  }
+  return null;
+}
+
+// src/engine/run-updates.ts
+function startRun(flow, now) {
+  const start = stateById(flow, flow.start);
+  if (!start) throw new Error(`\u0421\u0446\u0435\u043D\u0430\u0440\u0438\u0439 \xAB${flow.id}\xBB \u0431\u0435\u0437 \u0441\u0442\u0430\u0440\u0442\u0430: \u0441\u0442\u0430\u0440\u0442\u043E\u0432\u043E\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u043D\u0435 \u0432\u044B\u0431\u0440\u0430\u043D\u043E \u0438\u043B\u0438 \u0435\u0433\u043E \u043D\u0435\u0442.`);
+  return {
+    state: start.id,
+    enteredAt: now,
+    startedAt: now,
+    path: [{ state: start.id, at: now, tags: start.tags, from: null, exitId: null, decidedBy: "start" }],
+    pausedClocks: {},
+    notes: {},
+    humanMessages: 0,
+    agentAnswers: 0,
+    sideQuestionAt: null,
+    lastRejected: null,
+    lastAgentAt: null,
+    lastHumanAt: null,
+    chain: 0
+  };
+}
+function appendPath(path, entry) {
+  return [...path, entry].slice(-FLOW_PATH_LIMIT);
+}
+function applyTransition(flow, run, transition) {
+  const from = stateById(flow, transition.from);
+  const to = stateById(flow, transition.to);
+  let enteredAt = transition.at;
+  let pausedClocks = {};
+  if (transition.returned) {
+    enteredAt = transition.at - (run.pausedClocks[transition.to] ?? 0);
+  } else if (to && isTouch(to)) {
+    pausedClocks = from && !isTouch(from) ? { [from.id]: transition.at - run.enteredAt } : run.pausedClocks;
+  }
+  return {
+    ...run,
+    state: transition.to,
+    enteredAt,
+    pausedClocks,
+    path: appendPath(run.path, {
+      state: transition.to,
+      at: transition.at,
+      tags: transition.tags,
+      from: transition.from,
+      exitId: transition.exitId,
+      decidedBy: transition.decidedBy,
+      ...transition.probability === void 0 ? {} : { probability: transition.probability },
+      ...transition.reason === void 0 ? {} : { reason: transition.reason }
+    }),
+    chain: run.chain + 1,
+    lastRejected: null
+  };
+}
+function noteHumanMessage(run, now, dayKey, count = 1) {
+  return {
+    ...run,
+    humanMessages: run.humanMessages + count,
+    lastHumanAt: now,
+    chain: 0,
+    ...run.nudgeStep === void 0 ? {} : { nudgeStep: 0 },
+    ...run.serverTurns === void 0 ? {} : { serverTurns: 0 },
+    ...dayKey === void 0 ? {} : { dayCounts: { [dayKey]: (run.dayCounts?.[dayKey] ?? 0) + count } }
+  };
+}
+function noteAgentAnswer(run, now) {
+  return { ...run, agentAnswers: run.agentAnswers + 1, lastAgentAt: now, chain: 0 };
+}
+function withoutUndeliveredTouch(run, undelivered) {
+  const touch = run.touch;
+  if (!touch || !undelivered.has(touch.answerId)) return { run, undeliveredAt: null };
+  const { touch: _touch, ...rest } = run;
+  return {
+    run: { ...withoutOwnStep(rest), lastAgentAt: touch.lastAgentAt, nudgeStep: touch.nudgeStep, ...touch.nudgeStepOwn && { nudgeStepOwn: true }, agentAnswers: touch.agentAnswers },
+    undeliveredAt: touch.at
+  };
+}
+function noteRejectedClaim(run, exitId) {
+  return { ...run, lastRejected: { exitId, atHumanMessages: run.humanMessages } };
+}
+function claimAllowed(run, exitId) {
+  return !(run.lastRejected?.exitId === exitId && run.lastRejected.atHumanMessages === run.humanMessages);
+}
+function noteSideQuestion(run) {
+  return { ...run, sideQuestionAt: run.humanMessages };
+}
+function withoutOwnStep(run) {
+  const { nudgeStepOwn: _own, ...rest } = run;
+  return rest;
+}
+function withNudgeStep(run, step, own) {
+  return { ...withoutOwnStep(run), nudgeStep: step, ...own && { nudgeStepOwn: true } };
+}
+
+// src/engine/side-questions.ts
+function isFieldStale(field, updatedAt, now) {
+  if (field.refreshAfterMonths === null) return false;
+  const due = new Date(updatedAt);
+  due.setUTCMonth(due.getUTCMonth() + field.refreshAfterMonths);
+  return due.getTime() <= now;
+}
+function sideQuestion(flow, run, input) {
+  const state = stateById(flow, run.state);
+  if (!state || isFinal(state)) return null;
+  const known = (id2) => {
+    const found = fieldById(flow, id2);
+    if (!found) return true;
+    const value = found.place === "notes" ? run.notes[id2] : input.card[id2]?.value;
+    return fieldValueFits(found.field, value);
+  };
+  const learn = state.learn.find((id2) => !known(id2));
+  if (learn) return { fieldId: learn, reason: "learn" };
+  if (state.noSideQuestions) return null;
+  if (run.sideQuestionAt !== null && run.humanMessages - run.sideQuestionAt < flow.pace.sideQuestionEveryMessages) return null;
+  const stale = flow.clientCard.find((field) => {
+    const entry = input.card[field.id];
+    return entry !== void 0 && known(field.id) && isFieldStale(field, entry.updatedAt, input.now);
+  });
+  if (stale) return { fieldId: stale.id, reason: "stale" };
+  const unknown = flow.clientCard.find((field) => !known(field.id));
+  return unknown ? { fieldId: unknown.id, reason: "unknown" } : null;
+}
+
+// src/check/app-checks.ts
+function pick(items, key) {
+  if (!items || key === void 0) return void 0;
+  return /^\d+$/.test(key) ? items[Number(key)] : items.find((item) => item.id === key);
+}
+function placeOfPath(flow, path) {
+  const state = /^states\[([^\]]+)\](?:\.exits\[([^\]]+)\])?/.exec(path);
+  if (state) {
+    const found = pick(flow.states, state[1]);
+    if (!found) return {};
+    const exit = pick(found.exits, state[2]);
+    return exit ? { stateId: found.id, exitId: exit.id } : { stateId: found.id };
+  }
+  const any = /^anyState\.exits\[([^\]]+)\]/.exec(path);
+  if (any) {
+    const exit = pick(flow.anyState.exits, any[1]);
+    return exit ? { exitId: exit.id } : {};
+  }
+  const field = /^(clientCard|chatNotes)\[([^\]]+)\]/.exec(path);
+  if (field) {
+    const found = pick(flow[field[1]], field[2]);
+    return found ? { fieldId: found.id } : {};
+  }
+  const task = /^sideTasks\[([^\]]+)\]/.exec(path);
+  if (task) {
+    const found = pick(flow.sideTasks, task[1]);
+    return found ? { sideTaskId: found.id } : {};
+  }
+  return {};
+}
+function appIssues(flow, found) {
+  return found.map((issue) => ({
+    level: issue.level ?? "error",
+    code: issue.code ?? "app_check",
+    message: issue.message,
+    place: issue.place ?? (issue.path === void 0 ? {} : placeOfPath(flow, issue.path))
+  }));
+}
+
+// src/check/check-flow.ts
+var Issues = class {
+  list = [];
+  error(code, message, place = {}) {
+    this.list.push({ level: "error", code, message, place });
+  }
+  warning(code, message, place = {}) {
+    this.list.push({ level: "warning", code, message, place });
+  }
+};
+var quote = (text) => `\xAB${text}\xBB`;
+var stateName = (state) => quote(state.title.trim() || state.id);
+function checkDuplicates(flow, issues) {
+  const states = /* @__PURE__ */ new Set();
+  for (const state of flow.states) {
+    if (states.has(state.id)) issues.error("duplicate_state", `\u0414\u0432\u0430 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F \u0441 id ${quote(state.id)}`, { stateId: state.id });
+    states.add(state.id);
+  }
+  const exits2 = /* @__PURE__ */ new Set();
+  const exitsOf = [
+    ...flow.states.map((state) => ({ stateId: state.id, exits: state.exits })),
+    { exits: flow.anyState.exits }
+  ];
+  for (const { stateId, exits: list } of exitsOf) {
+    for (const exit of list) {
+      if (exits2.has(exit.id)) {
+        issues.error("duplicate_exit", `\u0414\u0432\u0430 \u0443\u0441\u043B\u043E\u0432\u0438\u044F \u0441 id ${quote(exit.id)}: \u0438\u0441\u0442\u043E\u0440\u0438\u044F \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u043E\u0432 \u0438\u0445 \u043D\u0435 \u0440\u0430\u0437\u043B\u0438\u0447\u0438\u0442`, {
+          ...stateId === void 0 ? {} : { stateId },
+          exitId: exit.id
+        });
+      }
+      exits2.add(exit.id);
+    }
+  }
+  const fields = /* @__PURE__ */ new Set();
+  for (const field of [...flow.clientCard, ...flow.chatNotes]) {
+    if (fields.has(field.id)) issues.error("duplicate_field", `\u0414\u0432\u0430 \u043F\u043E\u043B\u044F \u0441 id ${quote(field.id)} \u0432 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0435 \u0438 \u0437\u0430\u043C\u0435\u0442\u043A\u0430\u0445`, { fieldId: field.id });
+    fields.add(field.id);
+  }
+}
+function eventKnown(exit, catalog) {
+  if (exit.when.type !== "event" || exit.when.name === void 0) return true;
+  const { event, name } = exit.when;
+  if (event === "tool") return catalog.tools.includes(name);
+  if (event === "button") return catalog.widgets.includes(name) || catalogEventNames(catalog).includes(name);
+  if (event === "app") return catalogEventNames(catalog).includes(name);
+  return true;
+}
+function checkExit(flow, catalog, issues, exit, index, state) {
+  const where = state ? stateName(state) : "\u041E\u0431\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u044B";
+  const what = `${where}: \u0443\u0441\u043B\u043E\u0432\u0438\u0435 \u2116${index + 1}`;
+  const place = state ? { stateId: state.id, exitId: exit.id } : { exitId: exit.id };
+  if (exit.to === null) issues.error("exit_without_target", `${what} \u043D\u0438\u043A\u0443\u0434\u0430 \u043D\u0435 \u0432\u0435\u0434\u0451\u0442`, place);
+  else if (exit.to === RETURN_TARGET) {
+    if (!state) issues.error("return_from_any_state", `${what}: \xAB\u043D\u0430\u0437\u0430\u0434\xBB \u0438\u0437 \u043E\u0431\u0449\u0438\u0445 \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u043E\u0432 \u2014 \u043D\u0435\u043F\u043E\u043D\u044F\u0442\u043D\u043E, \u043A\u0443\u0434\u0430 \u0432\u043E\u0437\u0432\u0440\u0430\u0449\u0430\u0442\u044C\u0441\u044F`, place);
+  } else if (!stateById(flow, exit.to)) issues.error("unknown_target", `${what} \u0432\u0435\u0434\u0451\u0442 \u0432 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 ${quote(exit.to)}, \u043A\u043E\u0442\u043E\u0440\u043E\u0433\u043E \u043D\u0435\u0442`, place);
+  const when = exit.when;
+  if (when.type === "judge" && when.text.trim() === "") {
+    issues.error("empty_judge", `${what} \u043D\u0435 \u043D\u0430\u043F\u0438\u0441\u0430\u043D\u043E: \u0430\u0433\u0435\u043D\u0442\u0443 \u0438 \u0441\u0443\u0434\u044C\u0435 \u043D\u0435\u0447\u0435\u0433\u043E \u043F\u0440\u043E\u0432\u0435\u0440\u044F\u0442\u044C`, place);
+  }
+  if (when.type === "data") {
+    const found = fieldById(flow, when.field);
+    const fieldPlace = { ...place, fieldId: when.field };
+    if (!found) {
+      issues.error("unknown_field", `${what}: \u043F\u043E\u043B\u044F ${quote(when.field)} \u043D\u0435\u0442 \u043D\u0438 \u0432 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0435 \u043A\u043B\u0438\u0435\u043D\u0442\u0430, \u043D\u0438 \u0432 \u0437\u0430\u043C\u0435\u0442\u043A\u0430\u0445 \u0447\u0430\u0442\u0430`, fieldPlace);
+    } else if (!FLOW_OPS_BY_FIELD_TYPE[found.field.type].includes(when.op)) {
+      issues.error("op_not_for_type", `${what}: \u043F\u043E\u043B\u0435 ${quote(found.field.name)} \u0442\u0430\u043A \u043D\u0435 \u0441\u0440\u0430\u0432\u043D\u0438\u0432\u0430\u0435\u0442\u0441\u044F`, fieldPlace);
+    } else if (found.field.type === "number" && when.op !== "filled" && typeof when.value !== "number") {
+      issues.error("value_not_number", `${what}: \u043F\u043E\u043B\u0435 ${quote(found.field.name)} \u2014 \u0447\u0438\u0441\u043B\u043E, \u0441\u0440\u0430\u0432\u043D\u0438\u0432\u0430\u0442\u044C \u0435\u0433\u043E \u043D\u0443\u0436\u043D\u043E \u0441 \u0447\u0438\u0441\u043B\u043E\u043C`, fieldPlace);
+    } else if (found.field.type === "boolean" && when.op !== "filled" && typeof when.value !== "boolean") {
+      issues.error("value_not_boolean", `${what}: \u043F\u043E\u043B\u0435 ${quote(found.field.name)} \u2014 \xAB\u0434\u0430/\u043D\u0435\u0442\xBB, \u0441\u0440\u0430\u0432\u043D\u0438\u0432\u0430\u0442\u044C \u0435\u0433\u043E \u043D\u0443\u0436\u043D\u043E \u0441 \xAB\u0434\u0430\xBB \u0438\u043B\u0438 \xAB\u043D\u0435\u0442\xBB`, fieldPlace);
+    } else if (found.field.type === "choice" && when.op === "eq" && found.field.options.length > 0 && !found.field.options.some((option) => sameText(option, String(when.value)))) {
+      issues.error("value_not_in_options", `${what}: \u0443 \u043F\u043E\u043B\u044F ${quote(found.field.name)} \u043D\u0435\u0442 \u0432\u0430\u0440\u0438\u0430\u043D\u0442\u0430 ${quote(String(when.value))}`, fieldPlace);
+    }
+  }
+  if (when.type === "timer" && when.from === "state_days") {
+    if (!flow.schedule) {
+      issues.error("state_days_without_day_start", `${what}: \xAB\u0434\u043B\u0438\u0442\u0441\u044F ${when.days} \u0434\u043D.\xBB \u2014 \u0443 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u043D\u0435 \u0437\u0430\u0434\u0430\u043D\u043E \u043D\u0430\u0447\u0430\u043B\u043E \u0434\u043D\u044F (\xAB\u0414\u043D\u0438 \u0438 \u0432\u0440\u0435\u043C\u044F\xBB)`, place);
+    }
+    if (when.days < 1) issues.error("state_days_below_one", `${what}: \u043D\u043E\u0434\u0430 \u0434\u043E\u043B\u0436\u043D\u0430 \u0434\u043B\u0438\u0442\u044C\u0441\u044F \u0445\u043E\u0442\u044F \u0431\u044B \u043E\u0434\u0438\u043D \u0434\u0435\u043D\u044C`, place);
+  }
+  if (when.type === "timer" && when.from === "program_day") {
+    if (!Number.isInteger(when.day) || when.day < 1) {
+      issues.error("program_day_invalid", `${what}: \u0434\u0435\u043D\u044C \u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u044B \u2014 \u0446\u0435\u043B\u043E\u0435 \u0447\u0438\u0441\u043B\u043E \u0441 1`, place);
+    } else if (flow.schedule?.lengthDays !== void 0 && when.day > flow.schedule.lengthDays) {
+      issues.error("program_day_after_end", `${what}: \u0434\u043D\u044F ${when.day} \u043D\u0435\u0442 \u2014 \u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u0430 \u0434\u043B\u0438\u0442\u0441\u044F ${flow.schedule.lengthDays} \u0434\u043D.`, place);
+    }
+    if (!flow.schedule) issues.warning("program_day_without_schedule", `${what}: \xAB\u0441 \u0434\u043D\u044F ${when.day}\xBB \u043D\u0435 \u0441\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u2014 \u0443 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u043D\u0435\u0442 \xAB\u0414\u043D\u0435\u0439 \u0438 \u0432\u0440\u0435\u043C\u0435\u043D\u0438\xBB`, place);
+  }
+  if (when.type === "event" && when.event !== "message") {
+    if (when.name === void 0 || when.name.trim() === "") {
+      issues.error("event_without_name", `${what}: \u043D\u0435 \u0432\u044B\u0431\u0440\u0430\u043D\u043E, \u043A\u0430\u043A\u043E\u0435 \u0441\u043E\u0431\u044B\u0442\u0438\u0435 \u0436\u0434\u0430\u0442\u044C`, place);
+    } else if (!eventKnown(exit, catalog)) {
+      issues.error("unknown_event", `${what}: \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0435 \u043D\u0435 \u043E\u0431\u044A\u044F\u0432\u0438\u043B\u043E ${quote(when.name)}`, place);
+    }
+  }
+}
+function checkState(flow, catalog, issues, state) {
+  for (const tool of state.tools) {
+    if (!flow.tools.includes(tool)) {
+      issues.error("tool_not_in_flow", `${stateName(state)}: \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u0430 ${quote(tool)} \u043D\u0435\u0442 \u0432 \u0441\u043F\u0438\u0441\u043A\u0435 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u043E\u0432 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F`, { stateId: state.id });
+    } else if (!catalog.tools.includes(tool)) {
+      issues.error("unknown_tool", `${stateName(state)}: \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u0430 ${quote(tool)} \u043D\u0435\u0442 \u0443 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F`, { stateId: state.id });
+    }
+  }
+  for (const fieldId of state.learn) {
+    if (!fieldById(flow, fieldId)) {
+      issues.error("unknown_learn_field", `${stateName(state)}: \xAB\u0443\u0437\u043D\u0430\u0442\u044C \u0437\u0434\u0435\u0441\u044C\xBB \u2014 \u043F\u043E\u043B\u044F ${quote(fieldId)} \u043D\u0435\u0442`, { stateId: state.id, fieldId });
+    }
+  }
+  state.exits.forEach((exit, index) => checkExit(flow, catalog, issues, exit, index, state));
+  if (state.nudges && state.nudges !== "off" && nudgesEmpty(state.nudges)) {
+    issues.warning("empty_nudges", `${stateName(state)}: \u0432 \u043A\u0430\u0441\u0430\u043D\u0438\u044F\u0445 \u043D\u0435\u0442 \u043D\u0438 \u043E\u0434\u043D\u043E\u0433\u043E \u0441\u0440\u043E\u043A\u0430 \u2014 \u0430\u0433\u0435\u043D\u0442 \u043D\u0435 \u043D\u0430\u043F\u0438\u0448\u0435\u0442 \u043F\u0435\u0440\u0432\u044B\u043C`, { stateId: state.id });
+  }
+  const days = state.nudges && state.nudges !== "off" ? state.nudges.days : void 0;
+  if (days !== void 0 && (!Number.isInteger(days) || days < 1)) {
+    issues.error("nudges_days_invalid", `${stateName(state)}: \u0441\u0432\u043E\u0438 \u043A\u0430\u0441\u0430\u043D\u0438\u044F \u0434\u0435\u0439\u0441\u0442\u0432\u0443\u044E\u0442 \u0446\u0435\u043B\u043E\u0435 \u0447\u0438\u0441\u043B\u043E \u0434\u043D\u0435\u0439, \u0441 1`, { stateId: state.id });
+  }
+}
+var nudgesEmpty = (nudges2) => nudges2.afterSilence.length === 0 && !nudges2.dailyAt?.length;
+function checkSchedule(flow, issues) {
+  const schedule2 = flow.schedule;
+  if (!schedule2) return;
+  const dayStart = parseClock(schedule2.dayStart);
+  const nightFrom = schedule2.nightFrom === void 0 ? null : parseClock(schedule2.nightFrom);
+  if (dayStart !== null && nightFrom !== null && nightFrom <= dayStart) {
+    issues.error("night_before_day_start", `\xAB\u0414\u043D\u0438 \u0438 \u0432\u0440\u0435\u043C\u044F\xBB: \u043D\u043E\u0447\u044C (${schedule2.nightFrom}) \u043D\u0430\u0447\u0438\u043D\u0430\u0435\u0442\u0441\u044F \u043D\u0435 \u043F\u043E\u0437\u0436\u0435 \u043D\u0430\u0447\u0430\u043B\u0430 \u0434\u043D\u044F (${schedule2.dayStart})`);
+  }
+  if (schedule2.deadlineState !== void 0 && !stateById(flow, schedule2.deadlineState)) {
+    issues.error("unknown_deadline_state", `\xAB\u0414\u043D\u0438 \u0438 \u0432\u0440\u0435\u043C\u044F\xBB: \u043F\u0440\u0438 \xAB\u0441\u0440\u043E\u043A \u0432\u044B\u0448\u0435\u043B\xBB \u043F\u0435\u0440\u0435\u0445\u043E\u0434 \u0432 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 ${quote(schedule2.deadlineState)}, \u043A\u043E\u0442\u043E\u0440\u043E\u0433\u043E \u043D\u0435\u0442`, {
+      stateId: schedule2.deadlineState
+    });
+  }
+  const frame = schedule2.dayFrame;
+  if (frame?.softFrom !== void 0 && frame.hardAt !== void 0 && frame.softFrom >= frame.hardAt) {
+    issues.error("day_frame_soft_after_hard", `\xAB\u0414\u043D\u0438 \u0438 \u0432\u0440\u0435\u043C\u044F\xBB: \u043C\u044F\u0433\u043A\u0430\u044F \u0440\u0430\u043C\u043A\u0430 (${frame.softFrom}) \u0434\u043E\u043B\u0436\u043D\u0430 \u0431\u044B\u0442\u044C \u0440\u0430\u043D\u044C\u0448\u0435 \u0436\u0451\u0441\u0442\u043A\u043E\u0439 (${frame.hardAt})`);
+  }
+  if (schedule2.nudges && nudgesEmpty(schedule2.nudges)) {
+    issues.warning("empty_nudges", "\xAB\u0414\u043D\u0438 \u0438 \u0432\u0440\u0435\u043C\u044F\xBB: \u0432 \u043A\u0430\u0441\u0430\u043D\u0438\u044F\u0445 \u043D\u0435\u0442 \u043D\u0438 \u043E\u0434\u043D\u043E\u0433\u043E \u0441\u0440\u043E\u043A\u0430 \u2014 \u0430\u0433\u0435\u043D\u0442 \u043D\u0435 \u043D\u0430\u043F\u0438\u0448\u0435\u0442 \u043F\u0435\u0440\u0432\u044B\u043C");
+  }
+  if (schedule2.nudges && flow.nudges) {
+    issues.warning("nudges_shadowed", "\u041A\u0430\u0441\u0430\u043D\u0438\u044F \u0437\u0430\u0434\u0430\u043D\u044B \u0438 \u0443 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F, \u0438 \u0432 \xAB\u0414\u043D\u044F\u0445 \u0438 \u0432\u0440\u0435\u043C\u0435\u043D\u0438\xBB: \u0434\u0435\u0439\u0441\u0442\u0432\u0443\u044E\u0442 \u043A\u0430\u0441\u0430\u043D\u0438\u044F \xAB\u0414\u043D\u0435\u0439 \u0438 \u0432\u0440\u0435\u043C\u0435\u043D\u0438\xBB");
+  }
+}
+function checkFlowNudges(flow, issues) {
+  if (flow.nudges && nudgesEmpty(flow.nudges)) {
+    issues.warning("empty_nudges", "\u041A\u0430\u0441\u0430\u043D\u0438\u044F \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F: \u043D\u0435\u0442 \u043D\u0438 \u043E\u0434\u043D\u043E\u0433\u043E \u0441\u0440\u043E\u043A\u0430 \u2014 \u0430\u0433\u0435\u043D\u0442 \u043D\u0435 \u043D\u0430\u043F\u0438\u0448\u0435\u0442 \u043F\u0435\u0440\u0432\u044B\u043C");
+  }
+}
+function checkSideTasks(flow, issues) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const task of flow.sideTasks ?? []) {
+    if (seen.has(task.id)) issues.error("duplicate_side_task", `\u0414\u0432\u0435 \u043F\u043E\u043F\u0443\u0442\u043D\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u0441 id ${quote(task.id)}`, { sideTaskId: task.id });
+    seen.add(task.id);
+    if (task.field !== void 0 && !fieldById(flow, task.field)) {
+      issues.error("side_task_unknown_field", `\u041F\u043E\u043F\u0443\u0442\u043D\u0430\u044F \u0437\u0430\u0434\u0430\u0447\u0430 ${quote(task.id)}: \u043F\u043E\u043B\u044F ${quote(task.field)} \u043D\u0435\u0442 \u043D\u0438 \u0432 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0435, \u043D\u0438 \u0432 \u0437\u0430\u043C\u0435\u0442\u043A\u0430\u0445`, {
+        sideTaskId: task.id,
+        fieldId: task.field
+      });
+    }
+  }
+}
+function reachableFrom(flow, start) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [start];
+  const deadline = flow.schedule?.deadlineState === void 0 ? void 0 : stateById(flow, flow.schedule.deadlineState);
+  if (deadline) queue.push(deadline);
+  while (queue.length > 0) {
+    const state = queue.shift();
+    if (seen.has(state.id)) continue;
+    seen.add(state.id);
+    const exits2 = commonApplies(flow, state) ? [...state.exits, ...flow.anyState.exits] : state.exits;
+    for (const exit of exits2) {
+      const next = stateById(flow, exit.to);
+      if (next && !seen.has(next.id)) queue.push(next);
+    }
+  }
+  return seen;
+}
+function checkFlow(flow, catalog, options = {}) {
+  const issues = new Issues();
+  checkDuplicates(flow, issues);
+  const start = stateById(flow, flow.start);
+  if (flow.start === null) issues.error("no_start", "\u041D\u0435\u0442 \u0441\u0442\u0430\u0440\u0442\u043E\u0432\u043E\u0433\u043E \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F: \u043E\u0442\u043C\u0435\u0442\u044C\u0442\u0435, \u0433\u0434\u0435 \u043D\u0430\u0447\u0438\u043D\u0430\u0435\u0442\u0441\u044F \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439");
+  else if (!start) issues.error("unknown_start", `\u0421\u0442\u0430\u0440\u0442\u043E\u0432\u043E\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 ${quote(flow.start)} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E`);
+  for (const tool of flow.tools) {
+    if (!catalog.tools.includes(tool)) issues.error("unknown_tool", `\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u0430 ${quote(tool)} \u043D\u0435\u0442 \u0443 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F`);
+  }
+  for (const state of flow.states) checkState(flow, catalog, issues, state);
+  for (const stateId of flow.anyState.except) {
+    if (!stateById(flow, stateId)) {
+      issues.warning("unknown_except_state", `\u041E\u0431\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u044B: \u0438\u0441\u043A\u043B\u044E\u0447\u0435\u043D\u043E \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 ${quote(stateId)}, \u043A\u043E\u0442\u043E\u0440\u043E\u0433\u043E \u043D\u0435\u0442`, { stateId });
+    }
+  }
+  flow.anyState.exits.forEach((exit, index) => checkExit(flow, catalog, issues, exit, index));
+  checkSchedule(flow, issues);
+  checkFlowNudges(flow, issues);
+  checkSideTasks(flow, issues);
+  if (start) {
+    const reachable = reachableFrom(flow, start);
+    const reported = /* @__PURE__ */ new Set();
+    for (const state of flow.states) {
+      if (reachable.has(state.id) || reported.has(state.id)) continue;
+      reported.add(state.id);
+      issues.error("unreachable_state", `${stateName(state)}: \u043D\u0435\u0434\u043E\u0441\u0442\u0438\u0436\u0438\u043C\u043E \u2014 \u0441\u044E\u0434\u0430 \u043D\u0435 \u0432\u0435\u0434\u0451\u0442 \u043D\u0438 \u043E\u0434\u0438\u043D \u043F\u0435\u0440\u0435\u0445\u043E\u0434 \u043E\u0442 \u0441\u0442\u0430\u0440\u0442\u0430`, { stateId: state.id });
+    }
+    if (!flow.states.some((state) => reachable.has(state.id) && isFinal(state))) {
+      issues.warning("no_reachable_end", "\u041D\u0435\u0442 \u0434\u043E\u0441\u0442\u0438\u0436\u0438\u043C\u043E\u0433\u043E \u043A\u043E\u043D\u0435\u0447\u043D\u043E\u0433\u043E \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F: \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439 \u043D\u0438\u043A\u043E\u0433\u0434\u0430 \u043D\u0435 \u0437\u0430\u043A\u043E\u043D\u0447\u0438\u0442\u0441\u044F \u0441\u0430\u043C");
+    }
+  }
+  return [...issues.list, ...options.checks ? appIssues(flow, options.checks(flow)) : []];
+}
+
+export {
+  AGENT_FLOW_FORMAT,
+  AGENT_FLOW_FORMAT_VERSION,
+  RETURN_TARGET,
+  ANY_STATE_LAYOUT_KEY,
+  FLOW_FIELD_TYPES,
+  FLOW_DATA_OPS,
+  FLOW_OPS_BY_FIELD_TYPE,
+  FLOW_EVENT_TYPES,
+  FLOW_TIMER_UNITS,
+  FLOW_TIMER_SPANS,
+  DEFAULT_LATE_START_HOURS,
+  DEFAULT_SIDE_TASK_MAX_ATTEMPTS,
+  FLOW_AFTER_END_MODES,
+  DEFAULT_SIDE_QUESTION_EVERY_MESSAGES,
+  agentFlowSchema,
+  migrateFlow,
+  parseFlow,
+  catalogEventNames,
+  catalogEventLabel,
+  compactFlow,
+  FLOW_STATE_KEY,
+  FLOW_PATH_LIMIT,
+  FLOW_CHAIN_LIMIT,
+  DEFAULT_FIRST_MESSAGES,
+  stateById,
+  isFinal,
+  isTouch,
+  commonApplies,
+  activeExits,
+  fieldById,
+  sameText,
+  parseBooleanAnswer,
+  fieldValueFits,
+  dataConditionHolds,
+  returnTarget,
+  parseClock,
+  clockMinutes,
+  nextClockTime,
+  startOfNextDay,
+  localDay,
+  dayOf,
+  dayInProgress,
+  dayStartAt,
+  nextDayStartAfter,
+  dayAnchor,
+  stateDaysDue,
+  flowDay,
+  deadlineAt,
+  beforeFirstNight,
+  withDayAnchor,
+  clockText,
+  stateNudges,
+  nextNudge,
+  dayStartHoldUntil,
+  FLOW_DEADLINE_EXIT,
+  timerDueAt,
+  overdueOnEntry,
+  nextDue,
+  FLOW_FIRST_EXIT,
+  FLOW_GIVE_UP_EXIT,
+  nextWake,
+  dueReasons,
+  nextFirstMessageAfter,
+  endingWake,
+  deferredWake,
+  describeCondition,
+  nextTransition,
+  startRun,
+  appendPath,
+  applyTransition,
+  noteHumanMessage,
+  noteAgentAnswer,
+  withoutUndeliveredTouch,
+  noteRejectedClaim,
+  claimAllowed,
+  noteSideQuestion,
+  withNudgeStep,
+  isFieldStale,
+  sideQuestion,
+  placeOfPath,
+  appIssues,
+  checkFlow
+};
+//# sourceMappingURL=chunk-BOV6FJGU.js.map