@fraczak/k 7.1.0 → 8.0.0

package/codecs/djson.mjs

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+
+/**
+ * Dynamic JSON (djson) codec with universal singleton pattern.
+ *
+ * Translates arbitrary JSON data to/from self-describing enveloped k
+ * values using a single recursive AST pattern:
+ *
+ *   JSON = <
+ *     float64 number,
+ *     str string,
+ *     <{} true, {} false> bool,
+ *     {} null,
+ *     <{} nil, {JSON car, LIST cdr} cons> = LIST list,
+ *     <{} nil, {{str key, JSON val} car, OBJ cdr} cons> = OBJ object
+ *   >
+ */
+
+import {
+  Value,
+  isProduct,
+  isVariant,
+  withPattern,
+  patternFromFilter,
+  runCodecCLI
+} from "./runtime/codec-sdk.mjs";
+import { encodeNumberToValue, decodeValueToNumber } from "./ieee.mjs";
+import {
+  textToStringValue,
+  stringValueToText
+} from "./runtime/unicode-string.mjs";
+
+export const doc = `
+Dynamic JSON (djson) codec with universal singleton pattern.
+
+Translates any JSON value to/from self-describing enveloped k values
+conforming to the universal recursive JSON AST type:
+  JSON = <
+    float64 number,
+    str string,
+    <{} true, {} false> bool,
+    {} null,
+    <{} nil, {JSON car, LIST cdr} cons> = LIST list,
+    <{} nil, {{str key, JSON val} car, OBJ cdr} cons> = OBJ object
+  >
+`;
+
+export const DJSON_PATTERN = patternFromFilter(`
+? <
+  {
+    < {} "+", {} "-" > sign,
+    {
+      < {} 0, {} 1 >=Bit 0,
+      Bit 1, Bit 2, Bit 3, Bit 4, Bit 5,
+      Bit 6, Bit 7, Bit 8, Bit 9, Bit 10
+    } exponent,
+    {
+      Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5,
+      Bit 6, Bit 7, Bit 8, Bit 9, Bit 10, Bit 11,
+      Bit 12, Bit 13, Bit 14, Bit 15, Bit 16, Bit 17,
+      Bit 18, Bit 19, Bit 20, Bit 21, Bit 22, Bit 23,
+      Bit 24, Bit 25, Bit 26, Bit 27, Bit 28, Bit 29,
+      Bit 30, Bit 31, Bit 32, Bit 33, Bit 34, Bit 35,
+      Bit 36, Bit 37, Bit 38, Bit 39, Bit 40, Bit 41,
+      Bit 42, Bit 43, Bit 44, Bit 45, Bit 46, Bit 47,
+      Bit 48, Bit 49, Bit 50, Bit 51
+    } fraction
+  } number,
+
+  <
+    {} nil,
+    {
+      <
+        {
+          < {} 0, {} 1 >=Bit7 0,
+          Bit7 1, Bit7 2, Bit7 3, Bit7 4, Bit7 5, Bit7 6
+        }=Bits7 ascii,
+        {
+          <
+            { Bit7 0, Bit7 1, Bit7 2 }=Bits3 h08_0F,
+            Bits7 h10_7F,
+            Bits7 h80_CF,
+            Bits3 hD0_D7,
+            {} hF9,
+            { Bit7 0 }=Bits1 hFA_FB,
+            Bits1 hFC_FD,
+            Bits1 hFE_FF
+          > hi,
+          {
+            Bit7 0, Bit7 1, Bit7 2, Bit7 3,
+            Bit7 4, Bit7 5, Bit7 6, Bit7 7
+          }=Bits8 lo
+        } bmp_common,
+        {
+          <
+            { Bit7 0, Bit7 1, Bit7 2, Bit7 3 } hE0_EF,
+            Bits3 hF0_F7,
+            {} hF8
+          > hi,
+          Bits8 lo
+        } bmp_private_use,
+        {
+          Bit7 0, Bit7 1, Bit7 2, Bit7 3, Bit7 4, Bit7 5,
+          Bit7 6, Bit7 7, Bit7 8, Bit7 9, Bit7 10
+        } plane0,
+        { Bits8 mid, Bits8 lo } supplementary_plane1,
+        {
+          <
+            Bits1 p02_03,
+            { Bit7 0, Bit7 1 } p04_07,
+            Bits3 p08_0F,
+            {} p10
+          > plane,
+          Bits8 mid,
+          Bits8 lo
+        } supplementary_planes2_16
+      > car,
+      Str cdr
+    } cons
+  > = Str string,
+
+  < {} true, {} false > bool,
+  {} null,
+
+  < {} nil, { JSON car, LIST cdr } cons > = LIST list,
+
+  < {} nil, { { Str key, JSON val } car, OBJ cdr } cons > = OBJ object
+> = JSON
+`);
+
+const UNIT = Value.product({});
+
+function requireProduct(value, where) {
+  if (!isProduct(value)) {
+    throw new Error(`${where}: expected Product`);
+  }
+  return value.product;
+}
+
+function listToK(items) {
+  let result = Value.variant("nil", UNIT);
+  for (let i = items.length - 1; i >= 0; i--) {
+    result = Value.variant("cons", Value.product({
+      car: items[i],
+      cdr: result
+    }));
+  }
+  return result;
+}
+
+function listFromK(value, where) {
+  const result = [];
+  let current = value;
+  while (true) {
+    if (!isVariant(current)) {
+      throw new Error(`${where}: expected list variant (nil or cons)`);
+    }
+    if (current.tag === "nil") {
+      requireProduct(current.value, `${where}.nil`);
+      return result;
+    }
+    if (current.tag !== "cons") {
+      throw new Error(
+        `${where}: expected nil or cons, got ${current.tag}`
+      );
+    }
+    const pair = requireProduct(current.value, `${where}.cons`);
+    result.push(pair.car);
+    current = pair.cdr;
+  }
+}
+
+export function fromJsonValue(value) {
+  if (value === null) {
+    return Value.variant("null", UNIT);
+  }
+  if (typeof value === "boolean") {
+    return Value.variant(
+      "bool",
+      Value.variant(value ? "true" : "false", UNIT)
+    );
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("JSON numbers must be finite");
+    }
+    return Value.variant("number", encodeNumberToValue(value));
+  }
+  if (typeof value === "string") {
+    return Value.variant("string", textToStringValue(value));
+  }
+  if (Array.isArray(value)) {
+    return Value.variant("list", listToK(value.map(fromJsonValue)));
+  }
+  if (value && typeof value === "object") {
+    const keys = Object.keys(value).sort();
+    const entries = keys.map((k) =>
+      Value.product({
+        key: textToStringValue(k),
+        val: fromJsonValue(value[k])
+      })
+    );
+    return Value.variant("object", listToK(entries));
+  }
+  throw new Error(`Unsupported JSON value: ${value}`);
+}
+
+export function toJsonValue(value) {
+  if (!isVariant(value)) {
+    throw new Error("djson.value: expected top-level Variant");
+  }
+
+  if (value.tag === "null") {
+    requireProduct(value.value, "djson.null");
+    return null;
+  }
+
+  if (value.tag === "bool") {
+    if (!isVariant(value.value)) {
+      throw new Error("djson.bool: expected variant");
+    }
+    if (value.value.tag === "true") {
+      requireProduct(value.value.value, "djson.bool.true");
+      return true;
+    }
+    if (value.value.tag === "false") {
+      requireProduct(value.value.value, "djson.bool.false");
+      return false;
+    }
+    throw new Error(`djson.bool: invalid tag ${value.value.tag}`);
+  }
+
+  if (value.tag === "number") {
+    return decodeValueToNumber(value.value);
+  }
+
+  if (value.tag === "string") {
+    return stringValueToText(value.value);
+  }
+
+  if (value.tag === "list") {
+    const items = listFromK(value.value, "djson.list");
+    return items.map(toJsonValue);
+  }
+
+  if (value.tag === "object") {
+    const pairs = listFromK(value.value, "djson.object");
+    const result = {};
+    for (const pairValue of pairs) {
+      const pair = requireProduct(pairValue, "djson.object.pair");
+      const key = stringValueToText(pair.key);
+      result[key] = toJsonValue(pair.val);
+    }
+    return result;
+  }
+
+  throw new Error(`Unsupported djson tag: ${value.tag}`);
+}
+
+export function parse(text) {
+  const json = JSON.parse(text);
+  const value = fromJsonValue(json);
+  return withPattern(value, DJSON_PATTERN);
+}
+
+export function print(value) {
+  return JSON.stringify(toJsonValue(value));
+}
+
+runCodecCLI(import.meta.url, { parse, print, doc });

package/codecs/int.mjs

@@ -14,7 +14,8 @@ export const doc = `
 Decimal integers and integer lists.
 
 Syntax:
-  Decimal integer (e.g. 42, -15) or bracketed integer list (e.g. [0, 1, 2], []).
+  Decimal integer (e.g. 42, -15) or bracketed integer list
+  (e.g. [0, 1, 2], []).
 `;
 
 // Closed pattern for $ int = < bits '+', bits '-' >

package/codecs/json.mjs

@@ -4,9 +4,14 @@ import { withPattern, runCodecCLI } from "./runtime/codec-sdk.mjs";
 import { fromJsonValue, toJsonValue, patternFromJsonValue } from "./json-codec.mjs";
 
 export const doc = `
-JSON codec (RFC 8259).
+Schema-specializing JSON codec (RFC 8259).
 
-Translates JSON data to/from self-describing enveloped k values.
+Translates JSON data to/from self-describing enveloped k values where
+each JSON document derives a document-specific pattern:
+  - objects map to products { field: value, ... }
+  - arrays map to indexed products { "0": a0, "1": a1, ... }
+  - numbers, strings, booleans, and null map to canonical k values
+(See djson.mjs for the universal singleton-pattern dynamic JSON codec.)
 `;
 
 export function parse(text) {

package/codecs/k-parse.mjs

@@ -82,7 +82,13 @@ async function main() {
     return exit(1);
   }
 
-  const inputBuffer = valueFile ? fs.readFileSync(valueFile) : await readAll(stdin);
+  stdout.on("error", (err) => {
+    if (err.code === "EPIPE") exit(0);
+  });
+
+  const inputBuffer = valueFile
+    ? fs.readFileSync(valueFile)
+    : await readAll(stdin);
   const inputText = inputBuffer.toString("utf8");
   const value = parseValue(inputText, null, null);
 

package/codecs/k-print.mjs

@@ -60,6 +60,10 @@ async function main() {
     }
   }
 
+  stdout.on("error", (err) => {
+    if (err.code === "EPIPE") process.exit(0);
+  });
+
   const input = fileArg ? fs.createReadStream(fileArg) : stdin;
   const buffer = await readAll(input);
   const { pattern, value } = decodeWire(buffer);

package/codecs/runtime/codec-sdk.mjs

@@ -3,8 +3,17 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { stdin, stdout, stderr, exit } from "node:process";
-import { Value, isProduct, isVariant, withPattern } from "../../Value.mjs";
-import { decodeWire, encodeToWire } from "./prefix-codec.mjs";
+import {
+  Value,
+  isProduct,
+  isVariant,
+  withPattern
+} from "../../Value.mjs";
+import {
+  decodeWire,
+  decodeWireLazy,
+  encodeToWire
+} from "./prefix-codec.mjs";
 import { isMainEntrypoint } from "./cli-entry.mjs";
 import { patternFromFilter } from "./pattern-k.mjs";
 
@@ -53,6 +62,10 @@ function runCodecCLI(metaUrl, codec) {
 
   const mode = args[0];
 
+  stdout.on("error", (err) => {
+    if (err.code === "EPIPE") exit(0);
+  });
+
   (async () => {
     if (mode === "--parse") {
       let parsed;
@@ -92,6 +105,7 @@ export {
   withPattern,
   encodeToWire,
   decodeWire,
+  decodeWireLazy,
   isMainEntrypoint,
   runCodecCLI,
   patternFromFilter

package/codecs/runtime/pattern-json.mjs

@@ -80,17 +80,96 @@ function propertyListToPattern(propertyList) {
       throw new Error("Pattern node 'any' cannot have outgoing edges");
     }
 
+    const tagIndex = Object.create(null);
+    for (let i = 0; i < edges.length; i++) {
+      tagIndex[edges[i].label] = i;
+    }
+    const choiceBits = edges.length <= 1
+      ? 0
+      : Math.ceil(Math.log2(edges.length));
     return {
       kind,
-      edges: edges.map((edge) => ({ ...edge, symbolId: symbolIds.get(edge.label) }))
+      edges: edges.map((edge) => ({
+        ...edge,
+        symbolId: symbolIds.get(edge.label)
+      })),
+      tagIndex,
+      choiceBits
     };
   });
 
+  computePatternBitWidths(nodes);
+
   return {
     dictionary,
     nodes
   };
 }
 
+function computePatternBitWidths(nodes) {
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.fixedBitWidth !== undefined) continue;
+
+      if (node.kind === NAME_TO_NODE_KIND["closed-product"]) {
+        if (node.edges.length === 0) {
+          node.fixedBitWidth = 0;
+          node.staticOffsets = [];
+          changed = true;
+        } else {
+          let allKnown = true;
+          let sum = 0;
+          const offsets = new Array(node.edges.length);
+          for (let j = 0; j < node.edges.length; j++) {
+            const target = nodes[node.edges[j].target];
+            if (target.fixedBitWidth === undefined) {
+              allKnown = false;
+              break;
+            }
+            offsets[j] = sum;
+            sum += target.fixedBitWidth;
+          }
+          if (allKnown) {
+            node.fixedBitWidth = sum;
+            node.staticOffsets = offsets;
+            changed = true;
+          }
+        }
+      } else if (node.kind === NAME_TO_NODE_KIND["closed-union"]) {
+        if (node.edges.length > 0) {
+          const firstTarget = nodes[node.edges[0].target];
+          const w = firstTarget.fixedBitWidth;
+          if (w !== undefined) {
+            let allSame = true;
+            for (let j = 1; j < node.edges.length; j++) {
+              if (nodes[node.edges[j].target].fixedBitWidth !== w) {
+                allSame = false;
+                break;
+              }
+            }
+            if (allSame) {
+              node.fixedBitWidth = node.choiceBits + w;
+              changed = true;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < nodes.length; i++) {
+    const edges = nodes[i].edges;
+    for (let j = 0; j < edges.length; j++) {
+      const target = nodes[edges[j].target];
+      if (target.fixedBitWidth !== undefined) {
+        edges[j].fixedTargetBitWidth = target.fixedBitWidth;
+      }
+    }
+  }
+}
+
 export { patternToPropertyList, propertyListToPattern, NODE_KIND_TO_NAME, NAME_TO_NODE_KIND };
 export default { patternToPropertyList, propertyListToPattern, NODE_KIND_TO_NAME, NAME_TO_NODE_KIND };