@ykurilov/agent-chat-flows 0.64.0 → 0.65.0

package/dist/chunk-KRZMJJKG.js

@@ -0,0 +1,817 @@
+import {
+  FLOW_CHAIN_LIMIT,
+  FLOW_DEADLINE_EXIT,
+  FLOW_FIRST_EXIT,
+  FLOW_STATE_KEY,
+  activeExits,
+  applyTransition,
+  dayClosedToday,
+  dayInProgress,
+  deadlineAt,
+  describeCondition,
+  fieldById,
+  fieldValueFits,
+  firstMessageSlot,
+  flowDay,
+  isFieldStale,
+  isFinal,
+  localDay,
+  migrateRun,
+  nextDayStartAfter,
+  nextTransition,
+  noteAgentAnswer,
+  noteHumanMessage,
+  overdueOnEntry,
+  resolveFirstMessages,
+  sideQuestion,
+  startRun,
+  stateById,
+  withDayAnchor,
+  withNudgeStep,
+  withoutUndeliveredTouch
+} from "./chunk-7VR4YNTJ.js";
+
+// src/prompt/state-card.ts
+function judgeExits(flow, stateId) {
+  const state = stateById(flow, stateId);
+  if (!state) return [];
+  return activeExits(flow, state).flatMap(({ exit }) => exit.when.type === "judge" ? [{ exitId: exit.id, text: exit.when.text }] : []);
+}
+function stateGoal(instructions) {
+  return instructions.split("\n")[0].trim();
+}
+function stateCard(flow, run, present) {
+  const state = stateById(flow, run.state);
+  if (!state) return `\u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \xAB${run.state}\xBB \u0432 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0438 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E: \u0432\u0435\u0434\u0438 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440 \u043F\u043E \u043E\u0431\u0449\u0438\u043C \u043F\u0440\u0430\u0432\u0438\u043B\u0430\u043C.`;
+  const [goal = "", ...rest] = state.instructions.split("\n");
+  const lines = [`\u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435: \xAB${state.title}\xBB`, `\u0426\u0435\u043B\u044C: ${goal.trim()}`];
+  const how = rest.join("\n").trim();
+  if (how) lines.push("", how);
+  const fields = state.learn.map((id) => fieldById(flow, id)).flatMap((found) => found ? [`- ${found.field.name}: ${found.field.about}`] : []);
+  if (fields.length > 0) lines.push("", "\u0423\u0437\u043D\u0430\u0442\u044C \u0437\u0434\u0435\u0441\u044C:", ...fields);
+  const conditions = judgeExits(flow, state.id);
+  if (isFinal(state)) {
+    lines.push("", "\u042D\u0442\u043E \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u0435\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F: \u0443\u0441\u043B\u043E\u0432\u0438\u0439 \u0432\u044B\u0445\u043E\u0434\u0430 \u043D\u0435\u0442.");
+  } else if (conditions.length > 0) {
+    lines.push("", "\u0423\u0441\u043B\u043E\u0432\u0438\u044F \u0432\u044B\u0445\u043E\u0434\u0430 (\u043D\u043E\u043C\u0435\u0440 \u2014 \u0434\u043B\u044F flow_exit):", ...conditions.map((condition, index) => `${index + 1}. ${condition.text}`));
+  }
+  const inSet = (name) => !present || present.has(name);
+  const tools = state.tools.filter(inSet);
+  if (tools.length > 0) lines.push("", `\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u044D\u0442\u043E\u0433\u043E \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F: ${tools.join(", ")}.`);
+  const unavailable = flow.tools.filter((name) => inSet(name) && !state.tools.includes(name));
+  if (unavailable.length > 0) lines.push(`\u0421\u0435\u0439\u0447\u0430\u0441 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B: ${unavailable.join(", ")}.`);
+  return lines.join("\n");
+}
+
+// src/runtime/flow-events.ts
+async function reportTransition(handler, event, logError) {
+  if (!handler) return;
+  try {
+    await handler(event);
+  } catch (error) {
+    logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${event.chatId} onTransition ${event.from} \u2192 ${event.to} \u0443\u043F\u0430\u043B: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function storedRun(value) {
+  return value && typeof value === "object" && typeof value.state === "string" ? value : null;
+}
+function currentRun(flow, values, now) {
+  return storedRun(values?.[FLOW_STATE_KEY]) ?? startRun(flow, now);
+}
+function placedRun(flow, placement, now, timeZone) {
+  const start = startRun(flow, now);
+  const state = placement.stateId !== void 0 && stateById(flow, placement.stateId) || stateById(flow, flow.start);
+  const startedAt = placement.startedAt ?? now;
+  const enteredAt = placement.enteredAt ?? placement.startedAt ?? now;
+  return {
+    ...start,
+    state: state.id,
+    startedAt,
+    enteredAt,
+    path: [{ state: state.id, at: enteredAt, tags: state.tags, from: null, exitId: null, decidedBy: "start" }],
+    ...placement.lastHumanAt !== void 0 && { lastHumanAt: placement.lastHumanAt },
+    ...placement.lastAgentAt !== void 0 && { lastAgentAt: placement.lastAgentAt },
+    ...placement.nudgeStep !== void 0 && { nudgeStep: placement.nudgeStep },
+    ...placement.humanToday && flow.schedule && timeZone && { dayCounts: { [dayInProgress(placement.humanToday.at, timeZone, flow.schedule)]: placement.humanToday.count } }
+  };
+}
+var msOf = (value) => value === void 0 ? void 0 : Date.parse(value);
+function recordPlacement(record) {
+  const placement = record.placement;
+  if (!placement) return null;
+  const lastHumanAt = msOf(placement.lastHumanAt);
+  const lastAgentAt = msOf(placement.lastAgentAt);
+  return {
+    stateId: record.stateId,
+    startedAt: Date.parse(placement.startedAt),
+    enteredAt: Date.parse(placement.enteredAt),
+    ...lastHumanAt !== void 0 && { lastHumanAt },
+    ...lastAgentAt !== void 0 && { lastAgentAt },
+    ...placement.nudgeStep !== void 0 && { nudgeStep: placement.nudgeStep },
+    ...placement.humanToday && { humanToday: { at: Date.parse(placement.humanToday.at), count: placement.humanToday.count } }
+  };
+}
+function chatRun(flow, values, record, now, timeZone) {
+  const stored = storedRun(values?.[FLOW_STATE_KEY]);
+  if (stored) return stored;
+  const placement = record ? recordPlacement(record) : null;
+  return placement ? placedRun(flow, placement, now, timeZone) : startRun(flow, now);
+}
+async function personTimeZone(runtime, chat) {
+  const known = runtime.timeZones ? await runtime.timeZones.of(chat.ownerId, chat.chatId) : (await runtime.store.getChat(chat.chatId))?.timeZone;
+  return known || runtime.defaultTimeZone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+async function runOutsideTurn(runtime, chat, flow, values, now, record) {
+  const stored = storedRun(values?.[FLOW_STATE_KEY]);
+  if (stored) return stored;
+  const found = record === void 0 ? await runtime.store.getChat(chat.chatId) : record;
+  if (!found?.placement) return startRun(flow, now);
+  const timeZone = runtime.timeZones ? await runtime.timeZones.of(chat.ownerId, chat.chatId) : found.timeZone || void 0;
+  return chatRun(flow, values, found, now, timeZone);
+}
+function advance(flow, run, event, input) {
+  let current = run;
+  let step = event;
+  let entered = false;
+  let stopped = false;
+  while (step) {
+    const transition = nextTransition(flow, current, step, input.now);
+    if (!transition) {
+      if (current.chain >= FLOW_CHAIN_LIMIT && nextTransition(flow, { ...current, chain: 0 }, step, input.now)) {
+        if (!stopped) input.onChainLimit(current);
+        stopped = true;
+      }
+      const overdue = entered && !stopped && step.type === "data" ? overdueOnEntry(flow, current, input.now, input.timeZone) : null;
+      step = overdue ? { type: "timer", exitId: overdue, timeZone: input.timeZone } : null;
+      continue;
+    }
+    current = applyTransition(flow, current, transition);
+    input.out.push(transition);
+    entered = true;
+    step = { type: "data", card: input.card };
+  }
+  return current;
+}
+function pendingEvent(transition, timeZone) {
+  if (transition.decidedBy === "timer") return { type: "timer", exitId: transition.exitId, timeZone };
+  return { type: "verdict", exitId: transition.exitId, probability: transition.probability ?? 1, decidedBy: "judge" };
+}
+function withPending(flow, run, pending, input) {
+  let current = run;
+  for (const change of pending) {
+    if (change.kind === "transition") {
+      if (change.branchHead !== run.answerId || current.state !== change.transition.from) continue;
+      current = advance(flow, current, pendingEvent(change.transition, input.timeZone), input);
+    } else if (change.kind === "event") {
+      current = advance(flow, current, { type: "event", event: "app", name: change.name }, input);
+    }
+  }
+  return current;
+}
+var chainLimitMessage = (chatId, run) => `[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId} ${FLOW_CHAIN_LIMIT} \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u043E\u0432 \u043F\u043E\u0434\u0440\u044F\u0434 \u0431\u0435\u0437 \u043E\u0442\u0432\u0435\u0442\u0430 \u0430\u0433\u0435\u043D\u0442\u0430, \u0434\u0432\u0438\u0436\u043E\u043A \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u0432 \xAB${run.state}\xBB`;
+function exitById(flow, exitId) {
+  for (const state of flow.states) {
+    const found = state.exits.find((exit) => exit.id === exitId);
+    if (found) return found;
+  }
+  return flow.anyState.exits.find((exit) => exit.id === exitId);
+}
+function exactFirstText(flow, stateId) {
+  return stateById(flow, stateId)?.firstMessage ?? null;
+}
+var sayExactly = (text) => `\u041F\u0435\u0440\u0432\u043E\u0435 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u044D\u0442\u043E\u0433\u043E \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F \u2014 \u0441\u043A\u0430\u0436\u0438 \u0440\u043E\u0432\u043D\u043E \u044D\u0442\u043E: \xAB${text}\xBB`;
+function transitionNotice(flow, transitions) {
+  const lines = transitions.map((transition) => {
+    const exit = exitById(flow, transition.exitId);
+    const title = stateById(flow, transition.to)?.title ?? transition.to;
+    return `\u0421\u0440\u0430\u0431\u043E\u0442\u0430\u043B\u043E: ${exit ? describeCondition(flow, exit.when) : transition.exitId} \u2192 \xAB${title}\xBB.`;
+  });
+  const last = transitions.at(-1);
+  const first = exactFirstText(flow, last.to);
+  if (first) lines.push(sayExactly(first));
+  return {
+    kind: "app",
+    name: "flow_transition",
+    title: lines.join("\n"),
+    data: { from: transitions[0].from, to: last.to, exitIds: transitions.map((transition) => transition.exitId) }
+  };
+}
+function transitionReport(flow, run, transitions) {
+  const from = stateById(flow, transitions[0].from)?.title ?? transitions[0].from;
+  const lines = [`\u041F\u0435\u0440\u0435\u0445\u043E\u0434: \xAB${from}\xBB \u2192 \xAB${stateById(flow, run.state)?.title ?? run.state}\xBB. \u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0441\u043C\u0435\u043D\u0438\u043B\u043E\u0441\u044C, \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0430\u0439 \u043F\u043E \u043D\u043E\u0432\u043E\u0439 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0435.`, "", stateCard(flow, run)];
+  const first = exactFirstText(flow, run.state);
+  if (first) lines.push("", sayExactly(first));
+  return lines.join("\n");
+}
+
+// src/runtime/test-clock.ts
+var FLOW_TEST_CHAT_KEY = "flowTestChat";
+function flowTestChatData() {
+  return { [FLOW_TEST_CHAT_KEY]: { timeOffset: 0 } };
+}
+function testChatOffset(data) {
+  const mark = data?.[FLOW_TEST_CHAT_KEY];
+  if (!mark || typeof mark !== "object") return null;
+  const offset = mark.timeOffset;
+  return typeof offset === "number" && Number.isFinite(offset) ? offset : 0;
+}
+var chatTime = (run, serverNow) => serverNow + (run?.timeOffset ?? 0);
+var FlowTestClockError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FlowTestClockError";
+  }
+  code;
+};
+var NEXT_FIRST_MESSAGE_STEPS = 50;
+var TURN_WAIT_LIMIT = 5;
+async function placeRun(runtime, port, chat, flow, now) {
+  const { values } = await port.getChatState(chat.ownerId, chat.chatId);
+  const stored = storedRun(values[FLOW_STATE_KEY]);
+  if (stored) return stored;
+  const record = await runtime.store.getChat(chat.chatId);
+  return record ? runOutsideTurn(runtime, chat, flow, values, now, record) : null;
+}
+async function msToNextDay(runtime, port, ownerId, chatId, offset) {
+  const pinned = await runtime.chatFlow(ownerId, chatId);
+  const schedule = pinned?.flow.schedule;
+  if (!pinned || !schedule) throw new Error("\u041F\u0435\u0440\u0435\u043C\u043E\u0442\u043A\u0430 \u0434\u043E \u0443\u0442\u0440\u0430: \u0443 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u043D\u0435 \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043D\u044B \xAB\u0414\u043D\u0438 \u0438 \u0432\u0440\u0435\u043C\u044F\xBB (schedule)");
+  const chatNow = runtime.now() + offset;
+  const run = await placeRun(runtime, port, { ownerId, chatId }, pinned.flow, chatNow);
+  if (!run) throw new Error("\u041F\u0435\u0440\u0435\u043C\u043E\u0442\u043A\u0430 \u0434\u043E \u0443\u0442\u0440\u0430: \u0432 \u0447\u0430\u0442\u0435 \u0435\u0449\u0451 \u043D\u0435 \u0431\u044B\u043B\u043E \u0445\u043E\u0434\u0430, \u0434\u043D\u0438 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F \u043D\u0435 \u043D\u0430\u0447\u0430\u043B\u0438\u0441\u044C");
+  const timeZone = runtime.timeZones ? await runtime.timeZones.of(ownerId, chatId) : "UTC";
+  return flowDay(run, chatNow, timeZone, schedule).nextDayStartAt - chatNow;
+}
+async function turnFinished(port, ownerId, chatId) {
+  for (let turn = 0; turn < TURN_WAIT_LIMIT; turn += 1) {
+    const stream = await port.subscribe?.(ownerId, chatId);
+    if (!stream) return;
+    for await (const _chunk of stream) ;
+  }
+}
+async function advanceTestClock(input) {
+  const { runtime, port, timers, ownerId, chatId, clock } = input;
+  const offset = testChatOffset(await port.getChatData(ownerId, chatId));
+  if (offset === null) throw new Error(`\u0427\u0430\u0442 ${chatId} \u043D\u0435 \u0442\u0435\u0441\u0442\u043E\u0432\u044B\u0439: \u0447\u0430\u0441\u044B \u043F\u0435\u0440\u0435\u043C\u0430\u0442\u044B\u0432\u0430\u044E\u0442\u0441\u044F \u0442\u043E\u043B\u044C\u043A\u043E \u0443 \u0442\u0435\u0441\u0442\u043E\u0432\u044B\u0445 \u0447\u0430\u0442\u043E\u0432`);
+  if (clock.to === "next_first_message") return advanceToNextFirstMessage({ runtime, port, timers, ownerId, chatId, offset });
+  const ms = clock.to === "next_day_start" ? await msToNextDay(runtime, port, ownerId, chatId, offset) : clock.ms ?? Number.NaN;
+  if (!Number.isFinite(ms) || ms <= 0) throw new Error("\u041F\u0435\u0440\u0435\u043C\u043E\u0442\u043A\u0430 \u0447\u0430\u0441\u043E\u0432: \u043D\u0443\u0436\u0435\u043D \u0441\u0434\u0432\u0438\u0433 \u0432\u043F\u0435\u0440\u0451\u0434, \u043C\u0441 \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0443\u043B\u044F");
+  const timeOffset = offset + ms;
+  await port.updateChatData(ownerId, chatId, { [FLOW_TEST_CHAT_KEY]: { timeOffset } });
+  const pinned = timers && await runtime.chatFlow(ownerId, chatId);
+  if (!timers || !pinned) return { timeOffset };
+  const run = await placeRun(runtime, port, { ownerId, chatId }, pinned.flow, runtime.now() + timeOffset);
+  if (!run) return { timeOffset };
+  await timers.reschedule({ ownerId, chatId, run: { ...run, timeOffset }, branchHead: run.answerId ?? null });
+  await timers.tick();
+  await turnFinished(port, ownerId, chatId);
+  return { timeOffset };
+}
+var nothingScheduled = (chatId) => new FlowTestClockError("nothing_scheduled", `\u0427\u0430\u0442 ${chatId}: \u0432\u043F\u0435\u0440\u0435\u0434\u0438 \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439 \u0441\u0430\u043C \u043D\u0438\u0447\u0435\u0433\u043E \u043D\u0435 \u043D\u0430\u043F\u0438\u0448\u0435\u0442 \u2014 \u043F\u0435\u0440\u0435\u043C\u0430\u0442\u044B\u0432\u0430\u0442\u044C \u043D\u0435 \u043A \u0447\u0435\u043C\u0443`);
+async function advanceToNextFirstMessage(input) {
+  const { runtime, port, timers, ownerId, chatId } = input;
+  const pinned = timers && await runtime.chatFlow(ownerId, chatId);
+  if (!timers?.watch || !pinned) throw nothingScheduled(chatId);
+  let timeOffset = input.offset;
+  for (let step = 0; step < NEXT_FIRST_MESSAGE_STEPS; step += 1) {
+    const run = await placeRun(runtime, port, { ownerId, chatId }, pinned.flow, runtime.now() + timeOffset);
+    if (!run) throw nothingScheduled(chatId);
+    if (step === 0) await timers.reschedule({ ownerId, chatId, run: { ...run, timeOffset }, branchHead: run.answerId ?? null });
+    const record = await runtime.store.getChat(chatId);
+    if (!record || record.endedAt !== null || record.dueAt === null) throw nothingScheduled(chatId);
+    const serverNow = runtime.now();
+    const shift = Math.max(0, Date.parse(record.dueAt) - serverNow);
+    if (shift > 0) {
+      timeOffset += shift;
+      await port.updateChatData(ownerId, chatId, { [FLOW_TEST_CHAT_KEY]: { timeOffset } });
+      await runtime.store.setDue(chatId, { at: new Date(serverNow).toISOString(), exitId: record.dueExitId ?? FLOW_FIRST_EXIT, branchHead: record.dueBranchHead });
+    }
+    let reason = null;
+    const unwatch = timers.watch(chatId, (fired) => reason ??= fired);
+    try {
+      await timers.tick();
+      await turnFinished(port, ownerId, chatId);
+    } finally {
+      unwatch();
+    }
+    if (reason) return { timeOffset, reason };
+  }
+  throw new FlowTestClockError("not_reached", `\u0427\u0430\u0442 ${chatId}: \u0441\u0440\u043E\u043A \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F \u043E\u0442\u043A\u043B\u0430\u0434\u044B\u0432\u0430\u043B\u0441\u044F ${NEXT_FIRST_MESSAGE_STEPS} \u0440\u0430\u0437 \u043F\u043E\u0434\u0440\u044F\u0434 \u2014 \u043F\u0435\u0440\u0435\u043C\u043E\u0442\u043A\u0430 \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430`);
+}
+
+// src/runtime/client-facts.ts
+var FACT_PREFIX = "fact:";
+var MAX_FACTS = 30;
+var MAX_FACT_LENGTH = 200;
+var normalized = (text) => text.trim().toLowerCase().replace(/\s+/g, " ");
+function factId(text) {
+  let hash = 2166136261;
+  for (const char of normalized(text)) {
+    hash ^= char.codePointAt(0);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `f${hash.toString(16).padStart(8, "0")}`;
+}
+var sameFact = (left, right) => normalized(left) === normalized(right);
+var isFactEntry = (fieldId) => fieldId.startsWith(FACT_PREFIX);
+var byWriteOrder = (left, right) => left.updatedAt.localeCompare(right.updatedAt) || left.id.localeCompare(right.id);
+function moduleFacts(store) {
+  const read = async (ownerId) => {
+    const entries = await store.readCard(ownerId);
+    return entries.filter((entry) => isFactEntry(entry.fieldId)).map((entry) => ({ id: entry.fieldId.slice(FACT_PREFIX.length), text: String(entry.value), updatedAt: entry.updatedAt, chatId: entry.chatId, flowId: entry.flowId })).sort(byWriteOrder);
+  };
+  return {
+    read,
+    add: ({ ownerId, fact, chatId, flowId, at }) => store.writeCardField({ ownerId, fieldId: `${FACT_PREFIX}${fact.id}`, value: fact.text, chatId, flowId, at: at.toISOString() }),
+    async forget(ownerId, id) {
+      if (id !== "all") return store.forgetCard(ownerId, `${FACT_PREFIX}${id}`);
+      for (const fact of await read(ownerId)) await store.forgetCard(ownerId, `${FACT_PREFIX}${fact.id}`);
+    }
+  };
+}
+function clientFactStore(store, adapter) {
+  const own = adapter?.facts;
+  if (!own) return moduleFacts(store);
+  return {
+    read: async (ownerId) => [...await own.read(ownerId)].sort(byWriteOrder),
+    add: (input) => own.add(input),
+    forget: (ownerId, id) => own.forget(ownerId, id)
+  };
+}
+var factEntry = (fact) => ({ fieldId: `${FACT_PREFIX}${fact.id}`, value: fact.text, updatedAt: fact.updatedAt, chatId: fact.chatId, flowId: fact.flowId });
+
+// src/runtime/first-message-retry.ts
+var FIRST_MESSAGE_RETRY_MS = 36e5;
+var FIRST_MESSAGE_MIN_RETRY_MS = 6e4;
+
+// src/runtime/first-message-rules.ts
+function chatWriteBlock(chat, at, timeZone, schedule) {
+  if (chat.windowClosed) return { retryAt: null };
+  const pausedUntil = chat.pausedUntil ? Date.parse(chat.pausedUntil) : 0;
+  if (pausedUntil > at) return { retryAt: pausedUntil };
+  if (schedule && dayClosedToday(chat.dayClosedOn, at, timeZone, schedule)) return { retryAt: nextDayStartAfter(at, timeZone, schedule) };
+  return null;
+}
+function scenarioRules(rules, schedule) {
+  if (!schedule) return rules;
+  return {
+    quietHours: { from: schedule.nightFrom ?? rules.quietHours.from, to: schedule.dayStart },
+    maxPerDay: schedule.firstMessages?.maxPerDay ?? rules.maxPerDay
+  };
+}
+function createFirstMessageRules(setting, store) {
+  const rules = resolveFirstMessages(setting);
+  if (!rules) return null;
+  return {
+    async check({ ownerId, chatId, at, timeZone, schedule, chat }) {
+      const blocked = chat ? chatWriteBlock(chat, at, timeZone, schedule) : null;
+      if (blocked) return { allowed: false, retryAt: blocked.retryAt };
+      const sentToday = await store.countFirstMessages(ownerId, localDay(at, timeZone));
+      const slot = firstMessageSlot(scenarioRules(rules, schedule), { at, timeZone, sentToday });
+      if (!slot.allowed) return slot;
+      const answer = rules.canWriteNow ? await rules.canWriteNow({ ownerId, chatId, at: new Date(at) }) : true;
+      if (answer === true) return { allowed: true };
+      return { allowed: false, retryAt: retryAtOf(answer, at) };
+    },
+    async record({ ownerId, at, timeZone }) {
+      await store.addFirstMessage(ownerId, localDay(at, timeZone));
+    }
+  };
+}
+function retryAtOf(answer, at) {
+  if (answer === "never") return null;
+  const retryAt = typeof answer === "object" && answer !== null && answer.retryAt instanceof Date ? answer.retryAt.getTime() : Number.NaN;
+  if (!Number.isFinite(retryAt)) return at + FIRST_MESSAGE_RETRY_MS;
+  return Math.max(retryAt, at + FIRST_MESSAGE_MIN_RETRY_MS);
+}
+var UNKNOWN_TIME_ZONE = "";
+var serverTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
+function pageTimeZone(turnZone, appZone, sent) {
+  if (sent !== void 0) return sent;
+  return turnZone === (appZone ?? serverTimeZone()) ? null : turnZone;
+}
+function createChatTimeZones(input) {
+  const warned = /* @__PURE__ */ new Set();
+  return {
+    of(chatId, stored) {
+      if (stored) return stored;
+      if (input.defaultTimeZone) return input.defaultTimeZone;
+      const app = input.appTimeZone();
+      if (app) return app;
+      const server = serverTimeZone();
+      if (!warned.has(chatId)) {
+        warned.add(chatId);
+        input.warn(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${chatId}: \u043F\u043E\u044F\u0441 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u0435\u043D (\u043D\u0435\u0442 \u043D\u0438 \u0441\u043E \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u044B, \u043D\u0438 defaultTimeZone, \u043D\u0438 agent.timeZone) \u2014 \u0442\u0438\u0445\u0438\u0435 \u0447\u0430\u0441\u044B \u0438 \xAB\u0432\u0440\u0435\u043C\u044F \u0441\u0443\u0442\u043E\u043A\xBB \u043F\u043E \u043F\u043E\u044F\u0441\u0443 \u0441\u0435\u0440\u0432\u0435\u0440\u0430 ${server}`);
+      }
+      return server;
+    }
+  };
+}
+function ianaTimeZone(value) {
+  if (!value.trim()) return null;
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: value.trim() }).resolvedOptions().timeZone;
+  } catch {
+    return null;
+  }
+}
+function createFlowTimeZones(input) {
+  const { store } = input;
+  const iso = () => new Date(input.now()).toISOString();
+  const readPerson = (ownerId) => input.people ? input.people.readTimeZone(ownerId) : store.readTimeZone(ownerId);
+  const writePerson = (ownerId, timeZone) => input.people ? input.people.writeTimeZone(ownerId, timeZone) : store.writeTimeZone(ownerId, timeZone, iso());
+  async function known(ownerId, chatId) {
+    const person = await readPerson(ownerId);
+    if (person) return person;
+    return (await store.getChat(chatId))?.timeZone || null;
+  }
+  return {
+    known,
+    fallback: input.fallback,
+    async of(ownerId, chatId) {
+      return await known(ownerId, chatId) ?? input.fallback(chatId);
+    },
+    async write(ownerId, chatId, timeZone) {
+      if (await readPerson(ownerId) !== timeZone) await writePerson(ownerId, timeZone);
+      const record = await store.getChat(chatId);
+      if (record && record.timeZone !== timeZone) await store.updateChat(chatId, { timeZone }, iso());
+    }
+  };
+}
+
+// src/runtime/first-reasons-notice.ts
+var REASON_LINES = {
+  morning: "\u041D\u0430\u0447\u0430\u043B\u0441\u044F \u043D\u043E\u0432\u044B\u0439 \u0434\u0435\u043D\u044C \u0441\u0446\u0435\u043D\u0430\u0440\u0438\u044F: \u0443\u043C\u0435\u0441\u0442\u043D\u043E \u0434\u043E\u0431\u0440\u043E\u0435 \u0443\u0442\u0440\u043E.",
+  silence: (step) => `\u0427\u0435\u043B\u043E\u0432\u0435\u043A \u043C\u043E\u043B\u0447\u0438\u0442 \u043F\u043E\u0441\u043B\u0435 \u0442\u0432\u043E\u0435\u0433\u043E \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F (\u043A\u0430\u0441\u0430\u043D\u0438\u0435 ${step}).`,
+  daily: (at) => `\u041A\u0430\u0441\u0430\u043D\u0438\u0435 \u043F\u043E \u0440\u0430\u0441\u043F\u0438\u0441\u0430\u043D\u0438\u044E, ${at}.`,
+  nightMessages: (count) => `\u0427\u0435\u043B\u043E\u0432\u0435\u043A \u043D\u0430\u043A\u043E\u043F\u0438\u043B \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F \u0431\u0435\u0437 \u043E\u0442\u0432\u0435\u0442\u0430 (${count}): \u043E\u0442\u0432\u0435\u0442\u044C \u043D\u0430 \u043D\u0438\u0445.`
+};
+var TASK = "\u0422\u044B \u043F\u0438\u0448\u0435\u0448\u044C \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0443 \u043F\u0435\u0440\u0432\u044B\u043C. \u041D\u0430\u043F\u0438\u0448\u0438 \u043E\u0434\u043D\u043E \u043A\u043E\u0440\u043E\u0442\u043A\u043E\u0435 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435: \u043D\u043E\u0432\u043E\u0435 \u0438 \u043F\u043E\u043B\u0435\u0437\u043D\u043E\u0435 \u0434\u043B\u044F \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u043F\u043E \u0442\u0435\u043C\u0435 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440\u0430, \u0431\u0435\u0437 \u043F\u043E\u0432\u0442\u043E\u0440\u0430 \u0443\u0436\u0435 \u0441\u043A\u0430\u0437\u0430\u043D\u043D\u043E\u0433\u043E \u0438 \u0431\u0435\u0437 \u0443\u043F\u0440\u0451\u043A\u043E\u0432 \u0437\u0430 \u043C\u043E\u043B\u0447\u0430\u043D\u0438\u0435.";
+var transitionLine = (flow, exitId) => {
+  const exit = exitById(flow, exitId);
+  return `\u0421\u0440\u0430\u0431\u043E\u0442\u0430\u043B\u043E: ${exit ? describeCondition(flow, exit.when) : exitId}`;
+};
+function reasonLine(reason) {
+  switch (reason.kind) {
+    case "morning":
+      return REASON_LINES.morning;
+    case "silence":
+      return REASON_LINES.silence(reason.step);
+    case "daily":
+      return REASON_LINES.daily(reason.at);
+    case "night_messages":
+      return REASON_LINES.nightMessages(reason.count);
+    default:
+      return null;
+  }
+}
+function silentMsOf(run, at) {
+  return run.lastHumanAt === null ? void 0 : Math.max(0, at - run.lastHumanAt);
+}
+function firstReasonsNotice(flow, reasons, exitId, ownNudge = false, silentMs) {
+  const silence = reasons.find((reason) => reason.kind === "silence");
+  const moved = exitId !== null && reasons.some((reason) => reason.kind === "transition");
+  const morning = reasons.some((reason) => reason.kind === "morning");
+  const nudgeStep = moved || morning ? 0 : silence?.kind === "silence" ? silence.step : void 0;
+  const own = ownNudge && silence !== void 0 && !moved && !morning;
+  const exit = moved ? exitOnScreen(flow, exitId, reasons) : void 0;
+  const data = {
+    ...moved && { exitId },
+    reasons: [...reasons],
+    ...nudgeStep !== void 0 && { nudgeStep },
+    ...own && { nudgeStepOwn: true },
+    ...silentMs !== void 0 && { silentMs },
+    ...exit && { exit }
+  };
+  const others = reasons.flatMap((reason) => reasonLine(reason) ?? []);
+  if (others.length === 0 && moved) return { kind: "app", name: FLOW_TIMER_NOTICE, title: transitionLine(flow, exitId), data };
+  const lines = [...moved ? [`${transitionLine(flow, exitId)}.`] : [], ...others, TASK];
+  return { kind: "app", name: FLOW_TIMER_NOTICE, title: lines.join("\n"), data };
+}
+function exitOnScreen(flow, exitId, reasons) {
+  const to = reasons.find((reason) => reason.kind === "transition");
+  const state = to?.kind === "transition" ? stateById(flow, to.stateId) : void 0;
+  const when = exitById(flow, exitId)?.when;
+  if (!state && !when) return void 0;
+  return { ...state && { stateTitle: state.title }, ...when && { when } };
+}
+
+// src/runtime/flow-finish.ts
+var FLOW_DEADLINE_NOTICE = "flow_deadline";
+var DEADLINE_REASON = { kind: "timer", text: "\u0441\u0440\u043E\u043A \u0432\u044B\u0448\u0435\u043B" };
+var FAREWELL_NOTICE = "\u0421\u0440\u043E\u043A \u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u044B \u0432\u044B\u0448\u0435\u043B. \u041F\u043E\u043F\u0440\u043E\u0449\u0430\u0439\u0441\u044F \u0441 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u043E\u043C \u043E\u0434\u043D\u0438\u043C \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435\u043C: \u043A\u043E\u0440\u043E\u0442\u043A\u043E \u043F\u043E\u0434\u0432\u0435\u0434\u0438 \u0438\u0442\u043E\u0433 \u0438 \u0441\u043A\u0430\u0436\u0438, \u0447\u0442\u043E \u0434\u0430\u043B\u044C\u0448\u0435.";
+function afterEndOf(flow) {
+  return flow.afterEnd ?? "reply";
+}
+var finalEndsChat = (flow) => flow.schedule !== void 0 || flow.afterEnd !== void 0;
+function deadlineTransition(flow, run, at) {
+  const to = flow.schedule?.deadlineState;
+  const state = to === void 0 ? void 0 : stateById(flow, to);
+  if (!state || run.state === state.id) return null;
+  return { from: run.state, to: state.id, exitId: FLOW_DEADLINE_EXIT, decidedBy: "timer", tags: state.tags, at, reason: DEADLINE_REASON };
+}
+function endedRun(flow, run, ended) {
+  if (run.endedAt !== void 0) return run;
+  const transition = ended.endReason === "deadline" ? deadlineTransition(flow, run, ended.endedAt) : null;
+  const moved = transition ? applyTransition(flow, run, transition) : run;
+  return { ...moved, endedAt: ended.endedAt, endReason: ended.endReason };
+}
+function createFlowFinish(input) {
+  const { runtime } = input;
+  async function report(event) {
+    const { onFinish } = input;
+    if (!onFinish) return;
+    const { schedule } = event.pinned.flow;
+    let day = null;
+    if (schedule) {
+      const timeZone = await runtime.timeZones?.of(event.ownerId, event.chatId) ?? "UTC";
+      day = flowDay(event.run, event.at, timeZone, schedule).day;
+      if (schedule.lengthDays !== void 0) day = Math.min(day, schedule.lengthDays);
+    }
+    const { answerId: _answerId, firstReasons: _firstReasons, ...run } = event.run;
+    const finish = {
+      ownerId: event.ownerId,
+      chatId: event.chatId,
+      flowId: event.pinned.flowId,
+      versionId: event.pinned.versionId,
+      reason: event.reason,
+      ...event.outcome !== void 0 && { outcome: event.outcome },
+      day,
+      state: event.run.state,
+      tags: stateById(event.pinned.flow, event.run.state)?.tags ?? [],
+      run,
+      at: new Date(event.at)
+    };
+    const work = Promise.resolve().then(() => onFinish(finish)).catch((error) => runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${event.chatId} onFinish \u0443\u043F\u0430\u043B: ${error instanceof Error ? error.message : String(error)}`));
+    if (runtime.track) runtime.track(work);
+    else await work;
+  }
+  async function close(chatId, reason, at) {
+    const before = await runtime.store.getChat(chatId);
+    if (!before || before.endedAt !== null) return false;
+    const after = await runtime.store.endChat(chatId, { reason, at: new Date(at).toISOString() });
+    return after !== null && after.endReason === reason && Date.parse(after.endedAt ?? "") === at;
+  }
+  return {
+    async afterTransitions({ ownerId, chatId, pinned, run, transitions }) {
+      const final = transitions.find((transition) => {
+        const state = stateById(pinned.flow, transition.to);
+        return state !== void 0 && isFinal(state);
+      });
+      if (!final) return;
+      if (finalEndsChat(pinned.flow) && !await close(chatId, "final", final.at)) return;
+      await report({ ownerId, chatId, pinned, run, reason: "final", at: final.at });
+    },
+    async deadline({ ownerId, chatId, pinned, run, at }) {
+      const ended = await close(chatId, "deadline", at);
+      const transition = deadlineTransition(pinned.flow, run, at);
+      let next = run;
+      if (ended && transition) {
+        next = applyTransition(pinned.flow, run, transition);
+        await runtime.afterTransitions({ ownerId, chatId, pinned, run: next, transitions: [transition] });
+      }
+      if (ended) await report({ ownerId, chatId, pinned, run: next, reason: "deadline", at });
+      return { run: endedRun(pinned.flow, next, { endedAt: at, endReason: "deadline" }), ended };
+    },
+    async farewell({ ownerId, chatId, pinned, run, at, timeZone, port, firstMessages, delivery }) {
+      const schedule = pinned.flow.schedule;
+      if (!schedule?.farewellOnDeadline) return;
+      const record = await runtime.store.getChat(chatId);
+      const chat = record ? { dayClosedOn: record.dayClosedOn, pausedUntil: record.pausedUntil, windowClosed: record.windowClosed } : void 0;
+      const allowed = firstMessages ? await firstMessages.check({ ownerId, chatId, at, timeZone, schedule, ...chat && { chat } }) : { allowed: true };
+      if (!allowed.allowed) return;
+      const text = schedule.farewellText?.trim();
+      const silentMs = silentMsOf(run, at);
+      const result = await port.deliverNotices({
+        ownerId,
+        chatId,
+        notices: [{ kind: "app", name: FLOW_DEADLINE_NOTICE, title: FAREWELL_NOTICE, data: { reasons: [{ kind: "farewell" }], ...silentMs !== void 0 && { silentMs } } }],
+        wakeAgent: true,
+        deliveryKey: `flow:${chatId}:deadline`,
+        usageSource: "first_message",
+        maxServerTurnsInRow: false,
+        timeZone,
+        ...delivery?.own() && { awaitAnswer: true },
+        ...text && { reply: { text } }
+      });
+      if (result.status !== "delivered" || !result.turnStarted) return;
+      if (delivery) await delivery.afterFirstTurn({ ownerId, chatId, answer: result.answer, reasons: [{ kind: "farewell" }], at, timeZone });
+      else await firstMessages?.record({ ownerId, at, timeZone });
+    },
+    async end({ ownerId, chatId, pinned, run, reason, outcome, at }) {
+      const ended = await close(chatId, reason, at);
+      if (ended) await report({ ownerId, chatId, pinned, run, reason, ...outcome !== void 0 && { outcome }, at });
+      return { ended };
+    }
+  };
+}
+
+// src/runtime/prepare-turn.ts
+var FLOW_TIMER_NOTICE = "flow_timer";
+var FLOW_EVENT_NOTICE = "flow_event";
+var HUMAN_ACTIONS = /* @__PURE__ */ new Set(["send", "edit", "regenerate", "retry"]);
+var transitionKey = (transition) => `${transition.from}\0${transition.exitId}`;
+var errorText = (error) => error instanceof Error ? error.message : String(error);
+var dataOf = (notice) => notice.data && typeof notice.data === "object" ? notice.data : {};
+var firstReasonsOf = (notices) => notices.flatMap((notice) => {
+  if (notice.kind !== "app" || notice.name !== FLOW_TIMER_NOTICE && notice.name !== FLOW_DEADLINE_NOTICE) return [];
+  const { reasons } = dataOf(notice);
+  return Array.isArray(reasons) ? reasons : [];
+});
+function flowPrepareTurn(runtime, appTimeZone, finisher) {
+  return async (ctx) => {
+    if (ctx.audience === "group") return;
+    let pinned = await runtime.chatFlow(ctx.ownerId, ctx.chatId, ctx.chat);
+    if (!pinned) return;
+    const timeOffset = testChatOffset(ctx.chat.data);
+    const now = runtime.now() + (timeOffset ?? 0);
+    const transitions = [];
+    let card;
+    const applied = [];
+    const step = async (run2, event, out = transitions) => advance(pinned.flow, run2, event, {
+      now,
+      card: card ??= await runtime.cardValues(ctx.ownerId),
+      out,
+      onChainLimit: (stopped) => runtime.logError(chainLimitMessage(ctx.chatId, stopped)),
+      timeZone
+    });
+    const record = await runtime.store.getChat(ctx.chatId);
+    const page = pageTimeZone(ctx.timeZone, appTimeZone(), ctx.pageTimeZone);
+    const known = page ?? (runtime.timeZones ? await runtime.timeZones.known(ctx.ownerId, ctx.chatId) : record?.timeZone || null);
+    const timeZone = known ?? runtime.defaultTimeZone ?? ctx.timeZone;
+    let run = currentRun(pinned.flow, ctx.state, now);
+    const previousAnswer = run.answerId;
+    const pending = await runtime.store.takePending(ctx.chatId);
+    const appliedInTime = new Set(
+      pending.flatMap((change) => change.kind === "transition" && change.appliedAt !== void 0 && change.branchHead === previousAnswer ? [transitionKey(change.transition)] : [])
+    );
+    let restored = null;
+    const restore = () => restored ??= Promise.all(pending.map((change) => runtime.store.addPending(ctx.chatId, change)));
+    const onAbort = () => void restore().catch((error) => runtime.logError(`[\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439] \u0447\u0430\u0442=${ctx.chatId} \u043E\u0436\u0438\u0434\u0430\u044E\u0449\u0435\u0435 \u043D\u0435 \u0432\u043E\u0437\u0432\u0440\u0430\u0449\u0435\u043D\u043E: ${errorText(error)}`));
+    if (pending.length > 0) ctx.abortSignal.addEventListener("abort", onAbort, { once: true });
+    try {
+      return await applyTurn();
+    } catch (error) {
+      await restore();
+      throw error;
+    } finally {
+      ctx.abortSignal.removeEventListener("abort", onAbort);
+    }
+    async function applyTurn() {
+      const schedule = pinned.flow.schedule;
+      if (schedule) run = withDayAnchor(run, timeZone, schedule);
+      if (record?.endedAt) {
+        run = endedRun(pinned.flow, run, { endedAt: Date.parse(record.endedAt), endReason: record.endReason ?? "final" });
+      } else if (schedule && finisher) {
+        const deadline = deadlineAt(run, timeZone, schedule);
+        if (deadline !== null && deadline <= now) {
+          ({ run } = await finisher().deadline({ ownerId: ctx.ownerId, chatId: ctx.chatId, pinned, run, at: deadline, timeZone }));
+        }
+      }
+      const ended = run.endedAt !== void 0;
+      for (const change of ended ? [] : pending) {
+        if (change.kind === "migrate") {
+          const next = await runtime.chatFlow(ctx.ownerId, ctx.chatId);
+          if (next) {
+            run = { ...migrateRun(run, next.flow, change.map, now), answerId: previousAnswer };
+            pinned = next;
+          }
+        } else if (change.kind === "transition") {
+          if (change.branchHead !== previousAnswer || run.state !== change.transition.from) continue;
+          const out = [];
+          run = await step(run, pendingEvent(change.transition, timeZone), out);
+          for (const transition of out) (appliedInTime.has(transitionKey(transition)) ? applied : transitions).push(transition);
+        } else {
+          run = await step(run, { type: "event", event: "app", name: change.name });
+        }
+      }
+      let touchBase = null;
+      for (const notice of ended ? [] : ctx.notices) {
+        if (notice.kind !== "app") continue;
+        const data = dataOf(notice);
+        if (notice.name === FLOW_TIMER_NOTICE) {
+          if (typeof data.undelivered === "string") run = withoutUndeliveredTouch(run, /* @__PURE__ */ new Set([data.undelivered])).run;
+          if (typeof data.exitId === "string") run = await step(run, { type: "timer", exitId: data.exitId, timeZone });
+          touchBase = { lastAgentAt: run.lastAgentAt, nudgeStep: run.nudgeStep ?? 0, ...run.nudgeStepOwn && { nudgeStepOwn: true }, agentAnswers: run.agentAnswers };
+          if (typeof data.nudgeStep === "number") run = withNudgeStep(run, data.nudgeStep, data.nudgeStepOwn === true);
+        } else if (notice.name === FLOW_EVENT_NOTICE && typeof data.name === "string") {
+          run = await step(run, { type: "event", event: "app", name: data.name });
+        }
+      }
+      if (!ctx.resumed && HUMAN_ACTIONS.has(ctx.action)) {
+        if (record?.windowClosed) await runtime.store.setWindowClosed(ctx.chatId, false);
+        run = noteHumanMessage(run, now, schedule ? dayInProgress(now, timeZone, schedule) : void 0, ctx.burstMessageIds?.length ?? 1);
+        if (!ended) run = await step(run, { type: "event", event: "message" });
+      }
+      if (ctx.action === "notice" && !ctx.resumed) run = { ...run, serverTurns: (run.serverTurns ?? 0) + 1 };
+      if (ctx.action !== "approval" && ctx.action !== "widget") run = noteAgentAnswer(run, now);
+      const { touch: earlierTouch, firstReasons: earlierReasons, ...withoutTouch } = run;
+      const continued = ctx.action === "approval" || ctx.action === "widget";
+      const touch = touchBase ? { answerId: ctx.messageId, at: now, ...touchBase } : continued ? earlierTouch : void 0;
+      const reasons = firstReasonsOf(ctx.notices);
+      const firstReasons = reasons.length > 0 ? reasons : continued ? earlierReasons : void 0;
+      run = { ...withoutTouch, answerId: ctx.messageId, ...timeOffset !== null && { timeOffset }, ...touch && { touch }, ...firstReasons && { firstReasons } };
+      if (ctx.abortSignal.aborted) {
+        await restore();
+        return void 0;
+      }
+      if (known && runtime.timeZones) await runtime.timeZones.write(ctx.ownerId, ctx.chatId, known);
+      else if (record && page && record.timeZone !== page) await runtime.store.updateChat(ctx.chatId, { timeZone: page }, new Date(runtime.now()).toISOString());
+      await runtime.afterTransitions({ ownerId: ctx.ownerId, chatId: ctx.chatId, pinned, run, transitions });
+      return {
+        set: { [FLOW_STATE_KEY]: run },
+        ...applied.length + transitions.length > 0 && { notices: [transitionNotice(pinned.flow, [...applied, ...transitions])] }
+      };
+    }
+  };
+}
+
+// src/prompt/client-card-block.ts
+function fieldValueText(value) {
+  if (typeof value === "string") return value.trim();
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "\u0434\u0430" : "\u043D\u0435\u0442";
+  return JSON.stringify(value);
+}
+function questionLine(flow, run, card, now) {
+  const question = sideQuestion(flow, run, { card, now });
+  const found = question && fieldById(flow, question.fieldId);
+  if (!question || !found) return "\u0421\u0435\u0439\u0447\u0430\u0441 \u043D\u0435 \u0441\u043F\u0440\u0430\u0448\u0438\u0432\u0430\u0439 \u043D\u0438\u0447\u0435\u0433\u043E \u043E \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0435 \u043C\u0435\u0436\u0434\u0443 \u0434\u0435\u043B\u043E\u043C: \u043E\u0442\u0432\u0435\u0442\u044C \u043D\u0430 \u0442\u043E, \u0447\u0442\u043E \u043E\u043D \u043F\u0438\u0448\u0435\u0442.";
+  const { field } = found;
+  const noted = `flow_note { asked: "${field.id}" }`;
+  if (question.reason === "learn") return `\u0421\u043D\u0430\u0447\u0430\u043B\u0430 \u0443\u0437\u043D\u0430\u0439: \xAB${field.name}\xBB \u2014 ${field.about} \u0417\u0430\u043F\u0438\u0448\u0438 \u043E\u0442\u0432\u0435\u0442 \u0447\u0435\u0440\u0435\u0437 flow_note.`;
+  if (question.reason === "stale") {
+    return `\u0414\u0430\u0432\u043D\u043E \u043D\u0435 \u0443\u0442\u043E\u0447\u043D\u044F\u043B\u0438: \xAB${field.name}\xBB (\u0441\u0435\u0439\u0447\u0430\u0441 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E: ${fieldValueText(card[field.id].value)}). \u041C\u044F\u0433\u043A\u043E \u0441\u0432\u0435\u0440\u044C \u043E\u0434\u043D\u0438\u043C \u043A\u043E\u0440\u043E\u0442\u043A\u0438\u043C \u0432\u043E\u043F\u0440\u043E\u0441\u043E\u043C \u043A \u043C\u0435\u0441\u0442\u0443. \u0421\u043F\u0440\u043E\u0441\u0438\u043B \u2014 \u043E\u0442\u043C\u0435\u0442\u044C ${noted}; \u0435\u0441\u043B\u0438 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u043E\u0441\u044C \u2014 \u0437\u0430\u043F\u0438\u0448\u0438 \u043D\u043E\u0432\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0447\u0435\u0440\u0435\u0437 flow_note.`;
+  }
+  return `\u041C\u043E\u0436\u043D\u043E \u0441\u043F\u0440\u043E\u0441\u0438\u0442\u044C \u043C\u0435\u0436\u0434\u0443 \u0434\u0435\u043B\u043E\u043C: \xAB${field.name}\xBB \u2014 ${field.about} \u041E\u0434\u0438\u043D \u043A\u043E\u0440\u043E\u0442\u043A\u0438\u0439 \u0432\u043E\u043F\u0440\u043E\u0441 \u043A \u043C\u0435\u0441\u0442\u0443, \u043D\u0435 \u0432 \u043B\u043E\u0431. \u0421\u043F\u0440\u043E\u0441\u0438\u043B \u2014 \u043E\u0442\u043C\u0435\u0442\u044C ${noted}.`;
+}
+function clientCardBlock(input) {
+  const { flow, run, now } = input;
+  const facts = input.facts ?? [];
+  if (flow.clientCard.length === 0 && flow.chatNotes.length === 0 && facts.length === 0) return "";
+  const byId = new Map(input.card.map((entry) => [entry.fieldId, { value: entry.value, updatedAt: Date.parse(entry.updatedAt) }]));
+  const known = (field, value) => fieldValueFits(field, value);
+  const cardLines = flow.clientCard.flatMap((field) => {
+    const entry = byId.get(field.id);
+    if (!entry || !known(field, entry.value)) return [];
+    const stale = isFieldStale(field, entry.updatedAt, now) ? " (\u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E \u0434\u0430\u0432\u043D\u043E, \u043C\u043E\u0433\u043B\u043E \u0438\u0437\u043C\u0435\u043D\u0438\u0442\u044C\u0441\u044F)" : "";
+    return [`- ${field.name}: ${fieldValueText(entry.value)}${stale}`];
+  });
+  const noteLines = flow.chatNotes.flatMap((field) => known(field, run.notes[field.id]) ? [`- ${field.name}: ${fieldValueText(run.notes[field.id])}`] : []);
+  const lines = ["\u0427\u0442\u043E \u0438\u0437\u0432\u0435\u0441\u0442\u043D\u043E \u043E \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0435 (\u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0430 \u043A\u043B\u0438\u0435\u043D\u0442\u0430):", ...cardLines.length > 0 ? cardLines : facts.length > 0 ? [] : ["- \u043F\u043E\u043A\u0430 \u043D\u0438\u0447\u0435\u0433\u043E \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E"]];
+  if (facts.length > 0) lines.push("", "\u0424\u0430\u043A\u0442\u044B \u043E \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0435:", ...facts.map((fact) => `- ${fact.text}`));
+  if (noteLines.length > 0) lines.push("", "\u0417\u0430\u043C\u0435\u0442\u043A\u0438 \u044D\u0442\u043E\u0433\u043E \u0447\u0430\u0442\u0430:", ...noteLines);
+  lines.push("", questionLine(flow, run, Object.fromEntries(byId), now));
+  return lines.join("\n");
+}
+
+export {
+  judgeExits,
+  stateGoal,
+  stateCard,
+  reportTransition,
+  storedRun,
+  currentRun,
+  chatRun,
+  personTimeZone,
+  runOutsideTurn,
+  advance,
+  withPending,
+  chainLimitMessage,
+  exactFirstText,
+  transitionReport,
+  FIRST_MESSAGE_RETRY_MS,
+  chatWriteBlock,
+  createFirstMessageRules,
+  UNKNOWN_TIME_ZONE,
+  pageTimeZone,
+  createChatTimeZones,
+  ianaTimeZone,
+  createFlowTimeZones,
+  flowTestChatData,
+  testChatOffset,
+  chatTime,
+  FlowTestClockError,
+  advanceTestClock,
+  FLOW_TIMER_NOTICE,
+  FLOW_EVENT_NOTICE,
+  flowPrepareTurn,
+  silentMsOf,
+  firstReasonsNotice,
+  FLOW_DEADLINE_NOTICE,
+  afterEndOf,
+  endedRun,
+  createFlowFinish,
+  fieldValueText,
+  clientCardBlock,
+  FACT_PREFIX,
+  MAX_FACTS,
+  MAX_FACT_LENGTH,
+  factId,
+  sameFact,
+  isFactEntry,
+  clientFactStore,
+  factEntry
+};
+//# sourceMappingURL=chunk-KRZMJJKG.js.map