@algosail/lang 0.2.12 → 0.5.1

package/lib/typecheck/validate-adt.js

@@ -0,0 +1,201 @@
+/**
+ * L3 этап 2: проверка объявлений `&` (RFC-0.1 §7, §5.3) — type_expr в payload/полях.
+ */
+import * as diag from '../parse/diagnostics.js'
+
+/**
+ * @param {object[]} out
+ * @param {object} span
+ * @param {string} code
+ * @param {string} message
+ */
+function pushDiag (out, span, code, message) {
+  const d = { code, message }
+  if (span?.start) {
+    d.offset = span.start.offset
+    d.line = span.start.line
+    d.column = span.start.column
+  }
+  out.push(d)
+}
+
+/**
+ * @param {object | null | undefined} typeExpr
+ * @param {(node: object) => void} onModuleRef
+ * @param {(node: object) => void} onTypeVar
+ */
+function walkAdtSigStackItem (item, onModuleRef, onTypeVar) {
+  if (!item) return
+  switch (item.kind) {
+    case 'sig_type_expr':
+      walkAdtTypeExpr(item.type, onModuleRef, onTypeVar)
+      return
+    case 'quotation_sig':
+      walkAdtSignatureSlots(item.inner, onModuleRef, onTypeVar)
+      return
+    case 'named_quotation_sig':
+      walkAdtSigStackItem(item.quotation, onModuleRef, onTypeVar)
+      return
+    default:
+      return
+  }
+}
+
+function walkAdtSignatureSlots (sig, onModuleRef, onTypeVar) {
+  if (!sig) return
+  for (const x of sig.left) walkAdtSigStackItem(x, onModuleRef, onTypeVar)
+  for (const x of sig.right) walkAdtSigStackItem(x, onModuleRef, onTypeVar)
+}
+
+function walkAdtTypeExpr (typeExpr, onModuleRef, onTypeVar) {
+  if (!typeExpr) return
+  switch (typeExpr.kind) {
+    case 'type_var':
+      onTypeVar(typeExpr)
+      return
+    case 'type_name':
+      return
+    case 'module_type_ref':
+      onModuleRef(typeExpr)
+      return
+    case 'paren_type':
+      walkAdtTypeExpr(typeExpr.inner, onModuleRef, onTypeVar)
+      return
+    case 'quotation_type':
+      walkAdtSignatureSlots(typeExpr.inner, onModuleRef, onTypeVar)
+      return
+    case 'type_app':
+      for (const a of typeExpr.args) walkAdtTypeExpr(a, onModuleRef, onTypeVar)
+      return
+    default:
+      return
+  }
+}
+
+/**
+ * @param {object} item sum_type | product_type
+ * @param {Map<string, object>} importMap
+ * @param {object[]} diagnostics
+ */
+function diagnoseAdtItem (item, importMap, diagnostics) {
+  if (item.kind === 'sum_type') {
+    const allowedParams = new Set(item.typeParams)
+    const paramList = item.typeParams.length
+      ? item.typeParams.join(', ')
+      : '(нет)'
+
+    for (const tag of item.tags) {
+      if (!tag.payload) continue
+      walkAdtTypeExpr(
+        tag.payload,
+        (node) => {
+          const { module: m, type: ty } = node
+          const dep = importMap.get(m)
+          if (!dep) {
+            pushDiag(diagnostics, node.span, 'E1203', diag.e1203ModuleNotFound(m))
+          } else if (!dep.exportTypes.has(ty)) {
+            pushDiag(diagnostics, node.span, 'E1204', diag.e1204MissingMember(m, ty))
+          }
+        },
+        (node) => {
+          if (!allowedParams.has(node.name)) {
+            pushDiag(
+              diagnostics,
+              node.span,
+              'E1304',
+              diag.e1304TypeMismatch(
+                `параметры &${item.name}: ${paramList}`,
+                `переменная типа '${node.name}'`
+              )
+            )
+          }
+        }
+      )
+    }
+    return
+  }
+
+  if (item.kind === 'product_type') {
+    const allowedParams = new Set(item.typeParams)
+    const paramList = item.typeParams.length
+      ? item.typeParams.join(', ')
+      : '(нет)'
+
+    for (const field of item.fields) {
+      walkAdtTypeExpr(
+        field.type,
+        (node) => {
+          const { module: m, type: ty } = node
+          const dep = importMap.get(m)
+          if (!dep) {
+            pushDiag(diagnostics, node.span, 'E1203', diag.e1203ModuleNotFound(m))
+          } else if (!dep.exportTypes.has(ty)) {
+            pushDiag(diagnostics, node.span, 'E1204', diag.e1204MissingMember(m, ty))
+          }
+        },
+        (node) => {
+          if (!allowedParams.has(node.name)) {
+            pushDiag(
+              diagnostics,
+              node.span,
+              'E1304',
+              diag.e1304TypeMismatch(
+                `параметры &${item.name}: ${paramList}`,
+                `переменная типа '${node.name}'`
+              )
+            )
+          }
+        }
+      )
+    }
+  }
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @returns {{ diagnostics: object[], adtByPath: Map<string, Map<string, object>> }}
+ */
+export function validateAdtDeclarations (env) {
+  /** @type {object[]} */
+  const diagnostics = []
+  /** @type {Map<string, Map<string, object>>} */
+  const adtByPath = new Map()
+
+  for (const p of env.modulePathsOrdered) {
+    const snap = env.snapshots.get(p)
+    const scopeInfo = env.scopeByPath.get(p)
+    if (!snap?.ok || !scopeInfo) continue
+
+    /** @type {Map<string, object>} */
+    const perPath = new Map()
+    for (const item of snap.items) {
+      if (item.kind === 'sum_type' || item.kind === 'product_type') {
+        const itemDiags = []
+        diagnoseAdtItem(item, scopeInfo.importMap, itemDiags)
+        diagnostics.push(...itemDiags)
+        if (itemDiags.length === 0) {
+          if (item.kind === 'sum_type') {
+            perPath.set(item.name, {
+              kind: 'sum',
+              name: item.name,
+              typeParams: [...item.typeParams],
+              ast: item
+            })
+          } else {
+            perPath.set(item.name, {
+              kind: 'product',
+              name: item.name,
+              typeParams: [...item.typeParams],
+              ast: item
+            })
+          }
+        }
+      }
+    }
+    if (perPath.size > 0) {
+      adtByPath.set(p, perPath)
+    }
+  }
+
+  return { diagnostics, adtByPath }
+}

package/package.json

@@ -1,21 +1,16 @@
 {
   "name": "@algosail/lang",
-  "version": "0.2.12",
+  "version": "0.5.1",
   "type": "module",
   "main": "index.js",
   "bin": {
-    "sail": "cli/sail.js"
+    "sail-lang": "./bin/sail.mjs"
   },
   "scripts": {
-    "test": "brittle \"test/**/*.test.js\""
+    "test": "brittle \"test/**/*.test.js\"",
+    "regen:fixture-ast": "node scripts/regen-demo-full-syntax-ast.mjs"
   },
   "devDependencies": {
     "brittle": "^3.19.1"
-  },
-  "dependencies": {
-    "@algosail/builtins": "^0.0.6",
-    "@algosail/compiler": "^0.0.3",
-    "@algosail/parser": "^0.1.3",
-    "@algosail/typecheck": "^0.1.2"
   }
 }

package/scripts/regen-demo-full-syntax-ast.mjs

@@ -0,0 +1,22 @@
+/**
+ * Перезаписывает test/fixtures/demo-full-syntax.ast.json из demo-full-syntax.sail.
+ * Запуск из каталога lang: `npm run regen:fixture-ast`
+ */
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { parseSource } from '../index.js'
+
+const langRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), '..')
+const fixtureDir = path.join(langRoot, 'test/fixtures')
+const sailPath = path.join(fixtureDir, 'demo-full-syntax.sail')
+const jsonPath = path.join(fixtureDir, 'demo-full-syntax.ast.json')
+
+const sourceText = fs.readFileSync(sailPath, 'utf8')
+const r = parseSource(sourceText)
+if (!r.ok) {
+  console.error(r.diagnostics)
+  process.exit(1)
+}
+fs.writeFileSync(jsonPath, JSON.stringify(r.ast, null, 2) + '\n')
+console.log('wrote', jsonPath)

package/test/cli/sail-cli.test.js

@@ -0,0 +1,64 @@
+/**
+ * CLI sail-lang: typecheck и compile (spawn node bin/sail.mjs).
+ */
+import test from 'brittle'
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const langRoot = path.resolve(__dirname, '..', '..')
+const binPath = path.join(langRoot, 'bin', 'sail.mjs')
+const miniEntry = path.join(langRoot, 'test', 'fixtures', 'io-node-mini', 'entry.sail')
+
+function runCli (args, opts = {}) {
+  return spawnSync(process.execPath, [binPath, ...args], {
+    encoding: 'utf8',
+    cwd: opts.cwd ?? langRoot,
+    env: { ...process.env, ...opts.env }
+  })
+}
+
+test('sail-lang: typecheck ok на io-node-mini', function (t) {
+  const r = runCli(['typecheck', miniEntry])
+  t.is(r.status, 0, r.stderr)
+  t.ok(r.stdout.includes('ok'), 'stdout ok')
+  t.end()
+})
+
+test('sail-lang: typecheck fail — неизвестное слово', function (t) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sail-cli-bad-'))
+  const bad = path.join(dir, 'bad.sail')
+  fs.writeFileSync(bad, ['@w ( -> )', '', '  /noSuchWordXyz', ''].join('\n'), 'utf8')
+  const r = runCli(['typecheck', bad])
+  t.is(r.status, 1)
+  t.ok(r.stderr.includes('E1201'), r.stderr)
+  fs.rmSync(dir, { recursive: true, force: true })
+  t.end()
+})
+
+test('sail-lang: compile — entry + dep в out-dir', function (t) {
+  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sail-cli-compile-'))
+  const r = runCli(['compile', '-o', outDir, miniEntry])
+  t.is(r.status, 0, r.stderr)
+  t.ok(fs.existsSync(path.join(outDir, 'entry.js')))
+  t.ok(fs.existsSync(path.join(outDir, 'dep.js')))
+  fs.rmSync(outDir, { recursive: true, force: true })
+  t.end()
+})
+
+test('sail-lang: compile без -o — код 1', function (t) {
+  const r = runCli(['compile', miniEntry])
+  t.is(r.status, 1)
+  t.ok(r.stderr.includes('out-dir') || r.stderr.includes('--out-dir'), r.stderr)
+  t.end()
+})
+
+test('sail-lang: --help код 0', function (t) {
+  const r = runCli(['--help'])
+  t.is(r.status, 0)
+  t.ok(r.stderr.includes('typecheck') && r.stderr.includes('compile'), r.stderr)
+  t.end()
+})

package/test/codegen/compile-bracket-ffi-e2e.test.js

@@ -0,0 +1,64 @@
+/**
+ * L5: compileSailToOutDir — скобочный FFI, вложенные пути, исполнение Node ESM.
+ */
+import test from 'brittle'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { compileSailToOutDir } from '../../lib/codegen/index.js'
+
+const virtualRoot = path.resolve('/virtual/sail-codegen-bracket-ffi')
+
+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('compile: скобочный FFI + /add — зеркало .js и результат 5', async function (t) {
+  const sourceRoot = path.join(virtualRoot, 'nested')
+  const main = path.join(sourceRoot, 'app', 'entry', 'main.sail')
+  const math = path.join(sourceRoot, 'app', 'vendor', 'math.js')
+  const files = {
+    [main]: [
+      '+Math ( @add ) ../vendor/math.js',
+      '@main ( Num Num -> Num )',
+      '',
+      '  /add'
+    ].join('\n'),
+    [math]: [
+      '/**',
+      ' * @sail',
+      ' * @add ( Num Num -> Num )',
+      ' */',
+      'export function add (a, b) { return a + b }'
+    ].join('\n')
+  }
+  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sail-bracket-ffi-'))
+  const r = await compileSailToOutDir({
+    entryPath: main,
+    outDir,
+    sourceRoot,
+    readFile: vfs(files)
+  })
+  t.ok(r.ok === true, r.ok === false ? r.diagnostics?.[0]?.message : '')
+  const oMain = path.join(outDir, 'app', 'entry', 'main.js')
+  const oMath = path.join(outDir, 'app', 'vendor', 'math.js')
+  t.ok(fs.existsSync(oMain))
+  t.ok(fs.existsSync(oMath))
+  const mainSrc = fs.readFileSync(oMain, 'utf8')
+  t.ok(
+    /import \{\s*add\s*\} from ['"]\.\.\/vendor\/math\.js['"]/.test(mainSrc),
+    'именованный import на зеркальный math.js'
+  )
+  t.ok(!/\bimport\s*\(/.test(mainSrc), 'без динамического import()')
+
+  const mainMod = await import(pathToFileURL(oMain).href)
+  t.ok(typeof mainMod.main === 'function')
+  t.is(mainMod.main(2, 3), 5)
+
+  fs.rmSync(outDir, { recursive: true, force: true })
+  t.end()
+})

package/test/codegen/compile-stage0.test.js

@@ -0,0 +1,128 @@
+/**
+ * L5: драйвер compileSailToOutDir — typecheck; при ошибке без записи; при ok — ESM (этап 3).
+ */
+import test from 'brittle'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { compileSailToOutDir } from '../../lib/codegen/index.js'
+import { resolveCompileLayout, sailModuleToOutputJsPath } from '../../lib/codegen/out-layout.js'
+
+const virtualRoot = path.resolve('/virtual/sail-codegen-stage0')
+
+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('этап 0: L3 error — ни одной записи, diagnostics', async function (t) {
+  const main = path.join(virtualRoot, 'bad.sail')
+  const src = ['@bad ( -> )', '', '  drop', ''].join('\n')
+  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sail-cg0-'))
+  let writes = 0
+  const r = await compileSailToOutDir({
+    entryPath: main,
+    outDir,
+    readFile: vfs({ [main]: src }),
+    fs: {
+      mkdir: async () => {},
+      writeFile: async () => {
+        writes++
+      }
+    }
+  })
+  t.ok(r.ok === false)
+  t.ok(Array.isArray(r.diagnostics) && r.diagnostics.length > 0)
+  t.is(writes, 0)
+  const js = path.join(outDir, 'bad.js')
+  t.ok(!fs.existsSync(js), '.js не создан при ошибке L3')
+  fs.rmSync(outDir, { recursive: true, force: true })
+  t.end()
+})
+
+test('compile: ok один модуль — ESM с export function, путь O(S)', async function (t) {
+  const main = path.join(virtualRoot, 'one.sail')
+  const src = ['@w ( -> Num Num )', '', '  1', '', '  dup', ''].join('\n')
+  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sail-cg0-'))
+  const layout = resolveCompileLayout({
+    entryPath: main,
+    outDir,
+    sourceRoot: path.dirname(main)
+  })
+  const expectPath = sailModuleToOutputJsPath(layout, main)
+  t.ok(expectPath.ok)
+  t.is(expectPath.path, path.join(outDir, 'one.js'))
+
+  const r = await compileSailToOutDir({
+    entryPath: main,
+    outDir,
+    sourceRoot: path.dirname(main),
+    readFile: vfs({ [main]: src })
+  })
+  t.ok(r.ok === true)
+  t.is(r.diagnostics.length, 0)
+  t.is(r.emitted.length, 1)
+  t.is(r.emitted[0], expectPath.path)
+  t.ok(fs.existsSync(expectPath.path))
+  const txt = fs.readFileSync(expectPath.path, 'utf8')
+  t.ok(/\bexport function w\s*\(/.test(txt), 'export function w')
+  t.ok(!/\bimport\s*\(/.test(txt), 'без динамического import() в сгенерированном файле')
+
+  const mod = await import(pathToFileURL(expectPath.path).href)
+  t.ok(typeof mod.w === 'function')
+  const pair = mod.w()
+  t.ok(Array.isArray(pair) && pair.length === 2)
+  t.is(pair[0], 1)
+  t.is(pair[1], 1)
+  fs.rmSync(outDir, { recursive: true, force: true })
+  t.end()
+})
+
+test('compile: ok два .sail — статический import и оба модуля исполняются', async function (t) {
+  const sourceRoot = path.join(virtualRoot, 'repo')
+  const main = path.join(sourceRoot, 'main.sail')
+  const lib = path.join(sourceRoot, 'lib.sail')
+  const files = {
+    [main]: ['+Lib ./lib.sail', '@main ( -> )', '', '  ~Lib/hello'].join('\n'),
+    [lib]: ['@hello ( -> )', '', ''].join('\n')
+  }
+  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sail-cg0-'))
+  const layout = resolveCompileLayout({ entryPath: main, outDir, sourceRoot })
+  const oMain = sailModuleToOutputJsPath(layout, main)
+  const oLib = sailModuleToOutputJsPath(layout, lib)
+  t.ok(oMain.ok && oLib.ok)
+
+  const r = await compileSailToOutDir({
+    entryPath: main,
+    outDir,
+    sourceRoot,
+    readFile: vfs(files)
+  })
+  t.ok(r.ok === true)
+  t.is(r.emitted.length, 2)
+  t.ok(fs.existsSync(oMain.path))
+  t.ok(fs.existsSync(oLib.path))
+
+  const mainSrc = fs.readFileSync(oMain.path, 'utf8')
+  const libSrc = fs.readFileSync(oLib.path, 'utf8')
+  t.ok(
+    mainSrc.includes('import * as Lib from "./lib.js"'),
+    'main импортирует lib.js'
+  )
+  t.ok(/\bLib\.hello\s*\(/.test(mainSrc), 'вызов Lib.hello')
+  t.ok(/\bexport function main\s*\(/.test(mainSrc), 'export main')
+  t.ok(/\bexport function hello\s*\(/.test(libSrc), 'export hello в lib')
+  t.ok(!/\bimport\s*\(/.test(mainSrc), 'без import()')
+
+  const libMod = await import(pathToFileURL(oLib.path).href)
+  const mainMod = await import(pathToFileURL(oMain.path).href)
+  t.ok(typeof libMod.hello === 'function')
+  t.ok(typeof mainMod.main === 'function')
+  mainMod.main()
+
+  fs.rmSync(outDir, { recursive: true, force: true })
+  t.end()
+})

package/test/codegen/compile-stage4-layout.test.js

@@ -0,0 +1,124 @@
+/**
+ * L5 этап 4: зеркало FFI `.js` в out-dir, относительные import к O(S) для `.js`.
+ */
+import test from 'brittle'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { compileSailToOutDir } from '../../lib/codegen/index.js'
+import {
+  projectJsFileToOutputPath,
+  resolveCompileLayout,
+  sailModuleToOutputJsPath
+} from '../../lib/codegen/out-layout.js'
+
+const virtualRoot = path.resolve('/virtual/sail-codegen-stage4')
+
+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('этап 4: вложенные каталоги — O(S) и import ../lib/dep.js', async function (t) {
+  const sourceRoot = path.join(virtualRoot, 'nested')
+  const main = path.join(sourceRoot, 'app', 'entry', 'main.sail')
+  const dep = path.join(sourceRoot, 'app', 'lib', 'dep.sail')
+  const files = {
+    [main]: ['+Dep ../lib/dep.sail', '@main ( -> )', '', '  ~Dep/ping'].join('\n'),
+    [dep]: ['@ping ( -> )', '', ''].join('\n')
+  }
+  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sail-cg4-nested-'))
+  const layout = resolveCompileLayout({ entryPath: main, outDir, sourceRoot })
+  const oMain = sailModuleToOutputJsPath(layout, main)
+  const oDep = sailModuleToOutputJsPath(layout, dep)
+  t.ok(oMain.ok && oDep.ok)
+  t.is(
+    oMain.path,
+    path.join(outDir, 'app', 'entry', 'main.js')
+  )
+  t.is(oDep.path, path.join(outDir, 'app', 'lib', 'dep.js'))
+
+  const r = await compileSailToOutDir({
+    entryPath: main,
+    outDir,
+    sourceRoot,
+    readFile: vfs(files)
+  })
+  t.ok(r.ok === true, r.ok === false ? r.diagnostics?.[0]?.message : '')
+  t.is(r.emitted.length, 2)
+  t.ok(fs.existsSync(oMain.path))
+  t.ok(fs.existsSync(oDep.path))
+  const mainSrc = fs.readFileSync(oMain.path, 'utf8')
+  t.ok(
+    mainSrc.includes('import * as Dep from "../lib/dep.js"'),
+    'относительный путь к dep в out-dir'
+  )
+
+  const depMod = await import(pathToFileURL(oDep.path).href)
+  const mainMod = await import(pathToFileURL(oMain.path).href)
+  t.ok(typeof depMod.ping === 'function')
+  t.ok(typeof mainMod.main === 'function')
+  mainMod.main()
+
+  fs.rmSync(outDir, { recursive: true, force: true })
+  t.end()
+})
+
+test('этап 4: скобочный FFI + JSDoc-слово в helper — зеркало и import { add }', async function (t) {
+  const sourceRoot = path.join(virtualRoot, 'ffi-nested')
+  const main = path.join(sourceRoot, 'app', 'entry', 'main.sail')
+  const helper = path.join(sourceRoot, 'app', 'vendor', 'helper.js')
+  const helperText = [
+    '/**',
+    ' * @sail',
+    ' * @add ( Num Num -> Num )',
+    ' */',
+    'export function add (a, b) { return a + b }'
+  ].join('\n')
+  const files = {
+    [main]: [
+      '+Helper ( @add ) ../vendor/helper.js',
+      '@main ( Num Num -> Num )',
+      '',
+      '  /add'
+    ].join('\n'),
+    [helper]: helperText
+  }
+  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sail-cg4-ffi-'))
+  const layout = resolveCompileLayout({ entryPath: main, outDir, sourceRoot })
+  const oMain = sailModuleToOutputJsPath(layout, main)
+  const oHelper = projectJsFileToOutputPath(layout, helper)
+  t.ok(oMain.ok && oHelper.ok)
+  t.is(
+    oHelper.path,
+    path.join(outDir, 'app', 'vendor', 'helper.js')
+  )
+
+  const r = await compileSailToOutDir({
+    entryPath: main,
+    outDir,
+    sourceRoot,
+    readFile: vfs(files)
+  })
+  t.ok(r.ok === true, r.ok === false ? r.diagnostics?.[0]?.message : '')
+  t.is(r.emitted.length, 2)
+  t.ok(fs.existsSync(oHelper.path))
+  const copied = fs.readFileSync(oHelper.path, 'utf8')
+  t.is(copied, helperText, 'FFI .js скопирован без изменений')
+  const mainSrc = fs.readFileSync(oMain.path, 'utf8')
+  t.ok(
+    /import \{\s*add\s*\} from ['"]\.\.\/vendor\/helper\.js['"]/.test(mainSrc),
+    'именованный import на зеркальный helper.js'
+  )
+  t.ok(!/\bimport\s*\(/.test(mainSrc), 'без динамического import()')
+
+  const mainMod = await import(pathToFileURL(oMain.path).href)
+  t.ok(typeof mainMod.main === 'function')
+  t.is(mainMod.main(2, 3), 5)
+
+  fs.rmSync(outDir, { recursive: true, force: true })
+  t.end()
+})

package/test/codegen/e2e-prelude-ffi-adt/app/extra.sail

@@ -0,0 +1,6 @@
+-- Третий модуль: локальное слово поверх prelude (dup + add = удвоение). --
++Nums @algosail/prelude/num
+
+@double ( Num -> Num )
+  dup
+  ~Nums/add

package/test/codegen/e2e-prelude-ffi-adt/app/lib.sail

@@ -0,0 +1,34 @@
+-- Point; rot/add; list prelude; over+nip (доп. shuffle). --
++Nums @algosail/prelude/num
++Lists @algosail/prelude/list
+
+& Point
+: x Num
+: y Num
+
+@sumCoords ( Point -> Num )
+  -- Sasd --
+  dup
+  /xPoint
+  swap
+  /yPoint
+  ~Nums/add
+
+@rotSum ( -> Num )
+  2
+  3
+  4
+  rot
+  ~Nums/add
+  ~Nums/add
+
+@listMarker ( -> Num )
+  1
+  ~Lists/listOfOne
+  ~Lists/listLength
+
+@secondPlusTop ( Num Num -> Num )
+  swap
+  over
+  ~Nums/add
+  nip