@fraczak/k 6.5.0 → 6.7.0

package/backends/llvm/src/kvm2llvm.mjs

@@ -53,6 +53,7 @@ export function runtimeDeclarations() {
     "",
     "declare %k_rt_mark @k_rt_mark(ptr)",
     "declare void @k_rt_rewind(ptr, %k_rt_mark)",
+    "declare ptr @k_rt_compact(ptr, ptr, ptr)",
     "declare ptr @k_rt_alloc(ptr, i64)",
     "declare ptr @k_unit(ptr)",
     "declare ptr @k_bit0(ptr)",
@@ -146,10 +147,11 @@ function lowerRawVariant(ctx, tag, payload) {
   return variant;
 }
 
-function lowerProductGetAt(ctx, input, edgeIndex) {
+function lowerProductGetAt(ctx, input, edgeIndex, label = null) {
   const nonNullBlock = ctx.blockName("product_non_null");
   const productBlock = ctx.blockName("product_kind");
   const fieldBlock = ctx.blockName("product_field");
+  const fallbackBlock = ctx.blockName("product_fallback");
   const missingBlock = ctx.blockName("product_missing");
   const doneBlock = ctx.blockName("product_done");
   const isMissing = ctx.tempName("product_is_missing");
@@ -172,16 +174,38 @@ function lowerProductGetAt(ctx, input, edgeIndex) {
   const fields = loadPtrAt(ctx, input, K_VALUE_PRODUCT_FIELDS_OFFSET, "product_fields_ptr");
   const slot = bytePtr(ctx, fields, edgeIndex * K_FIELD_SIZE, "field_slot");
   const value = loadPtrAt(ctx, slot, K_FIELD_VALUE_OFFSET, "field");
-  ctx.lines.push(`  br label %${doneBlock}`);
 
-  ctx.lines.push(`${missingBlock}:`);
-  ctx.lines.push(`  br label %${doneBlock}`);
+  if (label) {
+    const fLabel = loadPtrAt(ctx, slot, K_FIELD_LABEL_OFFSET, "field_label");
+    const labelMatch = ctx.tempName("label_match");
+    ctx.lines.push(`  ${labelMatch} = icmp eq ptr ${fLabel}, ${label.pointer}`);
+    ctx.lines.push(`  br i1 ${labelMatch}, label %${doneBlock}, label %${fallbackBlock}`);
+
+    ctx.lines.push(`${fallbackBlock}:`);
+    const fallbackVal = ctx.tempName("fallback_field");
+    ctx.lines.push(`  ${fallbackVal} = call ptr @k_product_get_n(ptr ${input}, ptr ${label.pointer}, i64 ${label.length})`);
+    ctx.lines.push(`  br label %${doneBlock}`);
+
+    ctx.lines.push(`${missingBlock}:`);
+    ctx.lines.push(`  br label %${doneBlock}`);
+
+    ctx.lines.push(`${doneBlock}:`);
+    const resultValue = ctx.tempName("field_value");
+    ctx.lines.push(`  ${resultValue} = phi ptr [${value}, %${fieldBlock}], [${fallbackVal}, %${fallbackBlock}], [null, %${missingBlock}]`);
+    ctx.currentBlock = doneBlock;
+    return resultValue;
+  } else {
+    ctx.lines.push(`  br label %${doneBlock}`);
 
-  ctx.lines.push(`${doneBlock}:`);
-  const resultValue = ctx.tempName("field_value");
-  ctx.lines.push(`  ${resultValue} = phi ptr [${value}, %${fieldBlock}], [null, %${missingBlock}]`);
-  ctx.currentBlock = doneBlock;
-  return resultValue;
+    ctx.lines.push(`${missingBlock}:`);
+    ctx.lines.push(`  br label %${doneBlock}`);
+
+    ctx.lines.push(`${doneBlock}:`);
+    const resultValue = ctx.tempName("field_value");
+    ctx.lines.push(`  ${resultValue} = phi ptr [${value}, %${fieldBlock}], [null, %${missingBlock}]`);
+    ctx.currentBlock = doneBlock;
+    return resultValue;
+  }
 }
 
 function lowerVariantMatchBranch(ctx, input, label, matchBlock, mismatchBlock) {
@@ -287,6 +311,56 @@ function lowerRtRewind(ctx, mark) {
   ctx.currentBlock = doneBlock;
 }
 
+function lowerRtCompact(ctx, val, tailMarkSlot = "%tail_mark_slot") {
+  const curBlock = loadPtrAt(ctx, "%rt", K_RT_BLOCKS_OFFSET, "cur_block");
+  const hasBlock = ctx.tempName("has_block");
+  const markBlockPtr = ctx.tempName("mark_block_ptr");
+  ctx.lines.push(`  ${hasBlock} = icmp ne ptr ${curBlock}, null`);
+  ctx.lines.push(`  ${markBlockPtr} = getelementptr inbounds %k_rt_mark, ptr ${tailMarkSlot}, i32 0, i32 0`);
+  const markBlock = ctx.tempName("mark_block");
+  ctx.lines.push(`  ${markBlock} = load ptr, ptr ${markBlockPtr}`);
+
+  const diffBlock = ctx.tempName("diff_block");
+  ctx.lines.push(`  ${diffBlock} = icmp ne ptr ${curBlock}, ${markBlock}`);
+  const needCheck = ctx.tempName("need_growth_check");
+  ctx.lines.push(`  ${needCheck} = and i1 ${hasBlock}, ${diffBlock}`);
+
+  const checkGrowthBlock = ctx.blockName("check_growth");
+  const doCompactBlock = ctx.blockName("do_compact");
+  const doneBlock = ctx.blockName("compact_done");
+
+  ctx.lines.push(`  br i1 ${needCheck}, label %${doCompactBlock}, label %${checkGrowthBlock}`);
+
+  ctx.lines.push(`${checkGrowthBlock}:`);
+  const checkBlockHasBlock = ctx.tempName("check_has_block");
+  ctx.lines.push(`  ${checkBlockHasBlock} = icmp ne ptr ${curBlock}, null`);
+  const loadGrowthBlock = ctx.blockName("load_growth");
+  ctx.lines.push(`  br i1 ${checkBlockHasBlock}, label %${loadGrowthBlock}, label %${doneBlock}`);
+
+  ctx.lines.push(`${loadGrowthBlock}:`);
+  const curUsed = loadI64At(ctx, curBlock, K_ARENA_BLOCK_USED_OFFSET, "cur_used");
+  const markUsedPtr = ctx.tempName("mark_used_ptr");
+  ctx.lines.push(`  ${markUsedPtr} = getelementptr inbounds %k_rt_mark, ptr ${tailMarkSlot}, i32 0, i32 1`);
+  const markUsed = ctx.tempName("mark_used");
+  ctx.lines.push(`  ${markUsed} = load i64, ptr ${markUsedPtr}`);
+  const growth = ctx.tempName("arena_growth");
+  ctx.lines.push(`  ${growth} = sub i64 ${curUsed}, ${markUsed}`);
+  const threshExceeded = ctx.tempName("thresh_exceeded");
+  ctx.lines.push(`  ${threshExceeded} = icmp ugt i64 ${growth}, 4194304`);
+  ctx.lines.push(`  br i1 ${threshExceeded}, label %${doCompactBlock}, label %${doneBlock}`);
+
+  ctx.lines.push(`${doCompactBlock}:`);
+  const compacted = ctx.tempName("compacted");
+  ctx.lines.push(`  ${compacted} = call ptr @k_rt_compact(ptr %rt, ptr ${val}, ptr ${tailMarkSlot})`);
+  ctx.lines.push(`  br label %${doneBlock}`);
+
+  ctx.lines.push(`${doneBlock}:`);
+  const finalVal = ctx.tempName("compact_res");
+  ctx.lines.push(`  ${finalVal} = phi ptr [${val}, %${checkGrowthBlock}], [${val}, %${loadGrowthBlock}], [${compacted}, %${doCompactBlock}]`);
+  ctx.currentBlock = doneBlock;
+  return finalVal;
+}
+
 function nullCheck(ctx, val, failTarget) {
   const isMissing = ctx.tempName("missing");
   const okBlock = ctx.blockName("nonnull");
@@ -322,7 +396,8 @@ function statusCheck(ctx, callResult, failTarget = "func_fail") {
   if (ctx.catchTail) {
     const tailInput = ctx.tempName("tail_arg");
     ctx.lines.push(`  ${tailInput} = extractvalue %k_result ${callResult}, 1`);
-    ctx.lines.push(`  store ptr ${tailInput}, ptr %tail_input_slot`);
+    const compacted = lowerRtCompact(ctx, tailInput, "%tail_mark_slot");
+    ctx.lines.push(`  store ptr ${compacted}, ptr %tail_input_slot`);
     ctx.lines.push("  br label %tail_loop");
   } else {
     ctx.lines.push(`  ret %k_result ${callResult}`);
@@ -366,8 +441,7 @@ function hasSelfTailCall(insts, funcName, isTail = true) {
     if (inst.branches) {
       const unionIsTail = isTail && tailValueAfter(insts, i + 1, inst.dest);
       for (let bIdx = 0; bIdx < inst.branches.length; bIdx++) {
-        const isLast = (bIdx === inst.branches.length - 1);
-        if (hasSelfTailCall(inst.branches[bIdx].body, funcName, unionIsTail && isLast)) return true;
+        if (hasSelfTailCall(inst.branches[bIdx].body, funcName, unionIsTail)) return true;
       }
     }
   }
@@ -384,13 +458,6 @@ function getFieldEdgeIndex(inst, regPatterns, kvmFunc) {
       if (idx >= 0) return idx;
     }
   }
-  if (Array.isArray(inst.pattern) && inst.pattern.length > 0) {
-    const root = inst.pattern[0];
-    if ((root[0] === "open-product" || root[0] === "closed-product") && Array.isArray(root[1])) {
-      const idx = root[1].findIndex(([l]) => l === inst.label);
-      if (idx >= 0) return idx;
-    }
-  }
   return -1;
 }
 
@@ -538,7 +605,11 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
 
   if (isCatchTail) {
     ctx.allocas.push("  %tail_input_slot = alloca ptr");
+    ctx.allocas.push("  %tail_mark_slot = alloca %k_rt_mark");
     ctx.lines.push("  store ptr %input, ptr %tail_input_slot");
+    const initMark = ctx.tempName("init_mark");
+    ctx.lines.push(`  ${initMark} = call %k_rt_mark @k_rt_mark(ptr %rt)`);
+    ctx.lines.push(`  store %k_rt_mark ${initMark}, ptr %tail_mark_slot`);
     ctx.lines.push("  br label %tail_loop");
     ctx.lines.push("tail_loop:");
     ctx.lines.push("  %tail_input = load ptr, ptr %tail_input_slot");
@@ -598,17 +669,13 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const input = getReg(inst.src);
           nullCheck(ctx, input, failTarget);
           const edgeIndex = getFieldEdgeIndex(inst, regPatterns, kvmFunc);
+          const label = ctx.labelRef(inst.label);
           let val;
           if (edgeIndex >= 0 && ctx.runtimeMode !== "compact") {
-            val = lowerProductGetAt(ctx, input, edgeIndex);
+            val = lowerProductGetAt(ctx, input, edgeIndex, label);
           } else {
-            const label = ctx.labelRef(inst.label);
             val = ctx.tempName("field");
-            if (edgeIndex >= 0) {
-              ctx.lines.push(`  ${val} = call ptr @k_product_get_at(ptr ${input}, i64 ${edgeIndex})`);
-            } else {
-              ctx.lines.push(`  ${val} = call ptr @k_product_get_n(ptr ${input}, ptr ${label.pointer}, i64 ${label.length})`);
-            }
+            ctx.lines.push(`  ${val} = call ptr @k_product_get_n(ptr ${input}, ptr ${label.pointer}, i64 ${label.length})`);
           }
           nullCheck(ctx, val, failTarget);
           regValues.set(cleanReg(inst.dest), val);
@@ -656,7 +723,8 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const v = getReg(inst.src);
           if (isSelfTailCall(insts, i, tailRef)) {
             if (ctx.catchTail) {
-              ctx.lines.push(`  store ptr ${v}, ptr %tail_input_slot`);
+              const compacted = lowerRtCompact(ctx, v, "%tail_mark_slot");
+              ctx.lines.push(`  store ptr ${compacted}, ptr %tail_input_slot`);
               ctx.lines.push("  br label %tail_loop");
               return;
             } else {
@@ -689,6 +757,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const fieldValues = [];
           const pSrc = getReg(inst.src);
           const pPattern = regPatterns.get(cleanReg(inst.src)) || (cleanReg(inst.src) === "in" ? regPatterns.get("in") : null);
+          let productFailed = false;
 
           for (let bIdx = 0; bIdx < N; bIdx++) {
             const branch = inst.branches[bIdx];
@@ -715,12 +784,21 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
               nextBlock: branchDone
             });
 
+            if (!branchRegValues.has(cleanReg(branchRes))) {
+              productFailed = true;
+              break;
+            }
+
             ctx.lines.push(`${branchDone}:`);
             ctx.currentBlock = branchDone;
-            const fVal = branchRegValues.get(cleanReg(branchRes)) || branchRes;
+            const fVal = branchRegValues.get(cleanReg(branchRes));
             fieldValues.push({ label: branch.label, val: fVal });
           }
 
+          if (productFailed) {
+            break;
+          }
+
           const requestedSize = K_PRODUCT_HEADER_SIZE + (K_FIELD_SIZE * N);
           const product = lowerRawAlloc(ctx, requestedSize, alignArenaSize(requestedSize));
           nullCheck(ctx, product, failTarget);
@@ -796,7 +874,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
               outputPattern: kvmFunc.outputPattern,
               body: branch.body
             };
-            const armTailRef = (isLast && tailValueAfter(insts, i + 1, inst.dest)) ? tailRef : null;
+            const armTailRef = tailValueAfter(insts, i + 1, inst.dest) ? tailRef : null;
             const armBody = lowerKVMFunction(armFunc, armName, armFunc.name, moduleCtx, "internal", { ...options, tailRef: armTailRef });
             moduleCtx.syntheticFunctions.push(armBody);
 
@@ -818,7 +896,8 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
             if (ctx.catchTail) {
               const tailArg = ctx.tempName("arm_tail_arg");
               ctx.lines.push(`  ${tailArg} = extractvalue %k_result ${armCall}, 1`);
-              ctx.lines.push(`  store ptr ${tailArg}, ptr %tail_input_slot`);
+              const compacted = lowerRtCompact(ctx, tailArg, "%tail_mark_slot");
+              ctx.lines.push(`  store ptr ${compacted}, ptr %tail_input_slot`);
               ctx.lines.push("  br label %tail_loop");
             } else {
               ctx.lines.push(`  ret %k_result ${armCall}`);

package/backends/llvm/tests/integration.sh

@@ -10,8 +10,7 @@ command -v clang >/dev/null || {
 }
 
 node ../../objects/compile.mjs '()' "$TMP_DIR/id.ko"
-printf '[["open-product",[]]]' > "$TMP_DIR/input.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/input.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/id.ko" "$TMP_DIR/id.ll"
 grep -q '@k_llvm_metadata' "$TMP_DIR/id.ll"
 grep -q 'define %k_result @k_main' "$TMP_DIR/id.ll"
 
@@ -19,32 +18,28 @@ clang -Wno-override-module -Iruntime runtime/krt.c tests/identity-driver.c "$TMP
 "$TMP_DIR/id"
 
 node ../../objects/compile.mjs '.x' "$TMP_DIR/projection.ko"
-printf '[["closed-product",[["x",1]]],["closed-product",[]]]' > "$TMP_DIR/projection.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/projection.pattern.json" "$TMP_DIR/projection.ko" "$TMP_DIR/projection.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/projection.ko" "$TMP_DIR/projection.ll"
 grep -q 'product_fields_ptr' "$TMP_DIR/projection.ll"
 ! grep -q 'call ptr @k_product_get_at' "$TMP_DIR/projection.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/projection-driver.c "$TMP_DIR/projection.ll" -o "$TMP_DIR/projection"
 "$TMP_DIR/projection"
 
 node ../../objects/compile.mjs '{ .x fieldA, .y fieldB }' "$TMP_DIR/product.ko"
-printf '[["closed-product",[["x",1],["y",2]]],["closed-product",[["valA",1]]],["closed-product",[["valB",2]]]]' > "$TMP_DIR/product.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/product.pattern.json" "$TMP_DIR/product.ko" "$TMP_DIR/product.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/product.ko" "$TMP_DIR/product.ll"
 grep -q 'store i32 1, ptr %i32_slot' "$TMP_DIR/product.ll"
 grep -q 'store ptr %product_fields' "$TMP_DIR/product.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/product-driver.c "$TMP_DIR/product.ll" -o "$TMP_DIR/product"
 "$TMP_DIR/product"
 
 node ../../objects/compile.mjs '|tag' "$TMP_DIR/variant.ko"
-printf '[["closed-product",[]]]' > "$TMP_DIR/variant.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/variant.pattern.json" "$TMP_DIR/variant.ko" "$TMP_DIR/variant.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/variant.ko" "$TMP_DIR/variant.ll"
 grep -q 'call ptr @k_rt_alloc' "$TMP_DIR/variant.ll"
 grep -q 'store i32 2, ptr %i32_slot' "$TMP_DIR/variant.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/variant-driver.c "$TMP_DIR/variant.ll" -o "$TMP_DIR/variant"
 "$TMP_DIR/variant"
 
 node ../../objects/compile.mjs '/tag' "$TMP_DIR/variant-projection.ko"
-printf '[["closed-union",[["tag",1]]],["closed-product",[]]]' > "$TMP_DIR/variant-projection.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/variant-projection.pattern.json" "$TMP_DIR/variant-projection.ko" "$TMP_DIR/variant-projection.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/variant-projection.ko" "$TMP_DIR/variant-projection.ll"
 grep -q 'tag_byte_ptr' "$TMP_DIR/variant-projection.ll"
 grep -q 'payload_slot' "$TMP_DIR/variant-projection.ll"
 ! grep -q 'call i32 @k_variant_tag_matches' "$TMP_DIR/variant-projection.ll"
@@ -53,24 +48,21 @@ clang -Wno-override-module -Iruntime runtime/krt.c tests/variant-projection-driv
 "$TMP_DIR/variant-projection"
 
 node ../../objects/compile.mjs '(.x .y)' "$TMP_DIR/composition.ko"
-printf '[["closed-product",[["x",1]]],["closed-product",[["y",2]]],["closed-product",[]]]' > "$TMP_DIR/composition.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/composition.pattern.json" "$TMP_DIR/composition.ko" "$TMP_DIR/composition.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/composition.ko" "$TMP_DIR/composition.ll"
 grep -q 'product_fields_ptr' "$TMP_DIR/composition.ll"
 ! grep -q 'call ptr @k_product_get_at' "$TMP_DIR/composition.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/composition-driver.c "$TMP_DIR/composition.ll" -o "$TMP_DIR/composition"
 "$TMP_DIR/composition"
 
 node ../../objects/compile.mjs 'pick = .x; {.a pick left, .b pick right}' "$TMP_DIR/relation.ko"
-printf '[["open-product",[["a",1],["b",2]]],["open-product",[["x",3]]],["open-product",[["x",4]]],["closed-product",[]],["closed-product",[]]]' > "$TMP_DIR/relation.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/relation.pattern.json" "$TMP_DIR/relation.ko" "$TMP_DIR/relation.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/relation.ko" "$TMP_DIR/relation.ll"
 grep -q 'define internal %k_result @k_rel_pick' "$TMP_DIR/relation.ll"
 grep -q 'call %k_result @k_rel_pick' "$TMP_DIR/relation.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/relation-driver.c "$TMP_DIR/relation.ll" -o "$TMP_DIR/relation"
 "$TMP_DIR/relation"
 
 node ../../objects/compile.mjs '< /x |left, /y |right >' "$TMP_DIR/union.ko"
-printf '[["closed-union",[["x",1],["y",2]]],["closed-product",[]],["closed-product",[]]]' > "$TMP_DIR/union.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/union.pattern.json" "$TMP_DIR/union.ko" "$TMP_DIR/union.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/union.ko" "$TMP_DIR/union.ll"
 grep -q 'define internal %k_result @k_union_arm_0' "$TMP_DIR/union.ll"
 grep -q 'call %k_result @k_union_arm_1' "$TMP_DIR/union.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/union-driver.c "$TMP_DIR/union.ll" -o "$TMP_DIR/union"
@@ -94,8 +86,7 @@ node ../../objects/compile.mjs '{ .x fieldA, .y fieldB }' "$TMP_DIR/run-product.
 printf '{"x":"left","y":"right"}' > "$TMP_DIR/run-product-input.kv"
 node ./bin/k-llvm-run.mjs "$TMP_DIR/run-product.ko" "$TMP_DIR/run-product-input.kv" | grep -qx '{"fieldA":"left","fieldB":"right"}'
 
-printf '[["closed-product",[["x",1],["y",3]]],["open-union",[["left",2]]],["closed-product",[]],["open-union",[["right",2]]]]' > "$TMP_DIR/run-envelope.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/run-envelope.pattern.json" "$TMP_DIR/run.ko" "$TMP_DIR/run-exe"
+node ./bin/k-llvm-build.mjs '?{<{}=X0 left, ...> x, <X0 right, ...> y} .x' -o "$TMP_DIR/run-exe"
 printf '{"x":"left","y":"right"}' \
   | node ../../codecs/k-parse.mjs \
   | "$TMP_DIR/run-exe" \
@@ -104,15 +95,13 @@ printf '{"x":"left","y":"right"}' \
 
 printf '{"x":"left"}' | node ../../codecs/k-parse.mjs | "$TMP_DIR/run-exe" && exit 1 || test "$?" -eq 5
 
-printf '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]' > "$TMP_DIR/identity-variant.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/identity-variant.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id-exe"
+node ./bin/k-llvm-build.mjs '?<{} left, {} right, ...>' -o "$TMP_DIR/id-exe"
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const pattern = [[\"open-union\",[[\"left\",1],[\"right\",1]]],[\"closed-product\",[]]]; stdout.write(encodeToWire(Value.variant(\"left\", Value.product({}), pattern), pattern));" \
   | "$TMP_DIR/id-exe" \
   | node --input-type=module -e "import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; stdin.on('data', (chunk) => chunks.push(chunk)); stdin.on('end', () => console.log(JSON.stringify(decodeWire(Buffer.concat(chunks)).pattern)));" \
   | grep -Fqx '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]'
 
-printf '[["closed-union",[["+",1],["-",1]]],["closed-union",[["0",1],["1",1],["_",2]]],["closed-product",[]]]' > "$TMP_DIR/identity-int.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/identity-int.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id-int-exe"
+node ./bin/k-llvm-build.mjs '$bits = < {} _, bits 0, bits 1 >; $int = < bits "+", bits "-" >; $int' -o "$TMP_DIR/id-int-exe"
 printf '2' \
   | node ../../codecs/int.mjs --parse \
   | "$TMP_DIR/id-int-exe" \
@@ -121,6 +110,13 @@ printf '2' \
 
 node --input-type=module -e "import assert from 'node:assert/strict'; import { spawn } from 'node:child_process'; import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; import { parse, INT_PATTERN } from '../../codecs/int.mjs'; const input = encodeToWire(parse('2'), INT_PATTERN); const header = Buffer.alloc(4); header.writeUInt32BE(input.length); const child = spawn(process.argv[1], ['--server']); const chunks = []; const stderr = []; child.stdout.on('data', (chunk) => chunks.push(chunk)); child.stderr.on('data', (chunk) => stderr.push(chunk)); child.stdin.end(Buffer.concat([header, input])); const status = await new Promise((resolve, reject) => { child.on('error', reject); child.on('close', resolve); }); assert.equal(status, 0, Buffer.concat(stderr).toString('utf8')); const output = Buffer.concat(chunks); const length = output.readUInt32BE(0); assert.equal(output.length, 4 + length); assert.deepEqual(decodeWire(output.subarray(4)).value.toJSON(), parse('2').toJSON());" "$TMP_DIR/id-int-exe"
 
+node ./bin/k-llvm-build.mjs --lib ../../Examples/arithmetics.k --export times 's = {()x, ()y} times; s' -o "$TMP_DIR/square-exe"
+printf '987654321' \
+  | node ../../codecs/int.mjs --parse \
+  | "$TMP_DIR/square-exe" \
+  | node ../../codecs/int.mjs --print \
+  | grep -qx '975461057789971041'
+
 printf '{"x":"left","y":"right"}' \
   | node ../../codecs/k-parse.mjs \
   | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/run.ko" \

package/backends/llvm/tests/perf-support.mjs

@@ -33,7 +33,7 @@ function sha256(text) {
 function backendFingerprint() {
   if (cachedBackendFingerprint != null) return cachedBackendFingerprint;
   const hash = crypto.createHash("sha256");
-  for (const relPath of ["src/llvm.mjs", "src/executable.mjs", "runtime/krt.c", "runtime/krt.h"]) {
+  for (const relPath of ["src/llvm.mjs", "src/kvm2llvm.mjs", "src/executable.mjs", "runtime/krt.c", "runtime/krt.h"]) {
     hash.update(relPath);
     hash.update("\0");
     hash.update(fs.readFileSync(path.join(root, relPath)));

package/backends/wasm/bin/k-wasm-compile.mjs

@@ -20,6 +20,7 @@ function usage(stream = console.error) {
   stream("  wasm-file       Output .wasm path. Writes the binary artifact to stdout when omitted.");
   stream("");
   stream("Options:");
+  stream("  -o, --output     Specify output file path explicitly.");
   stream("  --lib file       Load one .klib dependency before compiling.");
   stream("  --export spec    Export a library alias into source scope. May be repeated.");
   stream("                   spec is 'name' or 'libname:localname'.");
@@ -33,10 +34,24 @@ try {
     exit(0);
   }
 
-  const { libraries, exportSpecs } = parseCompileOptions(args);
-  const input = resolveProgramInput(args, { allowStdinSource: true });
-  const outputPath = args.shift();
-  if (args.length > 0) throw new Error("Too many arguments");
+  let explicitOutput = null;
+  const remainingArgs = [];
+  while (args.length > 0) {
+    const arg = args[0];
+    if (arg === "-o" || arg === "--output") {
+      args.shift();
+      explicitOutput = args.shift();
+      if (!explicitOutput) throw new Error("-o/--output requires a file argument");
+    } else {
+      remainingArgs.push(args.shift());
+    }
+  }
+
+  const { libraries, exportSpecs } = parseCompileOptions(remainingArgs);
+  const input = resolveProgramInput(remainingArgs, { allowStdinSource: true });
+  const positionalOutput = remainingArgs.shift();
+  if (remainingArgs.length > 0) throw new Error("Too many arguments");
+  const outputPath = explicitOutput || positionalOutput || null;
   const artifact = await compileProgramInput(input, { libraries, exportSpecs, stdin });
   if (outputPath == null) {
     stdout.write(artifact);

package/browser/repl-browser.mjs

@@ -20,6 +20,7 @@ import {
 import { Value, isProduct, isVariant } from "../Value.mjs";
 import { encodeLibrary } from "../object.mjs";
 import { setVfsFile, getVfsFile, getAllVfsFiles } from "./shims/fs.mjs";
+import { createOutputEntryElement } from "./tree-view.mjs";
 
 // Make Value and helpers globally available for custom codecs
 if (typeof window !== "undefined") {
@@ -155,7 +156,7 @@ function setStatus(busy, text = "Ready") {
   }
 }
 
-function appendEntry({ prompt, command, outputs = [], errors = [], warnings = [], duration = null, timing = null }) {
+function appendEntry({ prompt, command, outputs = [], errors = [], warnings = [], duration = null, timing = null, value = null }) {
   if (!outputEl) return;
 
   const entry = document.createElement("div");
@@ -220,11 +221,26 @@ function appendEntry({ prompt, command, outputs = [], errors = [], warnings = []
   }
 
   // Outputs
-  for (const out of outputs) {
-    const outDiv = document.createElement("div");
-    outDiv.className = "entry-line line-output";
-    outDiv.innerHTML = ansiToHtml(out);
-    entry.appendChild(outDiv);
+  if (value && outputs.length > 0) {
+    const rawText = outputs.join("\n");
+    const allLines = outputs[0].split("\n");
+    const codecOutputs = allLines.slice(1);
+    const timingText = outputs.length > 1 ? outputs[1] : null;
+
+    const outElement = createOutputEntryElement({
+      value,
+      rawText,
+      codecOutputs,
+      timingText
+    });
+    entry.appendChild(outElement);
+  } else {
+    for (const out of outputs) {
+      const outDiv = document.createElement("div");
+      outDiv.className = "entry-line line-output";
+      outDiv.innerHTML = ansiToHtml(out);
+      entry.appendChild(outDiv);
+    }
   }
 
   outputEl.appendChild(entry);
@@ -298,7 +314,8 @@ export async function executeCommand(input) {
     errors,
     warnings,
     duration,
-    timing: state.lastTiming
+    timing: state.lastTiming,
+    value: state.lastResult
   });
 
   // Re-create completer with updated state