@fraczak/k 7.0.2 → 7.2.0

package/tests/test-access-table.mjs

@@ -0,0 +1,213 @@
+import assert from "node:assert/strict";
+import { buildAccessTable } from "../access-table.mjs";
+
+console.log("==> Running Access Table Tests (tests/test-access-table.mjs)");
+
+// --------------------------------------------------------------------
+// Test 1: Access Table for 'search' on Disparate Schema
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 1: Access Table for 'search' on Disparate Schema");
+
+  // Input Schema S: list of { data, flag, id }
+  const S_list = [
+    ["closed-union", [["cons", 1], ["nil", 2]]],
+    ["closed-product", [["car", 3], ["cdr", 0]]],
+    ["closed-product", []],
+    ["closed-product", [["data", 4], ["flag", 5], ["id", 6]]],
+    ["any", []],
+    ["closed-union", [["false", 2], ["true", 2]]],
+    ["any", []]
+  ];
+
+  // Function Pattern P: list of { flag: <true, ...> }
+  const P_search = [
+    ["closed-union", [["cons", 1], ["nil", 2]]],
+    ["closed-product", [["car", 3], ["cdr", 0]]],
+    ["closed-product", []],
+    ["open-product", [["flag", 4]]],
+    ["open-union", [["true", 2]]],
+  ];
+
+  const table = buildAccessTable(S_list, P_search, { wordSize: 8 });
+  assert.equal(table.stateCount, 7);
+
+  // 1a: Check list union resolution (State 0)
+  const consVariant = table.resolveVariant(0, "cons");
+  assert.equal(consVariant.tagId, 0);
+  assert.equal(consVariant.branchId, 0);
+  assert.equal(consVariant.childState, 1);
+
+  const nilVariant = table.resolveVariant(0, "nil");
+  assert.equal(nilVariant.tagId, 1);
+  assert.equal(nilVariant.branchId, 1);
+  assert.equal(nilVariant.childState, 2);
+
+  // 1b: Check cons product resolution (State 1)
+  const carField = table.resolveField(1, "car");
+  assert.equal(carField.physicalSlot, 0);
+  assert.equal(carField.byteOffset, 0);
+  assert.equal(carField.childState, 3);
+
+  const cdrField = table.resolveField(1, "cdr");
+  assert.equal(cdrField.physicalSlot, 1);
+  assert.equal(cdrField.byteOffset, 8);
+  assert.equal(cdrField.childState, 0);
+
+  // 1c: Check item product resolution (State 3: { data, flag, id })
+  // In alphabetical order: data = 0, flag = 1, id = 2
+  const flagField = table.resolveField(3, "flag");
+  assert.equal(flagField.physicalSlot, 1);
+  assert.equal(flagField.byteOffset, 8);
+  assert.equal(flagField.skipCount, 1);
+  assert.equal(flagField.childState, 5); // points to boolean union
+
+  // Logical slot access (by numeric slot 0)
+  const flagBySlot = table.resolveField(3, 0);
+  assert.equal(flagBySlot.byteOffset, 8);
+  assert.equal(flagBySlot.childState, 5);
+  assert.equal(flagBySlot.skipCount, 1);
+
+  console.log("    Passed: AccessTable correctly resolves fields and variants.");
+}
+
+// --------------------------------------------------------------------
+// Test 2: Access Table for Multi-Variant Dispatch ('extract_id')
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 2: Access Table for Multi-Variant Dispatch");
+
+  const P_extract = [
+    ["closed-union", [["click", 1], ["ping", 2], ["sensor", 3]]],
+    ["open-product", [["id", 4]]],
+    ["open-product", [["id", 4]]],
+    ["open-product", [["id", 4]]],
+    ["any", []]
+  ];
+
+  // Click: { active, id } -> id is at physical slot 1
+  const S_click = [
+    ["closed-union", [["click", 1]]],
+    ["closed-product", [["active", 2], ["id", 3]]],
+    ["any", []],
+    ["any", []]
+  ];
+
+  // Sensor: { battery_low, id, reading } -> id is at physical slot 1
+  const S_sensor = [
+    ["closed-union", [["sensor", 1]]],
+    ["closed-product", [["battery_low", 2], ["id", 3], ["reading", 4]]],
+    ["any", []],
+    ["any", []],
+    ["any", []]
+  ];
+
+  // Ping: { id } -> id is at physical slot 0
+  const S_ping = [
+    ["closed-union", [["ping", 1]]],
+    ["closed-product", [["id", 2]]],
+    ["any", []]
+  ];
+
+  const tClick = buildAccessTable(S_click, P_extract, { wordSize: 8 });
+  const tSensor = buildAccessTable(S_sensor, P_extract, { wordSize: 8 });
+  const tPing = buildAccessTable(S_ping, P_extract, { wordSize: 8 });
+
+  // In click, id is at offset 8 (after active)
+  assert.equal(tClick.resolveField(1, "id").byteOffset, 8);
+  assert.equal(tClick.resolveField(1, "id").skipCount, 1);
+
+  // In sensor, id is at offset 8 (after battery_low)
+  assert.equal(tSensor.resolveField(1, "id").byteOffset, 8);
+  assert.equal(tSensor.resolveField(1, "id").skipCount, 1);
+
+  // In ping, id is at offset 0
+  assert.equal(tPing.resolveField(1, "id").byteOffset, 0);
+  assert.equal(tPing.resolveField(1, "id").skipCount, 0);
+
+  console.log("    Passed: Variable offsets resolved per variant schema.");
+}
+
+// --------------------------------------------------------------------
+// Test 3: Simulating In-Memory Payload Navigation via AccessTable
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 3: Simulating In-Memory Payload Navigation");
+
+  // S: list of { data, flag, id }
+  const S = [
+    ["closed-union", [["cons", 1], ["nil", 2]]],
+    ["closed-product", [["car", 3], ["cdr", 0]]],
+    ["closed-product", []],
+    ["closed-product", [["data", 4], ["flag", 5], ["id", 6]]],
+    ["any", []],
+    ["closed-union", [["false", 2], ["true", 2]]],
+    ["any", []]
+  ];
+
+  const P = [
+    ["closed-union", [["cons", 1], ["nil", 2]]],
+    ["closed-product", [["car", 3], ["cdr", 0]]],
+    ["closed-product", []],
+    ["open-product", [["flag", 4]]],
+    ["open-union", [["true", 2]]],
+  ];
+
+  const table = buildAccessTable(S, P, { wordSize: 8 });
+
+  // Mock in-memory value representation:
+  // Node representation in word arrays:
+  // Item 1: { data: 'blob1', flag: 'true', id: 'alpha' }
+  // Sorted physical layout: slot 0 = data, slot 1 = flag, slot 2 = id
+  const item1 = {
+    tag: null,
+    words: [
+      { text: "blob1" }, // offset 0
+      { tag: 1, text: "true" }, // offset 8 (true is tag 1 in {false:0, true:1})
+      { text: "alpha" } // offset 16
+    ]
+  };
+
+  // Cons cell: slot 0 = car, slot 1 = cdr
+  const nilCell = { tag: 1, words: [] }; // tag 1 = nil
+  const consCell = {
+    tag: 0, // tag 0 = cons
+    words: [item1, nilCell]
+  };
+
+  // Navigate using table and word indices (zero string comparisons):
+  let state = table.rootState; // 0
+  assert.equal(state, 0);
+
+  // Step 1: Match union at root
+  const unionDesc = table.getDescriptor(state);
+  const tag = consCell.tag; // 0
+  const branch = unionDesc.branchMap[tag]; // 0 (cons)
+  assert.equal(branch, 0);
+  state = unionDesc.childStateMap[tag]; // state 1 (cons product)
+  assert.equal(state, 1);
+
+  // Step 2: Project .car (slot 0)
+  const carMeta = table.resolveField(state, 0);
+  assert.equal(carMeta.byteOffset, 0);
+  const carNode = consCell.words[carMeta.byteOffset / 8];
+  state = carMeta.childState; // state 3 (item product)
+  assert.equal(state, 3);
+
+  // Step 3: Project .flag (slot 0 in P's view of car)
+  const flagMeta = table.resolveField(state, 0);
+  assert.equal(flagMeta.byteOffset, 8); // correctly jumps to slot 1!
+  const flagVal = carNode.words[flagMeta.byteOffset / 8];
+  state = flagMeta.childState; // state 5 (boolean union)
+  assert.equal(state, 5);
+
+  // Step 4: Check if flag is 'true'
+  const boolDesc = table.getDescriptor(state);
+  const flagTag = flagVal.tag; // 1 ('true')
+  const flagBranch = boolDesc.branchMap[flagTag];
+  assert.equal(flagBranch, 0); // matches P's only branch ('true')
+
+  console.log("    Passed: Zero-string navigation simulation successful.");
+}
+
+console.log("\n==> All Access Table Tests Passed Successfully!");

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.");