@algosail/lang 0.2.12 → 0.5.1

package/lib/codegen/emit-body.js

@@ -0,0 +1,1265 @@
+/**
+ * L5 этап 1–2: эмиссия фрагмента тела слова по `irSteps` + `valueBindings`
+ * (RFC-compile-0.1 §6.2–6.3, RFC-IR-0.1 §4, RFC-0.1 §10.1).
+ *
+ * Без массива как модели стека: только `const` и выражения.
+ * Quotation: отложенная эмиссия; `call` — инлайн тела; значение Quote — `const qN = (…) => { … }`.
+ */
+
+import {
+  COMBINATOR_BUILTIN_NAMES,
+  tryEmitCombinatorBuiltin
+} from './emit-builtin.js'
+
+/**
+ * @typedef {import('../typecheck/normalize-sig.js').NormalizedSignature} NormalizedSignature
+ */
+
+/**
+ * @typedef {{
+ *   localPropagatesAsync: (name: string) => boolean
+ *   qualifiedPropagatesAsync: (moduleAlias: string, wordName: string) => boolean
+ * }} CalleeAsyncResolver
+ */
+
+/**
+ * @typedef {{
+ *   innerSteps: Record<string, unknown>[]
+ *   innerEntryStackIds: string[]
+ * }} QuoteEmitMeta
+ */
+
+/**
+ * Выражение shuffle — уже имя `const`/параметра из idToJs (без побочных эффектов);
+ * тогда новый `const` не нужен: это перестановка/dup на уровне имён (RFC-0.1, lowering §6.2).
+ *
+ * @param {string} expr
+ * @returns {boolean}
+ */
+function isShuffleReuseExpr (expr) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(expr)
+}
+
+/** @type {Record<string, (argExprs: string[]) => string[]>} */
+const BUILTIN_SHUFFLE_EXPR = {
+  dup: (a) => [a[0], a[0]],
+  drop: () => [],
+  swap: (a) => [a[1], a[0]],
+  over: (a) => [a[0], a[1], a[0]],
+  dup2: (a) => [a[0], a[1], a[0], a[1]],
+  drop2: () => [],
+  rot: (a) => [a[1], a[2], a[0]],
+  reverse: (a) => [a[2], a[0], a[1]],
+  nip: (a) => [a[1]],
+  tuck: (a) => [a[1], a[0], a[1]],
+  swap2: (a) => [...a.slice(2, 4), ...a.slice(0, 2)]
+}
+
+/**
+ * @param {number} nIn
+ * @param {number} nOut
+ * @returns {NormalizedSignature}
+ */
+function sigWireFromStackLens (nIn, nOut) {
+  const slot = { kind: 'prim', name: '_' }
+  return {
+    left: Array.from({ length: nIn }, () => slot),
+    right: Array.from({ length: nOut }, () => slot),
+    effectsAdd: [],
+    effectsRemove: []
+  }
+}
+
+/**
+ * @param {Record<string, unknown>[]} innerSteps
+ * @returns {number}
+ */
+function inferInnerOutLen (innerSteps) {
+  if (!Array.isArray(innerSteps)) return 0
+  for (let i = innerSteps.length - 1; i >= 0; i--) {
+    const s = innerSteps[i]
+    if (s != null && typeof s === 'object' && Array.isArray(s.postTypes)) {
+      return s.postTypes.length
+    }
+  }
+  return 0
+}
+
+/**
+ * @param {string[]} lines
+ * @param {string[]} currentStackIds
+ * @param {Map<string, string>} idToJs
+ * @param {NormalizedSignature} sig
+ * @param {string} wordLabel
+ */
+function appendReturnForLines (lines, currentStackIds, idToJs, sig, wordLabel) {
+  const right = Array.isArray(sig.right) ? sig.right : []
+  if (right.length !== currentStackIds.length) {
+    throw new Error(
+      `emit-body[${wordLabel}]: длина финального стека (${currentStackIds.length}) ` +
+        `не совпадает с sig.right (${right.length})`
+    )
+  }
+  if (right.length === 0) {
+    lines.push('return;')
+  } else if (right.length === 1) {
+    const id = currentStackIds[0]
+    const j = idToJs.get(id)
+    if (j == null) {
+      throw new Error(`emit-body[${wordLabel}]: нет привязки для финального id ${id}`)
+    }
+    lines.push(`return ${j};`)
+  } else {
+    const parts = currentStackIds.map((id) => {
+      const j = idToJs.get(id)
+      if (j == null) {
+        throw new Error(`emit-body[${wordLabel}]: нет привязки для финального id ${id}`)
+      }
+      return j
+    })
+    lines.push(`return [${parts.join(', ')}];`)
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} node
+ * @returns {string}
+ */
+function literalToJsExpr (node) {
+  const litKind = /** @type {string | undefined} */ (node.litKind)
+  const raw = node.raw != null ? String(node.raw) : ''
+  switch (litKind) {
+    case 'number': {
+      if (raw === '' || Number.isNaN(Number(raw))) {
+        throw new Error(`emit-body: некорректный number literal ${JSON.stringify(raw)}`)
+      }
+      return raw
+    }
+    case 'bigint':
+      return `BigInt(${JSON.stringify(raw)})`
+    case 'bool':
+      return raw === 'true' ? 'true' : 'false'
+    case 'nil':
+      return 'null'
+    case 'string':
+      return JSON.stringify(raw)
+    case 'regexp':
+      throw new Error('emit-body: regexp literal пока не поддержан')
+    default:
+      throw new Error(`emit-body: неизвестный litKind ${String(litKind)}`)
+  }
+}
+
+/**
+ * @param {string} name
+ */
+function assertValidJsCallee (name) {
+  if (!/^[A-Za-z_$][\w$]*$/.test(name)) {
+    throw new Error(
+      `emit-body: имя слова не является допустимым идентификатором JS: ${JSON.stringify(name)}`
+    )
+  }
+}
+
+/**
+ * Имя JS для входного слота слова: `named_quote.prefix` или очередное `pK`.
+ *
+ * @param {unknown} slot
+ * @param {() => string} allocP
+ * @returns {string}
+ */
+function jsParamNameForEntrySlot (slot, allocP) {
+  if (
+    slot != null &&
+    typeof slot === 'object' &&
+    /** @type {{ kind?: string, prefix?: string }} */ (slot).kind === 'named_quote' &&
+    typeof /** @type {{ prefix?: string }} */ (slot).prefix === 'string'
+  ) {
+    const px = /** @type {{ prefix: string }} */ (slot).prefix
+    try {
+      assertValidJsCallee(px)
+      return px
+    } catch {
+      /* fall through */
+    }
+  }
+  return allocP()
+}
+
+/**
+ * Список формальных параметров JS для обёртки `function` (wire `normalizedSig` + `entryStackIds` из bind-values).
+ *
+ * @param {NormalizedSignature | null | undefined} normalizedSig
+ * @param {string[] | null | undefined} entryStackIds
+ * @returns {string}
+ */
+export function formatFormalParametersForWireSig (normalizedSig, entryStackIds) {
+  if (normalizedSig == null || typeof normalizedSig !== 'object') return ''
+  const left = Array.isArray(normalizedSig.left) ? normalizedSig.left : []
+  if (left.length === 0) return ''
+  if (Array.isArray(entryStackIds) && entryStackIds.length === left.length) {
+    let pAcc = 0
+    const allocP = () => `p${pAcc++}`
+    return left.map((slot) => jsParamNameForEntrySlot(slot, allocP)).join(', ')
+  }
+  return left.map((_, i) => `p${i}`).join(', ')
+}
+
+/**
+ * Рекурсивно: есть ли в шагах узел с полем `calleeAsync === true` (маркер L3/IR).
+ *
+ * @param {unknown} steps
+ * @returns {boolean}
+ */
+export function irStepsContainsCalleeAsync (steps) {
+  if (!Array.isArray(steps)) return false
+  for (const raw of steps) {
+    if (raw == null || typeof raw !== 'object') continue
+    const n = /** @type {Record<string, unknown>} */ (raw)
+    if (n.calleeAsync === true) return true
+    const kind = String(n.kind ?? '')
+    if (kind === 'Builtin' && n.name === 'call') {
+      const meta = n.callInlineMeta
+      if (meta != null && typeof meta === 'object') {
+        const m = /** @type {{ innerSteps?: unknown }} */ (meta)
+        if (irStepsContainsCalleeAsync(m.innerSteps)) return true
+      }
+    }
+    if (
+      kind === 'Builtin' &&
+      COMBINATOR_BUILTIN_NAMES.has(String(n.name ?? ''))
+    ) {
+      const cmeta = n.combinatorInlineMeta
+      if (cmeta != null && typeof cmeta === 'object') {
+        const parts = /** @type {{ parts?: unknown }} */ (cmeta).parts
+        if (Array.isArray(parts)) {
+          for (const p of parts) {
+            if (
+              p != null &&
+              typeof p === 'object' &&
+              /** @type {{ kind?: string }} */ (p).kind === 'inline' &&
+              irStepsContainsCalleeAsync(
+                /** @type {{ innerSteps?: unknown }} */ (p).innerSteps
+              )
+            ) {
+              return true
+            }
+          }
+        }
+      }
+    }
+    if (kind === 'Quotation') {
+      const qm = n.quoteEmitMeta
+      if (qm != null && typeof qm === 'object') {
+        const inner = /** @type {{ innerSteps?: unknown }} */ (qm).innerSteps
+        if (irStepsContainsCalleeAsync(inner)) return true
+      }
+    }
+  }
+  return false
+}
+
+/**
+ * Рекурсивно: есть ли вызов слова, у которого по сигнатуре всплывает `+Async` (RFC-compile §10, вариант B).
+ * Не опирается на `node.calleeAsync` в IR.
+ *
+ * @param {unknown} steps
+ * @param {CalleeAsyncResolver | null | undefined} resolver
+ * @returns {boolean}
+ */
+export function irStepsCallsPropagatingAsyncCallee (steps, resolver) {
+  if (resolver == null || !Array.isArray(steps)) return false
+  for (const raw of steps) {
+    if (raw == null || typeof raw !== 'object') continue
+    const n = /** @type {Record<string, unknown>} */ (raw)
+    const kind = String(n.kind ?? '')
+    if (kind === 'Word') {
+      const ref = n.ref
+      if (ref === 'local') {
+        if (resolver.localPropagatesAsync(String(n.name ?? ''))) return true
+      } else if (ref === 'qualified') {
+        if (
+          resolver.qualifiedPropagatesAsync(
+            String(n.module ?? ''),
+            String(n.word ?? n.name ?? '')
+          )
+        ) {
+          return true
+        }
+      }
+    }
+    if (kind === 'Builtin' && n.name === 'call') {
+      const meta = n.callInlineMeta
+      if (meta != null && typeof meta === 'object') {
+        const m = /** @type {{ innerSteps?: unknown }} */ (meta)
+        if (irStepsCallsPropagatingAsyncCallee(m.innerSteps, resolver)) return true
+      }
+    }
+    if (
+      kind === 'Builtin' &&
+      COMBINATOR_BUILTIN_NAMES.has(String(n.name ?? ''))
+    ) {
+      const cmeta = n.combinatorInlineMeta
+      if (cmeta != null && typeof cmeta === 'object') {
+        const parts = /** @type {{ parts?: unknown }} */ (cmeta).parts
+        if (Array.isArray(parts)) {
+          for (const p of parts) {
+            if (
+              p != null &&
+              typeof p === 'object' &&
+              /** @type {{ kind?: string }} */ (p).kind === 'inline' &&
+              irStepsCallsPropagatingAsyncCallee(
+                /** @type {{ innerSteps?: unknown }} */ (p).innerSteps,
+                resolver
+              )
+            ) {
+              return true
+            }
+          }
+        }
+      }
+    }
+    if (kind === 'Quotation') {
+      const qm = n.quoteEmitMeta
+      if (qm != null && typeof qm === 'object') {
+        const inner = /** @type {{ innerSteps?: unknown }} */ (qm).innerSteps
+        if (irStepsCallsPropagatingAsyncCallee(inner, resolver)) return true
+      }
+    }
+  }
+  return false
+}
+
+/**
+ * @param {Record<string, unknown>} node
+ * @param {CalleeAsyncResolver | null | undefined} resolver
+ * @returns {boolean}
+ */
+function calleeStepNeedsAwaitFromSig (node, resolver) {
+  if (node.calleeAsync === true) return true
+  if (resolver == null) return false
+  const kind = String(node.kind ?? '')
+  if (kind !== 'Word') return false
+  const ref = node.ref
+  if (ref === 'local') {
+    return resolver.localPropagatesAsync(String(node.name ?? ''))
+  }
+  if (ref === 'qualified') {
+    return resolver.qualifiedPropagatesAsync(
+      String(node.module ?? ''),
+      String(node.word ?? node.name ?? '')
+    )
+  }
+  return false
+}
+
+/**
+ * @param {Record<string, unknown>} node
+ * @param {{ argIds: string[], resultIds: string[] }} vb
+ * @param {Map<string, string>} idToJs
+ * @param {() => string} genName
+ * @param {string[]} lines
+ */
+/**
+ * @param {Record<string, unknown>} node
+ * @param {{ argIds: string[], resultIds: string[] }} vb
+ * @param {number} L
+ * @param {Map<string, string>} idToJs
+ * @param {() => string} genName
+ * @param {string[]} lines
+ */
+function emitListLiteralStep (node, vb, L, idToJs, genName, lines) {
+  const nIn = vb.argIds.length
+  const baseLen = L - nIn
+  const topOutIds = vb.resultIds.slice(baseLen)
+  if (topOutIds.length !== 1) {
+    throw new Error('emit-body: ListLiteral ожидает ровно один новый id на вершине')
+  }
+  const elements = /** @type {Record<string, unknown>[] | undefined} */ (node.elements)
+  if (!Array.isArray(elements)) {
+    throw new Error('emit-body: ListLiteral без elements')
+  }
+  const exprs = elements.map((el) => literalToJsExpr(el))
+  const litId = topOutIds[0]
+  const nm = genName()
+  lines.push(`const ${nm} = [${exprs.join(', ')}];`)
+  idToJs.set(litId, nm)
+}
+
+/**
+ * @param {'read'|'write'} direction
+ * @param {string} slotName
+ * @param {{ argIds: string[], resultIds: string[] }} vb
+ * @param {number} L
+ * @param {Map<string, string>} idToJs
+ * @param {Map<string, string>} slotExprByName
+ * @param {() => string} genName
+ * @param {string[]} lines
+ * @param {boolean} strict
+ * @param {string} wordLabel
+ * @param {number} stepIndex
+ */
+function emitSlotStep (
+  direction,
+  slotName,
+  vb,
+  L,
+  idToJs,
+  slotExprByName,
+  genName,
+  lines,
+  strict,
+  wordLabel,
+  stepIndex
+) {
+  if (direction === 'write') {
+    const argIds = vb.argIds
+    if (argIds.length !== 1) {
+      throw new Error(`emit-body[${wordLabel}]: slot_write ожидает 1 argId`)
+    }
+    const j = idToJs.get(argIds[0])
+    if (j == null) {
+      throw new Error(`emit-body[${wordLabel}]: slot_write нет JS для arg`)
+    }
+    slotExprByName.set(slotName, j)
+    return
+  }
+  if (direction === 'read') {
+    const src = slotExprByName.get(slotName)
+    if (src == null) {
+      if (strict) {
+        throw new Error(
+          `emit-body[${wordLabel}]: шаг ${stepIndex} slot_read :${slotName} без предшествующей записи`
+        )
+      }
+      return
+    }
+    const nIn = vb.argIds.length
+    const baseLen = L - nIn
+    const topOutIds = vb.resultIds.slice(baseLen)
+    if (topOutIds.length !== 1) {
+      throw new Error(`emit-body[${wordLabel}]: slot_read один выход на вершине`)
+    }
+    const readId = topOutIds[0]
+    const nm = genName()
+    lines.push(`const ${nm} = ${src};`)
+    idToJs.set(readId, nm)
+    return
+  }
+  throw new Error(`emit-body[${wordLabel}]: Slot без direction`)
+}
+
+function emitLiteralStep (node, vb, idToJs, genName, lines) {
+  const pre = node.preTypes
+  const L = Array.isArray(pre) ? pre.length : 0
+  const nIn = vb.argIds.length
+  const baseLen = L - nIn
+  const topOutIds = vb.resultIds.slice(baseLen)
+  if (topOutIds.length !== 1) {
+    throw new Error('emit-body: Literal ожидает ровно один новый id на вершине')
+  }
+  const litId = topOutIds[0]
+  const expr = literalToJsExpr(node)
+  const nm = genName()
+  lines.push(`const ${nm} = ${expr};`)
+  idToJs.set(litId, nm)
+}
+
+/**
+ * @param {string} name
+ * @param {{ argIds: string[], resultIds: string[] }} vb
+ * @param {number} L
+ * @param {Map<string, string>} idToJs
+ * @param {() => string} genName
+ * @param {string[]} lines
+ */
+function emitBuiltinShuffleStep (
+  name,
+  vb,
+  L,
+  idToJs,
+  genName,
+  lines
+) {
+  const shuffler = BUILTIN_SHUFFLE_EXPR[name]
+  if (!shuffler) return false
+  const nIn = vb.argIds.length
+  const baseLen = L - nIn
+  const topOutIds = vb.resultIds.slice(baseLen)
+  const argExprs = vb.argIds.map((id) => {
+    const j = idToJs.get(id)
+    if (j == null) {
+      throw new Error(`emit-body: нет JS-имени для argId ${id} (builtin ${name})`)
+    }
+    return j
+  })
+  const outExprs = shuffler(argExprs)
+  if (outExprs.length !== topOutIds.length) {
+    throw new Error(`emit-body: внутренняя ошибка длины shuffle для ${name}`)
+  }
+  const seen = new Set()
+  for (let i = 0; i < topOutIds.length; i++) {
+    const rid = topOutIds[i]
+    const expr = outExprs[i]
+    if (seen.has(rid)) continue
+    seen.add(rid)
+    if (isShuffleReuseExpr(expr)) {
+      idToJs.set(rid, expr)
+    } else {
+      const nm = genName()
+      lines.push(`const ${nm} = ${expr};`)
+      idToJs.set(rid, nm)
+    }
+  }
+  return true
+}
+
+/**
+ * @param {QuoteEmitMeta} meta
+ * @param {{
+ *   idToJs: Map<string, string>
+ *   lines: string[]
+ *   genName: () => string
+ *   genQuoteName: () => string
+ *   quoteMetaByValueId: Map<string, QuoteEmitMeta>
+ *   slotExprByName: Map<string, string>
+ *   strict: boolean
+ *   wordLabel: string
+ *   entryParamCounter: { n: number }
+ *   callerAsync: boolean
+ *   calleeAsyncResolver?: CalleeAsyncResolver | null
+ *   sumEliminatorNames?: Set<string> | null
+ * }} env
+ * @returns {string} имя `qN`
+ */
+function emitQuoteAsFirstClass (meta, env) {
+  const n = meta.innerEntryStackIds.length
+  const nOut = inferInnerOutLen(meta.innerSteps)
+  const params =
+    n === 0 ? '' : Array.from({ length: n }, (_, i) => `p${i}`).join(', ')
+  const qn = env.genQuoteName()
+  const merged = new Map()
+  for (let i = 0; i < n; i++) {
+    merged.set(meta.innerEntryStackIds[i], `p${i}`)
+  }
+  const innerLines = []
+  const innerAsync = env.calleeAsyncResolver
+    ? irStepsCallsPropagatingAsyncCallee(
+        meta.innerSteps,
+        env.calleeAsyncResolver
+      )
+    : irStepsContainsCalleeAsync(meta.innerSteps)
+  const innerEnv = {
+    idToJs: merged,
+    lines: innerLines,
+    genName: env.genName,
+    genQuoteName: env.genQuoteName,
+    quoteMetaByValueId: env.quoteMetaByValueId,
+    slotExprByName: env.slotExprByName,
+    strict: env.strict,
+    wordLabel: env.wordLabel,
+    entryParamCounter: env.entryParamCounter,
+    resolveQualifiedCallee: env.resolveQualifiedCallee,
+    callerAsync: innerAsync,
+    calleeAsyncResolver: env.calleeAsyncResolver,
+    sumEliminatorNames: env.sumEliminatorNames,
+    initialStackIds:
+      meta.innerEntryStackIds.length > 0 ? meta.innerEntryStackIds : undefined
+  }
+  const finalIds = processIrSteps(meta.innerSteps, innerEnv)
+  const nsig = sigWireFromStackLens(n, nOut)
+  appendReturnForLines(innerLines, finalIds, merged, nsig, env.wordLabel)
+  const body = innerLines.join('\n')
+  const innerBlock = body ? `  ${body.split('\n').join('\n  ')}` : ''
+  const asyncKw = innerAsync ? 'async ' : ''
+  env.lines.push(`const ${qn} = ${asyncKw}(${params}) => {\n${innerBlock}\n}`)
+  return qn
+}
+
+/**
+ * @param {Record<string, unknown>} node
+ * @param {{ argIds: string[], resultIds: string[] }} vb
+ * @param {number} L
+ * @param {Map<string, string>} idToJs
+ * @param {() => string} genName
+ * @param {string[]} lines
+ * @param {Map<string, QuoteEmitMeta>} quoteMetaByValueId
+ * @param {() => string} genQuoteName
+ * @param {{ n: number }} entryParamCounter
+ * @param {boolean} strict
+ * @param {string} wordLabel
+ * @param {((moduleAlias: string, wordName: string) => string) | undefined} resolveQualifiedCallee
+ * @param {boolean} callerAsync
+ * @param {CalleeAsyncResolver | null | undefined} calleeAsyncResolver
+ * @param {string[]} stackIds стек id до шага (дно→вершина)
+ * @param {Set<string> | null | undefined} sumEliminatorNames
+ * @param {Map<string, string>} slotExprByName
+ */
+function emitWordLocalStep (
+  node,
+  vb,
+  L,
+  idToJs,
+  genName,
+  lines,
+  quoteMetaByValueId,
+  genQuoteName,
+  entryParamCounter,
+  strict,
+  wordLabel,
+  resolveQualifiedCallee,
+  callerAsync,
+  calleeAsyncResolver,
+  stackIds,
+  sumEliminatorNames,
+  slotExprByName
+) {
+  const name = /** @type {string} */ (node.name)
+  assertValidJsCallee(name)
+  const nIn = vb.argIds.length
+  const baseLen = L - nIn
+  const topOutIds = vb.resultIds.slice(baseLen)
+  const env = {
+    idToJs,
+    lines,
+    genName,
+    genQuoteName,
+    quoteMetaByValueId,
+    slotExprByName,
+    strict,
+    wordLabel,
+    entryParamCounter,
+    resolveQualifiedCallee,
+    callerAsync,
+    calleeAsyncResolver,
+    sumEliminatorNames,
+    initialStackIds: undefined
+  }
+  /** @type {string[]} */
+  let argExprs = vb.argIds.map((id) => {
+    const qm = quoteMetaByValueId.get(id)
+    if (qm) {
+      const existing = idToJs.get(id)
+      if (existing != null) return existing
+      return emitQuoteAsFirstClass(qm, env)
+    }
+    const j = idToJs.get(id)
+    if (j == null) {
+      throw new Error(`emit-body: нет JS-имени для argId ${id} (Word ${name})`)
+    }
+    return j
+  })
+  if (sumEliminatorNames?.has(name) === true) {
+    const prefixLen = L - nIn
+    if (stackIds.length !== L) {
+      throw new Error(
+        `emit-body[${wordLabel}]: неверная длина стека для eliminator (${stackIds.length} !== ${L})`
+      )
+    }
+    const prefixIds = stackIds.slice(0, prefixLen)
+    const prefixExprs = prefixIds.map((id) => {
+      const qm = quoteMetaByValueId.get(id)
+      if (qm) {
+        const existing = idToJs.get(id)
+        if (existing != null) return existing
+        return emitQuoteAsFirstClass(qm, env)
+      }
+      const j = idToJs.get(id)
+      if (j == null) {
+        throw new Error(`emit-body: нет JS-имени для prefix id ${id} (Word ${name})`)
+      }
+      return j
+    })
+    argExprs = [...prefixExprs, ...argExprs]
+  }
+  const innerCall = `${name}(${argExprs.join(', ')})`
+  const useAwait =
+    callerAsync && calleeStepNeedsAwaitFromSig(node, calleeAsyncResolver)
+  const callExpr = useAwait ? `await ${innerCall}` : innerCall
+  if (topOutIds.length === 0) {
+    lines.push(`${callExpr};`)
+    return
+  }
+  if (topOutIds.length === 1) {
+    const nm = genName()
+    lines.push(`const ${nm} = ${callExpr};`)
+    idToJs.set(topOutIds[0], nm)
+    return
+  }
+  const names = topOutIds.map(() => genName())
+  lines.push(`const [${names.join(', ')}] = ${callExpr};`)
+  for (let i = 0; i < topOutIds.length; i++) {
+    idToJs.set(topOutIds[i], names[i])
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} node
+ * @param {{ argIds: string[], resultIds: string[] }} vb
+ * @param {number} L
+ * @param {Map<string, string>} idToJs
+ * @param {() => string} genName
+ * @param {string[]} lines
+ * @param {Map<string, QuoteEmitMeta>} quoteMetaByValueId
+ * @param {() => string} genQuoteName
+ * @param {{ n: number }} entryParamCounter
+ * @param {boolean} strict
+ * @param {string} wordLabel
+ * @param {(moduleAlias: string, wordName: string) => string} resolveQualifiedCallee
+ * @param {boolean} callerAsync
+ * @param {CalleeAsyncResolver | null | undefined} calleeAsyncResolver
+ * @param {Map<string, string>} slotExprByName
+ */
+function emitWordQualifiedStep (
+  node,
+  vb,
+  L,
+  idToJs,
+  genName,
+  lines,
+  quoteMetaByValueId,
+  genQuoteName,
+  entryParamCounter,
+  strict,
+  wordLabel,
+  resolveQualifiedCallee,
+  callerAsync,
+  calleeAsyncResolver,
+  slotExprByName
+) {
+  const mod = /** @type {string} */ (node.module)
+  const name = /** @type {string} */ (node.word ?? node.name)
+  const calleeExpr = resolveQualifiedCallee(mod, name)
+  const nIn = vb.argIds.length
+  const baseLen = L - nIn
+  const topOutIds = vb.resultIds.slice(baseLen)
+  const env = {
+    idToJs,
+    lines,
+    genName,
+    genQuoteName,
+    quoteMetaByValueId,
+    slotExprByName,
+    strict,
+    wordLabel,
+    entryParamCounter,
+    resolveQualifiedCallee,
+    callerAsync,
+    calleeAsyncResolver,
+    sumEliminatorNames: null,
+    initialStackIds: undefined
+  }
+  const argExprs = vb.argIds.map((id) => {
+    const qm = quoteMetaByValueId.get(id)
+    if (qm) {
+      const existing = idToJs.get(id)
+      if (existing != null) return existing
+      return emitQuoteAsFirstClass(qm, env)
+    }
+    const j = idToJs.get(id)
+    if (j == null) {
+      throw new Error(`emit-body: нет JS-имени для argId ${id} (qualified ${mod}/${name})`)
+    }
+    return j
+  })
+  const innerCall = `${calleeExpr}(${argExprs.join(', ')})`
+  const useAwait =
+    callerAsync && calleeStepNeedsAwaitFromSig(node, calleeAsyncResolver)
+  const callExpr = useAwait ? `await ${innerCall}` : innerCall
+  if (topOutIds.length === 0) {
+    lines.push(`${callExpr};`)
+    return
+  }
+  if (topOutIds.length === 1) {
+    const nm = genName()
+    lines.push(`const ${nm} = ${callExpr};`)
+    idToJs.set(topOutIds[0], nm)
+    return
+  }
+  const names = topOutIds.map(() => genName())
+  lines.push(`const [${names.join(', ')}] = ${callExpr};`)
+  for (let i = 0; i < topOutIds.length; i++) {
+    idToJs.set(topOutIds[i], names[i])
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} node
+ * @param {{ argIds: string[], resultIds: string[] }} vb
+ * @param {number} L
+ * @param {{
+ *   idToJs: Map<string, string>
+ *   lines: string[]
+ *   genName: () => string
+ *   genQuoteName: () => string
+ *   quoteMetaByValueId: Map<string, QuoteEmitMeta>
+ *   strict: boolean
+ *   wordLabel: string
+ *   entryParamCounter: { n: number }
+ *   resolveQualifiedCallee?: (moduleAlias: string, wordName: string) => string
+ *   callerAsync: boolean
+ *   calleeAsyncResolver?: CalleeAsyncResolver | null
+ * }} env
+ */
+function emitCallInlineStep (node, vb, L, env) {
+  const meta = /** @type {{
+    kind?: 'inline' | 'invoke'
+    innerSteps?: Record<string, unknown>[]
+    innerEntryStackIds?: string[]
+    innerInLen?: number
+    innerOutLen?: number
+  } | undefined} */ (node.callInlineMeta)
+  if (!meta || typeof meta !== 'object') {
+    throw new Error(`emit-body[${env.wordLabel}]: call без callInlineMeta`)
+  }
+
+  const baseLen = L - vb.argIds.length
+  const topOutIds = vb.resultIds.slice(baseLen)
+  const m = topOutIds.length
+
+  if (meta.kind === 'invoke') {
+    const n = meta.innerInLen
+    const mMeta = meta.innerOutLen
+    if (typeof n !== 'number' || typeof mMeta !== 'number') {
+      throw new Error(`emit-body[${env.wordLabel}]: call invoke — нет innerInLen/innerOutLen`)
+    }
+    if (m !== mMeta) {
+      throw new Error(
+        `emit-body[${env.wordLabel}]: call invoke — m пост-стека (${m}) ≠ innerOutLen (${mMeta})`
+      )
+    }
+    if (vb.argIds.length !== n + 1) {
+      throw new Error(
+        `emit-body[${env.wordLabel}]: call invoke — ожидалось ${n + 1} argIds, есть ${vb.argIds.length}`
+      )
+    }
+    const quoteId = vb.argIds[vb.argIds.length - 1]
+    const quoteJs = env.idToJs.get(quoteId)
+    if (quoteJs == null) {
+      throw new Error(`emit-body[${env.wordLabel}]: call invoke — нет JS для quote id ${quoteId}`)
+    }
+    const callArgExprs = vb.argIds.slice(0, -1).map((id) => {
+      const j = env.idToJs.get(id)
+      if (j == null) {
+        throw new Error(`emit-body[${env.wordLabel}]: call invoke — нет JS для arg ${id}`)
+      }
+      return j
+    })
+    const paren = callArgExprs.length ? `(${callArgExprs.join(', ')})` : '()'
+    let callExpr = `${quoteJs}${paren}`
+    const qm = env.quoteMetaByValueId.get(quoteId)
+    const invokeInnerAsync =
+      qm != null &&
+      env.calleeAsyncResolver != null &&
+      irStepsCallsPropagatingAsyncCallee(
+        qm.innerSteps,
+        env.calleeAsyncResolver
+      )
+    const useAwaitInvoke =
+      env.callerAsync &&
+      (node.calleeAsync === true || invokeInnerAsync)
+    if (useAwaitInvoke) {
+      callExpr = `await ${callExpr}`
+    }
+    if (m === 0) {
+      env.lines.push(`${callExpr};`)
+    } else if (m === 1) {
+      const nm = env.genName()
+      env.lines.push(`const ${nm} = ${callExpr};`)
+      env.idToJs.set(topOutIds[0], nm)
+    } else {
+      const names = topOutIds.map(() => env.genName())
+      env.lines.push(`const [${names.join(', ')}] = ${callExpr};`)
+      for (let i = 0; i < m; i++) {
+        env.idToJs.set(topOutIds[i], names[i])
+      }
+    }
+    return
+  }
+
+  const inlineKind = meta.kind == null || meta.kind === 'inline'
+  if (
+    !inlineKind ||
+    !Array.isArray(meta.innerSteps) ||
+    !Array.isArray(meta.innerEntryStackIds)
+  ) {
+    throw new Error(`emit-body[${env.wordLabel}]: call без inline callInlineMeta`)
+  }
+  const innerArgs = vb.argIds.slice(0, -1)
+  if (innerArgs.length !== meta.innerEntryStackIds.length) {
+    throw new Error(`emit-body[${env.wordLabel}]: call — несовпадение числа аргументов quotation`)
+  }
+  const merged = new Map(env.idToJs)
+  for (let i = 0; i < meta.innerEntryStackIds.length; i++) {
+    const aid = innerArgs[i]
+    const j = env.idToJs.get(aid)
+    if (j == null) {
+      throw new Error(`emit-body[${env.wordLabel}]: call — нет JS для arg ${aid}`)
+    }
+    merged.set(meta.innerEntryStackIds[i], j)
+  }
+  const innerEnv = {
+    idToJs: merged,
+    lines: env.lines,
+    genName: env.genName,
+    genQuoteName: env.genQuoteName,
+    quoteMetaByValueId: env.quoteMetaByValueId,
+    slotExprByName: env.slotExprByName,
+    strict: env.strict,
+    wordLabel: env.wordLabel,
+    entryParamCounter: env.entryParamCounter,
+    resolveQualifiedCallee: env.resolveQualifiedCallee,
+    callerAsync: env.callerAsync,
+    calleeAsyncResolver: env.calleeAsyncResolver,
+    sumEliminatorNames: env.sumEliminatorNames,
+    initialStackIds:
+      Array.isArray(meta.innerEntryStackIds) && meta.innerEntryStackIds.length > 0
+        ? meta.innerEntryStackIds
+        : undefined
+  }
+  const innerFinalIds = processIrSteps(meta.innerSteps, innerEnv)
+  if (innerFinalIds.length !== m) {
+    throw new Error(
+      `emit-body[${env.wordLabel}]: call — ожидалось ${m} выходов, внутри ${innerFinalIds.length}`
+    )
+  }
+  for (let i = 0; i < m; i++) {
+    const rid = topOutIds[i]
+    const innerId = innerFinalIds[i]
+    const j = merged.get(innerId)
+    if (j == null) {
+      throw new Error(`emit-body[${env.wordLabel}]: call — нет JS для внутреннего id ${innerId}`)
+    }
+    env.idToJs.set(rid, j)
+  }
+}
+
+/**
+ * @param {Record<string, unknown>[]} irSteps
+ * @param {{
+ *   idToJs: Map<string, string>
+ *   lines: string[]
+ *   genName: () => string
+ *   genQuoteName: () => string
+ *   quoteMetaByValueId: Map<string, QuoteEmitMeta>
+ *   slotExprByName: Map<string, string>
+ *   strict: boolean
+ *   wordLabel: string
+ *   entryParamCounter: { n: number }
+ *   resolveQualifiedCallee?: (moduleAlias: string, wordName: string) => string
+ *   callerAsync: boolean
+ *   calleeAsyncResolver?: CalleeAsyncResolver | null
+ *   sumEliminatorNames?: Set<string> | null
+ *   initialStackIds?: string[] | undefined
+ * }} env
+ * @returns {string[]}
+ */
+function processIrSteps (irSteps, env) {
+  /** @type {string[]} */
+  let currentStackIds = Array.isArray(env.initialStackIds)
+    ? [...env.initialStackIds]
+    : []
+  const {
+    idToJs,
+    lines,
+    genName,
+    genQuoteName,
+    quoteMetaByValueId,
+    slotExprByName,
+    strict,
+    wordLabel,
+    entryParamCounter,
+    resolveQualifiedCallee,
+    sumEliminatorNames
+  } = env
+
+  if (!Array.isArray(irSteps)) {
+    throw new Error('emit-body: irSteps должен быть массивом')
+  }
+
+  for (let si = 0; si < irSteps.length; si++) {
+    const raw = irSteps[si]
+    if (raw == null || typeof raw !== 'object') continue
+    const node = /** @type {Record<string, unknown>} */ (raw)
+    const kind = String(node.kind ?? '')
+    const vb = /** @type {{ argIds?: string[], resultIds?: string[] } | undefined} */ (
+      node.valueBindings
+    )
+    const pre = node.preTypes
+    const L = Array.isArray(pre) ? pre.length : -1
+
+    if (!vb || !Array.isArray(vb.argIds) || !Array.isArray(vb.resultIds)) {
+      if (strict) {
+        throw new Error(
+          `emit-body[${wordLabel}]: шаг ${si} (${kind}) без valueBindings`
+        )
+      }
+      continue
+    }
+
+    if (L < 0) {
+      if (strict) {
+        throw new Error(`emit-body[${wordLabel}]: шаг ${si} (${kind}) без preTypes`)
+      }
+      continue
+    }
+
+    for (const aid of vb.argIds) {
+      if (quoteMetaByValueId.has(aid)) continue
+      if (!idToJs.has(aid)) {
+        const pn = `p${entryParamCounter.n++}`
+        idToJs.set(aid, pn)
+      }
+    }
+
+    const stackIds = currentStackIds
+
+    switch (kind) {
+      case 'Literal':
+        emitLiteralStep(node, vb, idToJs, genName, lines)
+        break
+      case 'ListLiteral':
+        emitListLiteralStep(node, vb, L, idToJs, genName, lines)
+        break
+      case 'Builtin': {
+        const bname = /** @type {string} */ (node.name)
+        if (bname === 'call') {
+          emitCallInlineStep(node, vb, L, env)
+          break
+        }
+        if (tryEmitCombinatorBuiltin(bname, node, vb, L, env, processIrSteps)) {
+          break
+        }
+        if (!emitBuiltinShuffleStep(bname, vb, L, idToJs, genName, lines)) {
+          throw new Error(
+            `emit-body[${wordLabel}]: неподдержанный builtin ${JSON.stringify(bname)}`
+          )
+        }
+        break
+      }
+      case 'Slot': {
+        const dir = /** @type {'read'|'write' | undefined} */ (node.direction)
+        const slotName = String(node.slotName ?? '')
+        if (dir !== 'read' && dir !== 'write') {
+          throw new Error(`emit-body[${wordLabel}]: Slot без direction`)
+        }
+        emitSlotStep(
+          dir,
+          slotName,
+          vb,
+          L,
+          idToJs,
+          slotExprByName,
+          genName,
+          lines,
+          strict,
+          wordLabel,
+          si
+        )
+        break
+      }
+      case 'Unknown': {
+        const ak = String(node.astKind ?? 'unknown')
+        throw new Error(
+          `emit-body[${wordLabel}]: шаг ${si} недопустим для codegen (Unknown AST ${ak})`
+        )
+      }
+      case 'Word': {
+        const ref = node.ref
+        if (ref === 'local') {
+          emitWordLocalStep(
+            node,
+            vb,
+            L,
+            idToJs,
+            genName,
+            lines,
+            quoteMetaByValueId,
+            genQuoteName,
+            entryParamCounter,
+            strict,
+            wordLabel,
+            resolveQualifiedCallee,
+            env.callerAsync,
+            env.calleeAsyncResolver,
+            stackIds,
+            sumEliminatorNames ?? null,
+            slotExprByName
+          )
+        } else if (ref === 'qualified') {
+          if (typeof resolveQualifiedCallee !== 'function') {
+            throw new Error(
+              `emit-body[${wordLabel}]: qualified Word без resolveQualifiedCallee`
+            )
+          }
+          emitWordQualifiedStep(
+            node,
+            vb,
+            L,
+            idToJs,
+            genName,
+            lines,
+            quoteMetaByValueId,
+            genQuoteName,
+            entryParamCounter,
+            strict,
+            wordLabel,
+            resolveQualifiedCallee,
+            env.callerAsync,
+            env.calleeAsyncResolver,
+            slotExprByName
+          )
+        } else {
+          throw new Error(
+            `emit-body[${wordLabel}]: Word ref=${String(ref)} пока не поддержан`
+          )
+        }
+        break
+      }
+      case 'Quotation': {
+        const meta = /** @type {QuoteEmitMeta | undefined} */ (node.quoteEmitMeta)
+        if (!meta) {
+          throw new Error(`emit-body[${wordLabel}]: Quotation без quoteEmitMeta`)
+        }
+        const delta = vb.resultIds.length - L
+        const newIds = vb.resultIds.slice(L)
+        if (newIds.length !== delta) {
+          throw new Error('emit-body: Quotation delta ids')
+        }
+        for (const qid of newIds) {
+          quoteMetaByValueId.set(qid, meta)
+        }
+        break
+      }
+      default:
+        throw new Error(`emit-body[${wordLabel}]: неподдержанный kind ${kind}`)
+    }
+
+    currentStackIds = [...vb.resultIds]
+  }
+
+  return currentStackIds
+}
+
+/**
+ * Генерирует JS-фрагмент тела слова по `irSteps` с заполненными `valueBindings`.
+ *
+ * Контракт `return`: если передан `normalizedSig`, в конец добавляется `return`:
+ * один выход — `return <expr>;`, несколько — `return [<expr>, ...];` (дно → вершина),
+ * ноль выходов — `return;`. Без `normalizedSig` оператор `return` не добавляется.
+ *
+ * @param {Record<string, unknown>[]} irSteps
+ * @param {{
+ *   strict?: boolean
+ *   normalizedSig?: NormalizedSignature | null
+ *   wordName?: string
+ *   entryStackIds?: string[] | null
+ *   resolveQualifiedCallee?: (moduleAlias: string, wordName: string) => string
+ *   callerAsync?: boolean
+ *   calleeAsyncResolver?: CalleeAsyncResolver | null
+ *   sumEliminatorNames?: Set<string> | null
+ * }} [options]
+ * @returns {{ source: string }}
+ *
+ * Входной стек слова: если `bind-values` подставил «resync»-id до первого реального шага,
+ * в теле используются свободные имена `p0`, `p1`, … (дно → вершина, вершина — больший индекс),
+ * как формальные параметры будущей обёртки-функции.
+ */
+export function emitWordBodyIr (irSteps, options = {}) {
+  const strict = options.strict === true
+  const wordLabel = options.wordName != null ? String(options.wordName) : 'word'
+  /** @type {Map<string, string>} */
+  const idToJs = new Map()
+  let counter = 0
+  let quoteCounter = 0
+  const genName = () => {
+    const n = counter++
+    return `v${n}`
+  }
+  const genQuoteName = () => {
+    const n = quoteCounter++
+    return `q${n}`
+  }
+  /** @type {Map<string, QuoteEmitMeta>} */
+  const quoteMetaByValueId = new Map()
+  /** @type {Map<string, string>} */
+  const slotExprByName = new Map()
+  /** @type {string[]} */
+  const lines = []
+  const entryParamCounter = { n: 0 }
+
+  const env = {
+    idToJs,
+    lines,
+    genName,
+    genQuoteName,
+    quoteMetaByValueId,
+    slotExprByName,
+    strict,
+    wordLabel,
+    entryParamCounter,
+    resolveQualifiedCallee: options.resolveQualifiedCallee,
+    callerAsync: options.callerAsync === true,
+    calleeAsyncResolver: options.calleeAsyncResolver ?? null,
+    sumEliminatorNames: options.sumEliminatorNames ?? null,
+    initialStackIds:
+      Array.isArray(options.entryStackIds) && options.entryStackIds.length > 0
+        ? options.entryStackIds
+        : undefined
+  }
+
+  const nsig = options.normalizedSig
+  const entryStackIds = options.entryStackIds
+  if (
+    nsig != null &&
+    typeof nsig === 'object' &&
+    Array.isArray(nsig.left) &&
+    Array.isArray(entryStackIds) &&
+    entryStackIds.length === nsig.left.length
+  ) {
+    let pAcc = 0
+    const allocP = () => `p${pAcc++}`
+    for (let i = 0; i < entryStackIds.length; i++) {
+      idToJs.set(entryStackIds[i], jsParamNameForEntrySlot(nsig.left[i], allocP))
+    }
+    entryParamCounter.n = pAcc
+  }
+
+  const currentStackIds = processIrSteps(irSteps, env)
+
+  if (options.normalizedSig != null) {
+    for (const id of currentStackIds) {
+      if (!idToJs.has(id) && quoteMetaByValueId.has(id)) {
+        const meta = quoteMetaByValueId.get(id)
+        if (meta) {
+          const qn = emitQuoteAsFirstClass(meta, {
+            idToJs,
+            lines,
+            genName,
+            genQuoteName,
+            quoteMetaByValueId,
+            slotExprByName,
+            strict,
+            wordLabel,
+            entryParamCounter,
+            resolveQualifiedCallee: options.resolveQualifiedCallee,
+            callerAsync: options.callerAsync === true,
+            calleeAsyncResolver: options.calleeAsyncResolver ?? null,
+            sumEliminatorNames: options.sumEliminatorNames ?? null,
+            initialStackIds: undefined
+          })
+          idToJs.set(id, qn)
+        }
+      }
+    }
+    appendReturnForLines(
+      lines,
+      currentStackIds,
+      idToJs,
+      options.normalizedSig,
+      wordLabel
+    )
+  }
+
+  return { source: lines.join('\n') }
+}