@besales/mcp 0.48.0 → 1.0.0-beta.4

package/scripts/request-query.mjs

@@ -0,0 +1,43 @@
+/**
+ * Строка запроса в форме входа HTTP-сервера: одиночное значение или массив повторений.
+ * Она выгружается отдельно от пути: имена параметров иначе не видны сторожу маршрута.
+ */
+export function parseQuery(pathWithQuery) {
+  const queryString = pathWithQuery.split('?')[1];
+  if (!queryString) return undefined;
+  const params = new URLSearchParams(queryString);
+  const query = {};
+  for (const key of new Set(params.keys())) {
+    const values = params.getAll(key);
+    query[key] = values.length === 1 ? values[0] : values;
+  }
+  return query;
+}
+
+/** Пустой query тоже сверяется, если v2 добавила параметры; их значения не подставляются. */
+export function shippedQuerySample(shippedRequest, currentQuery) {
+  if (shippedRequest === undefined) return undefined;
+  return (
+    parseQuery(shippedRequest.path) ??
+    (shippedRequest.method === 'GET' || currentQuery !== undefined ? {} : undefined)
+  );
+}
+
+/** Маршрут и query отгруженной версии берутся из одного фактического запроса. */
+export function shippedQueryCarrierSample(shippedSample) {
+  const request = shippedSample?.originalRequest;
+  if (request === undefined) {
+    if (shippedSample?.request !== undefined) {
+      throw new Error('Original shipped request is required for its query carrier');
+    }
+    return {};
+  }
+  const currentQuery =
+    shippedSample.request === undefined ? undefined : parseQuery(shippedSample.request.path);
+  const query = shippedQuerySample(request, currentQuery);
+  return {
+    shippedMethod: request.method ?? 'POST',
+    shippedSamplePath: request.path.split('?')[0],
+    ...(query === undefined ? {} : { shippedSampleQuery: query }),
+  };
+}

package/scripts/request-query.spec.mjs

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+import { parseQuery, shippedQueryCarrierSample, shippedQuerySample } from './request-query.mjs';
+
+describe('образец строки запроса отгруженного клиента', () => {
+  it('старый пустой GET сохраняется при новом POST без query', () => {
+    expect(shippedQuerySample({ method: 'GET', path: '/contacts' }, undefined)).toEqual({});
+  });
+  it('сохраняет успешный GET без query, когда v2 добавила страницу', () => {
+    expect(
+      shippedQuerySample(
+        { method: 'GET', path: '/icp/id/scenarios' },
+        { limit: '25', cursor: 'next' },
+      ),
+    ).toEqual({});
+  });
+
+  it('не выдаёт образец, когда отгруженный запрос не построен', () => {
+    expect(shippedQuerySample(undefined, { limit: '25' })).toBeUndefined();
+  });
+
+  it.each(['POST', 'PATCH', 'PUT', 'DELETE'])(
+    '%s без query сохраняется пустым образцом, когда v2 добавила параметры',
+    (method) => {
+      expect(shippedQuerySample({ method, path: '/items/id' }, { confirm: 'true' })).toEqual({});
+      expect(shippedQuerySample({ method, path: '/items/id' }, undefined)).toBeUndefined();
+    },
+  );
+
+  it('сохраняет фактические параметры отгруженного GET', () => {
+    expect(
+      shippedQuerySample({ method: 'GET', path: '/items?tag=a&tag=b&limit=10' }, { limit: '25' }),
+    ).toEqual({ tag: ['a', 'b'], limit: '10' });
+  });
+});
+
+describe('отгруженный маршрут и query — один носитель', () => {
+  it('удаление переменной сохраняет старый адрес и пустой query без подтверждения из v2', () => {
+    const inputShipped = {
+      originalRequest: {
+        method: 'DELETE',
+        path: '/workspaces/w/variables/v',
+        body: { scope: 'WORKSPACE', explicitConfirmation: true },
+      },
+      request: { method: 'DELETE', path: '/variables/v?confirm=true' },
+    };
+
+    expect(shippedQueryCarrierSample(inputShipped)).toEqual({
+      shippedMethod: 'DELETE',
+      shippedSamplePath: '/workspaces/w/variables/v',
+      shippedSampleQuery: {},
+    });
+    expect(parseQuery(inputShipped.request.path)).toEqual({ confirm: 'true' });
+  });
+
+  it('platforms и channels проверяются со своими параметрами', () => {
+    const inputCurrent = {
+      method: 'GET',
+      path: '/channels/c/setup/context?limit=25',
+    };
+    const inputShipped = {
+      originalRequest: {
+        method: 'GET',
+        path: '/platforms/p/setup/context?cursor=old',
+      },
+      request: inputCurrent,
+    };
+    expect(shippedQueryCarrierSample(inputShipped)).toEqual({
+      shippedMethod: 'GET',
+      shippedSamplePath: '/platforms/p/setup/context',
+      shippedSampleQuery: { cursor: 'old' },
+    });
+    expect(parseQuery(inputCurrent.path)).toEqual({ limit: '25' });
+  });
+  it('без originalRequest отвергает подмену текущим request', () => {
+    expect(() =>
+      shippedQueryCarrierSample({
+        request: { method: 'GET', path: '/contacts?search=synthetic' },
+      }),
+    ).toThrow('Original shipped request is required');
+    expect(shippedQueryCarrierSample(undefined)).toEqual({});
+  });
+});

package/scripts/route-lag.mjs

@@ -0,0 +1,23 @@
+/** Непостроенная ветка — долг маршрута; наличие инструмента и сохранение его схемы этот долг не снимают. */
+export function routeLagFindings(routeMap, routeLag, source) {
+  const routes = new Map();
+  for (const block of source.matchAll(/^ {4}"(\/[^\"]*)":\s*\{\n([\s\S]*?)^ {4}\};$/gm)) {
+    routes.set(block[1], new Set([...block[2].matchAll(/^ {8}([a-z]+):[ \t]*(\S[^\n]*)/gm)]
+      .filter(match => !/^never\b/u.test(match[2])).map(match => match[1])));
+  }
+  if (routes.size < 100) return ['Снимок маршрутов API не разобран'];
+  const missing = routeMap.filter(entry => entry.backendTarget === 'besales-api').filter(entry => {
+    const path = `/api/v2${entry.expected.pathTemplate.replace(/:([A-Za-z0-9_]+)/gu, '{$1}')}`;
+    return !routes.get(path)?.has(entry.expected.method.toLowerCase());
+  });
+  const findings = [];
+  for (const entry of missing) {
+    const debt = routeLag[entry.tool];
+    if (debt?.method !== entry.expected.method || debt?.pathTemplate !== entry.expected.pathTemplate ||
+      debt?.severity !== 'ROUTE_ABSENT' || !/^TASK-\d+(?:\.\d+)+$/u.test(debt?.owner ?? '') ||
+      !debt?.reason?.trim()) findings.push(`${entry.tool}: непостроенный маршрут без точной строки ROUTE_ABSENT`);
+  }
+  const missingKeys = new Set(missing.map(entry => entry.tool));
+  for (const key of Object.keys(routeLag)) if (!missingKeys.has(key)) findings.push(`${key}: протухшая строка ROUTE_ABSENT`);
+  return findings.sort();
+}

package/scripts/route-lag.spec.mjs

@@ -0,0 +1,30 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { routeLagFindings } from './route-lag.mjs';
+
+const inputMap = JSON.parse(readFileSync(new URL('../src/schemas/mcp-v2-route-map.json', import.meta.url), 'utf8'));
+const inputRegistry = JSON.parse(readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'));
+const inputSource = readFileSync(new URL('../src/types/api-contract.gen.ts', import.meta.url), 'utf8');
+const staleDebt = { owner: 'TASK-6.28.55', severity: 'ROUTE_ABSENT', reason: 'Отрицательная проба отсутствующего маршрута' };
+
+describe('серверные ветки Входящих на текущем образе', () => {
+  it('все шесть адресов построены, отсутствующий долг снят', () => {
+    const inbound = inputMap.filter(entry => entry.tool.startsWith('besales_inbound_analytics_get@'));
+    expect(inbound).toHaveLength(6);
+    expect(inbound.every(entry => entry.backendTarget === 'besales-api')).toBe(true);
+    expect(Object.keys(inputRegistry.routeLag)).toEqual([]);
+    expect(routeLagFindings(inputMap, inputRegistry.routeLag, inputSource)).toEqual([]);
+  });
+  it.each(['summary', 'money', 'topics'])('мутация: долг у построенного %s протух', (report) => {
+    expect(routeLagFindings(inputMap, { ...inputRegistry.routeLag,
+      [`besales_inbound_analytics_get@${report}`]: staleDebt }, inputSource)).toContain(
+      `besales_inbound_analytics_get@${report}: протухшая строка ROUTE_ABSENT`);
+  });
+  it('мутация: метод money исчез, другой метод на том же пути долг не закрывает', () => {
+    const mutated = inputSource.replace(/( {4}"\/api\/v2\/workspaces\/\{workspaceId\}\/inbound-analytics\/money":\s*\{\n)([\s\S]*?)(^ {4}\};)/m,
+      (_match, head, body, tail) => head + body.replace(/^ {8}get:[^\n]*/m, '        get: never;') + tail);
+    expect(mutated).not.toBe(inputSource);
+    expect(routeLagFindings(inputMap, inputRegistry.routeLag, mutated)).toContain(
+      'besales_inbound_analytics_get@money: непостроенный маршрут без точной строки ROUTE_ABSENT');
+  });
+});

package/scripts/sample-args.mjs

@@ -0,0 +1,174 @@
+import { resolveSchemaRef, schemaConstraints } from './registry-diff.mjs';
+
+// Счётчик образцов сбрасывается НА КАЖДЫЙ ВАРИАНТ (прежде — на инструмент).
+//
+// Сквозной счётчик сдвигал бы идентификаторы всех последующих записей от вставки одной соседней, и
+// побайтовое сравнение выгрузки краснело бы от чужой правки вместо своей. Сброс на инструменте эту
+// защиту давал только между инструментами: вставка варианта сдвигала идентификаторы последующих
+// вариантов ТОГО ЖЕ инструмента. Для фасада из пятнадцати отчётов это решающее — вставка одного
+// отчёта в середину сдвинула бы четырнадцать.
+let uid = 0;
+const distinctNumericIds = new Map();
+const nextUuid = () => `00000000-0000-4000-8000-${String(++uid).padStart(12, '0')}`;
+const INBOUND_SAMPLE_TRANSPORT = 'Telegram';
+
+/** Образец инструмента учитывает домен сервера, который свободная строка JSON-схемы не описывает. */
+export function sampleFor(toolName, schema, onlyRequired) {
+  try {
+    const args = sample(schema, '', 0, onlyRequired);
+    // Отгруженный channels принимает строки, но сервер проверяет транспорт по перечислению.
+    // Меняем только синтетическую заглушку: явное значение схемы и обязательный минимум сохраняются.
+    if (toolName === 'besales_inbound_analytics_get' && args !== null && typeof args === 'object' &&
+        Array.isArray(args.channels) && schemaConstraints(schema).get('channels[]')?.enum === undefined) {
+      args.channels = args.channels.map((value) => value === 'x' ? INBOUND_SAMPLE_TRANSPORT : value);
+    }
+    return args;
+  } catch (error) {
+    throw new Error(`${toolName}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * ⛔ Корень схемы обязателен: без него ссылку `#/$defs/x` разрешить не в чем, а нерешённая ссылка
+ * выглядит здесь узлом без `type` — то есть даёт СТРОКУ вместо объекта. Так и выходило: у
+ * инструмента правки поведения образец тела получался `{image: 'x', video: 'x', …}`, запрос
+ * отгруженного клиента не собирался (`shippedRequestFailed`), и api-сторонний страж, отбирающий
+ * записи по наличию образца, молча пропускал этот инструмент целиком.
+ */
+function sample(node, key = '', depth = 0, onlyRequired = false, root = node) {
+  if (!node || depth > 7) return {};
+  node = resolveSchemaRef(node, root, `образец тела (${key || 'корень'})`);
+  if (!node) return {};
+  // Включённый входящий фильтр по сделке требует настоящего типа; NONE со значением
+  // отгруженная схема принимает, но сервис закономерно отвергает как неполную настройку.
+  if (key === 'inbound_deal_filter_type' && node.enum?.includes('TAG')) return 'TAG';
+  if (node.enum) return node.enum[0];
+  if (node.const !== undefined) return node.const;
+  // ⛔ Корень прокидывается и СЮДА. Ветка `oneOf`/`anyOf` — такая же часть той же схемы, и
+  // потеря корня превращала бы законную ссылку внутри ветки в «указатель никуда не ведёт», то
+  // есть роняла бы выгрузку на исправном инструменте.
+  // ⛔ Ветка без типа и свойств у объекта со свойствами — не альтернативная ФОРМА, а условие «одно из полей
+  // обязательно» (`anyOf: [{required: ['final_content']}, {required: ['finalContent']}]`). Образцом такой ветки
+  // выходила строка, запрос не собирался ни из одного набора, и выгрузка реестра падала на исправных инструментах
+  // отправки результатов. Образец — сам объект, где поля первой ветки стали обязательными.
+  const branches = Array.isArray(node.oneOf) ? node.oneOf : Array.isArray(node.anyOf) ? node.anyOf : null;
+  const firstBranch = branches?.[0];
+  if (
+    node.properties &&
+    firstBranch &&
+    firstBranch.type === undefined &&
+    firstBranch.properties === undefined &&
+    firstBranch.$ref === undefined &&
+    Array.isArray(firstBranch.required)
+  ) {
+    const { oneOf: _oneOf, anyOf: _anyOf, ...object } = node;
+    return sample(
+      { ...object, required: [...(node.required ?? []), ...firstBranch.required] },
+      key,
+      depth,
+      onlyRequired,
+      root,
+    );
+  }
+  if (Array.isArray(node.oneOf)) return sample(node.oneOf[0], key, depth + 1, onlyRequired, root);
+  if (Array.isArray(node.anyOf)) return sample(node.anyOf[0], key, depth + 1, onlyRequired, root);
+  // ⛔ Тип бывает ОБЪЕДИНЁННЫМ (`["integer","null"]` у необязательного числового поля). Массив не
+  // совпадает ни с одной веткой `switch`, и образец молча уходил в ветку строки: у правки поведения
+  // `ai_error_target_stage_id` выходил строкой `'x'`, zod ждал число, сборка запроса отгруженного
+  // клиента падала — и выгрузка объявляла расхождением контракта то, что было мусором генератора.
+  // `null` отбрасывается: образец обязан быть НАСТОЯЩИМ значением, а не пустотой.
+  const declaredType = Array.isArray(node.type)
+    ? (node.type.find((candidate) => candidate !== 'null') ?? node.type[0])
+    : node.type;
+  const type = declaredType ?? (node.properties ? 'object' : node.items ? 'array' : 'string');
+  switch (type) {
+    case 'array':
+      return Array.from({ length: Math.max(node.minItems ?? 1, 1) }, () =>
+        sample(node.items ?? { type: 'string' }, key, depth + 1, onlyRequired, root),
+      );
+    case 'object': {
+      // У отгруженного Zod 4 запись по enum исчерпывающая. JSON-схема описывает её
+      // через propertyNames, и пустой объект фильтр отвергает по каждому транспорту.
+      if (!node.properties && Array.isArray(node.propertyNames?.enum)) {
+        return Object.fromEntries(node.propertyNames.enum.map((name) => [
+          name,
+          sample(node.additionalProperties ?? { type: 'string' }, name, depth + 1, onlyRequired, root),
+        ]));
+      }
+      if (!node.properties) return {};
+      const required = new Set(node.required ?? []);
+      const out = {};
+      for (const [name, child] of Object.entries(node.properties)) {
+        if (onlyRequired && !required.has(name)) continue;
+        out[name] = sample(child, name, depth + 1, onlyRequired, root);
+      }
+      return out;
+    }
+    case 'integer':
+    case 'number':
+      // Роли волны не делят поле сделки; роли ворот воронки не делят стадию.
+      // JSON-схема описывает отдельные числа, а принимающий сервис требует их различия.
+      if (key === 'field_id' || key === 'status_id') {
+        const offset = distinctNumericIds.get(key) ?? 0;
+        distinctNumericIds.set(key, offset + 1);
+        return Math.min(node.maximum ?? Number.MAX_SAFE_INTEGER, (node.minimum ?? 4) + offset);
+      }
+      return node.minimum ?? 4;
+    case 'boolean':
+      return true;
+    default: {
+      if (node.format === 'uuid') return nextUuid();
+      if (node.format === 'email') return 'sample@example.invalid';
+      if (
+        key.toLowerCase() === 'timezone' ||
+        /iana[\s_-]*time[\s_-]*zone/iu.test(`${node.format ?? ''} ${node.description ?? ''}`)
+      ) return 'Europe/Moscow';
+      if (node.format === 'uri' || /url/i.test(key)) return 'https://example.invalid/x';
+      // Форматы дат обязаны давать НАСТОЯЩЕЕ значение. Заглушка `x` проходила, пока образец
+      // никуда не отправлялся; с проверкой приёма настоящим DTO она даёт ложный отказ — красным
+      // становится инструмент, у которого контракт в порядке, а мусорным был образец.
+      if (node.format === 'date') return '2026-07-01';
+      if (node.format === 'date-time') return '2026-07-01T00:00:00.000Z';
+      if (node.pattern?.includes('\\d{4}-\\d{2}-\\d{2}')) return '2026-07-01';
+      // Шаблон строки узнаётся пробами: заглушка `x` нарушала шаблон САМОЙ схемы (`^\d+$` номера контакта, `HH:mm`
+      // окна), и отказ отгруженного фильтра на мусоре генератора выглядел расхождением контракта.
+      const probe = typeof node.pattern === 'string' ? patternProbe(node.pattern) : undefined;
+      if (probe !== undefined) return probe;
+      if (/_at$|At$/.test(key)) return '2026-07-01T00:00:00.000Z';
+      if (node.minLength && node.minLength > 1) return 'x'.repeat(node.minLength);
+      return 'x';
+    }
+  }
+}
+
+/** Пробы значения строки с шаблоном — в порядке предпочтения. */
+export const PATTERN_PROBES = Object.freeze([
+  '1',
+  '12:00',
+  '2026-07-01',
+  '2026-07-01T00:00:00.000Z',
+  'x',
+  'X',
+  'x1',
+  'x-1',
+  'x_1',
+]);
+
+/** Первая проба, проходящая шаблон; шаблон, который JavaScript не разбирает, проб не получает. */
+function patternProbe(pattern) {
+  let regex;
+  try {
+    regex = new RegExp(pattern, 'u');
+  } catch {
+    return undefined;
+  }
+  return PATTERN_PROBES.find((candidate) => regex.test(candidate));
+}
+
+/** Счётчик образцов сбрасывается вызывателем на каждый вариант инструмента. */
+export function resetSampleUid() {
+  uid = 0;
+  distinctNumericIds.clear();
+}
+
+export { sample };

package/scripts/sample-args.spec.mjs

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'vitest';
+
+import { resetSampleUid, sample } from './sample-args.mjs';
+
+/**
+ * Второй читатель ссылок схемы — генератор образца тела. Его слепота стоила дороже, чем у первого:
+ * нерешённая ссылка выглядит здесь узлом без типа, то есть даёт СТРОКУ вместо объекта, запрос
+ * отгруженного клиента не собирается, и проверка на стороне besales-api, отбирающая записи по
+ * НАЛИЧИЮ образца, молча пропускает такой инструмент целиком.
+ */
+describe('образец тела', () => {
+  it('IANA timezone определяется по имени, формату и описанию; enum имеет приоритет', () => {
+    expect(sample({ type: 'object', properties: {
+      timezone: { type: 'string' },
+      another: { type: 'string', description: 'IANA timezone для сообщений' },
+      formatted: { type: 'string', format: 'iana-timezone' },
+      enumerated: { type: 'string', format: 'iana-timezone', enum: ['Asia/Tashkent'] },
+    } })).toEqual({
+      timezone: 'Europe/Moscow',
+      another: 'Europe/Moscow',
+      formatted: 'Europe/Moscow',
+      enumerated: 'Asia/Tashkent',
+    });
+  });
+  const schemaWithRef = {
+    type: 'object',
+    properties: {
+      media: {
+        type: 'object',
+        properties: { image: { $ref: '#/$defs/handler' } },
+      },
+    },
+    $defs: {
+      handler: {
+        type: 'object',
+        properties: { behavior: { type: 'string', enum: ['SILENT'] } },
+      },
+    },
+  };
+
+  it('ветка-условие «одно из полей обязательно» у объекта даёт ОБЪЕКТ с полем первой ветки', () => {
+    resetSampleUid();
+    const schema = {
+      type: 'object',
+      required: ['operation_id'],
+      anyOf: [{ required: ['final_content'] }, { required: ['finalContent'] }],
+      properties: {
+        operation_id: { type: 'string' },
+        final_content: { type: 'string' },
+        finalContent: { type: 'string' },
+      },
+    };
+
+    // ⛔ Без различения образцом выходила строка: запрос не собирался, выгрузка реестра падала.
+    expect(sample(schema, '', 0, true)).toEqual({ operation_id: 'x', final_content: 'x' });
+    expect(sample(schema, '', 0, false)).toEqual({
+      operation_id: 'x',
+      final_content: 'x',
+      finalContent: 'x',
+    });
+  });
+
+  it('ссылка разворачивается в ОБЪЕКТ, а не в строку', () => {
+    resetSampleUid();
+
+    // ⛔ Различающая проверка именно для этого читателя: тесты `schemaConstraints` остались бы
+    // зелёными при снятом разыменовании здесь.
+    expect(sample(schemaWithRef)).toEqual({ media: { image: { behavior: 'SILENT' } } });
+  });
+
+  it('ссылка внутри ветки oneOf разрешается: корень доезжает и туда', () => {
+    resetSampleUid();
+    const schema = {
+      type: 'object',
+      properties: { x: { oneOf: [{ $ref: '#/$defs/inner' }] } },
+      $defs: { inner: { type: 'object', properties: { deep: { type: 'string' } } } },
+    };
+
+    // Потеря корня в этой ветке превращала бы законную ссылку в «указатель никуда не ведёт»,
+    // то есть роняла бы выгрузку на исправном инструменте.
+    expect(sample(schema)).toEqual({ x: { deep: 'x' } });
+  });
+
+  it('объединённый тип даёт значение НЕПУСТОЙ ветки, а не строку', () => {
+    resetSampleUid();
+
+    // Массив в `type` не совпадал ни с одной веткой и уходил в ветку строки: схема ждала число,
+    // сборка запроса падала, и выгрузка объявляла расхождением контракта мусор генератора.
+    expect(sample({ type: 'object', properties: { n: { type: ['integer', 'null'] } } })).toEqual({
+      n: 4,
+    });
+  });
+
+  it('строка с шаблоном получает значение, которое шаблон проходит, а не заглушку', () => {
+    resetSampleUid();
+
+    // Заглушка `x` нарушала шаблон САМОЙ схемы (номер контакта только цифрами, окно HH:mm), и отказ
+    // отгруженного фильтра на мусоре генератора выглядел расхождением контракта.
+    expect(
+      sample({
+        type: 'object',
+        properties: {
+          contact_id: { type: 'string', pattern: '^\\d+$' },
+          window_start: { type: 'string', pattern: '^([01]\\d|2[0-3]):[0-5]\\d$' },
+          code: { type: 'string', pattern: '^[A-Z]$' },
+          free: { type: 'string' },
+        },
+      }),
+    ).toEqual({ contact_id: '1', window_start: '12:00', code: 'X', free: 'x' });
+  });
+
+  it('соседние роли школы получают разные допустимые field_id', () => {
+    resetSampleUid();
+    const role = { type: 'object', properties: { field_id: { type: 'integer', minimum: 1, maximum: 10 } } };
+    const schema = { type: 'object', properties: { launch_type: role, product: role, segment: role } };
+    expect(sample(schema)).toEqual({
+      launch_type: { field_id: 1 },
+      product: { field_id: 2 },
+      segment: { field_id: 3 },
+    });
+    resetSampleUid();
+    expect(sample(schema)).toEqual({
+      launch_type: { field_id: 1 },
+      product: { field_id: 2 },
+      segment: { field_id: 3 },
+    });
+  });
+
+  it('роли ворот воронки получают разные status_id', () => {
+    resetSampleUid();
+    const stage = { type: 'object', properties: { status_id: { type: 'integer', minimum: 1, maximum: 10 } } };
+    const schema = { type: 'object', properties: { submitted: stage, approved: stage, rejected: stage } };
+    expect(sample(schema)).toEqual({
+      submitted: { status_id: 1 },
+      approved: { status_id: 2 },
+      rejected: { status_id: 3 },
+    });
+  });
+
+  it('включённый фильтр сделки получает действующий тип, а не NONE', () => {
+    resetSampleUid();
+    expect(sample({ type: 'object', properties: {
+      inbound_deal_filter_enabled: { type: 'boolean' },
+      inbound_deal_filter_type: { type: 'string', enum: ['NONE', 'TAG', 'CUSTOM_FIELD'] },
+      inbound_deal_filter_value: { type: 'string' },
+    } })).toEqual({
+      inbound_deal_filter_enabled: true,
+      inbound_deal_filter_type: 'TAG',
+      inbound_deal_filter_value: 'x',
+    });
+  });
+
+  it('битая ссылка роняет генератор, а не подсовывает пустой объект', () => {
+    resetSampleUid();
+
+    expect(() =>
+      sample({ type: 'object', properties: { x: { $ref: '#/$defs/typo' } }, $defs: {} }),
+    ).toThrow('никуда не ведёт');
+  });
+});