@fraczak/k 7.1.0 → 7.2.0

package/codecs/runtime/show-value.mjs

@@ -6,7 +6,11 @@ function pLabel(label) {
   return nameRE.test(label) ? ` ${label}` : ` ${JSON.stringify(label)}`;
 }
 
-function propertyListToFilter(propertyList, varPrefix = "X") {
+function propertyListToFilter(
+  propertyList,
+  varPrefix = "X",
+  limit = Infinity
+) {
   if (!propertyList || propertyList.length === 0) return "(...)";
 
   const refCount = new Array(propertyList.length).fill(0);
@@ -22,9 +26,15 @@ function propertyListToFilter(propertyList, varPrefix = "X") {
   }
 
   const defined = new Set();
+  let curLen = 0;
 
   function fmt(nodeId) {
-    if (varNames.has(nodeId) && defined.has(nodeId)) return varNames.get(nodeId);
+    if (curLen >= limit) return "...";
+    if (varNames.has(nodeId) && defined.has(nodeId)) {
+      const name = varNames.get(nodeId);
+      curLen += name.length;
+      return name;
+    }
 
     const [kind, edges] = propertyList[nodeId];
     const hasVar = varNames.has(nodeId);
@@ -32,16 +42,35 @@ function propertyListToFilter(propertyList, varPrefix = "X") {
 
     const suffix = hasVar ? `=${varNames.get(nodeId)}` : "";
 
-    if (kind === "any") return hasVar ? varNames.get(nodeId) : "(...)";
+    if (kind === "any") {
+      const s = (hasVar ? varNames.get(nodeId) : "(...)") + suffix;
+      curLen += s.length;
+      return s;
+    }
 
     const isOpen = kind.startsWith("open-");
     const isProduct = kind.endsWith("product");
     const open = isProduct ? "{" : "<";
     const close = isProduct ? "}" : ">";
 
-    if (edges.length === 0 && !isOpen) return `${open}${close}${suffix}`;
+    if (edges.length === 0 && !isOpen) {
+      const s = `${open}${close}${suffix}`;
+      curLen += s.length;
+      return s;
+    }
 
-    const fields = edges.map(([label, target]) => `${fmt(target)}${pLabel(label)}`);
+    const fields = [];
+    for (let i = 0; i < edges.length; i++) {
+      if (curLen >= limit) {
+        fields.push("...");
+        break;
+      }
+      const [label, target] = edges[i];
+      const targetStr = fmt(target);
+      const labelStr = pLabel(label);
+      fields.push(`${targetStr}${labelStr}`);
+      curLen += targetStr.length + labelStr.length + 2;
+    }
     if (isOpen) fields.push("...");
     return `${open}${fields.join(", ")}${close}${suffix}`;
   }
@@ -49,81 +78,94 @@ function propertyListToFilter(propertyList, varPrefix = "X") {
   return fmt(0);
 }
 
-function valueToK(root) {
-  let result = "";
-  const stack = [{
-    val: root,
-    assign(s) { result = s; }
-  }];
+function valueToK(root, limit = Infinity) {
+  const out = [];
+  let curLen = 0;
+  const stack = [root];
 
   while (stack.length > 0) {
-    const frame = stack.pop();
-    if (frame.finishProduct) {
-      frame.assign(`{${frame.parts.join(", ")}}`);
+    if (curLen >= limit) {
+      out.push("...");
+      break;
+    }
+    const item = stack.pop();
+    if (typeof item === "string") {
+      if (curLen + item.length > limit) {
+        out.push(item.slice(0, Math.max(0, limit - curLen)));
+        out.push("...");
+        break;
+      }
+      out.push(item);
+      curLen += item.length;
       continue;
     }
-    if (frame.finishVariant) {
-      const base = frame.base;
-      const tags = frame.tags;
-      frame.assign(tags.length === 0 ? base : `${base}|${tags.reverse().join("|")}`);
+
+    if (item == null) {
+      const s = String(item);
+      if (curLen + s.length > limit) {
+        out.push(s.slice(0, Math.max(0, limit - curLen)));
+        out.push("...");
+        break;
+      }
+      out.push(s);
+      curLen += s.length;
       continue;
     }
 
-    const v = frame.val;
-    if (isVariant(v)) {
+    if (isVariant(item)) {
       const tags = [];
-      let curr = v;
+      let curr = item;
       while (isVariant(curr)) {
         tags.push(pLabel(curr.tag).trimStart());
         curr = curr.value;
+        if (tags.length > limit) break;
       }
-      const finishFrame = {
-        finishVariant: true,
-        tags,
-        base: "",
-        assign: frame.assign
-      };
-      stack.push(finishFrame);
-      stack.push({
-        val: curr,
-        assign(s) { finishFrame.base = s; }
-      });
+      if (tags.length > 0) {
+        stack.push("|" + tags.reverse().join("|"));
+      }
+      stack.push(curr);
       continue;
     }
 
-    if (isProduct(v)) {
-      const keys = Object.keys(v.product);
+    if (isProduct(item)) {
+      const keys = Object.keys(item.product);
       if (keys.length === 0) {
-        frame.assign("{}");
+        out.push("{}");
+        curLen += 2;
         continue;
       }
-      const parts = new Array(keys.length);
-      const finishFrame = {
-        finishProduct: true,
-        parts,
-        assign: frame.assign
-      };
-      stack.push(finishFrame);
+      out.push("{");
+      curLen += 1;
+      stack.push("}");
       for (let i = keys.length - 1; i >= 0; i--) {
         const k = keys[i];
-        const label = pLabel(k);
-        stack.push({
-          val: v.product[k],
-          assign(s) { parts[i] = `${s}${label}`; }
-        });
+        if (i < keys.length - 1) {
+          stack.push(", ");
+        }
+        stack.push(pLabel(k));
+        stack.push(item.product[k]);
       }
       continue;
     }
 
-    frame.assign(String(v));
+    const s = String(item);
+    if (curLen + s.length > limit) {
+      out.push(s.slice(0, Math.max(0, limit - curLen)));
+      out.push("...");
+      break;
+    }
+    out.push(s);
+    curLen += s.length;
   }
 
-  return result;
+  return out.join("");
 }
 
-function valueWithEnvelopeToK(value) {
+function valueWithEnvelopeToK(value, limit = Infinity) {
   if (value === undefined) return "... undefined";
-  return `${valueToK(value)} ?${propertyListToFilter(value.pattern)}`;
+  const valStr = valueToK(value, limit);
+  const patStr = propertyListToFilter(value.pattern, "X", limit);
+  return `${valStr} ?${patStr}`;
 }
 
 export { propertyListToFilter, valueToK, valueWithEnvelopeToK };

package/codecs/runtime/unicode-string.mjs

@@ -3,6 +3,15 @@ import { Value, isProduct, isVariant } from "../../Value.mjs";
 const UNIT = Value.product({});
 const BIT0 = Value.variant("0", UNIT);
 const BIT1 = Value.variant("1", UNIT);
+const BIT_KEYS = [
+  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"
+];
+
+let lazyStringDecoder = null;
+
+function setLazyStringDecoder(fn) {
+  lazyStringDecoder = fn;
+}
 
 function bitValue(bit) {
   return bit === 0 ? BIT0 : BIT1;
@@ -25,7 +34,8 @@ function requireVariant(value, where) {
 function bitsProduct(width, n) {
   const product = {};
   for (let i = width - 1; i >= 0; i--) {
-    product[String(i)] = bitValue((n >> i) & 1);
+    const key = i < BIT_KEYS.length ? BIT_KEYS[i] : String(i);
+    product[key] = bitValue((n >> i) & 1);
   }
   return Value.product(product);
 }
@@ -34,7 +44,8 @@ function parseBitsProduct(value, maxBit, where) {
   const product = requireProduct(value, where);
   let n = 0;
   for (let i = maxBit; i >= 0; i--) {
-    const entry = requireVariant(product[String(i)], `${where}.bit${i}`);
+    const key = i < BIT_KEYS.length ? BIT_KEYS[i] : String(i);
+    const entry = requireVariant(product[key], `${where}.bit${i}`);
     if (entry.tag !== "0" && entry.tag !== "1") {
       throw new Error(`${where}.bit${i}: expected tag 0 or 1`);
     }
@@ -194,20 +205,31 @@ function textToStringValue(text) {
 }
 
 function stringValueToText(value) {
-  let out = "";
+  if (lazyStringDecoder) {
+    const fast = lazyStringDecoder(value);
+    if (fast !== null) return fast;
+  }
+
+  const chunks = [];
+  let chunk = "";
   let cursor = value;
 
   while (true) {
     const list = requireVariant(cursor, "string");
     if (list.tag === "nil") {
       requireProduct(list.value, "string.nil");
-      return out;
+      if (chunk.length > 0) chunks.push(chunk);
+      return chunks.join("");
     }
     if (list.tag !== "cons") {
       throw new Error(`Unsupported string list tag: ${list.tag}`);
     }
     const pair = requireProduct(list.value, "string.cons");
-    out += String.fromCodePoint(unicodeValueToCodePoint(pair.car));
+    chunk += String.fromCodePoint(unicodeValueToCodePoint(pair.car));
+    if (chunk.length >= 8192) {
+      chunks.push(chunk);
+      chunk = "";
+    }
     cursor = pair.cdr;
   }
 }
@@ -216,5 +238,6 @@ export {
   codePointToUnicodeValue,
   unicodeValueToCodePoint,
   textToStringValue,
-  stringValueToText
+  stringValueToText,
+  setLazyStringDecoder
 };

package/codecs/show.mjs

@@ -51,6 +51,10 @@ async function main() {
     else { usage(); process.exit(1); }
   }
 
+  stdout.on("error", (err) => {
+    if (err.code === "EPIPE") process.exit(0);
+  });
+
   const buffer = fileArg ? fs.readFileSync(fileArg) : await readAll(stdin);
 
   // forward unchanged to stdout

package/codecs/utf16.mjs

@@ -10,7 +10,8 @@ import {
 export const doc = `
 UTF-16 text codec (BOM-aware).
 
-Reads UTF-16 text (LE/BE with BOM or LE without BOM), outputs UTF-16LE with BOM.
+Reads UTF-16 text (LE/BE with BOM or LE without BOM),
+outputs UTF-16LE with BOM.
 `;
 
 function decodeUtf16Input(buf) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "7.1.0",
+    "version": "7.2.0",
     "description": "k — a language for content-addressable schemas and data transformations over algebraic data types (products and tagged unions); includes runtime, contract derivation, REPL, and codec toolchain",
     "publishConfig": {
         "access": "public"
@@ -58,6 +58,7 @@
         "k-wasm": "backends/wasm/bin/k-wasm.mjs",
         "k-wasm-compile": "backends/wasm/bin/k-wasm-compile.mjs",
         "k-wasm-run": "backends/wasm/bin/k-wasm-run.mjs",
+        "k-djson": "codecs/djson.mjs",
         "k-ieee": "codecs/ieee.mjs",
         "k-int": "codecs/int.mjs",
         "k-json": "codecs/json.mjs",

package/repl.mjs

@@ -50,7 +50,7 @@ const NAME_RE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
 const COMMAND_NAMES = [
   "help", "rel",
   "codecs", "rels", "codec", "input", "reset", "klib", "ko", "load",
-  "engine", "wasm", "pkir", "js",
+  "engine", "wasm", "pkir", "js", "limit",
   "quit", "exit"
 ];
 const CODEC_COMMAND_NAMES = ["load", "unload", "list"];
@@ -95,7 +95,8 @@ function createState(options = {}) {
     lastResult: null,
     lastMain: null,
     lastTiming: null,
-    showTiming: true
+    showTiming: true,
+    printLimit: options.printLimit ?? Infinity
   };
 }
 
@@ -354,7 +355,8 @@ function formatCodecOutput(output) {
 }
 
 function printValue(value, state = null) {
-  const lines = [valueWithEnvelopeToK(value)];
+  const limit = state?.printLimit ?? Infinity;
+  const lines = [valueWithEnvelopeToK(value, limit)];
   if (!state || value === undefined) return lines[0];
 
   const store = state.codecs || {};
@@ -363,7 +365,11 @@ function printValue(value, state = null) {
     try {
       const output = codec.print(value, { state });
       if (output != null) {
-        lines.push(`${codec.name}: ${formatCodecOutput(output)}`);
+        let text = formatCodecOutput(output);
+        if (Number.isFinite(limit) && text.length > limit) {
+          text = text.slice(0, limit) + "...";
+        }
+        lines.push(`${codec.name}: ${text}`);
       }
     } catch {
       // Codec cannot format this value; silently skip
@@ -1265,9 +1271,34 @@ async function evaluateCommand(line, state) {
       state.engine = "js";
       return ["engine set to js"];
     }
+    case "limit": {
+      const mode = (arg || "").trim().toLowerCase();
+      if (!mode) {
+        const current = Number.isFinite(state.printLimit)
+          ? state.printLimit
+          : "none";
+        return [`Current output limit: ${current}`];
+      }
+      if (mode === "none" || mode === "infinity" || mode === "off") {
+        state.printLimit = Infinity;
+        return ["output limit disabled"];
+      }
+      const n = parseInt(mode, 10);
+      if (Number.isNaN(n) || n < 0) {
+        throw new Error(
+          `Invalid limit '${arg.trim()}'. Usage: :limit [num|none]`
+        );
+      }
+      state.printLimit = n;
+      return [`output limit set to ${n}`];
+    }
     case "reset": {
       const currentEngine = state.engine;
-      const fresh = createState({ engine: currentEngine });
+      const currentLimit = state.printLimit;
+      const fresh = createState({
+        engine: currentEngine,
+        printLimit: currentLimit
+      });
       Object.assign(state, fresh);
       return ["reset"];
     }
@@ -1302,6 +1333,7 @@ function helpText() {
     ":engine [wasm|pkir|js]   display or switch evaluation engine",
     ":rel name            show relation definition",
     ":rels                list relation aliases",
+    ":limit [num|none]    set maximum characters for value output",
     ":codec load file     load a codec module from file (e.g. :codec load codecs/int.mjs)",
     ":codec unload name   unload a registered codec",
     ":codec list          list loaded codecs (or simply :codecs)",
@@ -1336,6 +1368,7 @@ function cliUsage() {
   console.log("  --pkir                   Shortcut for --engine=pkir.");
   console.log("  --wasm                   Shortcut for --engine=wasm.");
   console.log("  --js                     Shortcut for --engine=js.");
+  console.log("  --limit=<num>            Set maximum characters for output.");
   console.log("  -h, --help               Show this help.");
 }
 
@@ -1431,6 +1464,7 @@ function startRepl(options = {}) {
 if (isMainEntrypoint()) {
   const args = argv.slice(2);
   let engine = "wasm";
+  let printLimit = Infinity;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "-h" || arg === "--help") {
@@ -1461,13 +1495,30 @@ if (isMainEntrypoint()) {
         exit(1);
       }
       engine = val;
+    } else if (arg.startsWith("--limit=")) {
+      const val = parseInt(arg.slice("--limit=".length), 10);
+      if (Number.isNaN(val) || val < 0) {
+        console.error(
+          `Invalid limit '${arg.slice("--limit=".length)}'.`
+        );
+        exit(1);
+      }
+      printLimit = val;
+    } else if (arg === "--limit") {
+      i++;
+      const val = parseInt(args[i] || "", 10);
+      if (Number.isNaN(val) || val < 0) {
+        console.error(`Invalid limit '${args[i]}'.`);
+        exit(1);
+      }
+      printLimit = val;
     } else {
       console.error(`Unknown option '${arg}'.`);
       cliUsage();
       exit(1);
     }
   }
-  startRepl({ engine });
+  startRepl({ engine, printLimit });
 }
 
 export {

package/scripts/build-repl-html.mjs

@@ -91,7 +91,14 @@ for (const filename of verifiedExamples) {
 }
 
 // Bundle verified codecs for browser VFS as 100% self-contained ES modules
-const verifiedCodecs = ["json.mjs", "utf8.mjs", "int.mjs", "unit.mjs", "ieee.mjs"];
+const verifiedCodecs = [
+  "json.mjs",
+  "djson.mjs",
+  "utf8.mjs",
+  "int.mjs",
+  "unit.mjs",
+  "ieee.mjs"
+];
 const codecsDir = path.join(projectRoot, "codecs");
 
 const browserCodecSdkShim = `

package/tests/test-codecs.mjs

@@ -8,10 +8,15 @@ import { fileURLToPath } from "node:url";
 import * as SDK from "../codecs/runtime/codec-sdk.mjs";
 import * as IntCodec from "../codecs/int.mjs";
 import * as JsonCodec from "../codecs/json.mjs";
+import * as DjsonCodec from "../codecs/djson.mjs";
 import * as Utf8Codec from "../codecs/utf8.mjs";
 import * as Utf16Codec from "../codecs/utf16.mjs";
 import * as IeeeCodec from "../codecs/ieee.mjs";
 import * as UnitCodec from "../codecs/unit.mjs";
+import {
+  valueToK,
+  valueWithEnvelopeToK
+} from "../codecs/runtime/show-value.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -49,6 +54,7 @@ console.log("2. Verifying in-memory parse -> enveloped value (P, v)...");
 for (const [name, codec, sampleInput] of [
   ["int.mjs", IntCodec, "42"],
   ["json.mjs", JsonCodec, '{"x": 1}'],
+  ["djson.mjs", DjsonCodec, '{"x": 1, "arr": [true, null, "hi"]}'],
   ["utf8.mjs", Utf8Codec, "hello"],
   ["utf16.mjs", Utf16Codec, "hello"],
   ["ieee.mjs", IeeeCodec, "3.14"],
@@ -68,6 +74,7 @@ console.log("3. Verifying CLI --help flag...");
 for (const relPath of [
   "codecs/int.mjs",
   "codecs/json.mjs",
+  "codecs/djson.mjs",
   "codecs/utf8.mjs",
   "codecs/utf16.mjs",
   "codecs/ieee.mjs",
@@ -111,6 +118,24 @@ console.log("4. Verifying CLI --parse and --print pipelines...");
   assert.deepEqual(JSON.parse(printRes.stdout.toString("utf8")), JSON.parse(jsonInput));
 }
 
+// djson.mjs: dynamic JSON AST with singleton pattern
+{
+  const djsonInput = JSON.stringify({
+    name: "k",
+    count: 42.5,
+    tags: ["fast", "typed"],
+    meta: { active: true, extra: null }
+  });
+  const parseRes = runCLI("codecs/djson.mjs", ["--parse"], djsonInput);
+  assert.equal(parseRes.status, 0);
+  const printRes = runCLI("codecs/djson.mjs", ["--print"], parseRes.stdout);
+  assert.equal(printRes.status, 0);
+  assert.deepEqual(
+    JSON.parse(printRes.stdout.toString("utf8")),
+    JSON.parse(djsonInput)
+  );
+}
+
 // utf8.mjs: unicode text
 {
   const utf8Input = "Hello 🌍, ąęćłó! \nSecond line.";
@@ -183,4 +208,147 @@ console.log("6. Verifying pattern derivation via k type system (patternFromFilte
   assert.throws(() => SDK.patternFromFilter(".field"), /Main expression must be a filter or a type name/);
 }
 
+// 7. Lazy Prefix-Free Wire Decoding
+console.log("7. Verifying lazy prefix-free wire decoding...");
+{
+  assert.equal(typeof SDK.decodeWireLazy, "function");
+
+  // Lazy decoding should instantiate root in sub-millisecond time
+  const sampleStr = "a".repeat(20000);
+  const parsedStr = Utf8Codec.parse(sampleStr);
+  const wireStr = SDK.encodeToWire(parsedStr, parsedStr.pattern);
+
+  const t0 = performance.now();
+  const decodedLazy = SDK.decodeWire(wireStr);
+  const constructMs = performance.now() - t0;
+  assert(
+    constructMs < 50,
+    `Lazy decode took ${constructMs}ms (expected <50ms)`
+  );
+  assert.equal(decodedLazy.value.tag, "cons");
+
+  // On-demand traversal through print()
+  const printedStr = Utf8Codec.print(decodedLazy.value);
+  assert.equal(printedStr, sampleStr);
+
+  // Lazy list of integers
+  const ints = Array.from({ length: 5000 }, (_, i) => i).join(",");
+  const sampleList = `[${ints}]`;
+  const parsedList = IntCodec.parse(sampleList);
+  const wireList = SDK.encodeToWire(parsedList, parsedList.pattern);
+  const decodedList = SDK.decodeWireLazy(wireList);
+  assert.equal(IntCodec.print(decodedList.value), sampleList);
+
+  // Verify stack-safe toJSON on deep variant chains
+  let deepVal = SDK.Value.product({});
+  for (let i = 0; i < 15000; i++) {
+    deepVal = SDK.Value.variant("step", deepVal);
+  }
+  const json = deepVal.toJSON();
+  assert(json && typeof json === "object");
+}
+
+// 8. High-Speed Direct Bitstream String Decoding & Bounded Rendering
+console.log("8. Verifying fast string decoding & bounded rendering...");
+{
+  const testStrings = [
+    "hello world",
+    "Zażółć gęślą jaźń",
+    "Unicode: 🚀🎉 𝒦-lang π ≈ 3.14159",
+    "a".repeat(50000),
+    ""
+  ];
+
+  for (const s of testStrings) {
+    const parsed = Utf8Codec.parse(s);
+    const wire = SDK.encodeToWire(parsed, parsed.pattern);
+    const decoded = SDK.decodeWire(wire);
+    const restored = Utf8Codec.print(decoded.value);
+    assert.equal(
+      restored,
+      s,
+      `String round-trip failed for "${s.slice(0, 20)}..."`
+    );
+  }
+
+  // Fast decoding performance: 50,000 ASCII chars in < 500ms
+  const bigAscii = "x".repeat(50000);
+  const bigParsed = Utf8Codec.parse(bigAscii);
+  const bigWire = SDK.encodeToWire(bigParsed, bigParsed.pattern);
+  const tStart = performance.now();
+  const bigDecoded = SDK.decodeWire(bigWire);
+  const bigRestored = Utf8Codec.print(bigDecoded.value);
+  const elapsed = performance.now() - tStart;
+  assert.equal(bigRestored.length, 50000);
+  assert(
+    elapsed < 500,
+    `Fast string decoding took ${elapsed}ms (expected < 500ms)`
+  );
+
+  // Bounded rendering: valueToK with limit
+  let deepVal = SDK.Value.product({});
+  for (let i = 0; i < 1000; i++) {
+    deepVal = SDK.Value.variant("item", deepVal);
+  }
+  const preview = valueToK(deepVal, 30);
+  assert(preview.endsWith("..."), "Output should end with '...'");
+  assert(preview.length <= 35, "Preview length should stay bounded");
+
+  // valueWithEnvelopeToK with limit
+  const enveloped = SDK.withPattern(deepVal, [["any", []]]);
+  const envPreview = valueWithEnvelopeToK(enveloped, 30);
+  assert(envPreview.includes("..."), "Preview should contain '...'");
+
+  // Ensure early termination: evaluating deep chain with limit 20
+  let hugeVal = SDK.Value.product({});
+  for (let i = 0; i < 50000; i++) {
+    hugeVal = SDK.Value.variant("v", hugeVal);
+  }
+  const tEarly0 = performance.now();
+  const earlyPreview = valueToK(hugeVal, 20);
+  const tEarlyElapsed = performance.now() - tEarly0;
+  assert(earlyPreview.endsWith("..."));
+  assert(
+    tEarlyElapsed < 50,
+    `Early termination took ${tEarlyElapsed}ms (expected < 50ms)`
+  );
+}
+
+// 9. DJSON Singleton Pattern Invariant & Round-Trip
+console.log("9. Verifying DJSON singleton pattern invariant...");
+{
+  assert(Array.isArray(DjsonCodec.DJSON_PATTERN));
+  assert.equal(DjsonCodec.DJSON_PATTERN.length, 29);
+
+  const samples = [
+    null,
+    true,
+    false,
+    123.456,
+    "Hello world!",
+    [],
+    [1, "text", false, null],
+    {},
+    { key: "value", nested: [1, 2, { deep: true }] }
+  ];
+
+  for (const sample of samples) {
+    const jsonStr = JSON.stringify(sample);
+    const enveloped = DjsonCodec.parse(jsonStr);
+    assert.strictEqual(
+      enveloped.pattern,
+      DjsonCodec.DJSON_PATTERN,
+      "Every DJSON value must share the exact singleton pattern"
+    );
+    const wire = SDK.encodeToWire(enveloped, enveloped.pattern);
+    const decoded = SDK.decodeWire(wire);
+    const restored = DjsonCodec.print(decoded.value);
+    assert.deepEqual(
+      JSON.parse(restored),
+      sample,
+      `DJSON round-trip mismatch for: ${jsonStr}`
+    );
+  }
+}
+
 console.log("OK - All codec tests passed.");

package/tests/test-repl-html.mjs

@@ -140,6 +140,7 @@ if (chromiumBin) {
     const expectedFiles = [
       "arithmetics.k",
       "core.k",
+      "djson.mjs",
       "ieee.k",
       "ieee.mjs",
       "int.mjs",