@algosail/lang 0.2.12 → 0.5.1

package/test/fixtures/demo-full-syntax.sail

@@ -0,0 +1,35 @@
+-- import doc --
++Base ./vendor/base.sail
++Num @algosail/prelude/num
++Std ( @map @filter &Vec &Map ) ./std/lib.sail
+
+&Maybe a -- sum header doc --
+  | None -- tag None --
+  | Just a
+
+&Vec2 -- product doc --
+  :x Num -- field x --
+  :y Num
+
+@stacky ( ~s Num -> ~s Num )
+  -- word doc --
+  dup
+
+@effects ( Num -> Str +Async +Fail -Async )
+
+@modType ( ~Lib/Point -> )
+
+@maybeSlot ( ( Maybe Num ) -> )
+
+@dictsig ( Dict Str -> )
+
+@mapSig ( ( Map Str Num ) -> )
+
+@named ( q:( ~s a -> ~s b ) -> )
+  /drop
+
+@demoBody ( -> )
+  dup swap ~Net/fetch
+  ( nip ) [ 0 true 2n ]
+  :tmp ;tmp "ok" 7 /x/
+  42n nil true false

package/test/fixtures/io-node-ffi-adt/ffi.js

@@ -0,0 +1,7 @@
+/**
+ * @sail
+ * &Shape
+ *   | Circle Num
+ *   | Rect Num Num
+ */
+export function stub () {}

package/test/fixtures/io-node-ffi-adt/use.sail

@@ -0,0 +1,4 @@
++Ffi ./ffi.js
+@main ( -> )
+
+  ~Ffi/circle

package/test/fixtures/io-node-mini/dep.sail

@@ -0,0 +1,2 @@
+@fromDep ( -> )
+

package/test/fixtures/io-node-mini/entry.sail

@@ -0,0 +1,4 @@
++Dep ./dep.sail
+@entry ( -> )
+
+  ~Dep/fromDep

package/test/fixtures/io-node-prelude/entry.sail

@@ -0,0 +1,4 @@
++Str @algosail/prelude/str
+@main ( Str Str -> Str )
+
+  ~Str/concat

package/test/fixtures/io-node-reexport-chain/a.sail

@@ -0,0 +1,4 @@
++B ./b.sail
+@main ( -> )
+
+  ~B/origin

package/test/fixtures/io-node-reexport-chain/b.sail

@@ -0,0 +1,2 @@
++C ( @origin ) ./c.sail
+

package/test/fixtures/io-node-reexport-chain/c.sail

@@ -0,0 +1,2 @@
+@origin ( -> )
+

package/test/io-node/resolve-disk.test.js

@@ -0,0 +1,59 @@
+/**
+ * Интеграция L2 с диском: io-node + resolveSailNamesFromDisk.
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import {
+  createReadFileUtf8,
+  createResolvePackage,
+  resolveSailNames,
+  resolveSailNamesFromDisk
+} from '../../index.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const fixtures = path.join(__dirname, '../fixtures')
+/** Корень монорепозитория sail (родитель каталога lang). */
+const monorepoRoot = path.resolve(__dirname, '../../..')
+
+test('io-node: относительный импорт ./dep.sail', function (t) {
+  const entry = path.join(fixtures, 'io-node-mini/entry.sail')
+  const r = resolveSailNamesFromDisk({ entryPath: entry })
+  t.ok(r.ok, r.diagnostics.map(d => `${d.code} ${d.message}`).join('; '))
+  t.end()
+})
+
+test('io-node: цепочка реэкспорта a ← b ← c (@origin через b)', function (t) {
+  const entry = path.join(fixtures, 'io-node-reexport-chain/a.sail')
+  const r = resolveSailNamesFromDisk({ entryPath: entry })
+  t.ok(r.ok, r.diagnostics.map(d => `${d.code} ${d.message}`).join('; '))
+  t.end()
+})
+
+test('io-node: ADT только в JS @sail, autogen в соседнем .sail', function (t) {
+  const entry = path.join(fixtures, 'io-node-ffi-adt/use.sail')
+  const r = resolveSailNamesFromDisk({ entryPath: entry })
+  t.ok(r.ok, r.diagnostics.map(d => `${d.code} ${d.message}`).join('; '))
+  t.end()
+})
+
+test('io-node: @algosail/prelude/str с projectRoot монорепо', function (t) {
+  const entry = path.join(fixtures, 'io-node-prelude/entry.sail')
+  const r = resolveSailNamesFromDisk({
+    entryPath: entry,
+    projectRoot: monorepoRoot
+  })
+  t.ok(r.ok, r.diagnostics.map(d => `${d.code} ${d.message}`).join('; '))
+  t.end()
+})
+
+test('io-node: createReadFileUtf8 + createResolvePackage + resolveSailNames', function (t) {
+  const entry = path.join(fixtures, 'io-node-mini/entry.sail')
+  const r = resolveSailNames({
+    entryPath: entry,
+    readFile: createReadFileUtf8(),
+    resolvePackage: createResolvePackage()
+  })
+  t.ok(r.ok, r.diagnostics.map(d => `${d.code} ${d.message}`).join('; '))
+  t.end()
+})

package/test/ir/bind-values.test.js

@@ -0,0 +1,84 @@
+/**
+ * L4 фаза 4: valueBindings (RFC-IR section 4).
+ */
+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-phase4')
+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: dup — два resultIds с одинаковым id', 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',
+    valueBindings: true
+  })
+  const w = payload.words.find((x) => x.name === 'w')
+  const lit = w.irSteps[0]
+  const dup = w.irSteps[1]
+  t.is(dup.kind, 'Builtin')
+  t.is(dup.name, 'dup')
+  const vb = dup.valueBindings
+  t.ok(vb)
+  t.is(vb.argIds.length, 1)
+  t.is(vb.resultIds.length, 2)
+  t.is(vb.resultIds[0], vb.resultIds[1])
+  t.is(vb.argIds[vb.argIds.length - 1], vb.resultIds[0])
+  assertJsonSerializable(payload)
+  t.end()
+})
+
+test('фаза 4: swap — перестановка двух id на вершине', function (t) {
+  const main = path.join(root, 'swap.sail')
+  const src = ['@w ( -> Num Num )', '', '  1', '', '  2', '', '  swap', ''].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',
+    valueBindings: true
+  })
+  const w = payload.words.find((x) => x.name === 'w')
+  const id1 = w.irSteps[0].valueBindings.resultIds[0]
+  const id2 = w.irSteps[1].valueBindings.resultIds[1]
+  const sw = w.irSteps[2]
+  t.is(sw.name, 'swap')
+  const vb = sw.valueBindings
+  t.alike(vb.argIds, [id1, id2])
+  t.alike(vb.resultIds, [id2, id1])
+  assertJsonSerializable(payload)
+  t.end()
+})
+
+test('фаза 4: drop — один argId, пустые resultIds', function (t) {
+  const main = path.join(root, 'drop.sail')
+  const src = ['@w ( -> )', '', '  1', '', '  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 payload = buildModuleIr(r.env, norm, {
+    moduleStatus: 'ok',
+    valueBindings: true
+  })
+  const w = payload.words.find((x) => x.name === 'w')
+  const dr = w.irSteps[1]
+  t.is(dr.name, 'drop')
+  const vb = dr.valueBindings
+  t.is(vb.argIds.length, 1)
+  t.is(vb.resultIds.length, 0)
+  assertJsonSerializable(payload)
+  t.end()
+})

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

@@ -0,0 +1,100 @@
+/**
+ * L4 фаза 1: buildModuleIr / buildSerializedIrDocumentFromEnv из L3.
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+import {
+  assertJsonSerializable,
+  buildModuleIr,
+  buildSerializedIrDocumentFromEnv,
+  parseIrDocumentFull
+} from '../../lib/ir/index.js'
+
+const root = path.resolve('/virtual/sail-ir-phase1')
+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('buildSerializedIrDocumentFromEnv: ok — JSON, round-trip, stackSteps pre/post', function (t) {
+  const main = path.join(root, 'ok-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 doc = buildSerializedIrDocumentFromEnv(r.env, main, { moduleStatus: 'ok' })
+  assertJsonSerializable(doc)
+  t.is(doc.meta?.status, 'ok')
+
+  const round = parseIrDocumentFull(JSON.stringify(doc))
+  t.is(round.meta?.status, 'ok')
+  t.is(round.module.path, path.normalize(main))
+
+  const wEntry = round.module.words.find((x) => x.name === 'w')
+  t.ok(wEntry, 'слово w в payload')
+  t.is(wEntry.irSteps?.length, 2, 'фаза 2: два IR-шага (1 и dup)')
+  t.is(wEntry.irSteps[0].kind, 'Literal')
+  t.is(wEntry.irSteps[1].kind, 'Builtin')
+  t.ok(Array.isArray(wEntry.irSteps[0].postTypes), 'фаза 3: типы на irSteps')
+  const steps = wEntry.stackSteps?.steps
+  t.ok(steps && steps.length === 2, 'два шага снимка')
+  t.ok(Array.isArray(steps[0].preTypes))
+  t.ok(Array.isArray(steps[0].postTypes))
+  t.is(steps[0].postTypes[0].kind, 'prim')
+  t.is(steps[0].postTypes[0].name, 'Num')
+  t.end()
+})
+
+test('buildModuleIr: ok — вложенная quotation в nestedByParentStep', function (t) {
+  const main = path.join(root, 'ok-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 payload = buildModuleIr(r.env, main, { moduleStatus: 'ok' })
+  const wEntry = payload.words.find((x) => x.name === 'w')
+  t.ok(wEntry?.stackSteps?.steps?.length === 1)
+  const nested = wEntry.stackSteps.nestedByParentStep
+  t.ok(Array.isArray(nested) && nested.length === 1)
+  t.is(nested[0].parentStepIndex, 0)
+  t.ok(nested[0].record.steps.length === 1)
+  assertJsonSerializable(payload)
+  t.end()
+})
+
+test('buildSerializedIrDocumentFromEnv: error — частичный снимок у bad, пустой у ok', function (t) {
+  const main = path.join(root, 'fail-two.sail')
+  const src = [
+    '@bad ( -> )',
+    '',
+    '  drop',
+    '',
+    '@ok ( -> )',
+    '',
+    ''
+  ].join('\n')
+  const r = typecheckSail({ entryPath: main, readFile: vfs({ [main]: src }) })
+  t.ok(r.ok === false)
+
+  const doc = buildSerializedIrDocumentFromEnv(r.env, main, { moduleStatus: 'error' })
+  assertJsonSerializable(doc)
+  t.is(doc.meta?.status, 'error')
+  t.is(doc.module.status, 'error')
+
+  const round = parseIrDocumentFull(JSON.stringify(doc))
+  t.is(round.meta?.status, 'error')
+
+  const badEntry = round.module.words.find((x) => x.name === 'bad')
+  const okEntry = round.module.words.find((x) => x.name === 'ok')
+  t.ok(badEntry?.stackSteps?.steps?.length >= 1)
+  const lastBad = badEntry.stackSteps.steps[badEntry.stackSteps.steps.length - 1]
+  t.ok(Array.isArray(lastBad.preTypes))
+  t.ok(lastBad.postTypes === undefined, 'на шаге сбоя postTypes может отсутствовать')
+
+  t.ok(okEntry)
+  t.is(okEntry.stackSteps?.steps?.length ?? 0, 0)
+
+  t.end()
+})

package/test/ir/call-effects.test.js

@@ -0,0 +1,97 @@
+/**
+ * L4 фаза 5: +Async / +Fail на IR (RFC-IR section 6).
+ */
+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-phase5')
+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('фаза 5: caller + asyncCallee — asyncDefinition и calleeAsync', function (t) {
+  const main = path.join(root, 'async-caller.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@caller ( -> +Async )',
+    '  /asyncCallee',
+    ''
+  ].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 caller = payload.words.find((w) => w.name === 'caller')
+  const calle = payload.words.find((w) => w.name === 'asyncCallee')
+  t.ok(caller)
+  t.ok(calle)
+  t.is(caller.asyncDefinition, true)
+  t.is(caller.mayFail, false)
+  t.is(calle.asyncDefinition, true)
+  t.is(calle.mayFail, false)
+  const step = caller.irSteps[0]
+  t.is(step.kind, 'Word')
+  t.is(step.name, 'asyncCallee')
+  t.is(step.calleeAsync, true)
+  t.ok(step.calleeMayFail !== true)
+  assertJsonSerializable(payload)
+  t.end()
+})
+
+test('фаза 5: wrap вызывает risky (+Fail) — calleeMayFail не в IR (вариант B)', function (t) {
+  const main = path.join(root, 'fail-wrap-ir.sail')
+  const src = [
+    '@risky ( -> +Fail )',
+    '',
+    '@wrap ( -> -Fail )',
+    '  /risky',
+    ''
+  ].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 risky = payload.words.find((w) => w.name === 'risky')
+  const wrap = payload.words.find((w) => w.name === 'wrap')
+  t.ok(risky)
+  t.ok(wrap)
+  t.is(risky.mayFail, true)
+  t.is(risky.asyncDefinition, false)
+  t.is(wrap.mayFail, false)
+  const step = wrap.irSteps[0]
+  t.is(step.kind, 'Word')
+  t.is(step.name, 'risky')
+  t.ok(step.calleeMayFail !== true)
+  assertJsonSerializable(payload)
+  t.end()
+})
+
+test('фаза 5: wrap (-Async) + asyncCallee — calleeAsync на шаге нет (вариант B)', function (t) {
+  const main = path.join(root, 'async-wrap-ir.sail')
+  const src = [
+    '@asyncCallee ( -> +Async )',
+    '',
+    '@wrap ( -> -Async )',
+    '  /asyncCallee',
+    ''
+  ].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 wrap = payload.words.find((w) => w.name === 'wrap')
+  t.ok(wrap)
+  t.is(wrap.asyncDefinition, false)
+  const step = wrap.irSteps[0]
+  t.is(step.kind, 'Word')
+  t.is(step.name, 'asyncCallee')
+  t.ok(step.calleeAsync !== true)
+  assertJsonSerializable(payload)
+  t.end()
+})

package/test/ir/ffi-bracket-ir.test.js

@@ -0,0 +1,59 @@
+/**
+ * L4: IR для потребителя со скобочным импортом слова из FFI `.js`.
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+import { buildModuleIr } from '../../lib/ir/index.js'
+
+const root = path.resolve('/virtual/sail-ir-ffi-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('buildModuleIr: скобочный FFI — resolvedPath на .js и valueBindings у /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 = typecheckSail({ entryPath: main, readFile: vfs(files) })
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+
+  const payload = buildModuleIr(r.env, main, {
+    moduleStatus: 'ok',
+    valueBindings: true
+  })
+  const imp = payload.imports.find((i) => i.module === 'Num')
+  t.ok(imp, 'импорт Num')
+  t.ok(
+    typeof imp.resolvedPath === 'string' && imp.resolvedPath.endsWith('num.js'),
+    'resolvedPath указывает на .js'
+  )
+
+  const mainW = payload.words.find((w) => w.name === 'main')
+  t.ok(mainW?.irSteps?.length === 1, 'один шаг тела')
+  const step = mainW.irSteps[0]
+  t.is(step.kind, 'Word')
+  t.is(step.ref, 'local')
+  t.is(step.name, 'add')
+  t.ok(step.valueBindings?.argIds?.length === 2, 'два аргумента FFI')
+  t.ok(step.valueBindings?.resultIds?.length === 1, 'один результат')
+  t.end()
+})

package/test/ir/full-ir-document.test.js

@@ -0,0 +1,51 @@
+/**
+ * L4 фаза 7: полный сериализованный документ и round-trip JSON (RFC-IR §8).
+ */
+import test from 'brittle'
+import path from 'node:path'
+import { typecheckSail } from '../../index.js'
+import {
+  buildSerializedIrDocumentFromEnv,
+  stringifyIrDocument,
+  parseIrDocumentFull
+} from '../../lib/ir/index.js'
+import { assertSerializedIrDocumentOk } from './ir-document-assert.js'
+
+const root = path.resolve('/virtual/sail-ir-phase7-full')
+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('фаза 7: полный IR с valueBindings — stringify/parseFull и инварианты', 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 doc = buildSerializedIrDocumentFromEnv(r.env, norm, {
+    moduleStatus: 'ok',
+    valueBindings: true
+  })
+  assertSerializedIrDocumentOk(t, doc, {
+    expectedModulePath: norm,
+    expectMetaStatus: 'ok',
+    requireNonEmptyWords: true
+  })
+  const w = doc.module.words.find((x) => x.name === 'w')
+  t.ok(w?.irSteps?.length === 2)
+  const dupStep = w.irSteps[1]
+  t.is(dupStep.kind, 'Builtin')
+  t.ok(dupStep.valueBindings)
+  t.is(dupStep.valueBindings.resultIds[0], dupStep.valueBindings.resultIds[1])
+
+  const text = stringifyIrDocument(doc.module, { meta: doc.meta })
+  const round = parseIrDocumentFull(text)
+  t.is(round.module.path, doc.module.path)
+  t.is(round.module.words.length, doc.module.words.length)
+  const w2 = round.module.words.find((x) => x.name === 'w')
+  t.ok(w2?.irSteps?.[1]?.valueBindings)
+  t.end()
+})

package/test/ir/ir-document-assert.js

@@ -0,0 +1,67 @@
+/**
+ * Утилиты фазы 7 (RFC-IR §8): инварианты сериализованного IR-документа в brittle-тестах.
+ */
+import path from 'node:path'
+import { assertJsonSerializable } from '../../lib/ir/assert-json-serializable.js'
+import { IR_SCHEMA_VERSION } from '../../lib/ir/schema-version.js'
+
+/**
+ * @param {*} t экземпляр brittle (`test` callback)
+ * @param {unknown} doc корень после {@link createSerializedIrDocument}
+ * @param {{
+ *   expectedModulePath?: string
+ *   expectMetaStatus?: 'ok' | 'error'
+ *   requireNonEmptyWords?: boolean
+ *   requireResolvedImportsWhenPresent?: boolean
+ * }} [options]
+ */
+export function assertSerializedIrDocumentOk (t, doc, options = {}) {
+  assertJsonSerializable(doc)
+  t.ok(doc !== null && typeof doc === 'object' && !Array.isArray(doc), 'doc is object')
+  const d = /** @type {Record<string, unknown>} */ (doc)
+  t.is(d.irSchemaVersion, IR_SCHEMA_VERSION, 'irSchemaVersion matches IR_SCHEMA_VERSION')
+  const mod = d.module
+  t.ok(mod !== null && typeof mod === 'object' && !Array.isArray(mod), 'module is object')
+  const m = /** @type {Record<string, unknown>} */ (mod)
+  t.ok(typeof m.path === 'string' && m.path.length > 0, 'module.path is non-empty string')
+  if (options.expectedModulePath != null) {
+    t.is(
+      path.normalize(m.path),
+      path.normalize(options.expectedModulePath),
+      'module.path matches entry'
+    )
+  }
+  if (options.expectMetaStatus != null) {
+    const meta = d.meta
+    t.ok(meta != null && typeof meta === 'object', 'meta present')
+    t.is(
+      /** @type {Record<string, unknown>} */ (meta).status,
+      options.expectMetaStatus,
+      'meta.status'
+    )
+  }
+  t.ok(Array.isArray(m.words), 'module.words is array')
+  if (options.requireNonEmptyWords === true) {
+    t.ok(m.words.length >= 1, 'module.words non-empty')
+  }
+  for (const w of m.words ?? []) {
+    if (w == null || typeof w !== 'object') continue
+    const entry = /** @type {Record<string, unknown>} */ (w)
+    if (Object.prototype.hasOwnProperty.call(entry, 'irSteps')) {
+      t.ok(Array.isArray(entry.irSteps), `word ${entry.name}: irSteps is array`)
+    }
+  }
+  if (options.requireResolvedImportsWhenPresent === true) {
+    const imports = m.imports
+    if (Array.isArray(imports) && imports.length > 0) {
+      for (let i = 0; i < imports.length; i++) {
+        const row = imports[i]
+        t.ok(row != null && typeof row === 'object', `import[${i}] is object`)
+        t.ok(
+          typeof /** @type {Record<string, unknown>} */ (row).resolvedPath === 'string',
+          `import[${i}].resolvedPath is string`
+        )
+      }
+    }
+  }
+}