@reformer/builder-plugin-api 1.0.0-beta.1

package/dist/runtime-modules-CiUDFMIn.js

@@ -0,0 +1,597 @@
+import { b as A, g as b, h as S, i as I, P, n as j, p as N } from "./permissions-BWlsUVPs.js";
+const B = ".ui_builder/plugins", K = 200, _ = [
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts"
+], W = ["node_modules"];
+function Z(i) {
+  const e = i.toLowerCase();
+  return _.some((r) => e.endsWith(r));
+}
+function y(i) {
+  const e = [];
+  for (const r of i.replace(/\\/g, "/").split("/"))
+    if (!(r === "" || r === ".")) {
+      if (r === "..") {
+        if (e.length === 0) return;
+        e.pop();
+        continue;
+      }
+      e.push(r);
+    }
+  return e.join("/");
+}
+const t = "manifest.json", E = "1.0.0", O = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/, o = (i, e, r) => ({
+  ok: !1,
+  problem: { code: i, message: e, file: r?.file, cause: r?.cause }
+});
+function d(i, e) {
+  const r = i[e];
+  return typeof r == "string" && r.trim() !== "" ? r.trim() : void 0;
+}
+function H(i, e, r = {}) {
+  let n;
+  try {
+    n = JSON.parse(i);
+  } catch (s) {
+    return o("manifest-unreadable", `${t} не разбирается как JSON`, {
+      file: t,
+      cause: s
+    });
+  }
+  return q(n, e, r);
+}
+function q(i, e, r = {}) {
+  const n = h(i, e, r);
+  return n.ok ? { ok: !0, manifest: { ...n.manifest, source: e } } : n;
+}
+function X(i, e = {}) {
+  let r;
+  try {
+    r = JSON.parse(i);
+  } catch (a) {
+    return o("manifest-unreadable", `${t} не разбирается как JSON`, {
+      file: t,
+      cause: a
+    });
+  }
+  const n = h(r, { kind: "source" }, e);
+  if (!n.ok) return n;
+  const s = d(r, "version");
+  if (s === void 0 || A(s) === void 0)
+    return o(
+      "manifest-invalid",
+      `«version» исходников должна быть версией вида «1.0.0», а не «${s ?? ""}»: по ней собирается и публикуется пакет, и умолчания у неё нет`,
+      { file: t }
+    );
+  const { manifest: f } = n;
+  return "main" in f ? { ok: !0, manifest: f } : o("manifest-invalid", "в манифесте нет поля «main» или оно не строка", {
+    file: t
+  });
+}
+function h(i, e, r) {
+  const n = r.api ?? E;
+  if (typeof i != "object" || i === null || Array.isArray(i))
+    return o("manifest-invalid", `${t} должен быть объектом JSON`, {
+      file: t
+    });
+  const s = i, f = d(s, "id");
+  if (f === void 0)
+    return o("manifest-invalid", "в манифесте нет поля «id» или оно не строка", {
+      file: t
+    });
+  if (!O.test(f))
+    return o(
+      "manifest-invalid",
+      `«${f}» не годится в идентификаторы: допустимы буквы, цифры, «.», «_» и «-»`,
+      { file: t }
+    );
+  if (e.kind === "project" && f !== e.dir)
+    return o(
+      "id-mismatch",
+      `манифест объявляет «${f}», а каталог называется «${e.dir}». Идентификатор — ключ во всех реестрах, и он обязан совпадать с именем каталога: иначе список плагинов и команды перезагрузки говорят о разных вещах`,
+      { file: t }
+    );
+  const a = d(s, "apiVersion");
+  if (a === void 0)
+    return o("manifest-invalid", "в манифесте нет поля «apiVersion» или оно не строка", {
+      file: t
+    });
+  if (b(a) === void 0)
+    return o(
+      "manifest-invalid",
+      `из «apiVersion»: «${a}» не читается диапазон версий. Допустимы «^1», «~1.2», «>=1.0.0», «1.x» и точная версия; составные диапазоны и пререлизы не поддерживаются`,
+      { file: t }
+    );
+  if (!S(n, a))
+    return o(
+      "api-version",
+      `плагин написан против API «${a}», а оболочка даёт API ${n}. Совместимость между мажорами не обещана, поэтому плагин не загружается`,
+      { file: t }
+    );
+  const u = z(s.compatibility, r.builder);
+  if (u !== void 0 && "ok" in u) return u;
+  const l = L(s, e);
+  if ("ok" in l) return l;
+  const m = T(s.contributes);
+  if (m !== void 0 && "ok" in m) return m;
+  const c = M(s.provides);
+  if (c !== void 0 && "ok" in c) return c;
+  const v = U(s.requires);
+  if (v !== void 0 && "ok" in v) return v;
+  const p = R(s.permissions);
+  return p !== void 0 && "ok" in p ? p : { ok: !0, manifest: { ...{
+    id: f,
+    name: d(s, "name") ?? f,
+    version: d(s, "version") ?? "0.0.0",
+    apiVersion: a,
+    ...m === void 0 ? {} : { contributes: m.contributes },
+    ...c === void 0 ? {} : { provides: c.provides },
+    ...v === void 0 ? {} : { requires: v.requires },
+    ...p === void 0 ? {} : { permissions: p.permissions },
+    ...u === void 0 ? {} : { compatibility: u.compatibility }
+  }, ...l } };
+}
+function L(i, e) {
+  if (e.kind === "builtin") {
+    if (i.main !== void 0)
+      return o(
+        "manifest-invalid",
+        "у встроенного плагина не бывает поля «main»: его код приезжает вместе с оболочкой, и грузить из каталога нечего",
+        { file: t }
+      );
+    const f = x(i.builtin);
+    return "ok" in f ? f : { builtin: f.builtin };
+  }
+  if (i.builtin !== void 0)
+    return o(
+      "manifest-invalid",
+      "поле «builtin» объявляет способ доставки встроенного плагина, и у плагина каталога его быть не может: как он приезжает, решает не он",
+      { file: t }
+    );
+  const r = d(i, "main");
+  if (r === void 0)
+    return o("manifest-invalid", "в манифесте нет поля «main» или оно не строка", {
+      file: t
+    });
+  const n = y(r);
+  if (n === void 0 || n === "")
+    return o(
+      "manifest-invalid",
+      `точка входа «${r}» выходит за каталог плагина: загрузчик читает только его собственные файлы`,
+      { file: t }
+    );
+  const s = J(i.styles);
+  return s !== void 0 && "ok" in s ? s : { main: n, ...s === void 0 ? {} : { styles: s.styles } };
+}
+function x(i) {
+  const e = k(i);
+  if (e === void 0)
+    return o(
+      "manifest-invalid",
+      "в манифесте встроенного плагина нет поля «builtin» или оно не объект: способ доставки читается ДО загрузки кода и умолчания не имеет",
+      { file: t }
+    );
+  const r = d(e, "loading");
+  if (r !== "eager" && r !== "lazy")
+    return o(
+      "manifest-invalid",
+      `«builtin.loading» должен быть «eager» или «lazy», а не «${r ?? ""}»`,
+      { file: t }
+    );
+  const n = d(e, "reason");
+  return r === "eager" && n === void 0 ? o(
+    "manifest-invalid",
+    "статический плагин обязан объяснить себя полем «builtin.reason»: он едет в стартовом графе, и запись без довода через полгода не отличить от забытой",
+    { file: t }
+  ) : r === "lazy" && n !== void 0 ? o(
+    "manifest-invalid",
+    "у ленивого плагина «builtin.reason» лишний: ленивость — умолчание, объяснять надо отступление от него",
+    { file: t }
+  ) : { builtin: { loading: r, ...n === void 0 ? {} : { reason: n } } };
+}
+function R(i) {
+  if (i == null) return;
+  if (!Array.isArray(i))
+    return o("manifest-invalid", "поле «permissions» должно быть массивом", {
+      file: t
+    });
+  const e = [];
+  for (const [r, n] of i.entries()) {
+    const s = `permissions[${String(r)}]`;
+    if (typeof n != "string" || !I(n))
+      return o(
+        "manifest-invalid",
+        `${s}: «${String(n)}» не право. Оболочка знает: ${P.join(", ")}`,
+        { file: t }
+      );
+    if (e.includes(n))
+      return o("manifest-invalid", `${s}: право «${n}» названо дважды`, {
+        file: t
+      });
+    e.push(n);
+  }
+  return { permissions: e };
+}
+function z(i, e) {
+  if (i == null) return;
+  if (typeof i != "object" || Array.isArray(i))
+    return o("manifest-invalid", "поле «compatibility» должно быть объектом", {
+      file: t
+    });
+  const r = d(i, "builder");
+  return r === void 0 ? o(
+    "manifest-invalid",
+    "в «compatibility» нет поля «builder» или оно не строка. Пустой объект совместимости ничего не значит: либо диапазон версий билдера, либо поля нет вовсе",
+    { file: t }
+  ) : b(r) === void 0 ? o(
+    "manifest-invalid",
+    `из «compatibility.builder»: «${r}» не читается диапазон версий. Допустимы «^2», «~2.1», «>=2.0.0», «2.x» и точная версия`,
+    { file: t }
+  ) : e !== void 0 && !S(e, r) ? o(
+    "builder-version",
+    `плагину нужен билдер «${r}», а этот — ${e}. Контракт тут ни при чём: чинится обновлением билдера, а не правкой плагина`,
+    { file: t }
+  ) : { compatibility: { builder: r } };
+}
+function M(i) {
+  if (i == null) return;
+  if (!Array.isArray(i))
+    return o("manifest-invalid", "поле «provides» должно быть массивом", {
+      file: t
+    });
+  const e = [], r = /* @__PURE__ */ new Set();
+  for (const [n, s] of i.entries()) {
+    const f = `provides[${String(n)}]`, a = k(s);
+    if (a === void 0)
+      return o("manifest-invalid", `${f} должен быть объектом`, {
+        file: t
+      });
+    const u = d(a, "id");
+    if (u === void 0)
+      return o("manifest-invalid", `в ${f} нет поля «id» или оно не строка`, {
+        file: t
+      });
+    if (r.has(u))
+      return o(
+        "manifest-invalid",
+        `${f}: возможность «${u}» объявлена дважды. Слот в реестре служб один, и вторая версия не значила бы ничего`,
+        { file: t }
+      );
+    const l = d(a, "version");
+    if (l === void 0 || A(l) === void 0)
+      return o(
+        "manifest-invalid",
+        `${f}: «version» должна быть версией вида «1.0.0», а не «${l ?? ""}». Диапазон здесь недопустим: «provides» говорит, что ЕСТЬ, а не что требуется`,
+        { file: t }
+      );
+    r.add(u), e.push({ id: u, version: l });
+  }
+  return { provides: e };
+}
+function U(i) {
+  if (i == null) return;
+  const e = k(i);
+  if (e === void 0)
+    return o(
+      "manifest-invalid",
+      "поле «requires» должно быть объектом с полями «required» и «optional»",
+      { file: t }
+    );
+  const r = g(e.required, "requires.required");
+  if ("ok" in r) return r;
+  const n = g(e.optional, "requires.optional");
+  return "ok" in n ? n : { requires: { required: r.items, optional: n.items } };
+}
+function g(i, e) {
+  if (i == null) return { items: [] };
+  if (!Array.isArray(i))
+    return o("manifest-invalid", `поле «${e}» должно быть массивом`, {
+      file: t
+    });
+  const r = [];
+  for (const [n, s] of i.entries()) {
+    const f = `${e}[${String(n)}]`, a = k(s);
+    if (a === void 0)
+      return o("manifest-invalid", `${f} должен быть объектом`, {
+        file: t
+      });
+    const u = d(a, "id");
+    if (u === void 0)
+      return o("manifest-invalid", `в ${f} нет поля «id» или оно не строка`, {
+        file: t
+      });
+    const l = d(a, "range");
+    if (l === void 0 || b(l) === void 0)
+      return o(
+        "manifest-invalid",
+        `${f}: «range» должен быть диапазоном вида «^1», «~1.2», «>=1.0.0» или «*», а не «${l ?? ""}». Составные диапазоны и пререлизы не поддерживаются`,
+        { file: t }
+      );
+    r.push({ id: u, range: l });
+  }
+  return { items: r };
+}
+function k(i) {
+  if (!(typeof i != "object" || i === null || Array.isArray(i)))
+    return i;
+}
+function T(i) {
+  if (i == null) return;
+  if (typeof i != "object" || Array.isArray(i))
+    return o("manifest-invalid", "поле «contributes» должно быть объектом", {
+      file: t
+    });
+  const e = G(i.keybindings);
+  if (e !== void 0 && "ok" in e) return e;
+  const r = C(i.messages);
+  return r !== void 0 && "ok" in r ? r : {
+    contributes: {
+      ...e === void 0 ? {} : { keybindings: e.keybindings },
+      ...r === void 0 ? {} : { messages: r.messages }
+    }
+  };
+}
+function C(i) {
+  if (i == null) return;
+  if (typeof i != "object" || Array.isArray(i))
+    return o(
+      "manifest-invalid",
+      "поле «contributes.messages» должно быть объектом «локаль → путь к файлу словаря»",
+      { file: t }
+    );
+  const e = {};
+  for (const [r, n] of Object.entries(i)) {
+    if (r.trim() === "")
+      return o("manifest-invalid", "в «contributes.messages» есть пустое имя локали", {
+        file: t
+      });
+    const s = `contributes.messages[«${r}»]`;
+    if (typeof n != "string" || n.trim() === "")
+      return o("manifest-invalid", `${s}: путь к словарю должен быть непустой строкой`, {
+        file: t
+      });
+    const f = y(n.trim());
+    if (f === void 0 || f === "")
+      return o("manifest-invalid", `${s}: словарь «${n}» выходит за каталог плагина`, {
+        file: t
+      });
+    e[r] = f;
+  }
+  return { messages: e };
+}
+function G(i) {
+  if (i == null) return;
+  if (!Array.isArray(i))
+    return o("manifest-invalid", "поле «contributes.keybindings» должно быть массивом", {
+      file: t
+    });
+  const e = [];
+  for (const [r, n] of i.entries()) {
+    const s = `contributes.keybindings[${String(r)}]`;
+    if (typeof n != "object" || n === null || Array.isArray(n))
+      return o("manifest-invalid", `${s} должен быть объектом`, {
+        file: t
+      });
+    const f = n, a = d(f, "command");
+    if (a === void 0)
+      return o("manifest-invalid", `в ${s} нет поля «command» или оно не строка`, {
+        file: t
+      });
+    const u = d(f, "key");
+    if (u === void 0)
+      return o("manifest-invalid", `в ${s} нет поля «key» или оно не строка`, {
+        file: t
+      });
+    try {
+      j(u);
+    } catch (c) {
+      return o("manifest-invalid", `${s}: сочетание «${u}» разобрать нельзя`, {
+        file: t,
+        cause: c
+      });
+    }
+    const l = d(f, "when");
+    if (l !== void 0) {
+      const c = N(l);
+      if (!c.ok)
+        return o("manifest-invalid", `${s}: ${c.error.message}`, {
+          file: t
+        });
+    }
+    const m = f.allowInEditable;
+    if (m !== void 0 && typeof m != "boolean")
+      return o("manifest-invalid", `${s}: «allowInEditable» должно быть булевым`, {
+        file: t
+      });
+    e.push({
+      command: a,
+      key: u,
+      ...l === void 0 ? {} : { when: l },
+      ...f.args === void 0 ? {} : { args: f.args },
+      ...m === void 0 ? {} : { allowInEditable: m }
+    });
+  }
+  return { keybindings: e };
+}
+function J(i) {
+  if (i == null) return;
+  if (typeof i != "object" || Array.isArray(i))
+    return o("manifest-invalid", "поле «styles» должно быть объектом", {
+      file: t
+    });
+  const e = i, r = d(e, "file");
+  if (r === void 0)
+    return o("manifest-invalid", "в «styles» нет поля «file» или оно не строка", {
+      file: t
+    });
+  const n = y(r);
+  if (n === void 0 || n === "")
+    return o("manifest-invalid", `таблица стилей «${r}» выходит за каталог плагина`, {
+      file: t
+    });
+  const s = d(e, "isolation") ?? "scoped";
+  return s !== "scoped" ? o(
+    "manifest-invalid",
+    `«styles.isolation»: «${s}» не поддерживается, возможно только «scoped». Неизолированный чужой CSS перекрашивает оболочку — это не режим, а поломка`,
+    { file: t }
+  ) : { styles: { file: n, isolation: s } };
+}
+function Q(i) {
+  let e;
+  try {
+    e = JSON.parse(i);
+  } catch (r) {
+    return { ok: !1, reason: "не разбирается как JSON", cause: r };
+  }
+  if (typeof e != "object" || e === null || Array.isArray(e))
+    return { ok: !1, reason: "должен быть объектом JSON" };
+  for (const [r, n] of Object.entries(e))
+    if (typeof n != "string")
+      return {
+        ok: !1,
+        reason: `ключ «${r}» — не строка, а словарь обязан быть плоским «ключ → строка»`
+      };
+  return { ok: !0, bundle: e };
+}
+function $(i) {
+  if (typeof i != "object" || i === null) return;
+  const e = i;
+  if (!(typeof e.id != "string" || e.id.trim() === "") && typeof e.activate == "function")
+    return i;
+}
+function Y(i) {
+  const e = $(i);
+  if (e !== void 0) return e;
+  if (typeof i == "object" && i !== null)
+    return $(i.default);
+}
+const D = [
+  "@reformer/ui-kit/accordion",
+  "@reformer/ui-kit/alert",
+  "@reformer/ui-kit/alert-dialog",
+  "@reformer/ui-kit/aspect-ratio",
+  "@reformer/ui-kit/async-boundary",
+  "@reformer/ui-kit/attachment",
+  "@reformer/ui-kit/avatar",
+  "@reformer/ui-kit/badge",
+  "@reformer/ui-kit/box",
+  "@reformer/ui-kit/breadcrumb",
+  "@reformer/ui-kit/bubble",
+  "@reformer/ui-kit/button",
+  "@reformer/ui-kit/button-group",
+  "@reformer/ui-kit/calendar",
+  "@reformer/ui-kit/card",
+  "@reformer/ui-kit/carousel",
+  "@reformer/ui-kit/chart",
+  "@reformer/ui-kit/checkbox",
+  "@reformer/ui-kit/collapsible",
+  "@reformer/ui-kit/combobox",
+  "@reformer/ui-kit/command",
+  "@reformer/ui-kit/context-menu",
+  "@reformer/ui-kit/date-picker",
+  "@reformer/ui-kit/dialog",
+  "@reformer/ui-kit/direction",
+  "@reformer/ui-kit/drawer",
+  "@reformer/ui-kit/dropdown-menu",
+  "@reformer/ui-kit/empty",
+  "@reformer/ui-kit/example-card",
+  "@reformer/ui-kit/field",
+  "@reformer/ui-kit/fields",
+  "@reformer/ui-kit/file-upload",
+  "@reformer/ui-kit/form-array",
+  "@reformer/ui-kit/form-field",
+  "@reformer/ui-kit/form-wizard",
+  "@reformer/ui-kit/hover-card",
+  "@reformer/ui-kit/icon",
+  "@reformer/ui-kit/info-hint",
+  "@reformer/ui-kit/input",
+  "@reformer/ui-kit/input-group",
+  "@reformer/ui-kit/input-mask",
+  "@reformer/ui-kit/input-otp",
+  "@reformer/ui-kit/input-password",
+  "@reformer/ui-kit/item",
+  "@reformer/ui-kit/kbd",
+  "@reformer/ui-kit/label",
+  "@reformer/ui-kit/list",
+  "@reformer/ui-kit/marker",
+  "@reformer/ui-kit/menubar",
+  "@reformer/ui-kit/message",
+  "@reformer/ui-kit/message-scroller",
+  "@reformer/ui-kit/meta",
+  "@reformer/ui-kit/native-select",
+  "@reformer/ui-kit/navigation-menu",
+  "@reformer/ui-kit/pagination",
+  "@reformer/ui-kit/popover",
+  "@reformer/ui-kit/progress",
+  "@reformer/ui-kit/radio-group",
+  "@reformer/ui-kit/resizable",
+  "@reformer/ui-kit/scroll-area",
+  "@reformer/ui-kit/section",
+  "@reformer/ui-kit/select",
+  "@reformer/ui-kit/separator",
+  "@reformer/ui-kit/sheet",
+  "@reformer/ui-kit/sidebar",
+  "@reformer/ui-kit/skeleton",
+  "@reformer/ui-kit/slider",
+  "@reformer/ui-kit/sonner",
+  "@reformer/ui-kit/spinner",
+  "@reformer/ui-kit/switch",
+  "@reformer/ui-kit/table",
+  "@reformer/ui-kit/tabs",
+  "@reformer/ui-kit/textarea",
+  "@reformer/ui-kit/toggle",
+  "@reformer/ui-kit/toggle-group",
+  "@reformer/ui-kit/tooltip",
+  "@reformer/ui-kit/tree",
+  "@reformer/ui-kit/typography"
+], w = Object.freeze([
+  "@builder/sdk",
+  "@reformer/builder-plugin-api",
+  "react",
+  "react/jsx-runtime",
+  "react-dom",
+  "react-dom/client",
+  "@preact/signals-core",
+  "@reformer/core",
+  "@reformer/core/behaviors",
+  "@reformer/core/model",
+  "@reformer/core/signals",
+  "@reformer/core/validation",
+  "@reformer/core/validators",
+  "@reformer/renderer-json",
+  "@reformer/renderer-react",
+  "@reformer/form-registry",
+  "@reformer/form-registry/react",
+  "@reformer/form-registry/storage",
+  "@reformer/ui-kit",
+  ...D,
+  "@reformer/cdk",
+  "@reformer/cdk/async-boundary",
+  "@reformer/cdk/file-upload",
+  "@reformer/cdk/form-array",
+  "@reformer/cdk/form-field",
+  "@reformer/cdk/form-wizard",
+  "@reformer/cdk/list"
+]);
+export {
+  E as B,
+  B as P,
+  _ as a,
+  K as b,
+  W as c,
+  q as d,
+  X as e,
+  Q as f,
+  Y as g,
+  t as h,
+  Z as i,
+  w as j,
+  y as n,
+  H as p
+};

package/dist/services/context-keys.d.ts

@@ -0,0 +1,52 @@
+import { Disposable } from '../primitives/disposable.js';
+import { WhenContext } from '../primitives/when-context.js';
+/** Снимок состояния: одно значение, две проекции. */
+export interface ContextKeySnapshot {
+    /** Чтение любого ключа — платформенного, областного, плагинного. */
+    read(key: string): unknown;
+    /**
+     * Проекция на пять полей — для `CommandRegistry.execute` и `isEnabled`, которые по
+     * контракту принимают {@link WhenContext}. Один снимок обслуживает обоих, поэтому
+     * предикат и условие видят одно и то же состояние, а не два соседних во времени.
+     */
+    whenContext(): WhenContext;
+}
+export interface ContextKeyReader {
+    /** Значение ключа. Неизвестный ключ — `undefined`, и это норма, а не отказ. */
+    read(key: string): unknown;
+    /** Снимок. Ссылка стабильна между изменениями — требование `useSyncExternalStore`. */
+    snapshot(): ContextKeySnapshot;
+    /**
+     * Подписка на изменения. Уведомление НЕСЁТ имена изменившихся ключей: подписчик, который
+     * знает читаемые ключи своих условий, сравнивает пересечение и молчит, если оно пусто.
+     * Ради этого свойства `WhenExpr.keys` и считается один раз при разборе.
+     */
+    subscribe(listener: (changed: ReadonlySet<string>) => void): Disposable;
+}
+/** Объявленный ключ. `dispose()` снимает объявление — на этом держится выключение плагина. */
+export interface ContextKey<T> extends Disposable {
+    readonly key: string;
+    get(): T;
+    set(value: T): void;
+    /** Возвращает начальное значение, с которым ключ объявлен. */
+    reset(): void;
+}
+export interface ContextKeyInfo {
+    readonly key: string;
+    /** Идентификатор плагина либо `host`. */
+    readonly owner: string;
+}
+export interface ContextKeyService extends ContextKeyReader {
+    /**
+     * Объявляет ключ.
+     *
+     * @throws Error если имя зарезервировано платформой либо ключ уже объявлен. Повторное
+     * объявление — отказ, а не замена, по тому же доводу, что у умолчаний настроек: две
+     * записи одного ключа означали бы, что действующее значение зависит от порядка активации
+     * плагинов, а он по контракту рантайма ничего не значит.
+     */
+    createKey<T>(key: string, initial: T, owner?: string): ContextKey<T>;
+    /** Объявленные ключи — редактору клавиш для подсказки и диагностике «такого ключа нет». */
+    declared(): readonly ContextKeyInfo[];
+}
+export declare const ContextKeyServiceToken: import('../index.js').ServiceToken<ContextKeyService>;

package/dist/services/diagnostics/fixes.d.ts

@@ -0,0 +1,40 @@
+import { Diagnostic, QuickFix } from './types.js';
+/**
+ * Есть ли сейчас команда с таким идентификатором.
+ *
+ * Предикат, а не сам реестр команд: диагностика не должна знать про `CommandRegistry` (он ей
+ * не нужен ни для чего другого), а вызывающему проще всего отдать `(id) => commands.get(id)
+ * !== undefined`. Заодно это делает отбор проверяемым без единого реестра.
+ *
+ * **Применимость (`enabled`) здесь НЕ спрашивается.** «Команды нет» и «команда сейчас
+ * недоступна» — разные ответы: первое означает, что исправление неисполнимо в принципе,
+ * второе — что не в этом контексте, и второе обязано проверяться там же, где у человека, —
+ * в момент вызова. Смешать их значило бы прятать исправление на время, пока фокус стоит
+ * не в том месте.
+ */
+export type CommandLookup = (commandId: string) => boolean;
+export interface FixesOptions {
+    /**
+     * Куда сообщить об отброшенном исправлении. Необязателен, но нужен почти всем: без него
+     * опечатка в идентификаторе команды исчезает вместе с кнопкой.
+     */
+    readonly onUnavailable?: (fix: QuickFix, diagnostic: Diagnostic) => void;
+}
+/**
+ * Исправления диагностики, чью команду сейчас можно выполнить.
+ *
+ * Возвращает **ту же ссылку**, если отбрасывать нечего: список читают из отрисовки, и новый
+ * массив на каждый вызов ломал бы сравнение по ссылке ровно там, где на него рассчитывают
+ * (`useSyncExternalStore`, мемоизация строки панели).
+ */
+export declare function usableFixes(diagnostic: Diagnostic, isRegistered: CommandLookup, options?: FixesOptions): readonly QuickFix[];
+/**
+ * Тот же отбор для целого свода: диагностики с неисполнимыми исправлениями пересобираются,
+ * остальные остаются собой.
+ *
+ * Ссылки сохраняются по той же причине, что и в {@link usableFixes}, и на двух уровнях сразу:
+ * не изменившийся список отдаётся как есть, не изменившаяся запись — тоже. Свод диагностик
+ * читает панель проблем через подписку, и «всё новое на каждой правке» означало бы перерисовку
+ * всего списка на каждый набранный символ.
+ */
+export declare function withUsableFixes(items: readonly Diagnostic[], isRegistered: CommandLookup, options?: FixesOptions): readonly Diagnostic[];