@fraczak/k 6.3.3 → 6.5.0

package/kvm.mjs

@@ -1,21 +1,31 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import { argv, stdin, exit, stdout } from "node:process";
-import { Value, composePattern, withPattern, isProduct, isVariant } from "./Value.mjs";
-import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
-import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
+import { Value, composePattern, withPattern, isProduct, isVariant, edgeSubpattern, isValue } from "./Value.mjs";
 import {
   constrainWithPattern,
-  intersectPatterns,
   projectionPattern,
-  verify,
-  run
+  verify
 } from "./run.mjs";
-import { annotate } from "./index.mjs";
 import { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
-import { decodeObject, loadLibrary } from "./object.mjs";
+import { intersectPropertyListPatterns } from "./codecs/runtime/codec.mjs";
+import { compileObjectBuffer, decodeObject, loadLibrary } from "./object.mjs";
 import codes from "./codes.mjs";
 import { isMainEntrypoint } from "./codecs/runtime/cli-entry.mjs";
+import { isIntrinsic, unsupportedIntrinsic } from "./intrinsics.mjs";
+import { objectToKIRP, retypeObjectRelationForBackend } from "./kir.mjs";
+
+export const KVM_FORMAT = "k-vm";
+export const KVM_VERSION = 1;
+
+const KVM_SINGLETON_INPUT_KINDS = new Set(["closed-product", "closed-union", "type"]);
+const KIR_PATTERN_KIND_TO_PROPERTY_LIST_KIND = Object.freeze({
+  any: "any",
+  "open-product": "open-product",
+  "closed-product": "closed-product",
+  "open-union": "open-union",
+  "closed-union": "closed-union"
+});
 
 function isFile(filePath) {
   try {
@@ -53,9 +63,85 @@ function buildExportPreamble(exports, libraries) {
   return lines.join("\n") + "\n";
 }
 
+function kirFindCode(kir) {
+  return (hash) => kir.codes?.[hash] || codes.find(hash);
+}
+
+function kirTypePatternKind(node, codesTable = {}) {
+  const code = codesTable[node.code];
+  if (code?.code === "product") return "closed-product";
+  if (code?.code === "union") return "closed-union";
+  throw new Error(`KIR type pattern ${node.code || "<missing>"} is missing a product/union code definition`);
+}
+
+function kirPatternToPropertyList(patternGraph, codesTable, rootId) {
+  if (rootId == null) return null;
+  const nodes = patternGraph?.nodes || [];
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const ordered = [];
+  const idToIndex = new Map();
+
+  function visit(nodeId) {
+    if (idToIndex.has(nodeId)) return;
+    const node = nodeById.get(nodeId);
+    if (!node) throw new Error(`KIR pattern graph references missing node ${nodeId}`);
+
+    idToIndex.set(nodeId, ordered.length);
+    ordered.push(node);
+    for (const edge of [...(node.edges || [])].sort((a, b) => a.label.localeCompare(b.label) || a.target - b.target)) {
+      visit(edge.target);
+    }
+  }
+
+  visit(rootId);
+
+  return ordered.map((node) => {
+    const kind = node.kind === "type"
+      ? kirTypePatternKind(node, codesTable)
+      : KIR_PATTERN_KIND_TO_PROPERTY_LIST_KIND[node.kind];
+    if (!kind) throw new Error(`Unsupported KIR pattern kind: ${node.kind}`);
+    const edges = [...(node.edges || [])]
+      .sort((a, b) => a.label.localeCompare(b.label) || a.target - b.target)
+      .map((edge) => [edge.label, idToIndex.get(edge.target)]);
+    return [kind, edges];
+  });
+}
+
+function isKIRRelation(relDef) {
+  return relDef?.patternGraph && relDef?.body;
+}
+
+function objectRelationToKIRRelation(relDef, name, options = {}) {
+  const kir = objectToKIRP({
+    format: "k-object",
+    codes: options.codes || {},
+    rels: { [name]: relDef },
+    relAlias: {},
+    compileStats: {},
+    meta: {},
+    main: name
+  });
+  const relation = kir.rels[name];
+  const codesTable = { ...codesFromTypePatternGraph(relDef.typePatternGraph, relation), ...(options.codes || {}) };
+  return { relation, codesTable };
+}
+
+function codesFromTypePatternGraph(typePatternGraph, kirRelation) {
+  if (!typePatternGraph || typeof typePatternGraph.findCode !== "function") return {};
+  const result = {};
+  for (const node of kirRelation.patternGraph?.nodes || []) {
+    if (node.kind !== "type" || !node.code || result[node.code]) continue;
+    const code = typePatternGraph.findCode(node.code);
+    if (code) result[node.code] = code;
+  }
+  return result;
+}
+
 class KVMBuilder {
-  constructor(typePatternGraph) {
-    this.typePatternGraph = typePatternGraph;
+  constructor(patternGraph, codesTable = {}) {
+    this.patternGraph = patternGraph;
+    this.codes = codesTable;
+    this.patternCache = new Map();
     this.regCount = 0;
     this.instructions = [];
   }
@@ -69,13 +155,20 @@ class KVMBuilder {
   }
 
   getStaticPattern(exp, index) {
-    if (!this.typePatternGraph || !exp.patterns) return null;
-    const patternId = this.typePatternGraph.find(exp.patterns[index]);
-    return patternToPropertyList(exportPatternGraph(this.typePatternGraph, patternId));
+    if (!this.patternGraph || !exp.patterns) return null;
+    return this.getPattern(exp.patterns[index]);
+  }
+
+  getPattern(patternId) {
+    if (patternId == null) return null;
+    if (!this.patternCache.has(patternId)) {
+      this.patternCache.set(patternId, kirPatternToPropertyList(this.patternGraph, this.codes, patternId));
+    }
+    return this.patternCache.get(patternId);
   }
 }
 
-function compile(exp, inputReg, builder) {
+function compileKIRExp(exp, inputReg, builder) {
   switch (exp.op) {
     case "identity": {
       const dest = builder.nextReg();
@@ -114,7 +207,7 @@ function compile(exp, inputReg, builder) {
         op: "project_field",
         dest,
         src: inputReg,
-        label: exp.dot,
+        label: exp.label,
         pattern: builder.getStaticPattern(exp, 1),
         exp
       });
@@ -126,7 +219,7 @@ function compile(exp, inputReg, builder) {
         op: "project_variant",
         dest,
         src: inputReg,
-        tag: exp.div,
+        tag: exp.tag,
         pattern: builder.getStaticPattern(exp, 1),
         exp
       });
@@ -137,14 +230,14 @@ function compile(exp, inputReg, builder) {
       builder.emit({
         op: "make_variant",
         dest,
-        tag: exp.vid,
+        tag: exp.tag,
         src: inputReg
       });
       return dest;
     }
     case "ref": {
       const dest = builder.nextReg();
-      if (exp.ref.startsWith("_")) {
+      if (isIntrinsic(exp.ref)) {
         builder.emit({
           op: "call_intrinsic",
           dest,
@@ -172,18 +265,18 @@ function compile(exp, inputReg, builder) {
         builder.emit({ op: "guard_pattern", dest: guarded, src: currentReg, pattern: compInputPattern, exp });
         currentReg = guarded;
       }
-      for (const subExp of exp.comp) {
-        currentReg = compile(subExp, currentReg, builder);
+      for (const subExp of exp.items) {
+        currentReg = compileKIRExp(subExp, currentReg, builder);
       }
       return currentReg;
     }
     case "product": {
       const dest = builder.nextReg();
       const branches = [];
-      for (const { label, exp: fieldExp } of exp.product) {
-        const branchBuilder = new KVMBuilder(builder.typePatternGraph);
+      for (const { label, expr: fieldExp } of exp.fields) {
+        const branchBuilder = new KVMBuilder(builder.patternGraph, builder.codes);
         const branchInput = "%in";
-        const branchOutput = compile(fieldExp, branchInput, branchBuilder);
+        const branchOutput = compileKIRExp(fieldExp, branchInput, branchBuilder);
         branchBuilder.emit({ op: "return", src: branchOutput });
         branches.push({
           label,
@@ -203,10 +296,10 @@ function compile(exp, inputReg, builder) {
     case "union": {
       const dest = builder.nextReg();
       const branches = [];
-      for (const branchExp of exp.union) {
-        const branchBuilder = new KVMBuilder(builder.typePatternGraph);
+      for (const branchExp of exp.items) {
+        const branchBuilder = new KVMBuilder(builder.patternGraph, builder.codes);
         const branchInput = "%in";
-        const branchOutput = compile(branchExp, branchInput, branchBuilder);
+        const branchOutput = compileKIRExp(branchExp, branchInput, branchBuilder);
         branchBuilder.emit({ op: "return", src: branchOutput });
         branches.push({
           body: branchBuilder.instructions
@@ -222,30 +315,29 @@ function compile(exp, inputReg, builder) {
       return dest;
     }
     default:
-      throw new Error(`Unsupported AST operation: ${exp.op}`);
+      throw new Error(`Unsupported KIR operation: ${exp.op}`);
   }
 }
 
-export function lowerToKVM(relDef, name, options = {}) {
-  const typePatternGraph = relDef.typePatternGraph || null;
-  const builder = new KVMBuilder(typePatternGraph);
+export function lowerKIRRelationToKVM(kirRel, name, options = {}) {
+  const builder = new KVMBuilder(kirRel.patternGraph, options.codes || {});
   const inputReg = "%in";
 
   let currentReg = inputReg;
-  const inputPattern = builder.getStaticPattern(relDef.def, 0);
+  const inputPattern = builder.getPattern(kirRel.inputPattern);
   if (inputPattern) {
     const guarded = builder.nextReg();
-    builder.emit({ op: "guard_pattern", dest: guarded, src: currentReg, pattern: inputPattern, exp: relDef.def });
+    builder.emit({ op: "guard_pattern", dest: guarded, src: currentReg, pattern: inputPattern, exp: kirRel.body });
     currentReg = guarded;
   }
 
-  const bodyOutput = compile(relDef.def, currentReg, builder);
+  const bodyOutput = compileKIRExp(kirRel.body, currentReg, builder);
 
   let finalReg = bodyOutput;
-  const outputPattern = builder.getStaticPattern(relDef.def, 1);
+  const outputPattern = builder.getPattern(kirRel.outputPattern);
   if (outputPattern) {
     const guarded = builder.nextReg();
-    builder.emit({ op: "guard_pattern", dest: guarded, src: finalReg, pattern: outputPattern, exp: relDef.def });
+    builder.emit({ op: "guard_pattern", dest: guarded, src: finalReg, pattern: outputPattern, exp: kirRel.body });
     finalReg = guarded;
   }
 
@@ -255,20 +347,414 @@ export function lowerToKVM(relDef, name, options = {}) {
     name,
     inputPattern,
     outputPattern,
-    isConverged: relDef.typeDerivation?.status === "converged",
+    isConverged: kirRel.typeDerivation?.status === "converged",
     body: builder.instructions
   };
 }
 
-function executeBlock(instructions, inputVal, context) {
+export function lowerKIRToKVM(kir) {
+  if (kir?.format !== "k-ir" || kir.layer !== "KIR-P") {
+    throw new Error("kVM lowering requires a KIR-P object");
+  }
+  const kvmProgram = {};
+  for (const [name, relDef] of Object.entries(kir.rels || {})) {
+    kvmProgram[name] = lowerKIRRelationToKVM(relDef, name, { codes: kir.codes || {} });
+  }
+  return kvmProgram;
+}
+
+export function lowerToKVM(relDef, name, options = {}) {
+  if (isKIRRelation(relDef)) {
+    return lowerKIRRelationToKVM(relDef, name, options);
+  }
+  const { relation, codesTable } = objectRelationToKIRRelation(relDef, name, options);
+  return lowerKIRRelationToKVM(relation, name, { ...options, codes: codesTable });
+}
+
+export function isSingletonKVMInputPattern(pattern) {
+  return Array.isArray(pattern)
+    && pattern.length > 0
+    && pattern.every((node) => Array.isArray(node) && KVM_SINGLETON_INPUT_KINDS.has(node[0]));
+}
+
+function assertSingletonKVMInputPattern(pattern) {
+  if (!isSingletonKVMInputPattern(pattern)) {
+    throw new Error(
+      ".kvm emission requires a singleton input pattern; use a closed product/union pattern or a type/code input pattern"
+    );
+  }
+}
+
+export function objectToKVMArtifact(object, relationName, inputPattern, options = {}) {
+  if (!inputPattern) {
+    const kir = objectToKIRP(object);
+    const entry = relationName || kir.main || object.main;
+    const functions = lowerKIRToKVM(kir);
+    const entryFunc = functions[entry];
+    if (!entryFunc) throw new Error(`kVM entry relation '${entry}' was not produced`);
+
+    return {
+      format: KVM_FORMAT,
+      version: KVM_VERSION,
+      layer: "KVM-P",
+      isPolymorphic: true,
+      sourceFormat: object.format,
+      relation: entry,
+      entry,
+      inputPattern: entryFunc.inputPattern,
+      outputPattern: entryFunc.outputPattern,
+      isConverged: entryFunc.isConverged,
+      functions,
+      codes: kir.codes || {},
+      kir
+    };
+  }
+
+  assertSingletonKVMInputPattern(inputPattern);
+  const { relation, kir, entryName } = retypeObjectRelationForBackend(
+    object,
+    relationName || object.main,
+    inputPattern,
+    options
+  );
+  const entry = entryName;
+  const functions = lowerKIRToKVM(kir);
+  const entryFunc = functions[entry];
+  if (!entryFunc) throw new Error(`Retyped kVM entry relation '${entry}' was not produced`);
+
+  return {
+    format: KVM_FORMAT,
+    version: KVM_VERSION,
+    layer: "KVM",
+    sourceFormat: object.format,
+    relation,
+    entry,
+    inputPattern: entryFunc.inputPattern,
+    outputPattern: entryFunc.outputPattern,
+    isConverged: entryFunc.isConverged,
+    functions,
+    kir
+  };
+}
+
+export function checkEnvelopeCompatibility(targetPattern, inputPattern) {
+  if (!targetPattern || targetPattern.length === 0) return inputPattern;
+  if (!inputPattern || inputPattern.length === 0) return targetPattern;
+
+  const [targetKind, targetEdges] = targetPattern[0];
+  const [inputKind, inputEdges] = inputPattern[0];
+
+  if (targetKind === "any") {
+    return inputPattern;
+  }
+
+  if (targetKind === "open-product" || targetKind === "closed-product") {
+    if (inputKind !== "open-product" && inputKind !== "closed-product") {
+      throw new TypeError(`Type Error: expected product envelope, got ${inputKind}`);
+    }
+    const inputLabels = new Set(inputEdges.map(([label]) => label));
+    const missing = targetEdges.filter(([label]) => !inputLabels.has(label));
+    if (missing.length > 0) {
+      throw new TypeError(`Type Error: input product missing required fields: ${missing.map(([l]) => l).join(", ")}`);
+    }
+    if (targetKind === "closed-product" && inputKind === "closed-product") {
+      if (inputEdges.length !== targetEdges.length) {
+        throw new TypeError(`Type Error: closed product field mismatch`);
+      }
+    }
+    return inputPattern;
+  }
+
+  if (targetKind === "open-union" || targetKind === "closed-union") {
+    if (inputKind !== "open-union" && inputKind !== "closed-union") {
+      throw new TypeError(`Type Error: expected union envelope, got ${inputKind}`);
+    }
+    const targetTags = new Set(targetEdges.map(([tag]) => tag));
+    const unhandled = inputEdges.filter(([tag]) => !targetTags.has(tag));
+    if (unhandled.length > 0) {
+      throw new TypeError(`Type Error: unhandled variant tags: ${unhandled.map(([t]) => t).join(", ")}`);
+    }
+    return inputPattern;
+  }
+
+  try {
+    return intersectPropertyListPatterns(targetPattern, inputPattern);
+  } catch (err) {
+    throw new TypeError(`Type Error: input envelope does not match function's input pattern: ${err.message}`);
+  }
+}
+
+export function specializeKVM(artifactOrFunc, inputEnvelope, options = {}) {
+  let inputPattern = inputEnvelope;
+  if (inputEnvelope && isValue(inputEnvelope)) {
+    inputPattern = inputEnvelope.pattern;
+  }
+  if (inputPattern && !Array.isArray(inputPattern) && typeof inputPattern.toPropertyList === "function") {
+    inputPattern = inputPattern.toPropertyList();
+  }
+  if (!Array.isArray(inputPattern) || inputPattern.length === 0) {
+    throw new Error("specializeKVM requires a valid input envelope pattern property list");
+  }
+
+  const isArtifact = artifactOrFunc && typeof artifactOrFunc === "object" && artifactOrFunc.format === KVM_FORMAT;
+  const targetFunc = isArtifact ? artifactOrFunc.functions[artifactOrFunc.entry] : artifactOrFunc;
+  if (!targetFunc || !Array.isArray(targetFunc.body)) {
+    throw new Error("specializeKVM requires a valid kVM function or artifact");
+  }
+
+  // 1. Boundary Type Check & Pattern Intersection
+  let specializedInputPattern;
+  if (targetFunc.inputPattern) {
+    specializedInputPattern = checkEnvelopeCompatibility(targetFunc.inputPattern, inputPattern);
+  } else {
+    specializedInputPattern = inputPattern;
+  }
+
+  function specializeInstructionList(instructions, initialEnv) {
+    const regPatterns = new Map(initialEnv);
+    const specialized = [];
+
+    for (const inst of instructions) {
+      switch (inst.op) {
+        case "id": {
+          const srcPattern = regPatterns.get(inst.src);
+          if (srcPattern) regPatterns.set(inst.dest, srcPattern);
+          specialized.push({ ...inst });
+          break;
+        }
+        case "fail": {
+          specialized.push({ ...inst });
+          break;
+        }
+        case "project_field": {
+          const srcPattern = regPatterns.get(inst.src);
+          let fieldPattern = null;
+          if (srcPattern) {
+            fieldPattern = edgeSubpattern(srcPattern, inst.label);
+            if (fieldPattern) regPatterns.set(inst.dest, fieldPattern);
+          }
+          specialized.push({
+            ...inst,
+            pattern: fieldPattern || inst.pattern
+          });
+          break;
+        }
+        case "project_variant": {
+          const srcPattern = regPatterns.get(inst.src);
+          let variantPattern = null;
+          if (srcPattern) {
+            variantPattern = edgeSubpattern(srcPattern, inst.tag);
+            if (variantPattern) regPatterns.set(inst.dest, variantPattern);
+          }
+          specialized.push({
+            ...inst,
+            pattern: variantPattern || inst.pattern
+          });
+          break;
+        }
+        case "make_variant": {
+          const srcPattern = regPatterns.get(inst.src);
+          if (srcPattern) {
+            const vp = composePattern("closed-union", [[inst.tag, srcPattern]]);
+            regPatterns.set(inst.dest, vp);
+          }
+          specialized.push({ ...inst });
+          break;
+        }
+        case "guard_pattern": {
+          const srcPattern = regPatterns.get(inst.src);
+          if (srcPattern && inst.pattern) {
+            try {
+              const intersected = checkEnvelopeCompatibility(inst.pattern, srcPattern);
+              if (JSON.stringify(intersected) === JSON.stringify(srcPattern)) {
+                // Redundant guard: pattern is already satisfied
+                specialized.push({ op: "id", dest: inst.dest, src: inst.src });
+                regPatterns.set(inst.dest, srcPattern);
+                break;
+              } else {
+                regPatterns.set(inst.dest, intersected);
+                specialized.push({ ...inst, pattern: intersected });
+                break;
+              }
+            } catch {
+              // Disjoint guard: can never succeed
+              specialized.push({ op: "fail", dest: inst.dest });
+              break;
+            }
+          }
+          specialized.push({ ...inst });
+          break;
+        }
+        case "guard_code": {
+          const srcPattern = regPatterns.get(inst.src);
+          if (srcPattern) regPatterns.set(inst.dest, srcPattern);
+          specialized.push({ ...inst });
+          break;
+        }
+        case "product": {
+          const srcPattern = regPatterns.get(inst.src);
+          const specializedBranches = [];
+          const fieldEntries = [];
+
+          for (const branch of inst.branches) {
+            const branchEnv = new Map(regPatterns);
+            branchEnv.set("%in", srcPattern);
+            const { body: branchBody, returnPattern } = specializeInstructionList(branch.body, branchEnv);
+            specializedBranches.push({
+              label: branch.label,
+              body: branchBody
+            });
+            if (returnPattern) {
+              fieldEntries.push([branch.label, returnPattern]);
+            }
+          }
+
+          let productPattern = null;
+          if (fieldEntries.length === inst.branches.length) {
+            fieldEntries.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+            specializedBranches.sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0));
+            productPattern = composePattern("closed-product", fieldEntries);
+            regPatterns.set(inst.dest, productPattern);
+          }
+
+          specialized.push({
+            ...inst,
+            branches: specializedBranches,
+            pattern: productPattern || inst.pattern
+          });
+          break;
+        }
+        case "union": {
+          const srcPattern = regPatterns.get(inst.src);
+          const specializedBranches = [];
+          let unionResultPattern = null;
+
+          for (let i = 0; i < inst.branches.length; i++) {
+            const branch = inst.branches[i];
+            const branchEnv = new Map(regPatterns);
+            branchEnv.set("%in", srcPattern);
+
+            // Dead branch check: if branch begins with project_variant for tag not in srcPattern
+            const firstInst = branch.body?.[0];
+            if (firstInst?.op === "project_variant" && srcPattern) {
+              const tagPattern = edgeSubpattern(srcPattern, firstInst.tag);
+              if (srcPattern[0]?.[0]?.endsWith("union") && !tagPattern) {
+                continue;
+              }
+            }
+
+            const { body: branchBody, returnPattern } = specializeInstructionList(branch.body, branchEnv);
+            if (branchBody.length > 0 && branchBody[0].op === "fail") {
+              continue;
+            }
+
+            specializedBranches.push({
+              label: branch.label,
+              body: branchBody
+            });
+
+            if (returnPattern && !unionResultPattern) {
+              unionResultPattern = returnPattern;
+            }
+          }
+
+          if (unionResultPattern) {
+            regPatterns.set(inst.dest, unionResultPattern);
+          }
+
+          specialized.push({
+            ...inst,
+            branches: specializedBranches
+          });
+          break;
+        }
+        case "call": {
+          specialized.push({ ...inst });
+          break;
+        }
+        case "call_intrinsic": {
+          specialized.push({ ...inst });
+          break;
+        }
+        case "return": {
+          const retPattern = regPatterns.get(inst.src);
+          specialized.push({ ...inst });
+          return { body: specialized, returnPattern: retPattern };
+        }
+        default:
+          specialized.push({ ...inst });
+      }
+    }
+    return { body: specialized, returnPattern: regPatterns.get("%out") };
+  }
+
+  const { body: specializedBody, returnPattern } = specializeInstructionList(
+    targetFunc.body,
+    new Map([["%in", specializedInputPattern]])
+  );
+
+  const derivedOutputPattern = returnPattern || targetFunc.outputPattern;
+
+  const specializedFunc = {
+    name: `${targetFunc.name}__spec`,
+    inputPattern: specializedInputPattern,
+    outputPattern: derivedOutputPattern,
+    isConverged: true,
+    isSpecialized: true,
+    body: specializedBody
+  };
+
+  if (isArtifact) {
+    return {
+      ...artifactOrFunc,
+      layer: "KVM-M",
+      isPolymorphic: false,
+      isSpecialized: true,
+      inputPattern: specializedInputPattern,
+      outputPattern: derivedOutputPattern,
+      functions: {
+        ...artifactOrFunc.functions,
+        [specializedFunc.name]: specializedFunc
+      },
+      entry: specializedFunc.name
+    };
+  }
+
+  return specializedFunc;
+}
+
+const TAIL_CALL = Symbol("TAIL_CALL");
+
+function tailValueAfter(insts, startIndex, valueReg) {
+  let current = valueReg;
+  for (let i = startIndex; i < insts.length; i++) {
+    const inst = insts[i];
+    if (inst.op === "guard_pattern" || inst.op === "guard_code" || inst.op === "id") {
+      if (inst.src !== current) return false;
+      current = inst.dest;
+      continue;
+    }
+    if (inst.op === "return" && inst.src === current) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+
+function executeBlock(instructions, inputVal, context, isTail = false) {
   const registers = new Map();
   registers.set("%in", inputVal);
 
-  for (const inst of instructions) {
-    const res = executeInstruction(inst, registers, context);
+  for (let i = 0; i < instructions.length; i++) {
+    const inst = instructions[i];
+    const res = executeInstruction(inst, registers, context, instructions, i, isTail);
     if (res === undefined) {
       return undefined;
     }
+    if (res && res[TAIL_CALL]) {
+      return res;
+    }
     if (res.type === "return") {
       return res.value;
     }
@@ -276,7 +762,7 @@ function executeBlock(instructions, inputVal, context) {
   return undefined;
 }
 
-function executeInstruction(inst, registers, context) {
+function executeInstruction(inst, registers, context, instructions = null, instIndex = -1, isTail = false) {
   const options = context.options || {};
   switch (inst.op) {
     case "id": {
@@ -366,7 +852,10 @@ function executeInstruction(inst, registers, context) {
         console.log(`[Trace] Calling ${inst.func} with:`, val ? val.toString() : "null");
       }
       if (!relDef._kvmFunc) {
-        relDef._kvmFunc = lowerToKVM(relDef, inst.func);
+        relDef._kvmFunc = lowerToKVM(relDef, inst.func, { codes: context.codes || {} });
+      }
+      if (!options.trace && isTail && instructions && tailValueAfter(instructions, instIndex + 1, inst.dest)) {
+        return { [TAIL_CALL]: true, func: relDef._kvmFunc, val };
       }
       const res = executeKVM(relDef._kvmFunc, val, context);
       if (options.trace) {
@@ -377,32 +866,14 @@ function executeInstruction(inst, registers, context) {
       return { type: "continue" };
     }
     case "call_intrinsic": {
-      const val = registers.get(inst.src);
-      const builtinFunc = run.builtin[inst.symbol];
-      if (!builtinFunc) {
-        throw new Error(`Unknown builtin: '${inst.symbol}'`);
-      }
-      if (!options.envelopeFree && inst.pattern) {
-        try {
-          const constrained = constrainWithPattern(val, inst.pattern, inst.exp);
-          const res = builtinFunc(constrained);
-          registers.set(inst.dest, res);
-          return { type: "continue" };
-        } catch (err) {
-          throw err;
-        }
-      } else {
-        const res = builtinFunc(val);
-        registers.set(inst.dest, res);
-        return { type: "continue" };
-      }
+      throw unsupportedIntrinsic("kVM interpreter", inst.symbol);
     }
     case "product": {
       const val = registers.get(inst.src);
       const result = {};
       const patternEntries = [];
       for (const branch of inst.branches) {
-        const branchRes = executeBlock(branch.body, val, context);
+        const branchRes = executeBlock(branch.body, val, context, false);
         if (branchRes === undefined) return undefined;
         result[branch.label] = branchRes;
         if (!options.envelopeFree) {
@@ -425,9 +896,16 @@ function executeInstruction(inst, registers, context) {
     }
     case "union": {
       const val = registers.get(inst.src);
-      for (const branch of inst.branches) {
-        const branchRes = executeBlock(branch.body, val, context);
+      const unionIsTail = isTail && instructions && tailValueAfter(instructions, instIndex + 1, inst.dest);
+      for (let i = 0; i < inst.branches.length; i++) {
+        const branch = inst.branches[i];
+        const isLastBranch = i === inst.branches.length - 1;
+        const branchIsTail = unionIsTail && isLastBranch;
+        const branchRes = executeBlock(branch.body, val, context, branchIsTail);
         if (branchRes !== undefined) {
+          if (branchRes && branchRes[TAIL_CALL]) {
+            return branchRes;
+          }
           registers.set(inst.dest, branchRes);
           return { type: "continue" };
         }
@@ -444,22 +922,46 @@ function executeInstruction(inst, registers, context) {
 
 export function executeKVM(kvmFunc, inputVal, context) {
   const options = context.options || {};
-  if (options.requireConverged && !kvmFunc.isConverged) {
-    throw new Error(`Cannot run '${kvmFunc.name}' without envelopes: type derivation is not converged`);
-  }
+  let currentFunc = kvmFunc;
+  let currentVal = inputVal;
+
+  while (true) {
+    if (context.profile) {
+      let name = currentFunc.name || "anon";
+      if (context.hashToName && context.hashToName.has(name)) {
+        name = context.hashToName.get(name);
+      }
+      context.profile[name] = (context.profile[name] || 0) + 1;
+    }
+    if (options.requireConverged && !currentFunc.isConverged) {
+      throw new Error(`Cannot run '${currentFunc.name}' without envelopes: type derivation is not converged`);
+    }
 
-  const result = executeBlock(kvmFunc.body, inputVal, context);
-  if (result === undefined) return undefined;
+    const result = executeBlock(currentFunc.body, currentVal, context, true);
+    if (result === undefined) return undefined;
+    if (result && result[TAIL_CALL]) {
+      currentFunc = result.func;
+      currentVal = result.val;
+      continue;
+    }
 
-  if (options.envelopeFree && kvmFunc.isConverged) {
-    return withPattern(result, kvmFunc.outputPattern);
+    if (options.envelopeFree && currentFunc.isConverged) {
+      return withPattern(result, currentFunc.outputPattern);
+    }
+    return result;
   }
-  return result;
 }
 
 export default {
+  KVM_FORMAT,
+  KVM_VERSION,
   lowerToKVM,
-  executeKVM
+  lowerKIRRelationToKVM,
+  lowerKIRToKVM,
+  executeKVM,
+  isSingletonKVMInputPattern,
+  objectToKVMArtifact,
+  specializeKVM
 };
 
 function usage() {
@@ -521,7 +1023,7 @@ async function main() {
         if (object.main == null) {
           throw new Error("Cannot run a .klib library without a main relation; load it with --lib.");
         }
-        return { kind: "object", defs: { rels: object.rels }, main: object.main };
+        return { kind: "object", object };
       } catch (error) {
         if (error.message === "Cannot run a .klib library without a main relation; load it with --lib.") {
           throw error;
@@ -546,16 +1048,17 @@ async function main() {
     throw new Error(`Unexpected argument: ${args[0]}`);
   }
 
-  const defs = programInput.kind === "object"
-    ? programInput.defs
-    : annotate(programInput.source, { libraries });
-  const mainRelName = programInput.kind === "object" ? programInput.main : "__main__";
-  const mainRel = defs.rels[mainRelName];
+  const object = programInput.kind === "object"
+    ? programInput.object
+    : decodeObject(compileObjectBuffer(programInput.source, { libraries }));
+  const kir = objectToKIRP(object);
+  const mainRelName = kir.main;
+  const mainRel = kir.rels[mainRelName];
   if (!mainRel) {
     throw new Error(`No main relation (${mainRelName}) defined in script`);
   }
 
-  const kvmFunc = lowerToKVM(mainRel, mainRelName);
+  const kvmFunc = lowerKIRRelationToKVM(mainRel, mainRelName, { codes: kir.codes });
 
   const buffer = [];
   inputStream.on("data", (data) => buffer.push(Buffer.isBuffer(data) ? data : Buffer.from(data)));
@@ -564,8 +1067,9 @@ async function main() {
       const inputBuffer = Buffer.concat(buffer);
       const { pattern: inputPattern, value } = decodeWire(inputBuffer);
       const context = {
-        rels: defs.rels,
-        findCode: codes.find,
+        rels: kir.rels,
+        codes: kir.codes,
+        findCode: kirFindCode(kir),
         options: {
           envelopeFree
         }