@fraczak/k 6.1.2 → 6.2.0

package/k-vscode/test/background-ranges.test.js

@@ -0,0 +1,50 @@
+const assert = require("assert");
+const Module = require("module");
+
+const originalLoad = Module._load;
+Module._load = function load(request, parent, isMain) {
+  if (request === "vscode") return {};
+  return originalLoad.call(this, request, parent, isMain);
+};
+
+const { collectBackgroundRanges } = require("../extension");
+
+function slices(text, ranges) {
+  return ranges.map(({ start, end }) => text.slice(start, end));
+}
+
+const source = [
+  "$ pair = { leaf left, leaf right };",
+  "pick = $pair ?{<$leaf some, ...>=X branch, ...} .branch;",
+  "-- ?<ignored tag>",
+  "/* $ignored */",
+  "$pair pick"
+].join("\n");
+
+const ranges = collectBackgroundRanges(source);
+const type = slices(source, ranges.type);
+const filter = slices(source, ranges.filter);
+
+assert.deepStrictEqual(type, [
+  "$ pair = { leaf left, leaf right };",
+  "$pair",
+  "$leaf",
+  "$pair"
+]);
+assert.deepStrictEqual(filter, ["?{<$leaf some, ...>=X branch, ...}"]);
+
+const nested = "add = ?{ $nat x, ... } = X <{.x pred x, .y succ y} ? X add, .y> ;";
+const nestedRanges = collectBackgroundRanges(nested);
+
+assert.deepStrictEqual(slices(nested, nestedRanges.filter), [
+  "?{ $nat x, ... } = X",
+  "? X"
+]);
+assert.deepStrictEqual(slices(nested, nestedRanges.type), ["$nat"]);
+assert.deepStrictEqual(nestedRanges.filter, [
+  { start: 6, end: 26 },
+  { start: 51, end: 54 }
+]);
+assert.deepStrictEqual(nestedRanges.type, [{ start: 9, end: 13 }]);
+
+console.log("background range scanner tests passed");

package/k-vscode/themes/k-contrast-color-theme.json

@@ -0,0 +1,104 @@
+{
+  "$schema": "vscode://schemas/color-theme",
+  "name": "k Contrast",
+  "type": "dark",
+  "colors": {
+    "editor.background": "#161B22",
+    "editor.foreground": "#C9D1D9",
+    "editorLineNumber.foreground": "#6E7681",
+    "editorLineNumber.activeForeground": "#C9D1D9",
+    "editor.selectionBackground": "#264F78",
+    "editor.inactiveSelectionBackground": "#264F7855"
+  },
+  "tokenColors": [
+    {
+      "scope": [
+        "comment.block.k",
+        "comment.line.k"
+      ],
+      "settings": {
+        "foreground": "#8B949E",
+        "fontStyle": "italic"
+      }
+    },
+    {
+      "scope": "entity.name.type.k",
+      "settings": {
+        "foreground": "#FF7B72",
+        "fontStyle": "bold"
+      }
+    },
+    {
+      "scope": "support.type.k",
+      "settings": {
+        "foreground": "#FFA657"
+      }
+    },
+    {
+      "scope": "support.function.identifier.k",
+      "settings": {
+        "foreground": "#79C0FF"
+      }
+    },
+    {
+      "scope": "support.type.canonical.k",
+      "settings": {
+        "foreground": "#F778BA"
+      }
+    },
+    {
+      "scope": "support.function.canonical.k",
+      "settings": {
+        "foreground": "#FF967D"
+      }
+    },
+    {
+      "scope": "entity.name.label.k",
+      "settings": {
+        "foreground": "#7EE787"
+      }
+    },
+    {
+      "scope": "entity.name.tag.k",
+      "settings": {
+        "foreground": "#F2CC60"
+      }
+    },
+    {
+      "scope": "variable.other.pattern.k",
+      "settings": {
+        "foreground": "#56D4DD"
+      }
+    },
+    {
+      "scope": [
+        "keyword.operator.assignment.k",
+        "keyword.operator.binding.k",
+        "keyword.operator.filter.k",
+        "keyword.operator.projection.product.k",
+        "keyword.operator.projection.union.k",
+        "keyword.operator.type.k",
+        "keyword.operator.variant.k"
+      ],
+      "settings": {
+        "foreground": "#FFDF5D"
+      }
+    },
+    {
+      "scope": "punctuation.definition.canonical.k",
+      "settings": {
+        "foreground": "#B392F0"
+      }
+    },
+    {
+      "scope": [
+        "constant.language.any.k",
+        "string.quoted.double.k",
+        "string.quoted.single.k"
+      ],
+      "settings": {
+        "foreground": "#A5D6FF"
+      }
+    }
+  ]
+}

package/object.mjs

@@ -702,21 +702,29 @@ function codeToSource(code, aliases) {
   return code.code === "product" ? `{${body}}` : `< ${body} >`;
 }
 
-function boundaryFilterSource(typePatternGraph, patternId, aliases) {
-  const [filter] = patterns2filters(typePatternGraph, patternId);
-  return prettyRel({ op: "filter", filter: rewriteCodesInFilter(filter, aliases) });
+function boundaryFilterSources(typePatternGraph, patternIds, aliases) {
+  return patterns2filters(typePatternGraph, ...patternIds)
+    .map((filter) => prettyRel({
+      op: "filter",
+      filter: rewriteCodesInFilter(filter, aliases)
+    }));
 }
 
 function prettyRelation(rel, aliases = {}, relAliases = {}) {
+  const [inputFilter, outputFilter] = boundaryFilterSources(
+    rel.typePatternGraph,
+    [rel.def.patterns[0], rel.def.patterns[1]],
+    aliases
+  );
   const body = rewriteRefsInExp(
     stripRelationBoundaryFilters(stripDebugFieldsFromExp(rel.def), rel.typePatternGraph),
     aliases,
     relAliases
   );
   return [
-    boundaryFilterSource(rel.typePatternGraph, rel.def.patterns[0], aliases),
+    inputFilter,
     prettyRel(body),
-    boundaryFilterSource(rel.typePatternGraph, rel.def.patterns[1], aliases)
+    outputFilter
   ].join(" ");
 }
 
@@ -768,10 +776,15 @@ function decompileObject(object) {
 
   const mainRel = relAliases[hydrated.main] || hydrated.main;
   const mainRelDef = rels[hydrated.main];
+  const [mainInputFilter, mainOutputFilter] = boundaryFilterSources(
+    mainRelDef.typePatternGraph,
+    [mainRelDef.def.patterns[0], mainRelDef.def.patterns[1]],
+    aliases
+  );
   const main = [
-    boundaryFilterSource(mainRelDef.typePatternGraph, mainRelDef.def.patterns[0], aliases),
+    mainInputFilter,
     aliases[mainRel] || mainRel,
-    boundaryFilterSource(mainRelDef.typePatternGraph, mainRelDef.def.patterns[1], aliases)
+    mainOutputFilter
   ].join(" ");
 
   return [

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@fraczak/k",
-    "version": "6.1.2",
+    "version": "6.2.0",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "scripts": {
         "prepare": "jiwson -m es6 parser.jison -o parser.mjs; jiwson -m es6 valueParser.jison -o valueParser.mjs; ",
-        "test": "node test.mjs; for f in Code-derivation-tests/*.mjs; do echo $f; node $f; done; node test-fingerprint.mjs; node test-hash-fuzz.mjs; node test-hash-normalization.mjs; node test-k-object.mjs; node test-repl.mjs; node test-ieee-arithmetic.mjs; ./tests.sh",
+        "test": "node scripts/run-tests.mjs",
+        "perf:idempotency": "node scripts/benchmark-idempotency.mjs",
         "deps:graph": "node scripts/generate-dependency-graph.mjs"
     },
     "repository": {

package/repl.mjs

@@ -213,6 +213,40 @@ function mergeLibrary(state, lib, source = "<load>", options = {}) {
   restoreCodes(state);
 }
 
+function reachableRelations(rels, roots) {
+  const reachable = new Set();
+  const queue = [...roots];
+
+  function walkExp(exp) {
+    if (!exp) return;
+    switch (exp.op) {
+      case "ref":
+        if (exp.ref in rels && !reachable.has(exp.ref)) queue.push(exp.ref);
+        break;
+      case "comp":
+        exp.comp.forEach(walkExp);
+        break;
+      case "union":
+        exp.union.forEach(walkExp);
+        break;
+      case "product":
+        exp.product.forEach(({ exp: child }) => walkExp(child));
+        break;
+    }
+  }
+
+  while (queue.length > 0) {
+    const hash = queue.shift();
+    if (reachable.has(hash) || !(hash in rels)) continue;
+    reachable.add(hash);
+    walkExp(rels[hash].def);
+  }
+
+  return Object.fromEntries(
+    Object.entries(rels).filter(([hash]) => reachable.has(hash))
+  );
+}
+
 function savedLibrary(state) {
   const meta = cloneJSON(state.meta);
   const now = new Date().toISOString();
@@ -226,13 +260,20 @@ function savedLibrary(state) {
     if (meta[hash].type == null) meta[hash].type = "rel";
     meta[hash].origins.push({ source: "<repl>", name, compiledAt: now });
   }
+  const rels = reachableRelations(state.rels, Object.values(state.relAliases));
+  const storedHashes = new Set([
+    ...Object.keys(state.codes),
+    ...Object.keys(rels)
+  ]);
   return {
     format: "k-object",
     codes: state.codes,
-    rels: state.rels,
+    rels,
     relAlias: state.relAliases,
     compileStats: { sccs: [], sccCount: 0 },
-    meta,
+    meta: Object.fromEntries(
+      Object.entries(meta).filter(([hash]) => storedHashes.has(hash))
+    ),
     main: null
   };
 }

package/scripts/benchmark-idempotency.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { performance } from "node:perf_hooks";
+
+const DEFAULT_EXAMPLES = [
+  "Examples/nat.k",
+  "Examples/byte.k",
+  "Examples/bnat.k",
+  "Examples/arithmetics.k",
+  "Examples/ieee.k"
+];
+
+const iterations = Number(process.env.K_BENCH_ITERATIONS || 5);
+const examples = process.argv.slice(2);
+const benchmarkExamples = examples.length > 0 ? examples : DEFAULT_EXAMPLES;
+
+function run(args) {
+  const result = spawnSync("node", args, {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    throw new Error(`${args.join(" ")} failed\n${result.stderr || result.stdout}`);
+  }
+}
+
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+
+function formatMs(value) {
+  return `${Math.round(value)} ms`;
+}
+
+function formatBytes(value) {
+  if (value >= 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(1)} MiB`;
+  if (value >= 1024) return `${Math.round(value / 1024)} KiB`;
+  return `${value} B`;
+}
+
+console.log(`compile-lib/decompile round-trip benchmark (${iterations} iterations)`);
+console.log("example, median, min, max, object");
+
+for (const example of benchmarkExamples) {
+  const times = [];
+  let size = 0;
+
+  for (let i = 0; i < iterations; i++) {
+    const out = mkdtempSync(join(tmpdir(), `k-idempotency-bench-${example.replaceAll("/", "_")}-`));
+    const t0 = performance.now();
+    run(["objects/compile-lib.mjs", example, join(out, "1.klib")]);
+    run(["objects/decompile.mjs", join(out, "1.klib"), join(out, "1.k")]);
+    run(["objects/compile-lib.mjs", join(out, "1.k"), join(out, "2.klib")]);
+    run(["objects/decompile.mjs", join(out, "2.klib"), join(out, "2.k")]);
+    times.push(performance.now() - t0);
+    size = statSync(join(out, "1.klib")).size;
+  }
+
+  console.log([
+    example,
+    formatMs(median(times)),
+    formatMs(Math.min(...times)),
+    formatMs(Math.max(...times)),
+    formatBytes(size)
+  ].join(", "));
+}

package/scripts/run-tests.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+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 derivationTests = fs.readdirSync(path.join(root, "tests/code-derivation"))
+  .filter((name) => name.endsWith(".mjs"))
+  .sort()
+  .map((name) => [`tests/code-derivation/${name}`, node, [`tests/code-derivation/${name}`]]);
+
+const tests = [
+  ["tests/test.mjs", node, ["tests/test.mjs"]],
+  ...derivationTests,
+  ["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-k-object.mjs", node, ["tests/test-k-object.mjs"]],
+  ["tests/test-repl.mjs", node, ["tests/test-repl.mjs"]],
+  ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.mjs"]],
+  ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
+];
+
+function formatDuration(milliseconds) {
+  if (milliseconds < 1000) return `${milliseconds.toFixed(0)} ms`;
+  return `${(milliseconds / 1000).toFixed(2)} s`;
+}
+
+const suiteStarted = performance.now();
+for (const [name, command, args] of tests) {
+  console.log(`\n==> ${name}`);
+  const started = performance.now();
+  const result = spawnSync(command, args, {
+    cwd: root,
+    stdio: "inherit"
+  });
+  const duration = formatDuration(performance.now() - started);
+
+  if (result.error) {
+    console.error(`<== ${name} FAILED (${duration})`);
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    console.error(`<== ${name} FAILED (${duration})`);
+    process.exit(result.status ?? 1);
+  }
+  console.log(`<== ${name} passed (${duration})`);
+}
+
+console.log(`\nAll tests passed (${formatDuration(performance.now() - suiteStarted)})`);

package/{Code-derivation-tests → 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 { parseValue } from '../../valueIO.mjs';
+import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs';
+import { Product, Variant } from '../../Value.mjs';
 
 const value = parseValue('{a:{b:x,c:{}}}');
 const repeatedClosedValue = parseValue('{a:{m:{},n:{}},b:{m:{},n:{}}}');

package/{Code-derivation-tests → tests/code-derivation}/convergence-strategy.mjs

@@ -1,5 +1,5 @@
 import assert from "assert";
-import { annotate } from "../index.mjs";
+import { annotate } from "../../index.mjs";
 
 const script = `
   f = .x;

package/{Code-derivation-tests → tests/code-derivation}/dot.mjs

@@ -1,5 +1,5 @@
 import { t, in_out } from './index.mjs';
-import { hash } from '../hash.mjs';
+import { hash } from '../../hash.mjs';
 import assert from 'assert';
 
 t(`

package/{Code-derivation-tests → tests/code-derivation}/filter-syntax.mjs

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import { annotate } from '../index.mjs';
+import { annotate } from '../../index.mjs';
 
 function succeeds(script) {
   assert.doesNotThrow(() => annotate(script));

package/{Code-derivation-tests → tests/code-derivation}/index.mjs

@@ -1,4 +1,4 @@
-import { annotate } from "../index.mjs";
+import { annotate } from "../../index.mjs";
 
 function in_out(annotated) {
   const [input,output] = annotated.rels.__main__.def.patterns.map( (pat) => 

package/{Code-derivation-tests → tests/code-derivation}/pattern-envelope.mjs

@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
-import k from "../index.mjs";
-import { Product, Variant, mergePatterns, withPattern } from "../Value.mjs";
-import { decodeWire, encodeToWire } from "../codecs/runtime/prefix-codec.mjs";
-import run from "../run.mjs";
-import codes from "../codes.mjs";
+import k from "../../index.mjs";
+import { Product, Variant, mergePatterns, withPattern } from "../../Value.mjs";
+import { decodeWire, encodeToWire } from "../../codecs/runtime/prefix-codec.mjs";
+import run from "../../run.mjs";
+import codes from "../../codes.mjs";
 
 const INT_PATTERN = [
   ["closed-union", [["+", 1], ["-", 1]]],

package/{Code-derivation-tests → tests/code-derivation}/product.mjs

@@ -1,6 +1,6 @@
 import { t, in_out } from './index.mjs';
 import assert from 'assert';
-import hash from "../hash.mjs";
+import hash from "../../hash.mjs";
 
 const unitCode = hash('$C0={};');
 

package/{tests.sh → tests/integration.sh}

@@ -1,7 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
 
 # This script is used to run the k.mjs interpreter with various test cases.
 
-echo "Running './tests.sh' ..."
+echo "Running './tests/integration.sh' ..."
 
 echo '["zebara", "ela", "kupa", ala, owca]' | node ./codecs/k-parse.mjs | ./k.mjs '{.1 0,.3 1}' | node ./codecs/k-print.mjs
 echo 

package/{test-fingerprint.mjs → tests/test-fingerprint.mjs}

@@ -1,6 +1,6 @@
-import k from './index.mjs';
-import { encodeCodeToString, find } from './codes.mjs';
-import hash from './hash.mjs';
+import k from '../index.mjs';
+import { encodeCodeToString, find } from '../codes.mjs';
+import hash from '../hash.mjs';
 [
     `
     $bits = < bits 0,  bits 1, {} _ >;

package/{test-hash-fuzz.mjs → tests/test-hash-fuzz.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import assert from "node:assert/strict";
-import { annotate } from "./index.mjs";
+import { annotate } from "../index.mjs";
 
 function mulberry32(seed) {
   let t = seed >>> 0;

package/{test-hash-normalization.mjs → tests/test-hash-normalization.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 import assert from "node:assert/strict";
-import { annotate } from "./index.mjs";
-import { hash } from "./hash.mjs";
+import { annotate } from "../index.mjs";
+import { hash } from "../hash.mjs";
 
 const nameRegex = /^[a-zA-Z0-9_+][a-zA-Z0-9_?!+]*$/;
 

package/{test-ieee-arithmetic.mjs → tests/test-ieee-arithmetic.mjs}

@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 
-import { createState, evaluateInput } from "./repl.mjs";
-import { Product } 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";
+import { createState, evaluateInput } from "../repl.mjs";
+import { Product } 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";
 
 const state = createState();
 await evaluateInput(":load Examples/ieee.k", state);
@@ -44,7 +44,7 @@ function assertFloatResult(value, expected, label) {
   assert.equal(printFloat64(value), expected, label);
 }
 
-async function assertOperation({ op, x, y, result, flags = null }) {
+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.deepEqual(Object.keys(bundle.product).sort(), ["flags", "result"]);
@@ -53,37 +53,24 @@ async function assertOperation({ op, x, y, result, flags = null }) {
     assert.equal(bundle.product.flags.tag, flags, `${op}(${x}, ${y}).flags`);
   }
 
-  const projected = await runProjectedResult(op, x, y);
-  assertFloatResult(projected, result, `${op}(${x}, ${y}).result projection`);
+  if (projection) {
+    const projected = await runProjectedResult(op, x, y);
+    assertFloatResult(projected, result, `${op}(${x}, ${y}).result projection`);
+  }
 }
 
 const cases = [
-  // Addition: same sign, cancellation, exact fractional add, and specials.
-  { op: "add", x: "1", y: "1", result: "2", flags: "none" },
-  { op: "add", x: "-1", y: "1", result: "0", flags: "none" },
-  { op: "add", x: "0.5", y: "0.25", result: "0.75", flags: "none" },
+  // Keep this as a fast smoke matrix. Examples/ieee.k has detailed relation-level coverage.
+  { op: "add", x: "0.5", y: "0.25", result: "0.75", flags: "none", projection: true },
   { op: "add", x: "Infinity", y: "-Infinity", result: "NaN", flags: "invalid" },
-  { op: "add", x: "NaN", y: "1", result: "NaN", flags: "none" },
 
-  // Subtraction: positive result, negative result, signed-zero-equivalent, and invalid infinity subtraction.
-  { op: "sub", x: "4", y: "2", result: "2", flags: "none" },
+  // Cover each finite arithmetic implementation, including sign and fractional results.
   { op: "sub", x: "2", y: "4", result: "-2", flags: "none" },
-  { op: "sub", x: "0", y: "0", result: "0", flags: "none" },
-  { op: "sub", x: "Infinity", y: "Infinity", result: "NaN", flags: "invalid" },
-
-  // Multiplication: positive, signed, zero, and invalid infinity-by-zero.
-  { op: "mul", x: "4", y: "2", result: "8", flags: "none" },
   { op: "mul", x: "-2", y: "4", result: "-8", flags: "none" },
-  { op: "mul", x: "0", y: "5", result: "0", flags: "none" },
   { op: "mul", x: "Infinity", y: "0", result: "NaN", flags: "invalid" },
-
-  // Division: normalized exact cases, fractional quotient, divide-by-zero, invalid zero-over-zero, and infinity quotient.
-  { op: "div", x: "4", y: "2", result: "2" },
-  { op: "div", x: "1", y: "1", result: "1" },
   { op: "div", x: "1", y: "2", result: "0.5" },
   { op: "div", x: "1", y: "0", result: "Infinity", flags: "div_by_zero" },
-  { op: "div", x: "0", y: "0", result: "NaN", flags: "invalid" },
-  { op: "div", x: "Infinity", y: "2", result: "Infinity", flags: "none" }
+  { op: "div", x: "0", y: "0", result: "NaN", flags: "invalid" }
 ];
 
 for (const testCase of cases) {

package/{test-k-object.mjs → tests/test-k-object.mjs}

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 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 { exportPatternGraph } from "./codecs/runtime/codec.mjs";
-import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
+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 { exportPatternGraph } from "../codecs/runtime/codec.mjs";
+import { patternToPropertyList } from "../codecs/runtime/pattern-json.mjs";
 import {
   compileObjectBuffer,
   compileLibraryBuffer,
@@ -14,7 +14,7 @@ import {
   runConvergedObject,
   decompileObjectBuffer,
   extractAliasesFromObject
-} from "./object.mjs";
+} from "../object.mjs";
 
 const value = parseValue("{a:{b:x,c:{}}}");
 const wire = encodeToWire(value, null);
@@ -91,6 +91,25 @@ assert.match(decompiledSource, /\$ Nws3 =/);
 assert.match(decompiledSource, /^7jfi = /m);
 assert.match(decompiledSource, /^----- main -----\n\?\(\.\.\.\) 7jfi \$Nws3$/m);
 
+const natLibraryBuffer = compileLibraryBuffer(fs.readFileSync("Examples/nat.k", "utf8"), { source: "Examples/nat.k" });
+const natDecompiledSource = decompileObjectBuffer(natLibraryBuffer);
+const natRoundTripSource = decompileObjectBuffer(
+  compileLibraryBuffer(natDecompiledSource, { source: "Examples/nat.decompiled.k" })
+);
+const recursiveNatPattern = /\$dTww <\{\.x PgmQ x, \.y h4Wg y\} re64, \.y> \$e9WP;/;
+assert.equal(natRoundTripSource, natDecompiledSource);
+assert.match(natDecompiledSource, recursiveNatPattern);
+
+const arithmeticsLibraryBuffer = compileLibraryBuffer(
+  fs.readFileSync("Examples/arithmetics.k", "utf8"),
+  { source: "Examples/arithmetics.k" }
+);
+const arithmeticsDecompiledSource = decompileObjectBuffer(arithmeticsLibraryBuffer);
+const arithmeticsRoundTripSource = decompileObjectBuffer(
+  compileLibraryBuffer(arithmeticsDecompiledSource, { source: "Examples/arithmetics.decompiled.k" })
+);
+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(), {});