@fraczak/k 6.2.3 → 6.3.1

package/AGENTS.md

@@ -12,7 +12,7 @@
 - `npm run prepare` regenerates `parser.mjs` and `valueParser.mjs` from `.jison` grammars.
 - `npm test` runs the full suite through `scripts/run-tests.mjs`.
 - `node repl.mjs` (or `k-repl`) starts the interactive REPL.
-- `./k.mjs -k <file.k>` executes a k script on binary pattern+value stream input from stdin or a file; use `k-parse` and `k-print` at the boundaries.
+- `./k.mjs <file.k>` executes a k source/object file on binary pattern+value stream input from stdin or a file; if the argument is not an existing file, it is treated as an inline k expression.
 
 ## Coding Style & Naming Conventions
 - JavaScript uses ES modules (`.mjs`) with 2-space indentation and semicolons.

package/CLAUDE.md

@@ -20,7 +20,7 @@ npm test  # Run comprehensive test suite (unit tests, derivation tests, shell te
 
 **Running k programs:**
 ```bash
-./k.mjs -k <file.k>   # Execute k script
+./k.mjs <file.k>      # Execute k source/object file
 ./repl.mjs            # Start interactive REPL (or: k-repl)
 ```
 

package/DOCS/OBJECT_FILE_AND_PATTERN.md

@@ -133,12 +133,12 @@ Loading an object hydrates the type-pattern graphs back into runtime
 Object execution through `k.mjs`:
 
 ```sh
-echo "..." | some-codec --parse | k -k path/to/program.ko | some-codec --print
+echo "..." | some-codec --parse | k path/to/program.ko | some-codec --print
 ```
 
-The `-k` option accepts either an object file or a source `.k` file. `k.mjs`
-tries to load the file as an object first, then falls back to source parsing and
-compilation.
+When the first positional argument names an existing file, `k.mjs` loads it as
+either an object file or a source `.k` file. It tries to load the file as an
+object first, then falls back to source parsing and compilation.
 
 Standalone helpers live in `objects/`:
 

package/README.md

@@ -163,7 +163,7 @@ program for backend inspection and execution experiments.
 
 | Command | Purpose |
 | --- | --- |
-| `k` | Execute a k expression, or `-k` source/object file, over a binary stream |
+| `k` | Execute a k expression, or an existing source/object file, over a binary stream |
 | `k-repl` | Start the interactive interpreter |
 
 **Serialization boundaries**

package/Value.mjs

@@ -16,9 +16,9 @@ function fromObject(obj) {
   const fields = getFields(obj);
   if (fields.length === 1) {
     const field = fields[0];
-    return new Variant(field, fromObject(obj[field]));
+    return Value.variant(field, fromObject(obj[field]));
   } 
-  return new Product(
+  return Value.product(
     fields.reduce( (result, field) => {
       result[field] = fromObject(obj[field]);
       return result;
@@ -26,17 +26,26 @@ function fromObject(obj) {
   );
 };
 
-class Value {
-  constructor(type, pattern = null) {
-    this.type = type;
-    this.pattern = pattern;
-  }
-  toString() {
-    return `${this.constructor.name}(type: ${this.type})`;
-  }
-  toJSON() {
-    return { type: this.type };
-  }
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+
+function isProduct(value) {
+  return isObject(value) &&
+    value.type === "{}" &&
+    isObject(value.product) &&
+    !Array.isArray(value.product);
+}
+
+function isVariant(value) {
+  return isObject(value) &&
+    value.type === "<>" &&
+    typeof value.tag === "string" &&
+    Object.hasOwn(value, "value");
+}
+
+function isValue(value) {
+  return isProduct(value) || isVariant(value);
 }
 
 function toVector(m) {
@@ -147,46 +156,47 @@ function mergePatterns(declared, observed) {
 function withPattern(value, pattern) {
   if (!pattern) return value;
   if (value.pattern === pattern) return value;
-  if (value instanceof Product) return new Product(value.product, pattern);
-  if (value instanceof Variant) return new Variant(value.tag, value.value, pattern);
+  if (isProduct(value)) return Value.product(value.product, pattern);
+  if (isVariant(value)) return Value.variant(value.tag, value.value, pattern);
   return value;
 }
 
-class Product extends Value {
-  constructor(product, pattern = null) {
-    super("{}", pattern);
-    this.product = product;
-  }
-
-  toString() {
-    return `{${Object.entries(this.product).map(([k, v]) => `${JSON.stringify(k)}:${v.toString()}`).join(',')}}`;
+class Value {
+  constructor(fields) {
+    Object.assign(this, fields);
   }
 
-  toJSON() {
-    let vector = toVector(this.product);
-    if (vector.length > 0) return vector;
-    return this.product; 
+  static product(product, pattern = null) {
+    return new Value({ type: "{}", pattern, product });
   }
-}
 
-class Variant extends Value {
-  constructor(tag, value, pattern = null) {
-    super("<>", pattern);
-    this.tag = tag;
-    this.value = value;
+  static variant(tag, value, pattern = null) {
+    return new Value({ type: "<>", pattern, tag, value });
   }
 
   toString() {
-    // return `{${JSON.stringify(this.tag)}:${this.value.toString()}}`;
-    return `${this.value.toString()}|${pLabel(this.tag)}`;
+    if (isVariant(this)) {
+      // return `{${JSON.stringify(this.tag)}:${this.value.toString()}}`;
+      return `${this.value.toString()}|${pLabel(this.tag)}`;
+    }
+    if (isProduct(this)) {
+      return `{${Object.entries(this.product).map(([k, v]) => `${JSON.stringify(k)}:${v.toString()}`).join(',')}}`;
+    }
+    return String(this.type);
   }
 
   toJSON() {
-    if (this.value instanceof Product && Object.keys(this.value.product).length === 0) {
-      return this.tag;
+    if (isVariant(this)) {
+      if (isProduct(this.value) && Object.keys(this.value.product).length === 0) {
+        return this.tag;
+      }
+      return {[this.tag]: this.value.toJSON()};
     }
-    return {[this.tag]: this.value.toJSON()};
+    if (!isProduct(this)) return { type: this.type };
+    let vector = toVector(this.product);
+    if (vector.length > 0) return vector;
+    return this.product; 
   }
 }
-export { Value, Product, Variant, fromObject, cloneSubpattern, edgeSubpattern, composePattern, mergePatterns, withPattern };
-export default { Value, Product, Variant, fromObject, cloneSubpattern, edgeSubpattern, composePattern, mergePatterns, withPattern };
+export { Value, fromObject, cloneSubpattern, edgeSubpattern, composePattern, mergePatterns, withPattern, isProduct, isVariant, isValue };
+export default { Value, fromObject, cloneSubpattern, edgeSubpattern, composePattern, mergePatterns, withPattern, isProduct, isVariant, isValue };

package/backend-api.mjs

@@ -3,7 +3,7 @@ export { lowerToKVM, executeKVM } from "./kvm.mjs";
 export { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
 export { exportPatternGraph, NODE_KIND } from "./codecs/runtime/codec.mjs";
 export { patternToPropertyList, propertyListToPattern } from "./codecs/runtime/pattern-json.mjs";
-export { Product, Variant, fromObject } from "./Value.mjs";
+export { Value, fromObject, isProduct, isVariant, isValue } from "./Value.mjs";
 export { decodeObject, loadLibrary } from "./object.mjs";
 export { createState, evaluateInput } from "./repl.mjs";
 export { parse as parseFloat64, print as printFloat64 } from "./codecs/ieee.mjs";

package/codecs/example-pipeline.mjs

@@ -14,7 +14,7 @@
 import { deriveClosedPattern } from './runtime/codec.mjs';
 import { encodeToWire, decodeWire } from './runtime/prefix-codec.mjs';
 import { patternToPropertyList } from './runtime/pattern-json.mjs';
-import { Product, Variant } from '../Value.mjs';
+import { Value, isVariant } from '../Value.mjs';
 import hash from '../hash.mjs';
 import { argv, exit } from 'node:process';
 
@@ -84,9 +84,9 @@ function resolveType(typeName) {
 // Step 3: Create input value: Maybe Bool = something(true)
 // ============================================================================
 
-const inputValue = new Variant(
+const inputValue = Value.variant(
   'something',
-  new Variant('true', new Product({}))
+  Value.variant('true', Value.product({}))
 );
 
 console.log('Input value:', inputValue.toString());
@@ -119,14 +119,14 @@ console.log('Program sees value:', programInput.toString());
 
 // Example transformation: NOT operation (flip bool inside Maybe)
 let programOutput;
-if (programInput instanceof Variant && programInput.tag === 'something') {
+if (isVariant(programInput) && programInput.tag === 'something') {
   const innerBool = programInput.value;
-  if (innerBool instanceof Variant) {
-    const flipped = new Variant(
+  if (isVariant(innerBool)) {
+    const flipped = Value.variant(
       innerBool.tag === 'true' ? 'false' : 'true',
       innerBool.value
     );
-    programOutput = new Variant('something', flipped);
+    programOutput = Value.variant('something', flipped);
   }
 } else {
   programOutput = programInput; // nothing → nothing

package/codecs/ieee.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 import { stdin, stdout, argv, exit } from "node:process";
-import { Product, Variant } from "../Value.mjs";
+import { Value, isProduct, isVariant } from "../Value.mjs";
 import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
 import { decodeWire, encodeToWire } from "./runtime/prefix-codec.mjs";
 import { FLOAT64_PATTERN } from "./runtime/ieee-pattern.mjs";
-const UNIT = new Product({});
+const UNIT = Value.product({});
 const name = "ieee";
 const patterns = [FLOAT64_PATTERN];
 
@@ -17,7 +17,7 @@ function usage(stream = console.error) {
 }
 
 function bitValue(bit) {
-  return new Variant(bit === 0 ? "0" : "1", UNIT);
+  return Value.variant(bit === 0 ? "0" : "1", UNIT);
 }
 
 function bitsProduct(width, value) {
@@ -26,7 +26,7 @@ function bitsProduct(width, value) {
   for (let i = width - 1; i >= 0; i--) {
     product[String(i)] = bitValue(Number((big >> BigInt(i)) & 1n));
   }
-  return new Product(product);
+  return Value.product(product);
 }
 
 function encodeNumberToValue(number) {
@@ -37,22 +37,22 @@ function encodeNumberToValue(number) {
   const exponent = Number((bits >> 52n) & 0x7ffn);
   const fraction = bits & ((1n << 52n) - 1n);
 
-  return new Product({
-    sign: new Variant(sign === 0 ? "+" : "-", UNIT),
+  return Value.product({
+    sign: Value.variant(sign === 0 ? "+" : "-", UNIT),
     exponent: bitsProduct(11, exponent),
     fraction: bitsProduct(52, fraction)
   });
 }
 
 function requireProduct(value, where) {
-  if (!(value instanceof Product)) {
+  if (!isProduct(value)) {
     throw new Error(`${where}: expected Product`);
   }
   return value.product;
 }
 
 function requireVariant(value, where) {
-  if (!(value instanceof Variant)) {
+  if (!isVariant(value)) {
     throw new Error(`${where}: expected Variant`);
   }
   return value;

package/codecs/int.mjs

@@ -14,7 +14,7 @@
  */
 
 import { stdin, stdout, argv, exit } from "node:process";
-import { Product, Variant } from "../Value.mjs";
+import { Value, isVariant } from "../Value.mjs";
 import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
 import { decodeWire, encodeToWire } from "./runtime/prefix-codec.mjs";
 
@@ -47,9 +47,9 @@ function readAll(stream) {
 // Build bits Value (MSB outermost) from a non-negative BigInt.
 function buildBits(n) {
   const bitChars = n === 0n ? ["0"] : n.toString(2).split("");
-  let v = new Variant("_", new Product({}));
+  let v = Value.variant("_", Value.product({}));
   for (let i = bitChars.length - 1; i >= 0; i--) {
-    v = new Variant(bitChars[i], v);
+    v = Value.variant(bitChars[i], v);
   }
   return v;
 }
@@ -65,18 +65,18 @@ function parseIntStr(str) {
   }
   const n = BigInt(str);
   if (n === 0n) sign = "+"; // zero is always '+'
-  return new Variant(sign, buildBits(n));
+  return Value.variant(sign, buildBits(n));
 }
 
 // Walk a decoded int Value (Variant sign → bits) and return a decimal string.
 function printIntValue(value) {
-  if (!(value instanceof Variant) || (value.tag !== "+" && value.tag !== "-")) {
+  if (!isVariant(value) || (value.tag !== "+" && value.tag !== "-")) {
     throw new Error("Not a valid k int value");
   }
   const sign = value.tag;
   let bits = "";
   let node = value.value;
-  while (node instanceof Variant && node.tag !== "_") {
+  while (isVariant(node) && node.tag !== "_") {
     bits += node.tag;
     node = node.value;
   }

package/codecs/json-codec.mjs

@@ -1,8 +1,8 @@
-import { Product, Variant } from "../Value.mjs";
+import { Value, isProduct, isVariant } from "../Value.mjs";
 import { STRING_PATTERN_PROPERTY_LIST, textToStringValue, stringValueToText } from "./string-codec.mjs";
 import { FLOAT64_PATTERN } from "./runtime/ieee-pattern.mjs";
 
-const UNIT = new Product({});
+const UNIT = Value.product({});
 const BOOL_PATTERN = [
   ["closed-union", [["false", 1], ["true", 1]]],
   ["closed-product", []]
@@ -13,7 +13,7 @@ const NULL_PATTERN = [
 ];
 
 function bitValue(bit) {
-  return new Variant(bit === 0 ? "0" : "1", UNIT);
+  return Value.variant(bit === 0 ? "0" : "1", UNIT);
 }
 
 function bitsProduct(width, value) {
@@ -22,7 +22,7 @@ function bitsProduct(width, value) {
   for (let i = width - 1; i >= 0; i--) {
     product[String(i)] = bitValue(Number((big >> BigInt(i)) & 1n));
   }
-  return new Product(product);
+  return Value.product(product);
 }
 
 function encodeNumberToValue(number) {
@@ -33,22 +33,22 @@ function encodeNumberToValue(number) {
   const exponent = Number((bits >> 52n) & 0x7ffn);
   const fraction = bits & ((1n << 52n) - 1n);
 
-  return new Product({
-    sign: new Variant(sign === 0 ? "+" : "-", UNIT),
+  return Value.product({
+    sign: Value.variant(sign === 0 ? "+" : "-", UNIT),
     exponent: bitsProduct(11, exponent),
     fraction: bitsProduct(52, fraction)
   });
 }
 
 function requireProduct(value, where) {
-  if (!(value instanceof Product)) {
+  if (!isProduct(value)) {
     throw new Error(`${where}: expected Product`);
   }
   return value.product;
 }
 
 function requireVariant(value, where) {
-  if (!(value instanceof Variant)) {
+  if (!isVariant(value)) {
     throw new Error(`${where}: expected Variant`);
   }
   return value;
@@ -88,10 +88,10 @@ function decodeValueToNumber(value) {
 
 function fromJsonValue(value) {
   if (value === null) {
-    return new Variant("null", UNIT);
+    return Value.variant("null", UNIT);
   }
   if (typeof value === "boolean") {
-    return new Variant(value ? "true" : "false", UNIT);
+    return Value.variant(value ? "true" : "false", UNIT);
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
@@ -103,7 +103,7 @@ function fromJsonValue(value) {
     return textToStringValue(value);
   }
   if (Array.isArray(value)) {
-    return new Product(
+    return Value.product(
       value.reduce((product, item, index) => {
         product[String(index)] = fromJsonValue(item);
         return product;
@@ -111,7 +111,7 @@ function fromJsonValue(value) {
     );
   }
   if (value && typeof value === "object") {
-    return new Product(
+    return Value.product(
       Object.keys(value).reduce((product, key) => {
         product[key] = fromJsonValue(value[key]);
         return product;
@@ -161,7 +161,7 @@ function patternFromJsonValue(value) {
 }
 
 function toJsonValue(value) {
-  if (value instanceof Variant) {
+  if (isVariant(value)) {
     if (value.tag === "null") {
       requireProduct(value.value, "json.null");
       return null;
@@ -184,8 +184,8 @@ function toJsonValue(value) {
   if (isArray) {
     return keys.map((key) => {
       const child = product[key];
-      if (child instanceof Variant) return toJsonValue(child);
-      if (child instanceof Product) {
+      if (isVariant(child)) return toJsonValue(child);
+      if (isProduct(child)) {
         try {
           return decodeValueToNumber(child);
         } catch {}

package/codecs/runtime/codec.mjs

@@ -2,7 +2,7 @@
  * K pattern graph runtime helpers.
  */
 
-import { Product, Variant } from "../../Value.mjs";
+import { Value, isProduct, isVariant } from "../../Value.mjs";
 import { TypePatternGraph } from "../../TypePatternGraph.mjs";
 import { getCompressed } from "../../typing.mjs";
 import { finalize as finalizeCodes } from "../../codes.mjs";
@@ -501,7 +501,7 @@ function refinePatternForValue(pattern, value) {
 
         case NODE_KIND.CLOSED_PRODUCT:
         case NODE_KIND.OPEN_PRODUCT: {
-          if (!(frame.currentValue instanceof Product)) {
+          if (!isProduct(frame.currentValue)) {
             throw new Error(`Expected Product for pattern node ${frame.patternNodeId}`);
           }
           const actualLabels = Object.keys(frame.currentValue.product).sort();
@@ -542,7 +542,7 @@ function refinePatternForValue(pattern, value) {
 
         case NODE_KIND.CLOSED_UNION:
         case NODE_KIND.OPEN_UNION: {
-          if (!(frame.currentValue instanceof Variant)) {
+          if (!isVariant(frame.currentValue)) {
             throw new Error(`Expected Variant for pattern node ${frame.patternNodeId}`);
           }
           const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
@@ -583,8 +583,8 @@ function refinePatternForValue(pattern, value) {
       return { kind: NODE_KIND.ANY, edges: [] };
     }
 
-    const allProducts = values.every((node) => node instanceof Product);
-    const allVariants = values.every((node) => node instanceof Variant);
+    const allProducts = values.every(isProduct);
+    const allVariants = values.every(isVariant);
     if (!allProducts && !allVariants) {
       throw new Error("Cannot refine pattern from mixed product/union values");
     }
@@ -642,7 +642,7 @@ function refinePatternForValue(pattern, value) {
       let labels = [...explicit.keys()].sort();
       if (values.length > 0) {
         const actual = sameSortedKeys(values, "product pattern", (node) => {
-          if (!(node instanceof Product)) throw new Error("Expected Product while refining product pattern");
+          if (!isProduct(node)) throw new Error("Expected Product while refining product pattern");
           return Object.keys(node.product);
         });
         if (baseNode.kind === NODE_KIND.CLOSED_PRODUCT) {
@@ -673,7 +673,7 @@ function refinePatternForValue(pattern, value) {
       let tags = [...explicit.keys()].sort((a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8")));
       if (values.length > 0) {
         const observed = [...new Set(values.map((node) => {
-          if (!(node instanceof Variant)) throw new Error("Expected Variant while refining union pattern");
+          if (!isVariant(node)) throw new Error("Expected Variant while refining union pattern");
           return node.tag;
         }))].sort((a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8")));
         if (baseNode.kind === NODE_KIND.CLOSED_UNION) {
@@ -764,16 +764,16 @@ function coerceValueForPattern(pattern, value) {
       case NODE_KIND.CLOSED_PRODUCT:
       case NODE_KIND.OPEN_PRODUCT: {
         let productValue = frame.currentValue;
-        if (frame.currentValue instanceof Variant) {
-          productValue = new Product({ [frame.currentValue.tag]: frame.currentValue.value });
+        if (isVariant(frame.currentValue)) {
+          productValue = Value.product({ [frame.currentValue.tag]: frame.currentValue.value });
         }
-        if (!(productValue instanceof Product)) {
+        if (!isProduct(productValue)) {
           throw new Error(`Expected Product for pattern node ${frame.patternNodeId}`);
         }
 
         const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
         const product = {};
-        frame.assign(new Product(product));
+        frame.assign(Value.product(product));
         const entries = Object.entries(productValue.product);
         for (let i = entries.length - 1; i >= 0; i--) {
           const [label, childValue] = entries[i];
@@ -800,11 +800,11 @@ function coerceValueForPattern(pattern, value) {
 
       case NODE_KIND.CLOSED_UNION:
       case NODE_KIND.OPEN_UNION: {
-        if (!(frame.currentValue instanceof Variant)) {
+        if (!isVariant(frame.currentValue)) {
           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);
+        const variant = Value.variant(frame.currentValue.tag, undefined);
         frame.assign(variant);
         if (target == null) {
           variant.value = frame.currentValue.value;

package/codecs/runtime/prefix-codec.mjs

@@ -1,4 +1,4 @@
-import { Product, Variant, withPattern } from "../../Value.mjs";
+import { Value, withPattern, isProduct, isVariant } from "../../Value.mjs";
 import { refinePatternForValue, coerceValueForPattern, NODE_KIND } from "./codec.mjs";
 import { patternToPropertyList, propertyListToPattern } from "./pattern-json.mjs";
 import { textToStringValue, stringValueToText } from "./unicode-string.mjs";
@@ -33,7 +33,7 @@ const CORE_PATTERN_PROPERTY_LIST = [
 ];
 
 const CORE_PATTERN_PATTERN = propertyListToPattern(CORE_PATTERN_PROPERTY_LIST);
-const UNIT = new Product({});
+const UNIT = Value.product({});
 
 class BitWriter {
   constructor() {
@@ -135,7 +135,7 @@ function encodeNode(writer, value, pattern, patternNodeId) {
 
       case NODE_KIND.OPEN_PRODUCT:
       case NODE_KIND.CLOSED_PRODUCT: {
-        if (!(frame.value instanceof Product)) {
+        if (!isProduct(frame.value)) {
           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")));
@@ -152,7 +152,7 @@ function encodeNode(writer, value, pattern, patternNodeId) {
 
       case NODE_KIND.OPEN_UNION:
       case NODE_KIND.CLOSED_UNION: {
-        if (!(frame.value instanceof Variant)) {
+        if (!isVariant(frame.value)) {
           throw new Error(`Expected Variant for pattern node ${frame.patternNodeId}`);
         }
         const tagOrdinal = patternNode.edges.findIndex((edge) => edge.label === frame.value.tag);
@@ -194,7 +194,7 @@ function decodeNode(reader, pattern, patternNodeId) {
       case NODE_KIND.OPEN_PRODUCT:
       case NODE_KIND.CLOSED_PRODUCT: {
         const product = {};
-        frame.assign(new Product(product));
+        frame.assign(Value.product(product));
         for (let i = patternNode.edges.length - 1; i >= 0; i--) {
           const edge = patternNode.edges[i];
           stack.push({
@@ -218,7 +218,7 @@ function decodeNode(reader, pattern, patternNodeId) {
           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);
+        const variant = Value.variant(edge.label, undefined);
         frame.assign(variant);
         stack.push({
           patternNodeId: edge.target,
@@ -250,7 +250,7 @@ function deriveClosedPatternFromValue(value) {
 
   function visit(node) {
     const nodeId = nodes.length;
-    if (node instanceof Product) {
+    if (isProduct(node)) {
       const placeholder = { kind: NODE_KIND.CLOSED_PRODUCT, edges: [] };
       nodes.push(placeholder);
       const labels = Object.keys(node.product).sort((a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8")));
@@ -261,7 +261,7 @@ function deriveClosedPatternFromValue(value) {
       }));
       return nodeId;
     }
-    if (node instanceof Variant) {
+    if (isVariant(node)) {
       const placeholder = { kind: NODE_KIND.OPEN_UNION, edges: [] };
       nodes.push(placeholder);
       placeholder.edges = [{
@@ -291,23 +291,23 @@ function deriveClosedPatternFromValue(value) {
 }
 
 function requireProduct(value, where) {
-  if (!(value instanceof Product)) {
+  if (!isProduct(value)) {
     throw new Error(`${where}: expected Product`);
   }
   return value.product;
 }
 
 function requireVariant(value, where) {
-  if (!(value instanceof Variant)) {
+  if (!isVariant(value)) {
     throw new Error(`${where}: expected Variant`);
   }
   return value;
 }
 
 function listToK(items) {
-  let result = new Variant("nil", UNIT);
+  let result = Value.variant("nil", UNIT);
   for (let i = items.length - 1; i >= 0; i--) {
-    result = new Variant("cons", new Product({
+    result = Value.variant("cons", Value.product({
       car: items[i],
       cdr: result
     }));
@@ -354,7 +354,7 @@ function integerToBits(value) {
   if (!Number.isSafeInteger(value) || value < 0) {
     throw new Error(`bits target must be a non-negative safe integer, got ${value}`);
   }
-  if (value === 0) return new Variant("_", UNIT);
+  if (value === 0) return Value.variant("_", UNIT);
 
   const bits = [];
   let n = value;
@@ -363,15 +363,15 @@ function integerToBits(value) {
     n = Math.floor(n / 2);
   }
 
-  let result = new Variant("_", UNIT);
+  let result = Value.variant("_", UNIT);
   for (let i = bits.length - 1; i >= 0; i--) {
-    result = new Variant(bits[i] ? "1" : "0", result);
+    result = Value.variant(bits[i] ? "1" : "0", result);
   }
   return result;
 }
 
 function edgeToK([label, target]) {
-  return new Product({
+  return Value.product({
     label: textToStringValue(label),
     target: integerToBits(target)
   });
@@ -395,9 +395,9 @@ function patternToKValue(propertyList) {
     }
     const [kind, edges] = node;
     if (kind === "any") {
-      return new Variant("any", UNIT);
+      return Value.variant("any", UNIT);
     }
-    return new Variant(kind, listToK(edges.map(edgeToK)));
+    return Value.variant(kind, listToK(edges.map(edgeToK)));
   }));
 }