@algosail/lang 0.2.12 → 0.5.1

package/test/ir/lower-body-steps.test.js

@@ -0,0 +1,90 @@
+/**
+ * L4 фаза 2: lowerBodySteps / irSteps в module (RFC-IR section 5).
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+import {
+  assertJsonSerializable,
+  buildModuleIr,
+  irBodyStepNodeId,
+  lowerBodySteps
+} from '../../lib/ir/index.js'
+
+const root = path.resolve('/virtual/sail-ir-phase2')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('lowerBodySteps: один литерал', function (t) {
+  const main = path.join(root, 'lit.sail')
+  const src = ['@w ( -> Num )', '', '  42', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const norm = path.normalize(main)
+  const word = r.env.wordDeclByPath.get(norm).get('w')
+  const steps = lowerBodySteps(norm, 'w', word.body)
+  t.is(steps.length, 1)
+  t.is(steps[0].kind, 'Literal')
+  t.is(steps[0].litKind, 'number')
+  t.is(steps[0].raw, '42')
+  t.ok(steps[0].nodeId.includes('#w#0'))
+  t.ok(steps[0].span && steps[0].span.start)
+  assertJsonSerializable(steps)
+  t.end()
+})
+
+test('lowerBodySteps: dup и drop', function (t) {
+  const main = path.join(root, 'dupdrop.sail')
+  const src = ['@w ( Num -> Num )', '', '  dup', '', '  drop', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const norm = path.normalize(main)
+  const word = r.env.wordDeclByPath.get(norm).get('w')
+  const steps = lowerBodySteps(norm, 'w', word.body)
+  t.is(steps.length, 2)
+  t.is(steps[0].kind, 'Builtin')
+  t.is(steps[0].name, 'dup')
+  t.is(steps[1].kind, 'Builtin')
+  t.is(steps[1].name, 'drop')
+  t.is(steps[0].nodeId, irBodyStepNodeId(norm, 'w', [0]))
+  t.is(steps[1].nodeId, irBodyStepNodeId(norm, 'w', [1]))
+  assertJsonSerializable(steps)
+  t.end()
+})
+
+test('lowerBodySteps: quotation с литералом внутри', function (t) {
+  const main = path.join(root, 'quote.sail')
+  const src = ['@w ( -> ( -> Num ) )', '', '  ( 1 )', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const norm = path.normalize(main)
+  const word = r.env.wordDeclByPath.get(norm).get('w')
+  const steps = lowerBodySteps(norm, 'w', word.body)
+  t.is(steps.length, 1)
+  t.is(steps[0].kind, 'Quotation')
+  const inner = steps[0].steps
+  t.ok(Array.isArray(inner) && inner.length === 1)
+  t.is(inner[0].kind, 'Literal')
+  t.is(inner[0].litKind, 'number')
+  t.is(inner[0].nodeId, irBodyStepNodeId(norm, 'w', [0, 0]))
+  assertJsonSerializable(steps)
+  t.end()
+})
+
+test('buildModuleIr: irSteps у слова', function (t) {
+  const main = path.join(root, 'module-irsteps.sail')
+  const src = ['@w ( -> Num )', '', '  7', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok)
+  const payload = buildModuleIr(r.env, main, { moduleStatus: 'ok' })
+  const wEntry = payload.words.find((x) => x.name === 'w')
+  t.ok(wEntry?.irSteps)
+  t.is(wEntry.irSteps.length, 1)
+  t.is(wEntry.irSteps[0].kind, 'Literal')
+  assertJsonSerializable(payload)
+  t.end()
+})

package/test/ir/module-metadata.test.js

@@ -0,0 +1,42 @@
+/**
+ * L4 фаза 6: резолв импортов и квалифицированных вызовов (RFC-IR section 7).
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+import { assertJsonSerializable, buildModuleIr } from '../../lib/ir/index.js'
+
+const root = path.resolve('/virtual/sail-ir-phase6')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('фаза 6: импорт + ~Lib/hello — resolvedPath и resolvedModulePath', function (t) {
+  const main = path.join(root, 'main.sail')
+  const lib = path.join(root, 'lib.sail')
+  const files = {
+    [main]: ['+Lib ./lib.sail', '@main ( -> )', '', '  ~Lib/hello'].join('\n'),
+    [lib]: ['@hello ( -> )', '', ''].join('\n')
+  }
+  const r = typecheckSail({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const normMain = path.normalize(main)
+  const normLib = path.normalize(lib)
+  const payload = buildModuleIr(r.env, normMain, { moduleStatus: 'ok' })
+  t.is(payload.imports.length, 1)
+  t.is(payload.imports[0].module, 'Lib')
+  t.is(payload.imports[0].resolvedPath, normLib)
+  const mainWord = payload.words.find((w) => w.name === 'main')
+  t.ok(mainWord?.irSteps?.length === 1)
+  const step = mainWord.irSteps[0]
+  t.is(step.kind, 'Word')
+  t.is(step.ref, 'qualified')
+  t.is(step.module, 'Lib')
+  t.is(step.word, 'hello')
+  t.is(step.resolvedModulePath, normLib)
+  assertJsonSerializable(payload)
+  t.end()
+})

package/test/ir/serialization-model.test.js

@@ -0,0 +1,172 @@
+/**
+ * Ранняя фаза L4: модель JSON-сериализации IR (lib/ir/serialize.js).
+ */
+import test from 'brittle'
+import { IR_SCHEMA_VERSION } from '../../lib/ir/schema-version.js'
+import { assertJsonSerializable } from '../../lib/ir/assert-json-serializable.js'
+import {
+  createSerializedIrDocument as wrap,
+  unwrapSerializedIrDocument as unwrap,
+  unwrapSerializedIrDocumentFull as unwrapFull,
+  stringifyIrDocument as stringify,
+  parseIrDocument as parse,
+  parseIrDocumentFull as parseFull
+} from '../../lib/ir/serialize.js'
+
+test('IR_SCHEMA_VERSION — строка semver-подобная', function (t) {
+  t.ok(typeof IR_SCHEMA_VERSION === 'string' && IR_SCHEMA_VERSION.length > 0)
+  t.end()
+})
+
+test('createSerializedIrDocument: конверт с module и irSchemaVersion', function (t) {
+  const doc = wrap({ path: '/x.sail', words: [] })
+  t.is(doc.irSchemaVersion, IR_SCHEMA_VERSION)
+  t.ok(doc.module && typeof doc.module === 'object')
+  t.is(doc.module.path, '/x.sail')
+  t.ok(Array.isArray(doc.module.words))
+  t.ok(doc.views === undefined && doc.meta === undefined)
+  t.end()
+})
+
+test('createSerializedIrDocument: views и meta опциональны', function (t) {
+  const views = { stepOrder: ['m#w#0', 'm#w#1'] }
+  const meta = { producer: { name: 'test', version: '0' } }
+  const doc = wrap({ k: 1 }, { views, meta })
+  t.alike(doc.views, views)
+  t.alike(doc.meta, meta)
+  t.end()
+})
+
+test('createSerializedIrDocument: views не массив', function (t) {
+  t.exception(() => wrap({}, { views: [] }), /options.views/)
+  t.end()
+})
+
+test('unwrapSerializedIrDocument: извлечение module', function (t) {
+  const inner = unwrap(wrap({ k: 1 }))
+  t.is(inner.k, 1)
+  t.end()
+})
+
+test('unwrapSerializedIrDocumentFull: module, views, meta', function (t) {
+  const views = { stepOrder: ['a#w#0'] }
+  const meta = { producer: { name: 'p' } }
+  const full = unwrapFull(wrap({ x: 2 }, { views, meta }))
+  t.is(full.module.x, 2)
+  t.alike(full.views, views)
+  t.alike(full.meta, meta)
+  t.end()
+})
+
+test('unwrapSerializedIrDocumentFull: без views/meta — undefined', function (t) {
+  const full = unwrapFull(wrap({}))
+  t.ok(full.module && typeof full.module === 'object')
+  t.is(full.views, undefined)
+  t.is(full.meta, undefined)
+  t.end()
+})
+
+test('unwrapSerializedIrDocument: неизвестный ключ корня не мешает', function (t) {
+  const inner = unwrap({
+    irSchemaVersion: IR_SCHEMA_VERSION,
+    module: { ok: true },
+    futureField: [1, 2, 3]
+  })
+  t.is(inner.ok, true)
+  t.end()
+})
+
+test('unwrapSerializedIrDocument: неверная версия', function (t) {
+  t.exception(
+    () =>
+      unwrap({
+        irSchemaVersion: '0.0.0',
+        module: {}
+      }),
+    /неподдерживаемая irSchemaVersion/
+  )
+  t.end()
+})
+
+test('unwrapSerializedIrDocument: не объект / нет module', function (t) {
+  t.exception(() => unwrap(null), /ожидался объект/)
+  t.exception(
+    () => unwrap({ irSchemaVersion: IR_SCHEMA_VERSION, module: [] }),
+    /module должно быть объектом/
+  )
+  t.end()
+})
+
+test('unwrapSerializedIrDocumentFull: views не массив', function (t) {
+  t.exception(
+    () =>
+      unwrapFull({
+        irSchemaVersion: IR_SCHEMA_VERSION,
+        module: {},
+        views: []
+      }),
+    /views должно быть объектом/
+  )
+  t.end()
+})
+
+test('unwrapSerializedIrDocumentFull: meta не массив', function (t) {
+  t.exception(
+    () =>
+      unwrapFull({
+        irSchemaVersion: IR_SCHEMA_VERSION,
+        module: {},
+        meta: []
+      }),
+    /meta должно быть объектом/
+  )
+  t.end()
+})
+
+test('stringifyIrDocument / parseIrDocument — round-trip', function (t) {
+  const payload = { modulePath: '/a.sail', exports: { words: ['main'] } }
+  const text = stringify(payload)
+  t.ok(text.includes('irSchemaVersion'))
+  const back = parse(text)
+  t.alike(back, payload)
+  t.end()
+})
+
+test('stringifyIrDocument / parseIrDocumentFull — views лёгкий, module с фиктивным quote', function (t) {
+  const modulePayload = {
+    steps: [
+      {
+        nodeId: 'f#w#0',
+        span: { start: { offset: 0, line: 1, column: 1 } },
+        preTypes: [],
+        postTypes: [
+          {
+            kind: 'quote',
+            inner: { steps: [] }
+          }
+        ]
+      }
+    ]
+  }
+  const views = { stepOrder: ['f#w#0'] }
+  const text = stringify(modulePayload, { views })
+  const full = parseFull(text)
+  t.alike(full.module, modulePayload)
+  t.alike(full.views, views)
+  t.is(full.meta, undefined)
+  t.end()
+})
+
+test('assertJsonSerializable: ок для plain объекта', function (t) {
+  assertJsonSerializable({ a: 1, b: [true, null] })
+  t.pass()
+  t.end()
+})
+
+test('assertJsonSerializable: undefined в объекте — ошибка', function (t) {
+  t.exception(
+    () => assertJsonSerializable({ a: undefined }),
+    /undefined/
+  )
+  t.end()
+})

package/test/ir/stitch-types.test.js

@@ -0,0 +1,74 @@
+/**
+ * L4 фаза 3: stitch-types + типы на irSteps.
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+import {
+  assertJsonSerializable,
+  buildModuleIr,
+  verifyWireStackSnapshot
+} from '../../lib/ir/index.js'
+
+const root = path.resolve('/virtual/sail-ir-phase3')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('фаза 3: irSteps с preTypes/postTypes и verifyWireStackSnapshot', function (t) {
+  const main = path.join(root, 'dup.sail')
+  const src = ['@w ( -> Num Num )', '', '  1', '', '  dup', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const norm = path.normalize(main)
+  const payload = buildModuleIr(r.env, norm, { moduleStatus: 'ok' })
+  const w = payload.words.find((x) => x.name === 'w')
+  t.ok(w?.irSteps?.length === 2)
+  t.ok(Array.isArray(w.irSteps[0].preTypes))
+  t.ok(Array.isArray(w.irSteps[0].postTypes))
+  t.is(w.irSteps[0].postTypes[0].kind, 'prim')
+  t.ok(Array.isArray(w.irSteps[1].preTypes))
+  t.ok(Array.isArray(w.irSteps[1].postTypes))
+  t.ok(verifyWireStackSnapshot(w.stackSteps))
+  assertJsonSerializable(payload)
+  t.end()
+})
+
+test('фаза 3: вложенная quotation — типы внутри и verify', function (t) {
+  const main = path.join(root, 'nested.sail')
+  const src = ['@w ( -> ( -> Num ) )', '', '  ( 1 )', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  const norm = path.normalize(main)
+  const payload = buildModuleIr(r.env, norm, { moduleStatus: 'ok' })
+  const w = payload.words.find((x) => x.name === 'w')
+  const q = w.irSteps[0]
+  t.is(q.kind, 'Quotation')
+  t.ok(Array.isArray(q.preTypes))
+  t.ok(Array.isArray(q.postTypes))
+  const inner = q.steps[0]
+  t.is(inner.kind, 'Literal')
+  t.ok(Array.isArray(inner.preTypes))
+  t.ok(Array.isArray(inner.postTypes))
+  t.ok(verifyWireStackSnapshot(w.stackSteps))
+  assertJsonSerializable(payload)
+  t.end()
+})
+
+test('фаза 3: ошибка в теле — preTypes на шаге сбоя, verify не обязан true', function (t) {
+  const main = path.join(root, 'fail.sail')
+  const src = ['@bad ( -> )', '', '  drop', ''].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+  const norm = path.normalize(main)
+  const payload = buildModuleIr(r.env, norm, { moduleStatus: 'error' })
+  const bad = payload.words.find((x) => x.name === 'bad')
+  t.ok(bad?.irSteps?.length === 1)
+  t.ok(Array.isArray(bad.irSteps[0].preTypes))
+  t.ok(bad.irSteps[0].postTypes === undefined)
+  assertJsonSerializable(payload)
+  t.end()
+})

package/test/names/l2-resolve-adt-autogen.test.js

@@ -0,0 +1,155 @@
+/**
+ * L2: ADT — autogen не в symbol_tables.words (только типы и @); квалификация ~M/w; реэкспорт &Type.
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { resolveSailNames } from '../../lib/names/resolve-sail.js'
+
+const root = path.resolve('/virtual/sail-l2-adt')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('L2 ADT: symbol_tables — тип Maybe, autogen не в words; тело /just ok', function (t) {
+  const main = path.join(root, 'maybe.sail')
+  const src = [
+    '&Maybe a',
+    '  | Nothing',
+    '  | Just a',
+    '@t ( -> )',
+    '',
+    '  /nothing',
+    '  /just',
+    '  /maybe'
+  ].join('\n')
+  const r = resolveSailNames({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics.map(d => d.message).join('; '))
+  const tab = r.symbolTables?.get(path.normalize(main))
+  t.ok(tab)
+  t.ok(tab.types.includes('Maybe'))
+  t.ok(tab.words.includes('t'), 'только явные @ в words')
+  for (const w of ['just', 'nothing', 'maybe']) {
+    t.ok(!tab.words.includes(w), `autogen ${w} не экспортируется в words`)
+  }
+  t.end()
+})
+
+test('L2 ADT: product Point — тип в types, autogen не в words', function (t) {
+  const main = path.join(root, 'point.sail')
+  const src = [
+    '&Point',
+    '  :x Num',
+    '  :y Num',
+    '@t ( -> )',
+    '',
+    '  /point',
+    '  /xPoint',
+    '  /withPoint'
+  ].join('\n')
+  const r = resolveSailNames({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok, r.diagnostics.map(d => d.message).join('; '))
+  const tab = r.symbolTables?.get(path.normalize(main))
+  t.ok(tab.types.includes('Point'))
+  t.ok(tab.words.includes('t'))
+  for (const w of ['point', 'xPoint', 'yPoint', 'withPoint']) {
+    t.ok(!tab.words.includes(w), `autogen ${w} не в words`)
+  }
+  t.end()
+})
+
+test('L2 ADT: ~Lib/just — module_word_ref; у Lib autogen не в words', function (t) {
+  const main = path.join(root, 'main.sail')
+  const lib = path.join(root, 'lib.sail')
+  const files = {
+    [main]: [
+      '+Lib ./lib.sail',
+      '@m ( -> )',
+      '',
+      '  ~Lib/just'
+    ].join('\n'),
+    [lib]: [
+      '&Maybe a',
+      '  | Nothing',
+      '  | Just a'
+    ].join('\n')
+  }
+  const r = resolveSailNames({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics.map(d => d.message).join('; '))
+  const libTab = r.symbolTables?.get(path.normalize(lib))
+  t.ok(libTab?.types.includes('Maybe'))
+  t.ok(!libTab?.words.includes('just'), 'just не в export words Lib')
+  t.end()
+})
+
+test('L2 ADT: скобочный &Maybe — /just локально', function (t) {
+  const main = path.join(root, 'main.sail')
+  const lib = path.join(root, 'lib.sail')
+  const files = {
+    [main]: [
+      '+Lib ( &Maybe ) ./lib.sail',
+      '@m ( -> )',
+      '',
+      '  /just'
+    ].join('\n'),
+    [lib]: [
+      '&Maybe a',
+      '  | Nothing',
+      '  | Just a'
+    ].join('\n')
+  }
+  const r = resolveSailNames({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics.map(d => d.message).join('; '))
+  t.end()
+})
+
+test('L2 ADT: реэкспорт &Maybe — R.types содержит Maybe; ~R/just', function (t) {
+  const consumer = path.join(root, 'consumer.sail')
+  const reexport = path.join(root, 'reexport.sail')
+  const lib = path.join(root, 'lib.sail')
+  const files = {
+    [lib]: [
+      '&Maybe a',
+      '  | Nothing',
+      '  | Just a'
+    ].join('\n'),
+    [reexport]: '+Lib ( &Maybe ) ./lib.sail\n',
+    [consumer]: [
+      '+R ./reexport.sail',
+      '@use ( -> )',
+      '',
+      '  ~R/just'
+    ].join('\n')
+  }
+  const r = resolveSailNames({ entryPath: consumer, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics.map(d => d.message).join('; '))
+  const rTab = r.symbolTables?.get(path.normalize(reexport))
+  t.ok(rTab?.types.includes('Maybe'), 'реэкспорт типа в symbol_tables')
+  t.ok(!rTab?.words.includes('just'))
+  t.end()
+})
+
+test('L2 ADT: consumer со скобочным &Maybe от реэкспортёра — /just', function (t) {
+  const consumer = path.join(root, 'consumer2.sail')
+  const reexport = path.join(root, 'reexport2.sail')
+  const lib = path.join(root, 'lib2.sail')
+  const files = {
+    [lib]: [
+      '&Maybe a',
+      '  | Nothing',
+      '  | Just a'
+    ].join('\n'),
+    [reexport]: '+Lib ( &Maybe ) ./lib2.sail\n',
+    [consumer]: [
+      '+R ( &Maybe ) ./reexport2.sail',
+      '@use ( -> )',
+      '',
+      '  /just'
+    ].join('\n')
+  }
+  const r = resolveSailNames({ entryPath: consumer, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics.map(d => d.message).join('; '))
+  t.end()
+})

package/test/names/l2-resolve-bracket-ffi.test.js

@@ -0,0 +1,108 @@
+/**
+ * L2: скобочный импорт, E1205, E1110; виртуальный модуль из .js (FFI).
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { resolveSailNames } from '../../lib/names/resolve-sail.js'
+
+const root = path.resolve('/virtual/sail-l2-bracket')
+function vfs (files) {
+  const norm = Object.fromEntries(
+    Object.entries(files).map(([k, v]) => [path.normalize(k), v])
+  )
+  return (p) => norm[path.normalize(p)] ?? null
+}
+
+test('L2 bracket: внесённое @hello — /hello без квалификации', function (t) {
+  const main = path.join(root, 'main.sail')
+  const lib = path.join(root, 'lib.sail')
+  const files = {
+    [main]: [
+      '+Lib ( @hello ) ./lib.sail',
+      '@main ( -> )',
+      '',
+      '  /hello'
+    ].join('\n'),
+    [lib]: '@hello ( -> )\n\n'
+  }
+  const r = resolveSailNames({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics.map(d => d.message).join('; '))
+  t.end()
+})
+
+test('L2: полный импорт без скобок — /hello требует квалификации → E1205', function (t) {
+  const main = path.join(root, 'main.sail')
+  const lib = path.join(root, 'lib.sail')
+  const files = {
+    [main]: [
+      '+Lib ./lib.sail',
+      '@main ( -> )',
+      '',
+      '  /hello'
+    ].join('\n'),
+    [lib]: '@hello ( -> )\n\n'
+  }
+  const r = resolveSailNames({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok === false)
+  const d = r.diagnostics.find(x => x.code === 'E1205')
+  t.ok(d && d.message.includes('hello') && d.message.includes('Lib'))
+  t.end()
+})
+
+test('L2 bracket: символ не в экспорте → E1110', function (t) {
+  const main = path.join(root, 'main.sail')
+  const lib = path.join(root, 'lib.sail')
+  const files = {
+    [main]: '+Lib ( @missing ) ./lib.sail\n@main ( -> )\n\n',
+    [lib]: '@hello ( -> )\n\n'
+  }
+  const r = resolveSailNames({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok === false)
+  const d = r.diagnostics.find(x => x.code === 'E1110')
+  t.ok(d && d.message.includes('missing'))
+  t.end()
+})
+
+test('L2 FFI: скобочный &Buffer — нет ADT в JSDoc → E1110 (opaque не вносится скобками)', function (t) {
+  const main = path.join(root, 'opaque-bracket.sail')
+  const js = path.join(root, 'opaque-ffi.js')
+  const files = {
+    [main]: '+M ( &Buffer ) ./opaque-ffi.js\n',
+    [js]: [
+      '/**',
+      ' * @sail',
+      ' * @f ( -> )',
+      ' */',
+      'export const f = 1'
+    ].join('\n')
+  }
+  const r = resolveSailNames({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok === false)
+  const d = r.diagnostics.find((x) => x.code === 'E1110')
+  t.ok(d && d.message.includes('Buffer'))
+  t.end()
+})
+
+test('L2 FFI: +Num ./num.js и скобочный @add', function (t) {
+  const main = path.join(root, 'main.sail')
+  const num = path.join(root, 'num.js')
+  const files = {
+    [main]: [
+      '+Num ( @add ) ./num.js',
+      '@main ( Num Num -> Num )',
+      '',
+      '  /add'
+    ].join('\n'),
+    [num]: [
+      '/**',
+      ' * @sail',
+      ' * @add ( Num Num -> Num )',
+      ' * ',
+      ' */',
+      'export function add (a, b) { return a + b }'
+    ].join('\n')
+  }
+  const r = resolveSailNames({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics.map(d => d.code + ' ' + d.message).join('; '))
+  t.end()
+})