@fraczak/k 6.4.0 → 6.6.0

package/backends/wasm/runtime.wat

@@ -2,9 +2,12 @@
   (memory (export "memory") 1)
 
   ;; Start allocation at byte offset 1024 to leave a safety margin and avoid returning 0 (nullptr)
-  (global $arena_free (mut i32) (i32.const 1024))
+  (global $arena_free (export "arena_free") (mut i32) (i32.const 1024))
   ;; Maximum address of the currently allocated pages (1 page = 64KB)
-  (global $arena_max (mut i32) (i32.const 65536))
+  (global $arena_max (export "arena_max") (mut i32) (i32.const 65536))
+  ;; Out-of-memory status flags
+  (global $oom_flag (export "oom_flag") (mut i32) (i32.const 0))
+  (global $oom_size (export "oom_size") (mut i32) (i32.const 0))
 
   ;; Bump allocator function: aligns allocation size to 8 bytes, grows memory if needed, and returns the pointer
   (func $alloc (export "alloc") (param $size i32) (result i32)
@@ -13,6 +16,18 @@
     (local $pages_needed i32)
     (local $grow_res i32)
 
+    ;; Check if size exceeds maximum allocatable size
+    local.get $size
+    i32.const -8
+    i32.gt_u
+    if
+      i32.const 1
+      global.set $oom_flag
+      local.get $size
+      global.set $oom_size
+      unreachable
+    end
+
     ;; 1. Align size to 8 bytes: size = (size + 7) & ~8
     local.get $size
     i32.const 7
@@ -31,6 +46,18 @@
     i32.add
     local.set $new_free
 
+    ;; Check for 32-bit unsigned overflow
+    local.get $new_free
+    local.get $old_free
+    i32.lt_u
+    if
+      i32.const 1
+      global.set $oom_flag
+      local.get $size
+      global.set $oom_size
+      unreachable
+    end
+
     ;; 2. Check if we exceed current memory size
     local.get $new_free
     global.get $arena_max
@@ -56,6 +83,10 @@
       i32.const -1
       i32.eq
       if
+        i32.const 1
+        global.set $oom_flag
+        local.get $size
+        global.set $oom_size
         unreachable
       end
 
@@ -99,4 +130,346 @@
     local.get $mark
     global.set $arena_free
   )
+
+  ;; Compaction staging globals
+  (global $compact_buf_start (mut i32) (i32.const 0))
+  (global $compact_buf_free (mut i32) (i32.const 0))
+
+  ;; Ensure memory capacity in staging buffer
+  (func $ensure_buf_capacity (param $size i32)
+    (local $needed i32)
+    (local $pages i32)
+    (local $grow_res i32)
+
+    global.get $compact_buf_free
+    local.get $size
+    i32.add
+    local.set $needed
+
+    ;; Check for 32-bit overflow
+    local.get $needed
+    global.get $compact_buf_free
+    i32.lt_u
+    if
+      i32.const 1
+      global.set $oom_flag
+      local.get $size
+      global.set $oom_size
+      unreachable
+    end
+
+    local.get $needed
+    global.get $arena_max
+    i32.gt_u
+    if
+      local.get $needed
+      global.get $arena_max
+      i32.sub
+      i32.const 65535
+      i32.add
+      i32.const 65536
+      i32.div_u
+      local.set $pages
+
+      local.get $pages
+      memory.grow
+      local.set $grow_res
+
+      local.get $grow_res
+      i32.const -1
+      i32.eq
+      if
+        i32.const 1
+        global.set $oom_flag
+        local.get $size
+        global.set $oom_size
+        unreachable
+      end
+
+      global.get $arena_max
+      local.get $pages
+      i32.const 65536
+      i32.mul
+      i32.add
+      global.set $arena_max
+    end
+  )
+
+  ;; Initialize compaction staging buffer at current arena top
+  (func $compact_start (export "compact_start")
+    global.get $arena_free
+    global.set $compact_buf_start
+    global.get $arena_free
+    global.set $compact_buf_free
+  )
+
+  ;; Compact an object graph reachable from $root down toward $mark
+  (func $compact_obj (export "compact_obj") (param $root i32) (param $mark i32) (result i32)
+    (local $curr i32)
+    (local $first_final i32)
+    (local $prev_dest i32)
+    (local $dest i32)
+    (local $final_ptr i32)
+    (local $tag i32)
+    (local $payload i32)
+    (local $size i32)
+    (local $alignedSize i32)
+    (local $N i32)
+    (local $i i32)
+    (local $offsetVal i32)
+    (local $fieldPtr i32)
+    (local $child_final i32)
+
+    local.get $root
+    local.set $curr
+    i32.const 0
+    local.set $prev_dest
+
+    (block $break_chain
+      (loop $chain_loop
+        ;; 1. Check null / empty
+        local.get $curr
+        i32.eqz
+        if
+          local.get $prev_dest
+          if
+            local.get $prev_dest
+            i32.const 0
+            i32.store offset=8
+          end
+          br $break_chain
+        end
+
+        ;; 2. Check if < mark
+        local.get $curr
+        local.get $mark
+        i32.lt_u
+        if
+          local.get $prev_dest
+          if
+            local.get $prev_dest
+            local.get $curr
+            i32.store offset=8
+          end
+          local.get $first_final
+          i32.eqz
+          if
+            local.get $curr
+            local.set $first_final
+          end
+          br $break_chain
+        end
+
+        ;; 3. Check if forwarded
+        local.get $curr
+        i32.load offset=0
+        local.set $size
+
+        local.get $size
+        i32.const -1
+        i32.eq
+        if
+          local.get $curr
+          i32.load offset=4
+          local.set $final_ptr
+          local.get $prev_dest
+          if
+            local.get $prev_dest
+            local.get $final_ptr
+            i32.store offset=8
+          end
+          local.get $first_final
+          i32.eqz
+          if
+            local.get $final_ptr
+            local.set $first_final
+          end
+          br $break_chain
+        end
+
+        ;; 4. Compute final_ptr = mark + (compact_buf_free - compact_buf_start)
+        local.get $mark
+        global.get $compact_buf_free
+        global.get $compact_buf_start
+        i32.sub
+        i32.add
+        local.set $final_ptr
+
+        local.get $first_final
+        i32.eqz
+        if
+          local.get $final_ptr
+          local.set $first_final
+        end
+
+        ;; If prev_dest != 0, patch its payload to final_ptr
+        local.get $prev_dest
+        if
+          local.get $prev_dest
+          local.get $final_ptr
+          i32.store offset=8
+        end
+
+        ;; 5. Check if Variant (size == 12)
+        local.get $size
+        i32.const 12
+        i32.eq
+        if
+          i32.const 16
+          call $ensure_buf_capacity
+
+          local.get $curr
+          i32.load offset=4
+          local.set $tag
+          local.get $curr
+          i32.load offset=8
+          local.set $payload
+
+          local.get $curr
+          i32.const -1
+          i32.store offset=0
+          local.get $curr
+          local.get $final_ptr
+          i32.store offset=4
+
+          global.get $compact_buf_free
+          local.set $dest
+          global.get $compact_buf_free
+          i32.const 16
+          i32.add
+          global.set $compact_buf_free
+
+          local.get $dest
+          i32.const 12
+          i32.store offset=0
+          local.get $dest
+          local.get $tag
+          i32.store offset=4
+
+          local.get $dest
+          local.set $prev_dest
+          local.get $payload
+          local.set $curr
+          br $chain_loop
+        end
+
+        ;; 6. Product handling (size != 12)
+        local.get $size
+        i32.const 7
+        i32.add
+        i32.const -8
+        i32.and
+        local.set $alignedSize
+
+        local.get $alignedSize
+        call $ensure_buf_capacity
+
+        local.get $curr
+        i32.load offset=4
+        local.set $N
+
+        local.get $curr
+        i32.const -1
+        i32.store offset=0
+        local.get $curr
+        local.get $final_ptr
+        i32.store offset=4
+
+        global.get $compact_buf_free
+        local.set $dest
+        global.get $compact_buf_free
+        local.get $alignedSize
+        i32.add
+        global.set $compact_buf_free
+
+        local.get $dest
+        local.get $size
+        i32.store offset=0
+        local.get $dest
+        local.get $N
+        i32.store offset=4
+
+        i32.const 0
+        local.set $i
+        (block $break_prod
+          (loop $loop_prod
+            local.get $i
+            local.get $N
+            i32.ge_u
+            br_if $break_prod
+
+            local.get $curr
+            i32.const 8
+            local.get $i
+            i32.const 4
+            i32.mul
+            i32.add
+            i32.add
+            i32.load
+            local.set $offsetVal
+
+            local.get $dest
+            i32.const 8
+            local.get $i
+            i32.const 4
+            i32.mul
+            i32.add
+            i32.add
+            local.get $offsetVal
+            i32.store
+
+            local.get $curr
+            local.get $offsetVal
+            i32.add
+            i32.load
+            local.set $fieldPtr
+
+            local.get $fieldPtr
+            local.get $mark
+            call $compact_obj
+            local.set $child_final
+
+            local.get $dest
+            local.get $offsetVal
+            i32.add
+            local.get $child_final
+            i32.store
+
+            local.get $i
+            i32.const 1
+            i32.add
+            local.set $i
+            br $loop_prod
+          )
+        )
+        br $break_chain
+      )
+    )
+
+    local.get $first_final
+  )
+
+  ;; Finalize compaction by copying staging buffer into mark and resetting arena_free
+  (func $compact_finish (export "compact_finish") (param $mark i32)
+    (local $total_size i32)
+    global.get $compact_buf_free
+    global.get $compact_buf_start
+    i32.sub
+    local.set $total_size
+
+    local.get $total_size
+    i32.const 0
+    i32.gt_u
+    if
+      local.get $mark
+      global.get $compact_buf_start
+      local.get $total_size
+      memory.copy
+    end
+
+    local.get $mark
+    local.get $total_size
+    i32.add
+    global.set $arena_free
+  )
 )

package/backends/wasm/src/kvm2wasm.mjs

@@ -159,6 +159,7 @@ export function lowerToWasm(relDef, name, options = {}) {
   for (const field of inputProductFields) {
     registers.add(field.local);
   }
+  registers.add("tail_loop_mark");
 
   let nextUnionId = 0;
   const tailLoopLabel = "$tail_loop";
@@ -379,6 +380,24 @@ export function lowerToWasm(relDef, name, options = {}) {
               );
               lines.push(branchWat);
             }
+            lines.push(`    ;; compact if arena growth exceeds 1MB`);
+            lines.push(`    global.get $arena_free`);
+            lines.push(`    local.get $tail_loop_mark`);
+            lines.push(`    i32.sub`);
+            lines.push(`    i32.const 1048576`);
+            lines.push(`    i32.gt_u`);
+            lines.push(`    if`);
+            lines.push(`      call $compact_start`);
+            for (let i = 0; i < N; i++) {
+              const fieldTmp = `${dest}_f${i}`;
+              lines.push(`      local.get $${fieldTmp}`);
+              lines.push(`      local.get $tail_loop_mark`);
+              lines.push(`      call $compact_obj`);
+              lines.push(`      local.set $${fieldTmp}`);
+            }
+            lines.push(`      local.get $tail_loop_mark`);
+            lines.push(`      call $compact_finish`);
+            lines.push(`    end`);
             for (let i = 0; i < N; i++) {
               const branch = sortedBranches[i];
               const fieldTmp = `${dest}_f${i}`;
@@ -565,6 +584,21 @@ export function lowerToWasm(relDef, name, options = {}) {
               registers.add(callSrc);
               materializeInputProduct(lines, callSrc);
             }
+            lines.push(`    ;; compact if arena growth exceeds 1MB`);
+            lines.push(`    global.get $arena_free`);
+            lines.push(`    local.get $tail_loop_mark`);
+            lines.push(`    i32.sub`);
+            lines.push(`    i32.const 1048576`);
+            lines.push(`    i32.gt_u`);
+            lines.push(`    if`);
+            lines.push(`      call $compact_start`);
+            lines.push(`      local.get $${callSrc}`);
+            lines.push(`      local.get $tail_loop_mark`);
+            lines.push(`      call $compact_obj`);
+            lines.push(`      local.set $${callSrc}`);
+            lines.push(`      local.get $tail_loop_mark`);
+            lines.push(`      call $compact_finish`);
+            lines.push(`    end`);
             lines.push(`    local.get $${callSrc}`);
             lines.push(`    local.set $in`);
             lines.push(initInputProductLocals());
@@ -641,6 +675,8 @@ export function lowerToWasm(relDef, name, options = {}) {
   const wat = `(func $${name} (export "${name}") (param $in i32) (result i32 i32)
 ${localDecls}
 ${inputProductLocalInit}
+    global.get $arena_free
+    local.set $tail_loop_mark
     (loop ${tailLoopLabel}
 ${profWat}${bodyWat}
     )

package/backends/wasm/src/wasm.mjs

@@ -31,6 +31,24 @@ const METADATA_SECTION = "k.metadata";
 const ARTIFACT_FORMAT = "k-wasm";
 const ARTIFACT_VERSION = 1;
 
+class OutOfMemoryError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OutOfMemoryError";
+  }
+}
+
+function checkWasmOom(exports) {
+  if (exports.oom_flag && exports.oom_flag.value) {
+    const size = exports.oom_size ? exports.oom_size.value : 0;
+    const max = exports.arena_max ? exports.arena_max.value : 0;
+    const free = exports.arena_free ? exports.arena_free.value : 0;
+    throw new OutOfMemoryError(
+      `WebAssembly Out of Memory: linear memory arena exhausted (failed to allocate ${size} bytes; arena used: ${free >>> 0} bytes, arena max: ${max >>> 0} bytes)`
+    );
+  }
+}
+
 const cleanName = (name) => "rel_" + name.replace(/[^a-zA-Z0-9_]/g, "_");
 
 async function getWabt() {
@@ -894,9 +912,21 @@ async function instantiateWasmArtifact(wasmBuffer) {
     const t1 = process.hrtime.bigint();
     const mark = exports.arena_mark ? exports.arena_mark() : 0;
     const arenaValues = new Map();
-    const ptrIn = writeValueToArena(exports, value, inputPattern, 0, arenaValues, tags, metadata.inputPattern);
+    let ptrIn;
+    try {
+      ptrIn = writeValueToArena(exports, value, inputPattern, 0, arenaValues, tags, metadata.inputPattern);
+    } catch (error) {
+      checkWasmOom(exports);
+      throw error;
+    }
     const t2 = process.hrtime.bigint();
-    const result = exports[metadata.entry](ptrIn);
+    let result;
+    try {
+      result = exports[metadata.entry](ptrIn);
+    } catch (error) {
+      checkWasmOom(exports);
+      throw error;
+    }
     if (result[1] !== 1) {
       if (exports.arena_reset) exports.arena_reset(mark);
       throw new Error("Wasm relation execution failed (returned false)");
@@ -933,9 +963,21 @@ async function instantiateWasmArtifact(wasmBuffer) {
     const t1 = process.hrtime.bigint();
     const mark = exports.arena_mark ? exports.arena_mark() : 0;
     const arenaValues = new Map();
-    const ptrIn = writeValueToArena(exports, inputValue, inputPattern, 0, arenaValues, tags, metadata.inputPattern);
+    let ptrIn;
+    try {
+      ptrIn = writeValueToArena(exports, inputValue, inputPattern, 0, arenaValues, tags, metadata.inputPattern);
+    } catch (error) {
+      checkWasmOom(exports);
+      throw error;
+    }
     const t2 = process.hrtime.bigint();
-    const result = exports[metadata.entry](ptrIn);
+    let result;
+    try {
+      result = exports[metadata.entry](ptrIn);
+    } catch (error) {
+      checkWasmOom(exports);
+      throw error;
+    }
     if (result[1] !== 1) {
       if (exports.arena_reset) exports.arena_reset(mark);
       return undefined;
@@ -982,6 +1024,7 @@ export {
   ARTIFACT_FORMAT,
   ARTIFACT_VERSION,
   METADATA_SECTION,
+  OutOfMemoryError,
   appendCustomSection,
   compileWasmArtifactFromKVM,
   compileWasmArtifactFromObject,
@@ -998,6 +1041,7 @@ export default {
   ARTIFACT_FORMAT,
   ARTIFACT_VERSION,
   METADATA_SECTION,
+  OutOfMemoryError,
   appendCustomSection,
   compileWasmArtifactFromKVM,
   compileWasmArtifactFromObject,

package/backends/wasm/tests/test-wasm.mjs

@@ -88,6 +88,14 @@ console.log("==> Running runtime.wat Core Allocator Tests");
   const ptr3 = runtimeExports.alloc(70000);
   assert.ok(ptr3 > 1040, "Large allocation must return a valid pointer");
   assert.equal(ptr3 % 8, 0, "Large allocation must be 8-byte aligned");
+
+  // Test 5: Out of Memory flag recording on overflow
+  assert.equal(runtimeExports.oom_flag.value, 0, "OOM flag must be 0 initially");
+  assert.throws(() => {
+    runtimeExports.alloc(-1);
+  }, /unreachable/);
+  assert.equal(runtimeExports.oom_flag.value, 1, "OOM flag must be 1 after allocation failure");
+  assert.equal(runtimeExports.oom_size.value, -1, "OOM size must record requested size");
   console.log("Core Allocator tests passed successfully!");
 }
 

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