@wirecat/bitrix24-cli 0.3.0 → 0.5.0

package/dist/bundle/{chunk-VEWWAGTD.js → chunk-GLTKRLFT.js}

@@ -2,12 +2,12 @@ import { createRequire as __bundleRequire } from "node:module";
 const require = __bundleRequire(import.meta.url);
 import {
   CliError
-} from "./chunk-IRV2PCQ2.js";
+} from "./chunk-EYYOKT23.js";
 import {
   __name
 } from "./chunk-ZVVMGPBJ.js";
 
-// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/search/languages.js
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/search/languages.js
 var LANGUAGES = [
   { name: "russian", code: "ru", label: "Russian", script: "cyrillic", dictionary: "dictionary-ru" },
   { name: "english", code: "en", label: "English", script: "latin", dictionary: "dictionary-en" },
@@ -15,12 +15,12 @@ var LANGUAGES = [
 ];
 var languagesOf = /* @__PURE__ */ __name((script) => LANGUAGES.filter((one) => one.script === script).map(({ name }) => name), "languagesOf");
 
-// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/store/normalize.js
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/store/normalize.js
 var NORMALIZER_VERSION = 1;
 var fold = /* @__PURE__ */ __name((text) => text.normalize("NFKD").replace(new RegExp("\\p{M}+", "gu"), "").normalize("NFC").toLowerCase(), "fold");
 var normalize = /* @__PURE__ */ __name((text) => fold(text).replace(new RegExp("\\p{Cc}", "gu"), " ").replace(/\s+/gu, " ").trim(), "normalize");
 
-// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/search/snowball/base-stemmer.js
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/search/snowball/base-stemmer.js
 var BaseStemmer = class {
   static {
     __name(this, "BaseStemmer");
@@ -395,7 +395,7 @@ var BaseStemmer = class {
   }
 };
 
-// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/search/snowball/english-stemmer.js
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/search/snowball/english-stemmer.js
 var a_0 = [
   ["arsen", -1],
   ["commun", -1],
@@ -1096,7 +1096,7 @@ var english_stemmer_default = class extends BaseStemmer {
   stemWord = this.stem;
 };
 
-// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/search/snowball/russian-stemmer.js
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/search/snowball/russian-stemmer.js
 var a_02 = [
   ["\u0432", 1],
   ["\u0438\u0432", 2, 1],
@@ -1519,7 +1519,7 @@ var russian_stemmer_default = class extends BaseStemmer {
   stemWord = this.stem;
 };
 
-// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/search/snowball/spanish-stemmer.js
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/search/snowball/spanish-stemmer.js
 var a_03 = [
   ["", 6],
   ["\xE1", 1, 1],
@@ -2195,7 +2195,7 @@ var spanish_stemmer_default = class extends BaseStemmer {
   stemWord = this.stem;
 };
 
-// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/search/stem.js
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/search/stem.js
 var SNOWBALL_VERSION = "3.1.1";
 var CYRILLIC_STEMMERS = [...languagesOf("cyrillic"), "none"];
 var LATIN_STEMMERS = [...languagesOf("latin"), "none"];

package/dist/bundle/chunk-GUUZQ7NE.js

@@ -0,0 +1,581 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  LOG_ATTRIBUTES,
+  MESSENGER_CHANGE_REFUSAL,
+  currentRun,
+  fromLogAttributes,
+  logAttributes,
+  readOnlyRefusal
+} from "./chunk-G5MW6RCM.js";
+import {
+  CEILING_KEY,
+  keyForWrite,
+  levelFor,
+  skipFlagFor
+} from "./chunk-OUMFNB34.js";
+import {
+  CliError,
+  logRecordOf,
+  realSleep,
+  resolvePaths,
+  writeSecurely
+} from "./chunk-EYYOKT23.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/sends/guard.js
+import { randomUUID } from "node:crypto";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/sends/flood.js
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var MOST_DEADLINES = 50;
+var LIMITED_HOLD_MS = 60 * 60 * 1e3;
+var FROZEN_HOLD_MS = 24 * 60 * 60 * 1e3;
+var NO_END = "9999-12-31T23:59:59.999Z";
+var holdEnd = /* @__PURE__ */ __name((block, show = (iso) => iso) => block.until === null ? "until lifted" : `until ${show(block.until)}`, "holdEnd");
+var floodPathFor = /* @__PURE__ */ __name((app, profile, env = process.env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "flood", `${profile}.json`), "floodPathFor");
+var FloodMemory = class {
+  static {
+    __name(this, "FloodMemory");
+  }
+  path;
+  now;
+  constructor(path, now = Date.now) {
+    this.path = path;
+    this.now = now;
+  }
+  /** What is still in force; anything expired is left out. */
+  read() {
+    const now = this.now();
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(this.path, "utf8"));
+    } catch {
+      return { deadlines: [] };
+    }
+    const alive = /* @__PURE__ */ __name((until) => typeof until === "string" && Date.parse(until) > now, "alive");
+    const deadlines = Array.isArray(raw.deadlines) ? raw.deadlines.filter((one) => typeof one?.operation === "string" && alive(one.until)) : [];
+    const block = raw.sendBlock && (raw.sendBlock.until === NO_END ? { ...raw.sendBlock, until: null } : raw.sendBlock);
+    const held = block && (block.until === null || alive(block.until));
+    return { deadlines, ...held ? { sendBlock: block } : {} };
+  }
+  /** The deadline this call is still under: one for its chat, or one for the call in every chat. */
+  owed(operation, chatId) {
+    return this.read().deadlines.filter((one) => one.operation === operation && (one.chatId === void 0 || one.chatId === chatId)).sort((a, b) => b.until.localeCompare(a.until))[0];
+  }
+  remember(deadline) {
+    const { waitMs, ...rest } = deadline;
+    const kept = { ...rest, until: new Date(this.now() + waitMs).toISOString() };
+    const state = this.read();
+    const others = state.deadlines.filter((one) => one.operation !== kept.operation || one.chatId !== kept.chatId);
+    const deadlines = [...others, kept].sort((a, b) => b.until.localeCompare(a.until)).slice(0, MOST_DEADLINES);
+    this.#write({ ...state, deadlines });
+    return kept;
+  }
+  sendBlock() {
+    return this.read().sendBlock;
+  }
+  /** A ban the messenger gave no end for holds until lifted; a spam limit or a freeze without one, for a while. */
+  block(block) {
+    const now = this.now();
+    const holdMs = { limited: LIMITED_HOLD_MS, frozen: FROZEN_HOLD_MS, banned: void 0 }[block.state];
+    const kept = {
+      ...block,
+      since: new Date(now).toISOString(),
+      until: block.until ?? (holdMs === void 0 ? null : new Date(now + holdMs).toISOString())
+    };
+    this.#write({ ...this.read(), sendBlock: kept });
+    return kept;
+  }
+  /** Lifts only a block of this state: an account found not frozen may still be limited for spam. */
+  unblock(state) {
+    const { sendBlock, ...rest } = this.read();
+    if (sendBlock?.state === state)
+      this.#write(rest);
+  }
+  /** Forgets every wait and lifts the hold, and answers with what was still in force. */
+  clear() {
+    const cleared = this.read();
+    this.#write({ deadlines: [] });
+    return cleared;
+  }
+  #write({ sendBlock, ...rest }) {
+    const state = sendBlock ? { ...rest, sendBlock: { ...sendBlock, until: sendBlock.until ?? NO_END } } : rest;
+    mkdirSync(dirname(this.path), { recursive: true, mode: 448 });
+    const temporary = `${this.path}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(state)}
+`, { mode: 384 });
+    renameSync(temporary, this.path);
+  }
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/sends/journal.js
+import { appendFileSync, mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/sends/file-lock.js
+import { closeSync, mkdirSync as mkdirSync2, openSync, statSync, unlinkSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var LOCK_WAIT_MS = 5e3;
+var LOCK_STALE_MS = 3e4;
+var RETRY_MS = 20;
+var pause = new Int32Array(new SharedArrayBuffer(4));
+var withFileLock = /* @__PURE__ */ __name((path, what, body, waitMs = LOCK_WAIT_MS) => {
+  const lock = lockFor(path);
+  const deadline = Date.now() + waitMs;
+  while (!taken(lock)) {
+    if (Date.now() >= deadline)
+      throw lockTimeout(what, waitMs, lock);
+    Atomics.wait(pause, 0, 0, RETRY_MS);
+  }
+  return holding(lock, body);
+}, "withFileLock");
+var withFileLockAsync = /* @__PURE__ */ __name(async (path, what, body, waitMs = LOCK_WAIT_MS, sleep = realSleep) => {
+  const lock = lockFor(path);
+  const deadline = Date.now() + waitMs;
+  while (!taken(lock)) {
+    if (Date.now() >= deadline)
+      throw lockTimeout(what, waitMs, lock);
+    await sleep(RETRY_MS);
+  }
+  return holding(lock, body);
+}, "withFileLockAsync");
+var lockFor = /* @__PURE__ */ __name((path) => {
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  return `${path}.lock`;
+}, "lockFor");
+var taken = /* @__PURE__ */ __name((lock) => {
+  for (; ; ) {
+    try {
+      closeSync(openSync(lock, "wx", 384));
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      if (Date.now() - lockTime(lock) <= LOCK_STALE_MS)
+        return false;
+      try {
+        unlinkSync(lock);
+      } catch {
+      }
+    }
+  }
+}, "taken");
+var holding = /* @__PURE__ */ __name((lock, body) => {
+  try {
+    return body();
+  } finally {
+    try {
+      unlinkSync(lock);
+    } catch {
+    }
+  }
+}, "holding");
+var lockTimeout = /* @__PURE__ */ __name((what, waitMs, lock) => new CliError("timeout", `${what} stayed locked for ${waitMs / 1e3}s (${lock})`), "lockTimeout");
+var lockTime = /* @__PURE__ */ __name((lock) => {
+  try {
+    return statSync(lock).mtimeMs;
+  } catch {
+    return Date.now();
+  }
+}, "lockTime");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/sends/journal.js
+var sendsPathFor = /* @__PURE__ */ __name((app, profile, env = process.env) => join2(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "sends", `${profile}.jsonl`), "sendsPathFor");
+var SendJournal = class {
+  static {
+    __name(this, "SendJournal");
+  }
+  path;
+  resource;
+  constructor(path, resource = { service: "unknown", version: "unknown" }) {
+    this.path = path;
+    this.resource = resource;
+  }
+  /**
+   * Runs `body` with the journal to itself, across processes: two sends at the limit must not both
+   * read "one left". A lock file opened with `wx`, because `flock` is not there on Windows.
+   */
+  locked(body) {
+    return withFileLock(this.path, "the send journal", body);
+  }
+  /** `locked` without blocking the thread while another process holds the journal: what `serve` uses. */
+  lockedAsync(body) {
+    return withFileLockAsync(this.path, "the send journal", body);
+  }
+  append(entry) {
+    const { at, ...attributes } = entry;
+    const { runId, command, traceId } = currentRun();
+    const record = logRecordOf({
+      severity: entry.outcome === "sent" || entry.outcome === "reserved" ? "info" : "warn",
+      event: logAttributes({ event: "send.recorded", ...attributes }),
+      time: at,
+      runId,
+      ...traceId === void 0 ? {} : { traceId },
+      command,
+      resource: this.resource,
+      allow: LOG_ATTRIBUTES
+    });
+    mkdirSync3(dirname3(this.path), { recursive: true, mode: 448 });
+    appendFileSync(this.path, `${JSON.stringify(record)}
+`, { mode: 384 });
+  }
+  /**
+   * Oldest first, each reservation folded into its outcome; one with no outcome yet is in flight,
+   * or its process died. A line that does not parse is skipped: a torn last write must not block sending.
+   */
+  entries(filter) {
+    const lines = this.#lines();
+    const settled = new Set(lines.filter((entry) => entry.outcome !== "reserved").map((entry) => entry.reservation));
+    const entries = lines.filter((entry) => entry.outcome !== "reserved" || !settled.has(entry.reservation)).map(({ reservation, ...entry }) => entry.outcome === "reserved" ? { ...entry, reservation } : entry).map(withSendId);
+    return filter === void 0 ? entries : entries.filter((entry) => (filter.outcome === void 0 || entry.outcome === filter.outcome) && (filter.chatId === void 0 || entry.chatId === filter.chatId) && (filter.operationId === void 0 || entry.operationId === filter.operationId) && (filter.errorCode === void 0 || entry.errorCode === filter.errorCode) && (filter.key === void 0 || entry.key === filter.key));
+  }
+  #lines() {
+    let text;
+    try {
+      text = readFileSync2(this.path, "utf8");
+    } catch {
+      return [];
+    }
+    return text.split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+      try {
+        return [entryOf(JSON.parse(line))];
+      } catch {
+        return [];
+      }
+    });
+  }
+};
+var entryOf = /* @__PURE__ */ __name((line) => {
+  if (!("attributes" in line))
+    return line;
+  const { event: _, ...attributes } = line.attributes;
+  return { at: line.time, ...fromLogAttributes(attributes) };
+}, "entryOf");
+var withSendId = /* @__PURE__ */ __name((entry) => {
+  const { cid, ...rest } = entry;
+  return cid === void 0 || rest.sendId !== void 0 ? rest : { ...rest, sendId: String(cid) };
+}, "withSendId");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/sends/recipients.js
+import { existsSync, readFileSync as readFileSync3, rmSync } from "node:fs";
+import { join as join3 } from "node:path";
+var recipientsPathFor = /* @__PURE__ */ __name((app, profile, env = process.env) => join3(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "profiles", `${profile}.recipients.json`), "recipientsPathFor");
+var RecipientList = class {
+  static {
+    __name(this, "RecipientList");
+  }
+  path;
+  command;
+  lockWaitMs;
+  /** `command` names the program in the hint that turns the list off. */
+  constructor(path, command, lockWaitMs) {
+    this.path = path;
+    this.command = command;
+    this.lockWaitMs = lockWaitMs;
+  }
+  /** `undefined` when the list is off. A file that cannot be read refuses rather than opening up. */
+  read() {
+    if (!existsSync(this.path))
+      return void 0;
+    try {
+      const parsed = JSON.parse(readFileSync3(this.path, "utf8"));
+      if (!Array.isArray(parsed.chats))
+        throw new Error("no `chats` array");
+      return parsed.chats;
+    } catch (error) {
+      throw new CliError("configuration_error", `the recipient list ${this.path} cannot be read (${error instanceof Error ? error.message : String(error)}) \u2014 fix the file or turn the list off with \`${this.command} recipients clear\``);
+    }
+  }
+  list(filter = {}) {
+    const chats = this.read();
+    return {
+      state: chats === void 0 ? "off" : chats.length === 0 ? "empty" : "on",
+      items: (chats ?? []).filter((chat) => (filter.id === void 0 || chat.id === filter.id) && (filter.title === void 0 || chat.title?.toLocaleLowerCase() === filter.title.toLocaleLowerCase()))
+    };
+  }
+  /** Whether it was new. Adding one again fills in a partner an older entry was stored without. */
+  add(recipient) {
+    return this.#locked(() => this.#added(recipient));
+  }
+  /** `add` waiting for the lock on timers: `recipients add` connects, so it runs inside `serve` when one holds the account. */
+  addAsync(recipient) {
+    return withFileLockAsync(this.path, "the recipient list", () => this.#added(recipient), this.lockWaitMs);
+  }
+  #added(recipient) {
+    const chats = this.read() ?? [];
+    const known = chats.find((chat) => chat.id === recipient.id);
+    if (known) {
+      if (recipient.partnerId && !known.partnerId) {
+        this.#write(chats.map((chat) => chat === known ? { ...known, partnerId: recipient.partnerId } : chat));
+      }
+      return false;
+    }
+    this.#write([...chats, recipient]);
+    return true;
+  }
+  /** The id or the title as it was stored; `undefined` when neither matched. */
+  remove(reference) {
+    return this.#locked(() => {
+      const chats = this.read() ?? [];
+      const wanted = reference.trim();
+      const gone = chats.find((chat) => chat.id === wanted) ?? chats.find((chat) => chat.title?.toLocaleLowerCase() === wanted.toLocaleLowerCase());
+      if (gone)
+        this.#write(chats.filter((chat) => chat !== gone));
+      return gone;
+    });
+  }
+  /**
+   * The chat the messenger now names `to`: its entry, and a partner of that id, follow it. Only an entry already there
+   * changes, and no list is created, so the list never opens up. Whether anything changed.
+   */
+  async rekey(from, to) {
+    if (from === to)
+      return false;
+    return withFileLockAsync(this.path, "the recipient list", () => {
+      const chats = this.read();
+      if (!chats?.some((chat) => chat.id === from || chat.partnerId === from))
+        return false;
+      const held = chats.some((chat) => chat.id === to);
+      this.#write(chats.filter((chat) => !(held && chat.id === from)).map((chat) => ({
+        ...chat,
+        ...chat.id === from ? { id: to } : {},
+        ...chat.partnerId === from ? { partnerId: to } : {}
+      })));
+      return true;
+    }, this.lockWaitMs);
+  }
+  /** Whether there was a list to turn off. */
+  off() {
+    return this.#locked(() => {
+      if (!existsSync(this.path))
+        return false;
+      rmSync(this.path);
+      return true;
+    });
+  }
+  /**
+   * Every change reads and writes under one lock: a `serve` re-keying while the owner removes a chat must not write
+   * the removed chat back. A lock held too long refuses the change and leaves the list as it was. Blocks the thread
+   * while it waits: for callers that cannot be async, and `recipients remove` and `clear`, which never
+   * connect and so never run inside `serve`.
+   */
+  #locked(body) {
+    return withFileLock(this.path, "the recipient list", body, this.lockWaitMs);
+  }
+  #write(chats) {
+    writeSecurely(this.path, `${JSON.stringify({ chats }, null, 2)}
+`, 384);
+  }
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/sends/guard.js
+var HOUR_MS = 60 * 60 * 1e3;
+var READS_UNDER_HOLD = /* @__PURE__ */ new Set([
+  "attachments.extract",
+  "conversations.embeddings",
+  "conversations.links",
+  "messages.server-search",
+  "messages.sync-first",
+  "stats.contacts.top.sync-first",
+  "stats.messages.counters.sync",
+  "stats.messages.show.sync-first",
+  "stats.messages.top.sync-first",
+  "store.gaps.repair"
+]);
+var countsTowardLimit = /* @__PURE__ */ __name(({ kind = "message", action, notify }) => kind === "message" || kind === "forward" || kind === "edit" || kind === "delete" || kind === "pin" && notify === true || action === "create" || action === "members.add" || action === "requests.accept" || action === "join" || action === "contact-import", "countsTowardLimit");
+var weightOf = /* @__PURE__ */ __name(({ kind = "message", action, count, people }) => kind === "delete" || kind === "message" && action === void 0 ? Math.max(1, count ?? 1) : action === "create" || action === "members.add" || action === "requests.accept" || action === "contact-import" ? Math.max(1, people ?? count ?? 1) : 1, "weightOf");
+var timeOf = /* @__PURE__ */ __name((entry) => Date.parse(entry.scheduledFor ?? entry.at), "timeOf");
+var ceilingRefusal = /* @__PURE__ */ __name((key, command) => new CliError("permission_error", `${key} is not allowed: setup's answer keeps every WireCat tool read-only; the owner changes it at a terminal with \`${command} setup\``, { permission: key }), "ceilingRefusal");
+var levelRefusal = /* @__PURE__ */ __name((refused, fix = `${refused.command} ${refused.profile} config set permissions.${refused.key} allow`) => refused.named === CEILING_KEY ? ceilingRefusal(refused.key, refused.command) : new CliError("permission_error", `profile ${refused.profile} does not let ${refused.key} write (permissions.${refused.named} is ${refused.level}, from the ${refused.permissionSources[refused.named ?? ""] ?? "default"}); to allow it: ${fix}`, { permission: refused.key }), "levelRefusal");
+var sendGuard = /* @__PURE__ */ __name(({ profile, recipients, command = recipients.command, readOnlyLock, permissions, permissionSources = {}, permissionDefaults, permissionFix, ask = refuseToAsk, sendsPerHour, journal, flood, warn, now = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "now") }) => {
+  const currentPermissions = /* @__PURE__ */ __name(() => typeof permissions === "function" ? permissions() : permissions, "currentPermissions");
+  let reservation;
+  const answered = /* @__PURE__ */ new WeakSet();
+  const refuseReadOnly = /* @__PURE__ */ __name(() => {
+    if (readOnlyLock)
+      throw readOnlyRefusal(readOnlyLock, MESSENGER_CHANGE_REFUSAL);
+  }, "refuseReadOnly");
+  const refuseHeld = /* @__PURE__ */ __name(({ key }) => {
+    if (key !== void 0 && READS_UNDER_HOLD.has(key))
+      return;
+    const block = flood?.sendBlock();
+    if (!block)
+      return;
+    throw new CliError("permission_error", `profile ${profile} holds its writes ${holdEnd(block)}: ${block.hint} \u2014 reads still work; do not retry: the owner checks the account with \`${command} ${profile} doctor --online\`, and lifts the hold with \`${command} ${profile} flood clear\` once it is over`, { sendBlock: block, standing: { state: block.state, hint: block.hint } });
+  }, "refuseHeld");
+  const permitted = /* @__PURE__ */ __name((request) => {
+    const { chatId, kind = "message", action, personIds } = request;
+    refuseReadOnly();
+    const levels = currentPermissions();
+    if (levels !== void 0) {
+      const key = request.key ?? keyForWrite(kind, action);
+      const { level, key: named } = levelFor(levels, key, permissionDefaults);
+      if (level === "deny" || level === "readonly")
+        throw levelRefusal({ profile, command, key, level, named, permissionSources }, permissionFix?.(request, key));
+      if (level === "ask" && !answered.has(request)) {
+        throw new CliError("confirmation_required", `${key} asks before it acts, and it was not asked`);
+      }
+    }
+    const allowed = recipients.read();
+    if (chatId !== null && allowed && !allowed.some((chat) => chat.id === chatId)) {
+      throw new CliError("confirmation_required", `chat ${chatId} is not on the recipient list of profile ${profile} \u2014 the owner adds it with \`${command} ${profile} recipients add ${chatId}\``, { chat_id: chatId });
+    }
+    const strangers = allowed ? (personIds ?? []).filter((id) => !allowed.some((chat) => chat.partnerId === id)) : [];
+    if (strangers.length > 0) {
+      throw new CliError("confirmation_required", `${strangers.join(", ")} ${strangers.length === 1 ? "is" : "are"} not on the recipient list of profile ${profile} \u2014 the owner adds the one-to-one chat with each person (\`${command} ${profile} recipients add <chat>\`); a chat added to the list earlier is added again to be recognised`, { person_ids: strangers });
+    }
+  }, "permitted");
+  const withinLimit = /* @__PURE__ */ __name((request, entries) => {
+    const { chatId, sendId } = request;
+    const asked = { ...request, people: request.personIds?.length ?? request.count };
+    const count = weightOf(asked);
+    if (count > sendsPerHour) {
+      throw new CliError("rate_limited", `${count} at once is more than the hourly limit of profile ${profile} (sendsPerHour ${sendsPerHour}) \u2014 do fewer at a time`);
+    }
+    const at = request.scheduledFor ? Date.parse(request.scheduledFor) : now().getTime();
+    const counted = entries.filter(countsTowardLimit).filter((entry) => entry.outcome === "sent" || entry.outcome === "outcome_unknown" || entry.outcome === "reserved").filter((entry) => Math.abs(timeOf(entry) - at) < HOUR_MS);
+    const unsure = /* @__PURE__ */ __name((entry) => entry.outcome === "outcome_unknown", "unsure");
+    const same = /* @__PURE__ */ __name((a, b) => a.sendId !== void 0 && a.sendId === b.sendId && a.chatId === b.chatId, "same");
+    const last = [...counted].reverse().find((entry) => same(entry, { chatId, sendId }));
+    if (sendId !== void 0 && last && unsure(last)) {
+      if (last.sendAs !== request.sendAs) {
+        throw new CliError("validation_error", "this send id was tried under another identity; repeat it with the same --send-as, or it may post twice", { operation_id: sendId, retryable: false });
+      }
+      return false;
+    }
+    const recent = counted.filter((entry, index) => !(unsure(entry) && counted.slice(index + 1).some((later) => same(later, entry)))).map((entry) => ({ time: timeOf(entry), weight: weightOf(entry) })).sort((a, b) => a.time - b.time);
+    const used = recent.reduce((sum, { weight }) => sum + weight, 0);
+    if (used + count > sendsPerHour) {
+      let freed = 0;
+      const opening = recent.find(({ weight }) => {
+        freed += weight;
+        return used - freed + count <= sendsPerHour;
+      });
+      const nextMs = (opening?.time ?? 0) + HOUR_MS;
+      const next = new Date(nextMs).toISOString();
+      throw new CliError("rate_limited", `profile ${profile} has sent ${used} messages in the hour around ${new Date(at).toISOString()}, and its limit is ${sendsPerHour} (sendsPerHour) \u2014 the next send is possible at ${next}`, { retry_after_ms: nextMs - now().getTime(), retry_at: next });
+    }
+    return true;
+  }, "withinLimit");
+  const counting = /* @__PURE__ */ __name((request) => {
+    permitted(request);
+    refuseHeld(request);
+    const asked = { ...request, people: request.personIds?.length ?? request.count };
+    const creatingTopic = request.kind === "chat" && request.action === "topic-create";
+    if (!countsTowardLimit(asked) && !creatingTopic)
+      return void 0;
+    const checked = /* @__PURE__ */ __name((entries) => {
+      if (!creatingTopic)
+        return withinLimit(request, entries);
+      if (request.sendId === void 0)
+        throw new CliError("validation_error", "a topic creation needs an attempt id");
+      if (entries.some((entry) => entry.action === "topic-create" && entry.sendId === request.sendId && ["sent", "outcome_unknown", "reserved"].includes(entry.outcome))) {
+        throw new CliError("validation_error", "this topic creation was already attempted; check topics list and do not repeat an unknown creation", { operation_id: request.sendId, retryable: false });
+      }
+      return true;
+    }, "checked");
+    const reserving = /* @__PURE__ */ __name(() => {
+      if (!checked(journal.entries()))
+        return;
+      const id = randomUUID();
+      const { chatId, kind, action, sendId, operationId, scheduledFor, notify } = request;
+      journal.append({
+        at: now().toISOString(),
+        profile,
+        chatId,
+        outcome: "reserved",
+        reservation: id,
+        ...kind ? { kind } : {},
+        ...action ? { action } : {},
+        ...asked.people === void 0 ? {} : kind === "delete" || kind === "message" || kind === void 0 ? { count: asked.people } : { people: asked.people },
+        ...sendId === void 0 ? {} : { sendId },
+        ...operationId === void 0 ? {} : { operationId },
+        ...scheduledFor ? { scheduledFor } : {},
+        ...notify === void 0 ? {} : { notify }
+      });
+      reservation = id;
+    }, "reserving");
+    return { checked, reserving };
+  }, "counting");
+  return {
+    ask: /* @__PURE__ */ __name(async (request) => {
+      refuseReadOnly();
+      const levels = currentPermissions();
+      if (levels === void 0)
+        return;
+      const key = request.key ?? keyForWrite(request.kind ?? "message", request.action);
+      if (levelFor(levels, key, permissionDefaults).level !== "ask")
+        return;
+      refuseHeld(request);
+      await ask(key, request);
+      answered.add(request);
+    }, "ask"),
+    check: /* @__PURE__ */ __name((request, { reserve = true } = {}) => {
+      const counted = counting(request);
+      if (!counted)
+        return;
+      if (reserve)
+        journal.locked(counted.reserving);
+      else
+        counted.checked(journal.entries());
+    }, "check"),
+    reserve: /* @__PURE__ */ __name(async (request) => {
+      const counted = counting(request);
+      if (counted)
+        await journal.lockedAsync(counted.reserving);
+    }, "reserve"),
+    // After a send, a failure to write here must not become the command's answer: the message is
+    // already with a person, and an error would invite the caller to send it again.
+    record: /* @__PURE__ */ __name((entry) => {
+      const { personIds: _, ...kept } = entry;
+      const settles = entry.outcome === "refused" ? void 0 : reservation;
+      reservation = void 0;
+      try {
+        journal.append({ at: now().toISOString(), profile, ...kept, ...settles ? { reservation: settles } : {} });
+      } catch (error) {
+        warn(`this send is not in the send journal: ${journalFailure(error)}`, {
+          event: "warning",
+          code: "send_not_journaled",
+          operation: "sends.journal"
+        });
+      }
+    }, "record")
+  };
+}, "sendGuard");
+var refuseToAsk = /* @__PURE__ */ __name(async (key) => {
+  throw new CliError("confirmation_required", `${key} asks before it acts (its permission level is ask), and nobody is here to answer \u2014 add ${skipFlagFor(key)} to go ahead`);
+}, "refuseToAsk");
+var guardFor = /* @__PURE__ */ __name((app, settings, warn, env = process.env, ask) => sendGuard({
+  profile: settings.profile,
+  command: app.command,
+  ...settings.readOnlyLock ? { readOnlyLock: settings.readOnlyLock } : {},
+  permissions: /* @__PURE__ */ __name(() => settings.permissions, "permissions"),
+  permissionSources: settings.permissionSources,
+  ...settings.permissionDefaults ? { permissionDefaults: settings.permissionDefaults } : {},
+  ...ask ? { ask } : {},
+  sendsPerHour: settings.sendsPerHour,
+  journal: new SendJournal(sendsPathFor(app, settings.profile, env), { service: app.command, version: app.version }),
+  recipients: new RecipientList(recipientsPathFor(app, settings.profile, env), app.command),
+  flood: new FloodMemory(floodPathFor(app, settings.profile, env)),
+  warn
+}), "guardFor");
+var journalFailure = /* @__PURE__ */ __name((error) => error?.code ?? (error instanceof Error ? error.name : "error"), "journalFailure");
+
+export {
+  holdEnd,
+  floodPathFor,
+  FloodMemory,
+  withFileLockAsync,
+  sendsPathFor,
+  SendJournal,
+  recipientsPathFor,
+  RecipientList,
+  ceilingRefusal,
+  levelRefusal,
+  sendGuard,
+  guardFor
+};