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

package/dist/permissions-BWlsUVPs.js

@@ -0,0 +1,551 @@
+class o extends Error {
+  /** Смещение в исходной строке — редактор подсветит место, а не всю строку. */
+  at;
+  source;
+  constructor(t, e, r) {
+    super(`условие «${e}» разобрать нельзя: ${t}`), this.name = "WhenSyntaxError", this.source = e, this.at = r;
+  }
+}
+const A = /[A-Za-z_]/, W = /[A-Za-z0-9_.-]/, j = ["&&", "||", "==", "!=", "=~", "!", "(", ")"];
+function I(n) {
+  const t = [];
+  let e = 0;
+  for (; e < n.length; ) {
+    const r = n[e];
+    if (/\s/.test(r)) {
+      e += 1;
+      continue;
+    }
+    if (r === '"' || r === "'") {
+      const i = e;
+      e += 1;
+      let a = "";
+      for (; e < n.length && n[e] !== r; ) {
+        if (n[e] === "\\" && e + 1 < n.length) {
+          a += n[e + 1], e += 2;
+          continue;
+        }
+        a += n[e], e += 1;
+      }
+      if (e >= n.length) throw new o("строка не закрыта", n, i);
+      e += 1, t.push({ kind: "string", text: a, at: i });
+      continue;
+    }
+    if (r === "/") {
+      const i = e;
+      e += 1;
+      let a = "";
+      for (; e < n.length && n[e] !== "/"; ) {
+        if (n[e] === "\\" && e + 1 < n.length) {
+          a += n.slice(e, e + 2), e += 2;
+          continue;
+        }
+        a += n[e], e += 1;
+      }
+      if (e >= n.length) throw new o("шаблон не закрыт", n, i);
+      e += 1;
+      let c = "";
+      for (; e < n.length && /[a-z]/.test(n[e]); )
+        c += n[e], e += 1;
+      try {
+        new RegExp(a, c);
+      } catch {
+        throw new o(`шаблон «${a}» не разбирается`, n, i);
+      }
+      t.push({ kind: "regex", text: a, at: i, flags: c });
+      continue;
+    }
+    const s = j.find((i) => n.startsWith(i, e));
+    if (s !== void 0) {
+      t.push({ kind: "op", text: s, at: e }), e += s.length;
+      continue;
+    }
+    if (/[0-9]/.test(r) || r === "-" && /[0-9]/.test(n[e + 1] ?? "")) {
+      const i = e;
+      for (r === "-" && (e += 1); e < n.length && /[0-9.]/.test(n[e]); ) e += 1;
+      t.push({ kind: "number", text: n.slice(i, e), at: i });
+      continue;
+    }
+    if (A.test(r)) {
+      const i = e;
+      for (; e < n.length && W.test(n[e]); ) e += 1;
+      t.push({ kind: "word", text: n.slice(i, e), at: i });
+      continue;
+    }
+    throw new o(`непонятный символ «${r}»`, n, e);
+  }
+  return t.push({ kind: "end", text: "", at: n.length }), t;
+}
+const l = Object.freeze({ kind: "true" });
+function m(n) {
+  return n.kind === "eq" || n.kind === "match" || n.kind === "in" ? { ...n, negated: !n.negated } : n.kind === "not" ? n.operand : { kind: "not", operand: n };
+}
+function k(n, t) {
+  const e = [];
+  for (const r of t)
+    r.kind === n ? e.push(...r.operands) : e.push(r);
+  return e.length === 1 ? e[0] : { kind: n, operands: e };
+}
+const _ = {
+  true: !0,
+  false: !1,
+  null: null
+};
+class P {
+  index = 0;
+  // Поля объявлены явно, а не параметрами конструктора: сборка идёт с `erasableSyntaxOnly`,
+  // и сокращённая запись потребовала бы генерации кода там, где типы обязаны просто стираться.
+  tokens;
+  source;
+  constructor(t, e) {
+    this.tokens = t, this.source = e;
+  }
+  parse() {
+    const t = this.parseOr(), e = this.peek();
+    if (e.kind !== "end")
+      throw new o(`лишнее после условия: «${e.text}»`, this.source, e.at);
+    return t;
+  }
+  peek() {
+    return this.tokens[this.index];
+  }
+  take() {
+    const t = this.tokens[this.index];
+    return this.index += 1, t;
+  }
+  eatOperator(t) {
+    const e = this.peek();
+    return e.kind === "op" && e.text === t ? (this.index += 1, !0) : !1;
+  }
+  eatWord(t) {
+    const e = this.peek();
+    return e.kind === "word" && e.text === t ? (this.index += 1, !0) : !1;
+  }
+  parseOr() {
+    const t = [this.parseAnd()];
+    for (; this.eatOperator("||"); ) t.push(this.parseAnd());
+    return k("or", t);
+  }
+  parseAnd() {
+    const t = [this.parseUnary()];
+    for (; this.eatOperator("&&"); ) t.push(this.parseUnary());
+    return k("and", t);
+  }
+  /**
+   * `!` связывает только primary: `!a == b` разбирается как «отрицание a, сравнённое с b»,
+   * а не как отрицание всего сравнения. Место спорное, и решается оно так же, как в VS Code,
+   * — ради переносимости привычки: человек, писавший условия там, не должен переучиваться.
+   */
+  parseUnary() {
+    return this.eatOperator("!") ? m(this.parseUnary()) : this.parsePrimary();
+  }
+  parsePrimary() {
+    if (this.eatOperator("(")) {
+      const e = this.parseOr();
+      if (!this.eatOperator(")"))
+        throw new o("не закрыта скобка", this.source, this.peek().at);
+      return e;
+    }
+    const t = this.take();
+    if (t.kind !== "word")
+      throw new o(
+        t.kind === "end" ? "условие обрывается" : `здесь ожидался ключ, а не «${t.text}»`,
+        this.source,
+        t.at
+      );
+    return this.isValuePosition(t.text) ? t.text === "true" ? l : m(l) : this.parseComparison(t.text);
+  }
+  /** Слово-значение, за которым НЕ идёт оператор сравнения: `true`, `false`. */
+  isValuePosition(t) {
+    if (t !== "true" && t !== "false") return !1;
+    const e = this.peek();
+    return !(e.kind === "op" && (e.text === "==" || e.text === "!=" || e.text === "=~"));
+  }
+  parseComparison(t) {
+    return this.eatOperator("==") ? { kind: "eq", key: t, value: this.parseLiteral(), negated: !1 } : this.eatOperator("!=") ? { kind: "eq", key: t, value: this.parseLiteral(), negated: !0 } : this.eatOperator("=~") ? this.parseMatch(t) : this.eatWord("in") ? { kind: "in", key: t, collection: this.parseKey(), negated: !1 } : this.peek().text === "not" && this.tokens[this.index + 1]?.text === "in" ? (this.index += 2, { kind: "in", key: t, collection: this.parseKey(), negated: !0 }) : { kind: "key", key: t };
+  }
+  parseKey() {
+    const t = this.take();
+    if (t.kind !== "word")
+      throw new o(
+        `справа от «in» ожидался ключ, а не «${t.text}»`,
+        this.source,
+        t.at
+      );
+    return t.text;
+  }
+  /**
+   * Правая часть сравнения — ВСЕГДА литерал, и голое слово там является строкой.
+   *
+   * Довод не про удобство записи. Читайся голое слово ключом, самая частая запись проекта —
+   * `activeResourceKind == form.schema` — молча сравнивала бы два `undefined` и была бы
+   * истинной ВСЕГДА. Промах выглядел бы как «клавиша работает везде», а это худший вид
+   * отказа: он не падает, не пишет в консоль и обнаруживается только чужой жалобой.
+   */
+  parseLiteral() {
+    const t = this.take();
+    if (t.kind === "string") return t.text;
+    if (t.kind === "number") return Number(t.text);
+    if (t.kind === "word") {
+      const e = _[t.text];
+      return e === void 0 ? t.text : e;
+    }
+    throw new o(
+      `справа от сравнения ожидалось значение, а не «${t.text}»`,
+      this.source,
+      t.at
+    );
+  }
+  parseMatch(t) {
+    const e = this.take();
+    if (e.kind !== "regex")
+      throw new o(
+        "справа от «=~» ожидается шаблон в косых чертах",
+        this.source,
+        e.at
+      );
+    return { kind: "match", key: t, pattern: e.text, flags: e.flags ?? "", negated: !1 };
+  }
+}
+const b = {
+  scope: 4,
+  scopes: 4,
+  focus: 3,
+  activeEditorId: 2,
+  activeResourceKind: 2
+};
+function h(n) {
+  return b[n] ?? 1;
+}
+function f(n) {
+  switch (n.kind) {
+    case "true":
+      return 0;
+    case "key":
+      return h(n.key);
+    case "eq":
+    case "match":
+      return h(n.key) + 1;
+    case "in":
+      return h(n.collection) + 1;
+    case "not":
+      return f(n.operand);
+    case "and":
+      return n.operands.reduce((t, e) => t + f(e), 0);
+    case "or":
+      return Math.min(...n.operands.map((t) => f(t)));
+  }
+}
+function C(n) {
+  const t = /* @__PURE__ */ new Set(), e = (r) => {
+    switch (r.kind) {
+      case "true":
+        return;
+      case "key":
+      case "eq":
+      case "match":
+        t.add(r.key);
+        return;
+      case "in":
+        t.add(r.key), t.add(r.collection);
+        return;
+      case "not":
+        e(r.operand);
+        return;
+      case "and":
+      case "or":
+        for (const s of r.operands) e(s);
+    }
+  };
+  return e(n), [...t].sort();
+}
+const w = /* @__PURE__ */ new Map();
+function M(n, t) {
+  const e = `${t} ${n}`;
+  let r = w.get(e);
+  return r === void 0 && (r = new RegExp(n, t), w.set(e, r)), r;
+}
+function D(n) {
+  return n != null && n !== !1 && n !== "" && n !== 0;
+}
+function E(n, t) {
+  return n === t ? !0 : typeof t == "string" && (typeof n == "number" || typeof n == "boolean") ? String(n) === t : !1;
+}
+function K(n, t) {
+  return Array.isArray(n) ? n.includes(t) : typeof n == "object" && n !== null ? Object.prototype.hasOwnProperty.call(n, String(t)) : !1;
+}
+function B(n, t) {
+  const e = (r) => {
+    switch (r.kind) {
+      case "true":
+        return !0;
+      case "key":
+        return D(t(r.key));
+      case "not":
+        return !e(r.operand);
+      case "and":
+        return r.operands.every(e);
+      case "or":
+        return r.operands.some(e);
+      case "eq":
+        return E(t(r.key), r.value) !== r.negated;
+      case "match": {
+        const s = t(r.key);
+        return (s == null ? !1 : M(r.pattern, r.flags).test(String(s))) !== r.negated;
+      }
+      case "in":
+        return K(t(r.collection), t(r.key)) !== r.negated;
+    }
+  };
+  return e(n.ast);
+}
+function O(n, t) {
+  return Object.freeze({
+    source: n,
+    ast: t,
+    keys: C(t),
+    specificity: f(t)
+  });
+}
+const S = O("", l);
+function d(n) {
+  const t = n.trim();
+  return t === "" ? S : O(t, new P(I(t), t).parse());
+}
+function J(n) {
+  try {
+    return { ok: !0, expr: d(n) };
+  } catch (t) {
+    if (t instanceof o)
+      return { ok: !1, error: { message: t.message, at: t.at, source: n } };
+    throw t;
+  }
+}
+function x(n) {
+  const t = /* @__PURE__ */ new Map(), e = (r) => {
+    if (r.kind === "eq" && !r.negated) t.set(r.key, r.value);
+    else if (r.kind === "and") for (const s of r.operands) e(s);
+  };
+  return e(n), t;
+}
+function Q(n, t) {
+  const e = x(n.ast);
+  if (e.size === 0) return !1;
+  const r = x(t.ast);
+  for (const [s, i] of e)
+    if (r.has(s) && !E(r.get(s), i))
+      return !0;
+  return !1;
+}
+class z extends Error {
+  kind;
+  /** Параметры кода: `commandId`, `keybinding`. */
+  params;
+  constructor(t, e, r = {}, s) {
+    super(e, s), this.name = "CommandError", this.kind = t, this.params = r;
+  }
+}
+const L = {
+  mod: "mod",
+  commandorcontrol: "mod",
+  cmdorctrl: "mod",
+  ctrl: "ctrl",
+  control: "ctrl",
+  meta: "meta",
+  cmd: "meta",
+  command: "meta",
+  super: "meta",
+  win: "meta",
+  alt: "alt",
+  option: "alt",
+  opt: "alt",
+  shift: "shift"
+}, q = ["mod", "ctrl", "meta", "alt", "shift"], N = {
+  esc: "escape",
+  return: "enter",
+  del: "delete",
+  ins: "insert",
+  spacebar: "space",
+  plus: "+",
+  left: "arrowleft",
+  right: "arrowright",
+  up: "arrowup",
+  down: "arrowdown"
+};
+function T(n) {
+  const t = [];
+  let e = "";
+  for (const r of n)
+    r === "+" && e.trim() !== "" ? (t.push(e), e = "") : e += r;
+  return t.push(e), t;
+}
+function u(n, t) {
+  return new z(
+    "invalid-keybinding",
+    `сочетание «${n}» разобрать нельзя: ${t}`,
+    { keybinding: n }
+  );
+}
+function U(n) {
+  const t = /* @__PURE__ */ new Set();
+  let e = null;
+  for (const r of T(n)) {
+    const s = r.trim().toLowerCase();
+    if (s === "") throw u(n, "пустая часть");
+    const i = L[s];
+    if (i !== void 0) {
+      if (t.has(i))
+        throw u(n, `модификатор «${i}» повторён`);
+      t.add(i);
+      continue;
+    }
+    if (e !== null) throw u(n, "больше одной клавиши");
+    e = N[s] ?? s;
+  }
+  if (e === null) throw u(n, "нет клавиши, только модификаторы");
+  return [...q.filter((r) => t.has(r)), e].join("+");
+}
+const p = /* @__PURE__ */ new WeakMap(), V = d("false");
+function tt(n) {
+  const t = p.get(n);
+  if (t !== void 0) return t;
+  let e;
+  try {
+    e = n.when === void 0 ? S : d(n.when);
+  } catch {
+    e = V;
+  }
+  return p.set(n, e), e;
+}
+function et(n, t) {
+  p.set(n, t);
+}
+const g = 2;
+function nt(n) {
+  const t = n.replace(/\s*\+\s*/g, "+").trim().split(/\s+/);
+  if (t.length > g)
+    throw u(
+      n,
+      `в аккорде больше ${String(g)} ступеней: такое сочетание не воспроизводят по памяти`
+    );
+  return t.map((e) => U(e));
+}
+const H = /* @__PURE__ */ new Set(["x", "X", "*"]);
+function Y(n) {
+  const t = $(n.trim());
+  return t === void 0 || t.wildcard ? void 0 : t.version;
+}
+function rt(n) {
+  return `${String(n.major)}.${String(n.minor)}.${String(n.patch)}`;
+}
+function v(n, t) {
+  return n.major !== t.major ? n.major - t.major : n.minor !== t.minor ? n.minor - t.minor : n.patch - t.patch;
+}
+function G(n) {
+  const t = n.trim();
+  if (t === "") return;
+  const e = /^(\^|~|>=|<=|>|<|=)?\s*(\S+)$/.exec(t);
+  if (e === null) return;
+  const r = e[1], s = $(e[2]);
+  if (s === void 0) return;
+  const { version: i, specified: a } = s;
+  if (a === 0)
+    return r === void 0 ? { source: t } : void 0;
+  switch (r) {
+    case "^":
+      return { source: t, min: { version: i, inclusive: !0 }, max: Z(i, a) };
+    case "~":
+      return { source: t, min: { version: i, inclusive: !0 }, max: y(i, a) };
+    case ">=":
+      return { source: t, min: { version: i, inclusive: !0 } };
+    case ">":
+      return { source: t, min: { version: i, inclusive: !1 } };
+    case "<=":
+      return { source: t, max: { version: i, inclusive: !0 } };
+    case "<":
+      return { source: t, max: { version: i, inclusive: !1 } };
+    default:
+      return a === 3 ? { source: t, min: { version: i, inclusive: !0 }, max: { version: i, inclusive: !0 } } : { source: t, min: { version: i, inclusive: !0 }, max: y(i, a) };
+  }
+}
+function X(n, t) {
+  if (t.min !== void 0) {
+    const e = v(n, t.min.version);
+    if (e < 0 || e === 0 && !t.min.inclusive) return !1;
+  }
+  if (t.max !== void 0) {
+    const e = v(n, t.max.version);
+    if (e > 0 || e === 0 && !t.max.inclusive) return !1;
+  }
+  return !0;
+}
+function it(n, t) {
+  const e = Y(n), r = G(t);
+  return e === void 0 || r === void 0 ? !1 : X(e, r);
+}
+function Z(n, t) {
+  const e = [n.major, n.minor, n.patch], r = e.slice(0, t).findIndex((i) => i > 0), s = r >= 0 ? r : t - 1;
+  return { version: R(e, s), inclusive: !1 };
+}
+function y(n, t) {
+  const e = [n.major, n.minor, n.patch];
+  return { version: R(e, t >= 2 ? 1 : 0), inclusive: !1 };
+}
+function R(n, t) {
+  const e = n.map((r, s) => s < t ? r : s === t ? r + 1 : 0);
+  return { major: e[0], minor: e[1], patch: e[2] };
+}
+function $(n) {
+  if (n === "" || n.includes("-") || n.includes("+")) return;
+  const t = n.split(".");
+  if (t.length > 3) return;
+  const e = [0, 0, 0];
+  let r = 0, s = !1;
+  for (const [i, a] of t.entries()) {
+    if (H.has(a)) {
+      s = !0;
+      continue;
+    }
+    if (s || !/^\d+$/.test(a)) return;
+    const c = Number.parseInt(a, 10);
+    if (!Number.isSafeInteger(c)) return;
+    e[i] = c, r += 1;
+  }
+  return {
+    version: { major: e[0], minor: e[1], patch: e[2] },
+    specified: r,
+    wildcard: s
+  };
+}
+const F = Object.freeze([
+  "workspace.save",
+  "workspace.resources",
+  "plugins.manage"
+]);
+function st(n) {
+  return F.includes(n);
+}
+export {
+  z as C,
+  g as M,
+  F as P,
+  S as W,
+  U as a,
+  Y as b,
+  d as c,
+  v as d,
+  B as e,
+  rt as f,
+  G as g,
+  it as h,
+  st as i,
+  o as j,
+  f as k,
+  C as l,
+  Q as m,
+  nt as n,
+  J as p,
+  et as r,
+  X as s,
+  tt as w
+};

package/dist/plugin/bundled-modules.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Пакеты, которые сборка внешнего плагина ВКЛАДЫВАЕТ в свой `main.js`, а не берёт у оболочки.
+ *
+ * ## Почему не в `PLUGIN_RUNTIME_MODULES`
+ *
+ * Модули рантайма оболочка подставляет сама — и держит их в стартовом графе. Пакеты стеков
+ * (модель схемы, каталог, печать модуля формы) туда не годятся: статическая регистрация втянула бы
+ * стек в стартовый граф оболочки, которая стека не знает (ось стеков, Ф3). А отказать внешнему
+ * плагину стека в них значило бы, что стек можно написать только встроенным.
+ *
+ * ## Почему второй экземпляр здесь безвреден
+ *
+ * Запрет вкладывать `@reformer/*` существует из-за второго экземпляра: вложенная копия React или
+ * ядра форм — два мира, которые молча не видят друг друга. У пакетов стеков мира нет: это чистые
+ * функции и данные, ни одного синглтона, а токены служб и точек ключуются строкой `id`, так что
+ * копия токена находит ту же службу. Что эти пакеты сами тянут из рантайма (`@reformer/core`,
+ * `@reformer/renderer-json`, React), остаётся внешним — по общему списку.
+ *
+ * @module @reformer/builder-plugin-api/plugin/bundled-modules
+ */
+export declare const PLUGIN_BUNDLED_PACKAGES: readonly string[];
+/** Имя пакета по спецификатору: `@scope/name/sub` → `@scope/name`, `name/sub` → `name`. */
+export declare function packageNameOf(specifier: string): string;
+/** Вкладывается ли модуль в сборку плагина (сам пакет или его подпуть). */
+export declare function isBundledPluginModule(specifier: string): boolean;

package/dist/plugin/layout.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Раскладка каталога плагина: где он лежит, какие файлы в нём — код и сколько их может быть.
+ *
+ * Правила загрузчика оболочки, вынесенные в контракт, потому что их проверяет ещё и
+ * `reformer-plugin validate`: плагин, который валидатор пропустил, а загрузчик отверг
+ * за лишний файл, — ровно тот отказ, ради которого валидатор существует.
+ *
+ * @module @reformer/builder-plugin-api/plugin/layout
+ */
+/** Где в проекте лежат плагины. Путь из контракта; по образцу Obsidian. */
+export declare const PLUGIN_CATALOG_DIR = ".ui_builder/plugins";
+/**
+ * Потолок числа файлов одного плагина.
+ *
+ * Загрузка читает каталог плагина ЦЕЛИКОМ (линковщик резолвит импорты по набору файлов,
+ * а `require` синхронен — дочитать по требованию нельзя). Значит нужен предел: каталог
+ * на тысячи файлов — это не плагин, а чужое дерево, случайно оказавшееся под этим именем,
+ * и вычитывать его по сети или через File System Access мы не будем. Отказ, а не усечение:
+ * молча недочитанный плагин ломался бы «необъяснимо» на первом же импорте.
+ */
+export declare const PLUGIN_FILE_LIMIT = 200;
+/** Что вообще может быть модулем. Остальное в набор не попадает — читать его незачем. */
+export declare const PLUGIN_CODE_EXTENSIONS: readonly string[];
+/** Каталоги, в которые загрузчик не заходит. */
+export declare const PLUGIN_SKIPPED_DIRS: readonly string[];
+/** Файл кода — по расширению, без учёта регистра: `Main.TS` у автора на Windows тоже код. */
+export declare function isPluginCodeFile(name: string): boolean;

package/dist/plugin/manifest-parser.d.ts

@@ -0,0 +1,54 @@
+import { ManifestOf, ManifestParseResult, PluginSource, PluginSourceManifest } from './manifest.js';
+/**
+ * Разбирает текст манифеста.
+ *
+ * @param text содержимое `manifest.json`
+ * @param source откуда плагин — от этого зависят две проверки, см. {@link PluginSource}
+ * @param versions версии спрашивающего, см. {@link ShellVersions}
+ */
+export declare function parsePluginManifest<S extends PluginSource>(text: string, source: S, versions?: ShellVersions): ManifestParseResult<ManifestOf<S>>;
+/**
+ * Разбирает УЖЕ разобранный JSON.
+ *
+ * Отдельный вход нужен встроенным: их манифест приезжает статическим импортом, то есть
+ * значением, а не текстом. Обратно в строку его сериализовать только затем, чтобы тут же
+ * разобрать, — значит завести второй путь, который однажды разойдётся с первым. Проверки
+ * же обязаны быть ТЕМИ ЖЕ: «встроенные и внешние — один контракт» держится на том, что
+ * манифест встроенного проходит разбор каталога целиком, а не свою облегчённую копию.
+ */
+export declare function parsePluginManifestValue<S extends PluginSource>(raw: unknown, source: S, versions?: ShellVersions): ManifestParseResult<ManifestOf<S>>;
+/**
+ * Разбирает манифест ИСХОДНИКОВ плагина — тот, что лежит в репозитории автора.
+ *
+ * Это не третья поставка, а стадия ДО поставки: такой манифест оболочка не читает никогда,
+ * его читают инструменты (`reformer-plugin validate`, `build`). Правила — те же самые, одним
+ * кодом, и отличий ровно два, оба названы:
+ *
+ * - **имя каталога не сверяется с `id`.** Репозиторий автора зовётся как угодно (`acme-forms-plugin`),
+ *   а каталогом с именем `id` плагин становится только при установке. Сверка возвращается
+ *   на выходе сборки: собранный каталог проверяется разбором поставки `project` целиком.
+ * - **`version` обязательна и обязана быть версией.** Оболочка подставляет `0.0.0` — ей нужна
+ *   подпись в списке, а не номер. Исходники же идут в сборку и упаковку, где версия — это
+ *   адрес пакета, и умолчание тихо опубликовало бы `0.0.0`.
+ *
+ * `main` при этом указывает на исходник (`src/main.ts`), а не на собранный файл: проверяется
+ * тем же `normalizeModulePath`, поэтому выход за корень отсекается и здесь.
+ */
+export declare function parsePluginSourceManifest(text: string, versions?: ShellVersions): ManifestParseResult<PluginSourceManifest>;
+/**
+ * Версии того, кто спрашивает разбор.
+ *
+ * Обе необязательны, и необязательность у них разная. `api` умалчивается до
+ * {@link BUILDER_API_VERSION} — версия контракта известна самому пакету, и подменяют её
+ * только тесты. `builder` умолчания не имеет и иметь не может: пакет не знает, каким
+ * приложением он подан. Её отсутствие означает «спрашивающий не билдер» — так манифест
+ * читает CLI автора плагина, и тогда `compatibility.builder` проверяется ФОРМОЙ, без
+ * сверки. Подставь пакет сюда что-нибудь «по умолчанию», CLI отвергал бы плагины по версии
+ * приложения, которого не видел.
+ */
+export interface ShellVersions {
+    /** Версия контракта плагинов. Умолчание — {@link BUILDER_API_VERSION}. */
+    readonly api?: string;
+    /** Версия приложения-билдера. Без неё `compatibility.builder` только разбирается. */
+    readonly builder?: string;
+}