@fraczak/k 7.0.2 → 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

@@ -6,13 +6,27 @@ import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
 import { decodeWire } from "./runtime/prefix-codec.mjs";
 import { propertyListToFilter, valueToK } from "./runtime/show-value.mjs";
 
+function helpText() {
+  const prog = argv[1] || "show.mjs";
+  return [
+    "Pass a binary wire stream through unchanged on stdout while",
+    "printing the decoded value and filter to stderr.",
+    "",
+    `Usage: ${prog} [wire-file]`,
+    "",
+    "Arguments:",
+    "  wire-file    Input binary wire file (default: stdin).",
+    "",
+    "Options:",
+    "  -h, --help   Show this help.",
+    "",
+    "Examples:",
+    `  echo '"hello"' | k-parse | ${prog} | k-print`
+  ].join("\n");
+}
+
 function usage(stream = console.error) {
-  stream(`Usage: ${argv[1]} [wire-file]`);
-  stream("  Pass the wire stream through unchanged on stdout.");
-  stream("  Print the decoded value and filter to stderr.");
-  stream("");
-  stream("Options:");
-  stream("  -h, --help   Show this help.");
+  stream(helpText());
 }
 
 function readAll(stream) {
@@ -37,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/k.mjs

@@ -4,27 +4,58 @@
 import fs from "node:fs";
 import { argv, stdin, exit, stdout } from "node:process";
 import k from "./index.mjs";
-import { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
-import { decodeObject, objectToFunction, loadLibrary } from "./object.mjs";
-
-const prog = argv[1];
+import {
+  decodeWire,
+  encodeToWire
+} from "./codecs/runtime/prefix-codec.mjs";
+import {
+  compileLibrary,
+  decodeObject,
+  objectToFunction,
+  loadLibrary
+} from "./object.mjs";
 
 let kScript, inputStream;
 
-function usage() {
-  console.error(`Usage: ${prog} [ --lib lib-file ] [ --export spec ]... ( k-expr | file ) [ input-file ]`);
-  console.error(`       E.g.,  echo '["zebara","ela"]' | k-parse --input-type '$x=<{} zebara, {} ela>; $v={x 0, x 1}; $v' | ${prog} '{.1 0}'`);
-  console.error("Options:");
-  console.error("  --lib file      Load one .klib dependency before compiling.");
-  console.error("  --export spec   Export a library alias into scope. 'name' or 'libname:localname'. May be repeated.");
-  console.error("  -h, --help      Show this help.");
+function helpText() {
+  const prog = argv[1] || "k.mjs";
+  return [
+    "Compile and execute a k expression or file over a binary",
+    "pattern+value wire stream using the JavaScript interpreter.",
+    "",
+    `Usage: ${prog} [options]`,
+    "       ( source-snippet | input-file ) [ input-wire-file ]",
+    "",
+    "Arguments:",
+    "  source-snippet   Inline k source snippet.",
+    "  input-file       Source .k, .ko, or .klib file.",
+    "  input-wire-file  Optional binary wire input (default: stdin).",
+    "",
+    "Options:",
+    "  --lib file       Load one .klib or .k library before compiling.",
+    "  --export spec    Export library alias into scope. Repeatable.",
+    "                   spec is 'name' or 'libname:localname'.",
+    "  -h, --help       Show this help.",
+    "",
+    "Examples:",
+    `  echo '"abc"' | k-parse | ${prog} '{.1 0}' | k-print`,
+    `  echo '{"x":1,"y":2}' | k-json --parse | \\`,
+    `    ${prog} --lib Examples/poly.k --export concat \\`,
+    `      's={()xs,()ys}concat; s' | k-json --print`
+  ].join("\n");
+}
+
+function usage(stream = console.error) {
+  stream(helpText());
 }
 
 function isFile(filePath) {
   try {
     return fs.statSync(filePath).isFile();
   } catch (error) {
-    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") return false;
+    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") {
+      return false;
+    }
     throw error;
   }
 }
@@ -41,7 +72,7 @@ function compileFile(filePath, libraries, preamble) {
 ({ kScript, inputStream } = ((args) => {
   try {
     if (args.includes("-h") || args.includes("--help")) {
-      usage();
+      usage(console.log);
       return exit(0);
     }
 
@@ -53,9 +84,18 @@ function compileFile(filePath, libraries, preamble) {
         args.shift();
         const libPath = args.shift();
         if (!libPath) throw new Error("--lib requires a file argument");
-        if (libraries.length > 0) throw new Error("--lib may be specified at most once");
-        const libBuffer = fs.readFileSync(libPath);
-        libraries.push(loadLibrary(decodeObject(libBuffer)));
+        if (libraries.length > 0) {
+          throw new Error("--lib may be specified at most once");
+        }
+        if (libPath.endsWith(".k")) {
+          const raw = fs.readFileSync(libPath, "utf8");
+          libraries.push(
+            loadLibrary(compileLibrary(raw, { source: libPath }))
+          );
+        } else {
+          const libBuffer = fs.readFileSync(libPath);
+          libraries.push(loadLibrary(decodeObject(libBuffer)));
+        }
       } else if (args[0] === "--export") {
         args.shift();
         const spec = args.shift();

package/kir.mjs

@@ -601,20 +601,27 @@ export default {
 };
 
 function helpText() {
+  const prog = argv[1] || "kir.mjs";
   return [
     "Export the KIR-P JSON view from a k .ko or .klib object.",
     "",
-    `Usage: ${argv[1]} [options] [object-file]`,
+    `Usage: ${prog} [options] [object-file]`,
     "",
     "Arguments:",
-    "  object-file    Input .ko or .klib file. Reads from stdin when omitted.",
+    "  object-file            Input .ko or .klib file (default: stdin).",
     "",
     "Options:",
+    "  -o, --output path      Specify output file path explicitly.",
     "  --retype rel           Export retyped KIR-P for relation rel.",
-    "  --input-pattern json   Input pattern property-list JSON, or a file containing it.",
-    "  -h, --help     Show this help.",
+    "  --input-pattern json   Input pattern JSON or file for spec.",
+    "  -h, --help             Show this help.",
     "",
-    "KIR-P is an inspection/export view; retyping also emits KIR-P."
+    "KIR-P is an inspection/export view; retyping also emits KIR-P.",
+    "",
+    "Examples:",
+    `  ${prog} program.ko`,
+    `  ${prog} program.ko -o program.kir.json`,
+    `  ${prog} --retype main --input-pattern pattern.json program.ko`
   ].join("\n");
 }
 
@@ -643,32 +650,64 @@ async function main() {
 
   let retypeRelation = null;
   let inputPatternArg = null;
-  while (args.length > 0 && args[0].startsWith("--")) {
-    const option = args.shift();
-    if (option === "--retype") {
+  let explicitOutput = null;
+  const remainingArgs = [];
+  while (args.length > 0) {
+    const arg = args[0];
+    if (arg === "-o" || arg === "--output") {
+      args.shift();
+      explicitOutput = args.shift();
+      if (!explicitOutput) {
+        throw new Error("-o/--output requires a file argument");
+      }
+    } else if (arg === "--retype") {
+      args.shift();
       retypeRelation = args.shift();
       if (!retypeRelation) throw new Error("--retype requires a relation name");
-    } else if (option === "--input-pattern") {
+    } else if (arg === "--input-pattern") {
+      args.shift();
       inputPatternArg = args.shift();
-      if (!inputPatternArg) throw new Error("--input-pattern requires JSON or a file path");
+      if (!inputPatternArg) {
+        throw new Error("--input-pattern requires JSON or a file path");
+      }
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
     } else {
-      throw new Error(`Unknown option: ${option}`);
+      remainingArgs.push(args.shift());
     }
   }
 
-  const inputPath = args.shift() || null;
-  if (args.length > 0) {
-    throw new Error(`Unexpected argument: ${args[0]}`);
+  const inputPath = remainingArgs.shift() || null;
+  if (remainingArgs.length > 0) {
+    throw new Error(`Unexpected argument: ${remainingArgs[0]}`);
   }
 
-  const buffer = inputPath == null ? await readStdinBytes() : fs.readFileSync(inputPath);
+  const buffer = inputPath == null
+    ? await readStdinBytes()
+    : fs.readFileSync(inputPath);
   const object = decodeObject(buffer);
+  let outputData;
   if (retypeRelation != null) {
-    if (inputPatternArg == null) throw new Error("--retype requires --input-pattern");
-    const inputPatternText = fs.existsSync(inputPatternArg) ? fs.readFileSync(inputPatternArg, "utf8") : inputPatternArg;
-    stdout.write(JSON.stringify(retypeObjectRelation(object, retypeRelation, JSON.parse(inputPatternText)), null, 2) + "\n");
+    if (inputPatternArg == null) {
+      throw new Error("--retype requires --input-pattern");
+    }
+    const inputPatternText = fs.existsSync(inputPatternArg)
+      ? fs.readFileSync(inputPatternArg, "utf8")
+      : inputPatternArg;
+    outputData = retypeObjectRelation(
+      object,
+      retypeRelation,
+      JSON.parse(inputPatternText)
+    );
+  } else {
+    outputData = objectToKIRP(object);
+  }
+
+  const json = JSON.stringify(outputData, null, 2) + "\n";
+  if (explicitOutput) {
+    fs.writeFileSync(explicitOutput, json, "utf8");
   } else {
-    stdout.write(JSON.stringify(objectToKIRP(object), null, 2) + "\n");
+    stdout.write(json);
   }
 }
 

package/kvm.mjs

@@ -9,7 +9,12 @@ import {
 } from "./run.mjs";
 import { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
 import { intersectPropertyListPatterns } from "./codecs/runtime/codec.mjs";
-import { compileObjectBuffer, decodeObject, loadLibrary } from "./object.mjs";
+import {
+  compileLibrary,
+  compileObjectBuffer,
+  decodeObject,
+  loadLibrary
+} from "./object.mjs";
 import codes from "./codes.mjs";
 import { isMainEntrypoint } from "./codecs/runtime/cli-entry.mjs";
 import { isIntrinsic, unsupportedIntrinsic } from "./intrinsics.mjs";
@@ -964,20 +969,43 @@ export default {
   specializeKVM
 };
 
-function usage() {
+function helpText() {
   const prog = argv[1] || "kvm.mjs";
-  console.error(`Usage: node ${prog} [ options ] ( k-expr | input-file ) [ input-file ]`);
-  console.error("Options:");
-  console.error("  --lib file          Load one .klib dependency before compiling.");
-  console.error("  --export spec       Export a library alias into scope. 'name' or 'libname:localname'. May be repeated.");
-  console.error("  --envelope-free     Run the interpreter in envelope-free mode.");
-  console.error("  -h, --help          Show this help.");
+  return [
+    "Execute a k expression or file via the kVM bytecode interpreter",
+    "over a binary pattern+value wire stream.",
+    "",
+    `Usage: ${prog} [options]`,
+    "       ( source-snippet | input-file ) [ input-wire-file ]",
+    "",
+    "Arguments:",
+    "  source-snippet   Inline k source snippet.",
+    "  input-file       Source .k, .ko, or .klib file.",
+    "  input-wire-file  Optional binary wire input (default: stdin).",
+    "",
+    "Options:",
+    "  --lib file       Load one .klib or .k library before compiling.",
+    "  --export spec    Export library alias into scope. Repeatable.",
+    "                   spec is 'name' or 'libname:localname'.",
+    "  --envelope-free  Run the interpreter in envelope-free mode.",
+    "  -h, --help       Show this help.",
+    "",
+    "Examples:",
+    `  echo '"abc"' | k-parse | ${prog} '{.1 0}' | k-print`,
+    `  echo '{"x":1,"y":2}' | k-json --parse | \\`,
+    `    ${prog} --lib Examples/poly.k --export concat \\`,
+    `      's={()xs,()ys}concat; s' | k-json --print`
+  ].join("\n");
+}
+
+function usage(stream = console.error) {
+  stream(helpText());
 }
 
 async function main() {
   const args = argv.slice(2);
   if (args.includes("-h") || args.includes("--help")) {
-    usage();
+    usage(console.log);
     return exit(0);
   }
 
@@ -994,9 +1022,18 @@ async function main() {
       args.shift();
       const libPath = args.shift();
       if (!libPath) throw new Error("--lib requires a file argument");
-      if (libraries.length > 0) throw new Error("--lib may be specified at most once");
-      const libBuffer = fs.readFileSync(libPath);
-      libraries.push(loadLibrary(decodeObject(libBuffer)));
+      if (libraries.length > 0) {
+        throw new Error("--lib may be specified at most once");
+      }
+      if (libPath.endsWith(".k")) {
+        const raw = fs.readFileSync(libPath, "utf8");
+        libraries.push(
+          loadLibrary(compileLibrary(raw, { source: libPath }))
+        );
+      } else {
+        const libBuffer = fs.readFileSync(libPath);
+        libraries.push(loadLibrary(decodeObject(libBuffer)));
+      }
     } else if (args[0] === "--export") {
       args.shift();
       const spec = args.shift();