@fraczak/k 6.2.1 → 6.2.3

package/codecs/runtime/codec.mjs

@@ -480,67 +480,89 @@ function refinePatternForValue(pattern, value) {
   }
 
   function collect(patternNodeId, currentValue) {
-    const patternNode = base.nodes[patternNodeId];
-    if (!patternNode) {
-      throw new Error(`Unknown pattern node ${patternNodeId}`);
-    }
-    pushOccurrence(patternNodeId, currentValue);
+    const stack = [{ patternNodeId, currentValue }];
 
-    switch (patternNode.kind) {
-      case NODE_KIND.ANY:
-        return;
+    while (stack.length > 0) {
+      const frame = stack.pop();
+      if (frame.extra) {
+        pushExtra(frame.patternNodeId, frame.label, frame.currentValue);
+        continue;
+      }
 
-      case NODE_KIND.CLOSED_PRODUCT:
-      case NODE_KIND.OPEN_PRODUCT: {
-        if (!(currentValue instanceof Product)) {
-          throw new Error(`Expected Product for pattern node ${patternNodeId}`);
-        }
-        const actualLabels = Object.keys(currentValue.product).sort();
-        const explicit = patternNode.edges.map((edge) => edge.label);
-        if (patternNode.kind === NODE_KIND.CLOSED_PRODUCT) {
-          if (actualLabels.length !== explicit.length || actualLabels.some((label, idx) => label !== explicit[idx])) {
-            throw new Error(`Closed product pattern does not match value fields [${actualLabels.join(", ")}]`);
+      const patternNode = base.nodes[frame.patternNodeId];
+      if (!patternNode) {
+        throw new Error(`Unknown pattern node ${frame.patternNodeId}`);
+      }
+      pushOccurrence(frame.patternNodeId, frame.currentValue);
+
+      switch (patternNode.kind) {
+        case NODE_KIND.ANY:
+          break;
+
+        case NODE_KIND.CLOSED_PRODUCT:
+        case NODE_KIND.OPEN_PRODUCT: {
+          if (!(frame.currentValue instanceof Product)) {
+            throw new Error(`Expected Product for pattern node ${frame.patternNodeId}`);
           }
-        } else {
-          for (const label of explicit) {
-            if (!(label in currentValue.product)) {
-              throw new Error(`Open product pattern is missing required field '${label}'`);
+          const actualLabels = Object.keys(frame.currentValue.product).sort();
+          const explicit = patternNode.edges.map((edge) => edge.label);
+          if (patternNode.kind === NODE_KIND.CLOSED_PRODUCT) {
+            if (actualLabels.length !== explicit.length || actualLabels.some((label, idx) => label !== explicit[idx])) {
+              throw new Error(`Closed product pattern does not match value fields [${actualLabels.join(", ")}]`);
+            }
+          } else {
+            for (const label of explicit) {
+              if (!(label in frame.currentValue.product)) {
+                throw new Error(`Open product pattern is missing required field '${label}'`);
+              }
             }
           }
-        }
 
-        const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
-        for (const label of actualLabels) {
-          if (explicitTargets.has(label)) {
-            collect(explicitTargets.get(label), currentValue.product[label]);
-          } else if (patternNode.kind === NODE_KIND.OPEN_PRODUCT) {
-            pushExtra(patternNodeId, label, currentValue.product[label]);
-          } else {
-            throw new Error(`Unexpected extra field '${label}' for closed product pattern`);
+          const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
+          for (let i = actualLabels.length - 1; i >= 0; i--) {
+            const label = actualLabels[i];
+            if (explicitTargets.has(label)) {
+              stack.push({
+                patternNodeId: explicitTargets.get(label),
+                currentValue: frame.currentValue.product[label]
+              });
+            } else if (patternNode.kind === NODE_KIND.OPEN_PRODUCT) {
+              stack.push({
+                extra: true,
+                patternNodeId: frame.patternNodeId,
+                label,
+                currentValue: frame.currentValue.product[label]
+              });
+            } else {
+              throw new Error(`Unexpected extra field '${label}' for closed product pattern`);
+            }
           }
+          break;
         }
-        return;
-      }
 
-      case NODE_KIND.CLOSED_UNION:
-      case NODE_KIND.OPEN_UNION: {
-        if (!(currentValue instanceof Variant)) {
-          throw new Error(`Expected Variant for pattern node ${patternNodeId}`);
-        }
-        const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
-        if (explicitTargets.has(currentValue.tag)) {
-          collect(explicitTargets.get(currentValue.tag), currentValue.value);
-          return;
-        }
-        if (patternNode.kind === NODE_KIND.OPEN_UNION) {
-          pushExtra(patternNodeId, currentValue.tag, currentValue.value);
-          return;
+        case NODE_KIND.CLOSED_UNION:
+        case NODE_KIND.OPEN_UNION: {
+          if (!(frame.currentValue instanceof Variant)) {
+            throw new Error(`Expected Variant for pattern node ${frame.patternNodeId}`);
+          }
+          const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
+          if (explicitTargets.has(frame.currentValue.tag)) {
+            stack.push({
+              patternNodeId: explicitTargets.get(frame.currentValue.tag),
+              currentValue: frame.currentValue.value
+            });
+            break;
+          }
+          if (patternNode.kind === NODE_KIND.OPEN_UNION) {
+            pushExtra(frame.patternNodeId, frame.currentValue.tag, frame.currentValue.value);
+            break;
+          }
+          throw new Error(`Unexpected variant tag '${frame.currentValue.tag}' for closed union pattern`);
         }
-        throw new Error(`Unexpected variant tag '${currentValue.tag}' for closed union pattern`);
-      }
 
-      default:
-        throw new Error(`Unknown pattern node kind: ${patternNode.kind}`);
+        default:
+          throw new Error(`Unknown pattern node kind: ${patternNode.kind}`);
+      }
     }
   }
 
@@ -714,47 +736,88 @@ function refinePatternForValue(pattern, value) {
 
 function coerceValueForPattern(pattern, value) {
   const base = normalizePattern(pattern);
-
-  function coerce(patternNodeId, currentValue) {
-    const patternNode = base.nodes[patternNodeId];
+  let result;
+  const stack = [{
+    patternNodeId: 0,
+    currentValue: value,
+    assign(coercedValue) {
+      result = coercedValue;
+    }
+  }];
+
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (frame.passthrough) {
+      frame.assign();
+      continue;
+    }
+    const patternNode = base.nodes[frame.patternNodeId];
     if (!patternNode) {
-      throw new Error(`Unknown pattern node ${patternNodeId}`);
+      throw new Error(`Unknown pattern node ${frame.patternNodeId}`);
     }
 
     switch (patternNode.kind) {
       case NODE_KIND.ANY:
-        return currentValue;
+        frame.assign(frame.currentValue);
+        break;
 
       case NODE_KIND.CLOSED_PRODUCT:
       case NODE_KIND.OPEN_PRODUCT: {
-        let productValue = currentValue;
-        if (currentValue instanceof Variant) {
-          productValue = new Product({ [currentValue.tag]: currentValue.value });
+        let productValue = frame.currentValue;
+        if (frame.currentValue instanceof Variant) {
+          productValue = new Product({ [frame.currentValue.tag]: frame.currentValue.value });
         }
         if (!(productValue instanceof Product)) {
-          throw new Error(`Expected Product for pattern node ${patternNodeId}`);
+          throw new Error(`Expected Product for pattern node ${frame.patternNodeId}`);
         }
 
         const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
         const product = {};
-        for (const [label, childValue] of Object.entries(productValue.product)) {
-          product[label] = explicitTargets.has(label)
-            ? coerce(explicitTargets.get(label), childValue)
-            : childValue;
+        frame.assign(new Product(product));
+        const entries = Object.entries(productValue.product);
+        for (let i = entries.length - 1; i >= 0; i--) {
+          const [label, childValue] = entries[i];
+          const target = explicitTargets.get(label);
+          if (target == null) {
+            stack.push({
+              assign() {
+                product[label] = childValue;
+              },
+              passthrough: true
+            });
+          } else {
+            stack.push({
+              patternNodeId: target,
+              currentValue: childValue,
+              assign(coercedValue) {
+                product[label] = coercedValue;
+              }
+            });
+          }
         }
-        return new Product(product);
+        break;
       }
 
       case NODE_KIND.CLOSED_UNION:
       case NODE_KIND.OPEN_UNION: {
-        if (!(currentValue instanceof Variant)) {
-          throw new Error(`Expected Variant for pattern node ${patternNodeId}`);
+        if (!(frame.currentValue instanceof Variant)) {
+          throw new Error(`Expected Variant for pattern node ${frame.patternNodeId}`);
+        }
+        const target = patternNode.edges.find((edge) => edge.label === frame.currentValue.tag)?.target;
+        const variant = new Variant(frame.currentValue.tag, undefined);
+        frame.assign(variant);
+        if (target == null) {
+          variant.value = frame.currentValue.value;
+        } else {
+          stack.push({
+            patternNodeId: target,
+            currentValue: frame.currentValue.value,
+            assign(coercedValue) {
+              variant.value = coercedValue;
+            }
+          });
         }
-        const target = patternNode.edges.find((edge) => edge.label === currentValue.tag)?.target;
-        return new Variant(
-          currentValue.tag,
-          target == null ? currentValue.value : coerce(target, currentValue.value)
-        );
+        break;
       }
 
       default:
@@ -762,7 +825,7 @@ function coerceValueForPattern(pattern, value) {
     }
   }
 
-  return coerce(0, value);
+  return result;
 }
 
 export { deriveClosedPattern, exportPatternGraph, refinePatternForValue, coerceValueForPattern, canonicalizePattern, intersectPropertyListPatterns, NODE_KIND };

package/codecs/runtime/prefix-codec.mjs

@@ -120,87 +120,121 @@ function choiceWidth(cardinality) {
 }
 
 function encodeNode(writer, value, pattern, patternNodeId) {
-  const patternNode = pattern.nodes[patternNodeId];
-  if (!patternNode) {
-    throw new Error(`Unknown pattern node ${patternNodeId}`);
-  }
-
-  switch (patternNode.kind) {
-    case NODE_KIND.ANY:
-      throw new Error("Pattern node 'any' is not directly encodable");
+  const stack = [{ value, patternNodeId }];
 
-    case NODE_KIND.OPEN_PRODUCT:
-    case NODE_KIND.CLOSED_PRODUCT: {
-      if (!(value instanceof Product)) {
-        throw new Error(`Expected Product for pattern node ${patternNodeId}`);
-      }
-      const actual = Object.keys(value.product).sort((a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8")));
-      const expected = patternNode.edges.map((edge) => edge.label);
-      if (actual.length !== expected.length || actual.some((label, i) => label !== expected[i])) {
-        throw new Error(`Product fields do not match pattern node ${patternNodeId}`);
-      }
-      for (const edge of patternNode.edges) {
-        encodeNode(writer, value.product[edge.label], pattern, edge.target);
-      }
-      return;
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    const patternNode = pattern.nodes[frame.patternNodeId];
+    if (!patternNode) {
+      throw new Error(`Unknown pattern node ${frame.patternNodeId}`);
     }
 
-    case NODE_KIND.OPEN_UNION:
-    case NODE_KIND.CLOSED_UNION: {
-      if (!(value instanceof Variant)) {
-        throw new Error(`Expected Variant for pattern node ${patternNodeId}`);
+    switch (patternNode.kind) {
+      case NODE_KIND.ANY:
+        throw new Error("Pattern node 'any' is not directly encodable");
+
+      case NODE_KIND.OPEN_PRODUCT:
+      case NODE_KIND.CLOSED_PRODUCT: {
+        if (!(frame.value instanceof Product)) {
+          throw new Error(`Expected Product for pattern node ${frame.patternNodeId}`);
+        }
+        const actual = Object.keys(frame.value.product).sort((a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8")));
+        const expected = patternNode.edges.map((edge) => edge.label);
+        if (actual.length !== expected.length || actual.some((label, i) => label !== expected[i])) {
+          throw new Error(`Product fields do not match pattern node ${frame.patternNodeId}`);
+        }
+        for (let i = patternNode.edges.length - 1; i >= 0; i--) {
+          const edge = patternNode.edges[i];
+          stack.push({ value: frame.value.product[edge.label], patternNodeId: edge.target });
+        }
+        break;
       }
-      const tagOrdinal = patternNode.edges.findIndex((edge) => edge.label === value.tag);
-      if (tagOrdinal === -1) {
-        throw new Error(`Variant tag '${value.tag}' is not present in pattern node ${patternNodeId}`);
+
+      case NODE_KIND.OPEN_UNION:
+      case NODE_KIND.CLOSED_UNION: {
+        if (!(frame.value instanceof Variant)) {
+          throw new Error(`Expected Variant for pattern node ${frame.patternNodeId}`);
+        }
+        const tagOrdinal = patternNode.edges.findIndex((edge) => edge.label === frame.value.tag);
+        if (tagOrdinal === -1) {
+          throw new Error(`Variant tag '${frame.value.tag}' is not present in pattern node ${frame.patternNodeId}`);
+        }
+        const width = choiceWidth(patternNode.edges.length);
+        writer.writeBits(tagOrdinal, width);
+        stack.push({ value: frame.value.value, patternNodeId: patternNode.edges[tagOrdinal].target });
+        break;
       }
-      const width = choiceWidth(patternNode.edges.length);
-      writer.writeBits(tagOrdinal, width);
-      encodeNode(writer, value.value, pattern, patternNode.edges[tagOrdinal].target);
-      return;
-    }
 
-    default:
-      throw new Error(`Unsupported pattern node kind ${patternNode.kind}`);
+      default:
+        throw new Error(`Unsupported pattern node kind ${patternNode.kind}`);
+    }
   }
 }
 
 function decodeNode(reader, pattern, patternNodeId) {
-  const patternNode = pattern.nodes[patternNodeId];
-  if (!patternNode) {
-    throw new Error(`Unknown pattern node ${patternNodeId}`);
-  }
-
-  switch (patternNode.kind) {
-    case NODE_KIND.ANY:
-      throw new Error("Pattern node 'any' is not directly decodable");
+  let result;
+  const stack = [{
+    patternNodeId,
+    assign(value) {
+      result = value;
+    }
+  }];
 
-    case NODE_KIND.OPEN_PRODUCT:
-    case NODE_KIND.CLOSED_PRODUCT: {
-      const product = {};
-      for (const edge of patternNode.edges) {
-        product[edge.label] = decodeNode(reader, pattern, edge.target);
-      }
-      return new Product(product);
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    const patternNode = pattern.nodes[frame.patternNodeId];
+    if (!patternNode) {
+      throw new Error(`Unknown pattern node ${frame.patternNodeId}`);
     }
 
-    case NODE_KIND.OPEN_UNION:
-    case NODE_KIND.CLOSED_UNION: {
-      if (patternNode.edges.length === 0) {
-        throw new Error(`Union pattern node ${patternNodeId} has no tags`);
+    switch (patternNode.kind) {
+      case NODE_KIND.ANY:
+        throw new Error("Pattern node 'any' is not directly decodable");
+
+      case NODE_KIND.OPEN_PRODUCT:
+      case NODE_KIND.CLOSED_PRODUCT: {
+        const product = {};
+        frame.assign(new Product(product));
+        for (let i = patternNode.edges.length - 1; i >= 0; i--) {
+          const edge = patternNode.edges[i];
+          stack.push({
+            patternNodeId: edge.target,
+            assign(value) {
+              product[edge.label] = value;
+            }
+          });
+        }
+        break;
       }
-      const width = choiceWidth(patternNode.edges.length);
-      const tagOrdinal = reader.readBits(width);
-      if (tagOrdinal >= patternNode.edges.length) {
-        throw new Error(`Choice ${tagOrdinal} is out of range for pattern node ${patternNodeId}`);
+
+      case NODE_KIND.OPEN_UNION:
+      case NODE_KIND.CLOSED_UNION: {
+        if (patternNode.edges.length === 0) {
+          throw new Error(`Union pattern node ${frame.patternNodeId} has no tags`);
+        }
+        const width = choiceWidth(patternNode.edges.length);
+        const tagOrdinal = reader.readBits(width);
+        if (tagOrdinal >= patternNode.edges.length) {
+          throw new Error(`Choice ${tagOrdinal} is out of range for pattern node ${frame.patternNodeId}`);
+        }
+        const edge = patternNode.edges[tagOrdinal];
+        const variant = new Variant(edge.label, undefined);
+        frame.assign(variant);
+        stack.push({
+          patternNodeId: edge.target,
+          assign(value) {
+            variant.value = value;
+          }
+        });
+        break;
       }
-      const edge = patternNode.edges[tagOrdinal];
-      return new Variant(edge.label, decodeNode(reader, pattern, edge.target));
-    }
 
-    default:
-      throw new Error(`Unsupported pattern node kind ${patternNode.kind}`);
+      default:
+        throw new Error(`Unsupported pattern node kind ${patternNode.kind}`);
+    }
   }
+
+  return result;
 }
 
 function preparePatternAndValue(value, propertyList) {

package/k.mjs

@@ -12,19 +12,20 @@ const prog = argv[1];
 let kScript, inputStream;
 
 function usage() {
-  console.error(`Usage: ${prog} [ --lib lib-file ]... ( k-expr | -k file ) [ input-file ]`);
+  console.error(`Usage: ${prog} [ --lib lib-file ]... [ --export spec ]... ( k-expr | -k 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 a .klib dependency before compiling. May be repeated.");
-  console.error("  -h, --help   Show this help.");
+  console.error("  --lib file      Load a .klib dependency before compiling. May be repeated.");
+  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 compileFile(path, libraries) {
-  const buffer = fs.readFileSync(path);
+function compileFile(filePath, libraries, preamble) {
+  const buffer = fs.readFileSync(filePath);
   try {
     return objectToFunction(decodeObject(buffer));
   } catch {
-    return k.compile(buffer.toString("utf8"), { libraries });
+    return k.compile(preamble + buffer.toString("utf8"), { libraries });
   }
 }
 
@@ -36,13 +37,48 @@ function compileFile(path, libraries) {
     }
 
     const libraries = [];
-    // Parse --lib flags
-    while (args.length > 0 && args[0] === "--lib") {
-      args.shift();
-      const libPath = args.shift();
-      if (!libPath) throw new Error("--lib requires a file argument");
-      const libBuffer = fs.readFileSync(libPath);
-      libraries.push(loadLibrary(decodeObject(libBuffer)));
+    const exports = [];
+    // Parse --lib and --export flags
+    while (args.length > 0 && args[0].startsWith("--")) {
+      if (args[0] === "--lib") {
+        args.shift();
+        const libPath = args.shift();
+        if (!libPath) throw new Error("--lib requires a file argument");
+        const libBuffer = fs.readFileSync(libPath);
+        libraries.push(loadLibrary(decodeObject(libBuffer)));
+      } else if (args[0] === "--export") {
+        args.shift();
+        const spec = args.shift();
+        if (!spec) throw new Error("--export requires a spec argument");
+        exports.push(spec);
+      } else {
+        break;
+      }
+    }
+
+    function buildExportPreamble() {
+      if (exports.length === 0) return "";
+      const aliasMap = {};
+      for (const lib of libraries) {
+        for (const [name, hash] of Object.entries(lib.relAlias || {})) {
+          if (name !== "__main__") aliasMap[name] = hash;
+        }
+        for (const [hash, entry] of Object.entries(lib.meta || {})) {
+          if (entry?.type !== "rel") continue;
+          for (const origin of entry?.origins || []) {
+            if (origin?.name && origin.name !== "__main__") aliasMap[origin.name] = hash;
+          }
+        }
+      }
+      const lines = [];
+      for (const spec of exports) {
+        const [libName, localName] = spec.includes(":") ? spec.split(":", 2) : [spec, spec];
+        const hash = aliasMap[libName];
+        if (!hash) throw new Error(`--export: '${libName}' not found in loaded libraries`);
+        const body = hash.startsWith("@") ? hash.slice(1) : hash;
+        lines.push(`${localName} = @${body};`);
+      }
+      return lines.join("\n") + "\n";
     }
 
     let kScriptStr = (function (arg) {
@@ -50,9 +86,9 @@ function compileFile(path, libraries) {
         throw new Error("Missing script argument");
       }
       if (arg === "-k") {
-        return compileFile(args.shift(), libraries);
+        return compileFile(args.shift(), libraries, buildExportPreamble());
       } else {
-        return arg;
+        return buildExportPreamble() + arg;
       }
     })(args.shift());
     let kScript = typeof kScriptStr === "function" ? kScriptStr : k.compile(kScriptStr, { libraries });

package/objects/README.md

@@ -6,27 +6,17 @@ CLI tools for compiling and inspecting k object files (`.ko`) and library files
 
 ### `k-compile`
 
-Compiles a `.k` source file into an executable object file (`.ko`).
-The output contains only the codes and relations reachable from `main`.
-Each stored relation includes `typeDerivation.status` for backend eligibility.
+Compiles `.k` source into an executable object file (`.ko`), library file
+(`.klib`), or kVM JSON (`.kvm`). Output format is inferred from the output
+extension, or from `--format`.
 
 ```bash
-k-compile [--lib lib-file]... [k-file [object-file]]
+k-compile [--lib lib-file]... [--format ko|klib|kvm] [source-snippet | input-file [output-file]]
 ```
 
-### `k-compile-lib`
-
-Compiles a `.k` source file into a library file (`.klib`).
-The output is plain JSON with no binary header. It contains the library closure
-formed from loaded `--lib` dependencies plus the compiled source definitions,
-with `main: null`.
-Use `--lib` to build on top of existing libraries.
-Each stored relation includes `typeDerivation.status`; libraries may contain a
-mix of converged and non-converged relations.
-
-```bash
-k-compile-lib [--lib lib-file]... [k-file [lib-file]]
-```
+Existing input paths are read as files. A non-existing input with `.k`, `.ko`,
+or `.klib` extension is reported as a missing file; otherwise it is compiled as
+inline k source, in the same style as `k.mjs`.
 
 ### `k-decompile`