@fraczak/k 6.2.4 → 6.3.2

package/scripts/git-hooks/pre-commit

@@ -0,0 +1,10 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ "${SKIP_BENCHMARK:-}" = "1" ]; then
+  echo "Skipping benchmark because SKIP_BENCHMARK=1"
+  exit 0
+fi
+
+npm run benchmark
+git add benchmark-results.json

package/scripts/render-benchmark.mjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const inputPath = path.resolve(root, process.argv[2] || "benchmark-results.json");
+const outputPath = path.resolve(root, process.argv[3] || "benchmark-results.html");
+
+const rowOrder = [
+  "Native JS (Envelope-Aware)",
+  "Native JS (Envelope-Free)",
+  "kVM Interpreter (Env-Free)"
+];
+
+const columnGroups = [
+  {
+    title: "ieee",
+    source: "Examples/ieee.k",
+    columns: [
+      { key: "ieee.add", label: "add" },
+      { key: "ieee.div", label: "div" },
+      { key: "ieee.mul", label: "mul" },
+      { key: "ieee.sub", label: "sub" }
+    ]
+  },
+  {
+    title: "int",
+    source: "Examples/arithmetics.k",
+    columns: [
+      { key: "int.factorial", label: "factorial" },
+      { key: "int.gcd.90d", label: "gcd" },
+      { key: "int.times.220d", label: "times" }
+    ]
+  }
+];
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll("\"", "&quot;");
+}
+
+function fmtMs(value) {
+  return value == null ? "n/a" : `${value.toFixed(2)} ms`;
+}
+
+function fmtMiB(value) {
+  return value == null ? "n/a" : `${value.toFixed(1)} MiB`;
+}
+
+function fmtRatio(value) {
+  return Number.isFinite(value) ? `${value.toFixed(2)}x` : "";
+}
+
+function resultMap(results) {
+  const map = new Map();
+  for (const result of results) {
+    if (!map.has(result.mode)) map.set(result.mode, new Map());
+    map.get(result.mode).set(result.case, result);
+  }
+  return map;
+}
+
+function factorialResults(byCase) {
+  return [...byCase.entries()]
+    .filter(([caseName]) => caseName.startsWith("int.factorial."))
+    .sort(([a], [b]) => Number(a.split(".").at(-1)) - Number(b.split(".").at(-1)))
+    .map(([caseName, result]) => ({
+      input: caseName.split(".").at(-1),
+      result
+    }));
+}
+
+function bestForColumn(results, column) {
+  const relevant = column.key === "int.factorial"
+    ? results.filter(result => result.case.startsWith("int.factorial."))
+    : results.filter(result => result.case === column.key);
+  return relevant
+    .filter(result => result.status === "ok" && typeof result.avgMs === "number")
+    .sort((a, b) => a.avgMs - b.avgMs)[0] || null;
+}
+
+function cellFor(result, best) {
+  if (!result) return `<span class="muted">not run</span>`;
+  if (result.status !== "ok") return `<span class="bad">${escapeHtml(result.status)}</span>`;
+  const ratio = best ? result.avgMs / best.avgMs : NaN;
+  return `
+    <div class="time">${fmtMs(result.avgMs)} <span>${fmtRatio(ratio)}</span></div>
+    <div class="sub">rss ${fmtMiB(result.maxRssMiB)}</div>`;
+}
+
+function factorialCell(byCase, allResults) {
+  const rows = factorialResults(byCase);
+  if (rows.length === 0) return `<span class="muted">not run</span>`;
+  return rows.map(({ input, result }) => {
+    const best = bestForColumn(allResults, { key: result.case });
+    return `
+      <div class="mini">
+        <span class="mini-label">${escapeHtml(input)}</span>
+        <div>${cellFor(result, best)}</div>
+      </div>`;
+  }).join("");
+}
+
+function buildMatrix(doc) {
+  const results = doc.results || [];
+  const byMode = resultMap(results);
+
+  const groupHeader = columnGroups.map(group =>
+    `<th colspan="${group.columns.length}" class="group">${escapeHtml(group.title)} <span>${escapeHtml(group.source)}</span></th>`
+  ).join("");
+
+  const columnHeader = columnGroups.flatMap(group => group.columns)
+    .map(column => `<th>${escapeHtml(column.label)}</th>`)
+    .join("");
+
+  const body = rowOrder.map(mode => {
+    const byCase = byMode.get(mode) || new Map();
+    const cells = columnGroups.flatMap(group => group.columns).map(column => {
+      if (column.key === "int.factorial") {
+        return `<td>${factorialCell(byCase, results)}</td>`;
+      }
+      return `<td>${cellFor(byCase.get(column.key), bestForColumn(results, column))}</td>`;
+    }).join("");
+    return `<tr><th class="row-head">${escapeHtml(mode)}</th>${cells}</tr>`;
+  }).join("");
+
+  return `
+    <table class="matrix">
+      <thead>
+        <tr><th></th>${groupHeader}</tr>
+        <tr><th>implementation</th>${columnHeader}</tr>
+      </thead>
+      <tbody>${body}</tbody>
+    </table>`;
+}
+
+function buildDetails(results) {
+  return results
+    .slice()
+    .sort((a, b) => a.case.localeCompare(b.case) || a.mode.localeCompare(b.mode))
+    .map(result => `
+      <tr>
+        <td>${escapeHtml(result.case)}</td>
+        <td>${escapeHtml(result.mode)}</td>
+        <td>${escapeHtml(result.status)}</td>
+        <td class="num">${fmtMs(result.avgMs)}</td>
+        <td class="num">${fmtMs(result.minMs)}</td>
+        <td class="num">${fmtMs(result.maxMs)}</td>
+        <td class="num">${fmtMiB(result.maxRssMiB)}</td>
+        <td class="hash">${escapeHtml(result.resultDigest || "")}</td>
+      </tr>`)
+    .join("");
+}
+
+function render(doc) {
+  const results = doc.results || [];
+  const generatedAt = doc.generatedAt ? new Date(doc.generatedAt).toLocaleString() : "unknown";
+  const completed = results.filter(result => result.status === "ok").length;
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>k Benchmark Results</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --ink: #17212f;
+      --muted: #627083;
+      --line: #d9e0ea;
+      --paper: #f5f7fa;
+      --panel: #fff;
+      --accent: #1d5fd1;
+      --soft: #eef3fb;
+      --bad: #b42318;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      color: var(--ink);
+      background: var(--paper);
+    }
+    header {
+      padding: 28px 32px 20px;
+      background: var(--panel);
+      border-bottom: 1px solid var(--line);
+    }
+    h1 { margin: 0 0 10px; font-size: 30px; letter-spacing: 0; }
+    .meta {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 14px;
+      color: var(--muted);
+      font-size: 14px;
+    }
+    main {
+      max-width: 1320px;
+      margin: 0 auto;
+      padding: 24px 32px 40px;
+    }
+    .summary {
+      display: grid;
+      grid-template-columns: repeat(4, minmax(0, 1fr));
+      gap: 12px;
+      margin-bottom: 18px;
+    }
+    .metric, .panel {
+      background: var(--panel);
+      border: 1px solid var(--line);
+      border-radius: 8px;
+    }
+    .metric { padding: 14px 16px; }
+    .metric .label { color: var(--muted); font-size: 13px; }
+    .metric .value { margin-top: 5px; font-size: 22px; font-weight: 700; }
+    .panel { overflow: auto; }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+    }
+    th, td {
+      border-bottom: 1px solid var(--line);
+      padding: 12px;
+      text-align: left;
+      vertical-align: top;
+      font-size: 13px;
+    }
+    thead th {
+      background: #fafbfd;
+      color: var(--muted);
+      font-weight: 700;
+    }
+    .matrix {
+      min-width: 980px;
+    }
+    .matrix .group {
+      text-align: center;
+      color: var(--ink);
+      font-size: 15px;
+      background: var(--soft);
+    }
+    .matrix .group span {
+      display: block;
+      color: var(--muted);
+      font-size: 12px;
+      font-weight: 500;
+      margin-top: 2px;
+    }
+    .row-head {
+      width: 230px;
+      color: var(--ink);
+      font-weight: 800;
+      background: #fbfcfe;
+    }
+    .time {
+      font-weight: 800;
+      font-variant-numeric: tabular-nums;
+      white-space: nowrap;
+    }
+    .time span {
+      color: var(--muted);
+      font-weight: 600;
+      margin-left: 4px;
+    }
+    .sub {
+      margin-top: 3px;
+      color: var(--muted);
+      font-size: 12px;
+      white-space: nowrap;
+    }
+    .mini {
+      display: grid;
+      grid-template-columns: 42px 1fr;
+      gap: 8px;
+      padding: 5px 0;
+      border-bottom: 1px solid #edf1f6;
+    }
+    .mini:last-child { border-bottom: 0; }
+    .mini-label {
+      color: var(--muted);
+      font-weight: 800;
+      font-variant-numeric: tabular-nums;
+    }
+    .muted { color: var(--muted); }
+    .bad { color: var(--bad); font-weight: 800; }
+    h2 { margin: 24px 0 10px; font-size: 18px; }
+    .details { margin-top: 16px; }
+    .details table { min-width: 920px; }
+    .num { text-align: right; font-variant-numeric: tabular-nums; }
+    .hash { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; color: var(--muted); }
+    @media (max-width: 900px) {
+      header, main { padding-left: 16px; padding-right: 16px; }
+      .summary { grid-template-columns: 1fr; }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>k Benchmark Results</h1>
+    <div class="meta">
+      <span>Generated: ${escapeHtml(generatedAt)}</span>
+      <span>Node: ${escapeHtml(doc.node || "unknown")}</span>
+      <span>Platform: ${escapeHtml(doc.platform || "unknown")}</span>
+      <span>CPUs: ${escapeHtml(doc.cpuCount ?? "unknown")}</span>
+      <span>Samples/job: ${escapeHtml(doc.samples ?? "unknown")}</span>
+    </div>
+  </header>
+  <main>
+    <section class="summary">
+      <div class="metric"><div class="label">Completed Jobs</div><div class="value">${completed}/${results.length}</div></div>
+      <div class="metric"><div class="label">Timeout</div><div class="value">${((doc.timeoutMs || 0) / 60000).toFixed(1)} min</div></div>
+      <div class="metric"><div class="label">Parallel Jobs</div><div class="value">${escapeHtml(doc.parallelJobs ?? "n/a")}</div></div>
+      <div class="metric"><div class="label">Result Rows</div><div class="value">${results.length}</div></div>
+    </section>
+    <section class="panel">
+      ${buildMatrix(doc)}
+    </section>
+    <section class="details">
+      <h2>Raw Result Rows</h2>
+      <div class="panel">
+        <table>
+          <thead>
+            <tr><th>Case</th><th>Mode</th><th>Status</th><th>Avg</th><th>Min</th><th>Max</th><th>Max RSS</th><th>Digest</th></tr>
+          </thead>
+          <tbody>${buildDetails(results)}</tbody>
+        </table>
+      </div>
+    </section>
+  </main>
+</body>
+</html>
+`;
+}
+
+const data = JSON.parse(fs.readFileSync(inputPath, "utf8"));
+fs.writeFileSync(outputPath, render(data));
+console.log(`Rendered ${path.relative(root, outputPath)} from ${path.relative(root, inputPath)}`);

package/scripts/run-tests.mjs

@@ -18,10 +18,12 @@ const tests = [
   ["tests/test-fingerprint.mjs", node, ["tests/test-fingerprint.mjs"]],
   ["tests/test-hash-fuzz.mjs", node, ["tests/test-hash-fuzz.mjs"]],
   ["tests/test-hash-normalization.mjs", node, ["tests/test-hash-normalization.mjs"]],
+  ["tests/test-structural-values.mjs", node, ["tests/test-structural-values.mjs"]],
   ["tests/test-deep-wire-value.mjs", node, ["tests/test-deep-wire-value.mjs"]],
   ["tests/test-k-object.mjs", node, ["tests/test-k-object.mjs"]],
   ["tests/test-repl.mjs", node, ["tests/test-repl.mjs"]],
   ["tests/test-kvm.mjs", node, ["tests/test-kvm.mjs"]],
+  ["tests/test-arithmetics.mjs", node, ["tests/test-arithmetics.mjs"]],
   ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.mjs"]],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
 ];

package/tests/code-derivation/codec-witness-pattern.mjs

@@ -1,7 +1,7 @@
 import assert from 'assert';
 import { parseValue } from '../../valueIO.mjs';
 import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs';
-import { Product, Variant } from '../../Value.mjs';
+import { isProduct, isVariant } from '../../Value.mjs';
 
 const value = parseValue('{a:{b:x,c:{}}}');
 const repeatedClosedValue = parseValue('{a:{m:{},n:{}},b:{m:{},n:{}}}');
@@ -27,9 +27,9 @@ assert.deepEqual(explicitProductWire.pattern, [
 ]);
 
 const decoded = explicitProductWire.value;
-assert(decoded instanceof Product);
-assert(decoded.product.a instanceof Product);
-assert(decoded.product.a.product.b instanceof Variant);
+assert(isProduct(decoded));
+assert(isProduct(decoded.product.a));
+assert(isVariant(decoded.product.a.product.b));
 assert.equal(decoded.product.a.product.b.tag, "x");
 
 const repeatedClosedWire = decodeWire(encodeToWire(repeatedClosedValue, null));

package/tests/code-derivation/pattern-envelope.mjs

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import k from "../../index.mjs";
-import { Product, Variant, mergePatterns, withPattern } from "../../Value.mjs";
+import { Value, mergePatterns, withPattern } from "../../Value.mjs";
 import { decodeWire, encodeToWire } from "../../codecs/runtime/prefix-codec.mjs";
 import run from "../../run.mjs";
 import codes from "../../codes.mjs";
@@ -17,16 +17,16 @@ const script = `
   {}|_|0|1|+ $int
 `;
 
-const result = k.compile(script)(new Product({}));
+const result = k.compile(script)(Value.product({}));
 assert.deepEqual(result.pattern, INT_PATTERN);
 
 const decoded = decodeWire(encodeToWire(result, result.pattern));
 assert.deepEqual(decoded.pattern, INT_PATTERN);
 
-const two = new Variant("+",
-  new Variant("1",
-    new Variant("0",
-      new Variant("_", new Product({}))
+const two = Value.variant("+",
+  Value.variant("1",
+    Value.variant("0",
+      Value.variant("_", Value.product({}))
     )
   )
 );
@@ -53,13 +53,13 @@ const wrappedFloatPattern = [
   ["closed-product", []],
   ["closed-union", [["inexact", 5]]]
 ];
-const wrappedFloat = new Product({
-  result: new Product({
-    sign: new Variant("+", new Product({})),
-    exponent: new Product({ 0: new Variant("1", new Product({})) }),
-    fraction: new Product({ 0: new Variant("0", new Product({})) })
+const wrappedFloat = Value.product({
+  result: Value.product({
+    sign: Value.variant("+", Value.product({})),
+    exponent: Value.product({ 0: Value.variant("1", Value.product({})) }),
+    fraction: Value.product({ 0: Value.variant("0", Value.product({})) })
   }),
-  flags: new Variant("inexact", new Product({}))
+  flags: Value.variant("inexact", Value.product({}))
 });
 const resultProjection = k.compile(".result")(withPattern(wrappedFloat, wrappedFloatPattern));
 assert.deepEqual(resultProjection.pattern, [

package/tests/integration.sh

@@ -19,7 +19,9 @@ grep -q '"__main__"' "$TMP_DIR/stdin.kvm"
 ./objects/compile.mjs --lib "$TMP_DIR/export.klib" --export id:alias 'alias' "$TMP_DIR/export.ko"
 ./objects/decompile.mjs "$TMP_DIR/export.ko" | grep -q '^----- main -----$'
 node ./codecs/unit.mjs --parse | ./k.mjs --lib "$TMP_DIR/export.klib" --export id:alias 'alias' | node ./codecs/unit.mjs --print | grep -qx '{}'
+node ./codecs/unit.mjs --parse | ./kvm.mjs --lib "$TMP_DIR/export.klib" --export id:alias 'alias' | node ./codecs/unit.mjs --print | grep -qx '{}'
 node ./codecs/unit.mjs --parse | ./k.mjs "$TMP_DIR/export.ko" | node ./codecs/unit.mjs --print | grep -qx '{}'
+node ./codecs/unit.mjs --parse | ./kvm.mjs "$TMP_DIR/export.ko" | node ./codecs/unit.mjs --print | grep -qx '{}'
 if ./k.mjs --lib "$TMP_DIR/export.klib" --lib "$TMP_DIR/export.klib" '()' > "$TMP_DIR/two-lib.out" 2> "$TMP_DIR/two-lib.err"; then
   echo "expected repeated --lib to fail" >&2
   exit 1
@@ -56,6 +58,11 @@ if ./k.mjs -k Examples/byte.k > "$TMP_DIR/dash-k.out" 2> "$TMP_DIR/dash-k.err";
   exit 1
 fi
 grep -q -- '-k is no longer supported' "$TMP_DIR/dash-k.err"
+if ./kvm.mjs -k Examples/byte.k > "$TMP_DIR/dash-k-kvm.out" 2> "$TMP_DIR/dash-k-kvm.err"; then
+  echo "expected k-vm -k to fail" >&2
+  exit 1
+fi
+grep -q -- '-k is no longer supported' "$TMP_DIR/dash-k-kvm.err"
 printf 'A🙂\nBé~\t' | ./codecs/utf8.mjs --parse | ./k.mjs Examples/byte.k |./codecs/utf8.mjs --print
 echo
 ./objects/compile.mjs Examples/ieee.k "$TMP_DIR/ieee.klib"

package/tests/test-arithmetics.mjs

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const node = process.execPath;
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-arithmetics-"));
+const libPath = path.join(tmpDir, "arithmetics.klib");
+const program = "{inc x, () y} o";
+
+const smallInput = "11111112222223333334444444555555666666777777788888899999900000011111122222233333344444455555";
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: root,
+    input: options.input,
+    encoding: options.encoding ?? null,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (result.error && result.status == null) throw result.error;
+  return result;
+}
+
+function assertOk(result, label) {
+  if (result.status !== 0) {
+    const stderr = Buffer.isBuffer(result.stderr) ? result.stderr.toString("utf8") : String(result.stderr ?? "");
+    const stdout = Buffer.isBuffer(result.stdout) ? result.stdout.toString("utf8") : String(result.stdout ?? "");
+    assert.fail(`${label} failed with status ${result.status}\nSTDERR:\n${stderr}\nSTDOUT:\n${stdout}`);
+  }
+}
+
+function parseIntWire(text) {
+  const result = run(node, ["codecs/int.mjs", "--parse"], {
+    input: `${text}\n`
+  });
+  assertOk(result, `parse int ${text}`);
+  return result.stdout;
+}
+
+function printIntWire(wire, label) {
+  const result = run(node, ["codecs/int.mjs", "--print"], {
+    input: wire,
+    encoding: "utf8"
+  });
+  assertOk(result, `${label} print`);
+  return result.stdout.trim();
+}
+
+function runnerArgs(operation) {
+  return [
+    "--lib", libPath,
+    "--export", `${operation}:o`,
+    "--export", "inc",
+    program
+  ];
+}
+
+function runNative(operation, inputText) {
+  const wire = parseIntWire(inputText);
+  const result = run(node, ["k.mjs", ...runnerArgs(operation)], {
+    input: wire
+  });
+  assertOk(result, `native ${operation}(${inputText})`);
+  return printIntWire(result.stdout, `native ${operation}`);
+}
+
+function expected(operation, inputText) {
+  const n = BigInt(inputText);
+  if (operation === "plus") return (n + n + 1n).toString();
+  if (operation === "minus") return "1";
+  if (operation === "times") return (n * (n + 1n)).toString();
+  throw new Error(`Unknown operation: ${operation}`);
+}
+
+try {
+  assertOk(
+    run(node, ["objects/compile.mjs", "Examples/arithmetics.k", libPath], { encoding: "utf8" }),
+    "compile Examples/arithmetics.k"
+  );
+
+  for (const operation of ["plus", "minus", "times"]) {
+    assert.equal(
+      runNative(operation, smallInput),
+      expected(operation, smallInput),
+      `native ${operation} should match BigInt oracle`
+    );
+  }
+
+  console.log("OK");
+} finally {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+}

package/tests/test-deep-wire-value.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { Product, Variant } from "../Value.mjs";
+import { Value } from "../Value.mjs";
 import { decodeWire, encodeToWire } from "../codecs/runtime/prefix-codec.mjs";
 
 const depth = 12000;
@@ -9,12 +9,12 @@ const pattern = [
   ["closed-product", []]
 ];
 
-let bits = new Variant("_", new Product({}));
+let bits = Value.variant("_", Value.product({}));
 for (let i = 0; i < depth; i++) {
-  bits = new Variant("1", bits);
+  bits = Value.variant("1", bits);
 }
 
-const wire = encodeToWire(new Variant("+", bits), pattern);
+const wire = encodeToWire(Value.variant("+", bits), pattern);
 const decoded = decodeWire(wire).value;
 assert.equal(decoded.tag, "+");
 

package/tests/test-ieee-arithmetic.mjs

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 
 import { createState, evaluateInput } from "../repl.mjs";
-import { Product } from "../Value.mjs";
+import { Value, isProduct } from "../Value.mjs";
 import codes from "../codes.mjs";
 import { parse as parseFloat64, print as printFloat64 } from "../codecs/ieee.mjs";
 import { singletonPatternToCodeHash, valueForCode } from "../repl-codecs.mjs";
@@ -21,7 +21,7 @@ function float64(text) {
 }
 
 function floatPair(x, y) {
-  return valueForCode(new Product({
+  return valueForCode(Value.product({
     x: float64(x),
     y: float64(y)
   }), floatPairHash, codes.find);
@@ -46,7 +46,7 @@ function assertFloatResult(value, expected, label) {
 
 async function assertOperation({ op, x, y, result, flags = null, projection = false }) {
   const bundle = await runOperation(op, x, y);
-  assert.ok(bundle instanceof Product, `${op} should return a result bundle`);
+  assert.ok(isProduct(bundle), `${op} should return a result bundle`);
   assert.deepEqual(Object.keys(bundle.product).sort(), ["flags", "result"]);
   assertFloatResult(bundle.product.result, result, `${op}(${x}, ${y}).result`);
   if (flags != null) {

package/tests/test-k-object.mjs

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import k from "../index.mjs";
 import { parseValue } from "../valueIO.mjs";
 import { decodeWire, encodeToWire, CORE_PATTERN_PROPERTY_LIST } from "../codecs/runtime/prefix-codec.mjs";
-import { Product, Variant } from "../Value.mjs";
+import { Value } from "../Value.mjs";
 import { exportPatternGraph } from "../codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "../codecs/runtime/pattern-json.mjs";
 import {
@@ -27,9 +27,9 @@ assert.deepEqual(decodedWire.pattern, [
 ]);
 assert.deepEqual(decodedWire.value.toJSON(), value.toJSON());
 
-const unicodeLabelValue = new Product({
-  "é": new Variant("🙂", new Product({})),
-  "𐐷": new Product({})
+const unicodeLabelValue = Value.product({
+  "é": Value.variant("🙂", Value.product({})),
+  "𐐷": Value.product({})
 });
 const unicodeWire = encodeToWire(unicodeLabelValue, null);
 const decodedUnicode = decodeWire(unicodeWire);
@@ -73,15 +73,15 @@ assert(object.meta[object.relAlias.__main__]?.origins?.some((origin) =>
 ));
 
 const objectFn = objectToFunction(object);
-const objectResult = objectFn(new Product({}));
+const objectResult = objectFn(Value.product({}));
 assert.deepEqual(objectResult.pattern, INT_PATTERN);
 assert.deepEqual(objectResult.toJSON(), { "+": { "1": { "0": "_" } } });
-const convergedObjectResult = runConvergedObject(object, new Product({}));
+const convergedObjectResult = runConvergedObject(object, Value.product({}));
 assert.deepEqual(convergedObjectResult.pattern, INT_PATTERN);
 assert.deepEqual(convergedObjectResult.toJSON(), objectResult.toJSON());
 
 const decompiledSource = decompileObjectBuffer(objectBuffer);
-const decompiledResult = k.compile(decompiledSource)(new Product({}));
+const decompiledResult = k.compile(decompiledSource)(Value.product({}));
 assert.deepEqual(decompiledResult.pattern, INT_PATTERN);
 assert.deepEqual(decompiledResult.toJSON(), objectResult.toJSON());
 assert.match(decompiledSource, /^----- codes -----$/m);
@@ -112,11 +112,11 @@ assert.equal(arithmeticsRoundTripSource, arithmeticsDecompiledSource);
 
 assert.throws(() => k.compile("@A = (); @A"), /Parse error/);
 assert.throws(() => k.compile("$ @A = {}; $@A"), /Parse error/);
-assert.deepEqual(k.compile("7jfi = ?X0; 7jfi")(new Product({})).toJSON(), {});
+assert.deepEqual(k.compile("7jfi = ?X0; 7jfi")(Value.product({})).toJSON(), {});
 
 const sccSource = decompileObjectBuffer(compileObjectBuffer("c = {}; b = c |x; a = b |y; a"));
 assert.match(sccSource, /----- rels -----\nPQgV = .+\n\naQAD = .+\n\nN9UH = /s);
-assert.deepEqual(k.compile(sccSource)(new Product({})).toJSON(), { y: "x" });
+assert.deepEqual(k.compile(sccSource)(Value.product({})).toJSON(), { y: "x" });
 
 const libraryBuffer = compileLibraryBuffer("$ nat = <{} zero, nat succ>;\nsucc = |succ;\n", { source: "defs-only.k" });
 assert.equal(libraryBuffer.subarray(0, 1).toString("utf8"), "{");
@@ -173,7 +173,7 @@ assert(derivedAliases.indexOf("other = @") < derivedAliases.indexOf("succ = @"))
     }));
     assert.equal(nonConverged.rels.__main__.typeDerivation.status, "not-converged");
     assert.throws(
-      () => runConvergedObject(nonConverged, new Product({ x: new Product({}) })),
+      () => runConvergedObject(nonConverged, Value.product({ x: Value.product({}) })),
       /type derivation is not-converged/
     );
   } finally {