@fraczak/k 6.2.4 → 6.3.2

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)));
   }));
 }
 

package/codecs/runtime/show-value.mjs

@@ -1,4 +1,4 @@
-import { Product, Variant } from "../../Value.mjs";
+import { isProduct, isVariant } from "../../Value.mjs";
 
 const nameRE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
 
@@ -50,8 +50,8 @@ function propertyListToFilter(propertyList) {
 }
 
 function valueToK(v) {
-  if (v instanceof Variant) return `${valueToK(v.value)}|${pLabel(v.tag).trimStart()}`;
-  if (v instanceof Product) {
+  if (isVariant(v)) return `${valueToK(v.value)}|${pLabel(v.tag).trimStart()}`;
+  if (isProduct(v)) {
     const keys = Object.keys(v.product);
     if (keys.length === 0) return "{}";
     const fields = keys.map((k) => `${valueToK(v.product[k])}${pLabel(k)}`);

package/codecs/runtime/test-codec.mjs

@@ -6,7 +6,7 @@
 import { deriveClosedPattern } from './codec.mjs';
 import { encodeToWire, decodeWire } from './prefix-codec.mjs';
 import { patternToPropertyList } from './pattern-json.mjs';
-import { Product, Variant } from '../../Value.mjs';
+import { Value, isProduct, isVariant } from '../../Value.mjs';
 import hash from '../../hash.mjs';
 
 // Type repository
@@ -44,7 +44,7 @@ function resolveType(typeName) {
 
 // Test 1: Unit value
 console.log('\n=== Test 1: Unit ===');
-const unitValue = new Product({});
+const unitValue = Value.product({});
 console.log('Encoding unit:', unitValue.toString());
 
 const unitPattern = patternToPropertyList(deriveClosedPattern(unitTypeName, unitTypeDef, resolveType));
@@ -54,12 +54,12 @@ console.log('Hex:', unitEncoded.toString('hex'));
 
 const unitDecoded = decodeWire(unitEncoded);
 console.log('Decoded value:', unitDecoded.value.toString());
-console.log('Match:', unitDecoded.value instanceof Product && 
+console.log('Match:', isProduct(unitDecoded.value) &&
             Object.keys(unitDecoded.value.product).length === 0);
 
 // Test 2: Bool false
 console.log('\n=== Test 2: Bool (false) ===');
-const falseValue = new Variant('false', new Product({}));
+const falseValue = Value.variant('false', Value.product({}));
 console.log('Encoding false:', falseValue.toString());
 
 const boolPattern = patternToPropertyList(deriveClosedPattern(boolTypeName, boolTypeDef, resolveType));
@@ -69,12 +69,12 @@ console.log('Hex:', falseEncoded.toString('hex'));
 
 const falseDecoded = decodeWire(falseEncoded);
 console.log('Decoded value:', falseDecoded.value.toString());
-console.log('Match:', falseDecoded.value instanceof Variant && 
+console.log('Match:', isVariant(falseDecoded.value) &&
             falseDecoded.value.tag === 'false');
 
 // Test 3: Bool true
 console.log('\n=== Test 3: Bool (true) ===');
-const trueValue = new Variant('true', new Product({}));
+const trueValue = Value.variant('true', Value.product({}));
 console.log('Encoding true:', trueValue.toString());
 
 const trueEncoded = encodeToWire(trueValue, boolPattern);
@@ -83,7 +83,7 @@ console.log('Hex:', trueEncoded.toString('hex'));
 
 const trueDecoded = decodeWire(trueEncoded);
 console.log('Decoded value:', trueDecoded.value.toString());
-console.log('Match:', trueDecoded.value instanceof Variant && 
+console.log('Match:', isVariant(trueDecoded.value) &&
             trueDecoded.value.tag === 'true');
 
 console.log('\n=== All tests complete ===');

package/codecs/runtime/typeFromValue.mjs

@@ -1,4 +1,4 @@
-import { Product, Variant } from "../../Value.mjs";
+import { isProduct, isVariant } from "../../Value.mjs";
 
 function typeDefsFromValue(value) {
   let nextId = 0;
@@ -6,7 +6,7 @@ function typeDefsFromValue(value) {
 
   function visit(node) {
     const name = `:auto${nextId++}`;
-    if (node instanceof Product) {
+    if (isProduct(node)) {
       const labels = Object.keys(node.product).sort();
       const product = {};
       for (const label of labels) {
@@ -16,7 +16,7 @@ function typeDefsFromValue(value) {
       return name;
     }
 
-    if (node instanceof Variant) {
+    if (isVariant(node)) {
       const childName = visit(node.value);
       defs[name] = { code: "union", union: { [node.tag]: childName } };
       return name;
@@ -31,4 +31,4 @@ function typeDefsFromValue(value) {
 }
 
 export { typeDefsFromValue };
-export default { typeDefsFromValue };
+export default { typeDefsFromValue };

package/codecs/runtime/unicode-string.mjs

@@ -1,22 +1,22 @@
-import { Product, Variant } from "../../Value.mjs";
+import { Value, isProduct, isVariant } from "../../Value.mjs";
 
-const UNIT = new Product({});
-const BIT0 = new Variant("0", UNIT);
-const BIT1 = new Variant("1", UNIT);
+const UNIT = Value.product({});
+const BIT0 = Value.variant("0", UNIT);
+const BIT1 = Value.variant("1", UNIT);
 
 function bitValue(bit) {
   return bit === 0 ? BIT0 : BIT1;
 }
 
 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;
@@ -27,7 +27,7 @@ function bitsProduct(width, n) {
   for (let i = width - 1; i >= 0; i--) {
     product[String(i)] = bitValue((n >> i) & 1);
   }
-  return new Product(product);
+  return Value.product(product);
 }
 
 function parseBitsProduct(value, maxBit, where) {
@@ -52,14 +52,14 @@ function parseByteProduct(value, where) {
 }
 
 function encodeBmpCommonHi(hi) {
-  if (hi >= 0x08 && hi <= 0x0f) return new Variant("h08_0F", bitsProduct(3, hi - 0x08));
-  if (hi >= 0x10 && hi <= 0x7f) return new Variant("h10_7F", bitsProduct(7, hi - 0x10));
-  if (hi >= 0x80 && hi <= 0xcf) return new Variant("h80_CF", bitsProduct(7, hi - 0x80));
-  if (hi >= 0xd0 && hi <= 0xd7) return new Variant("hD0_D7", bitsProduct(3, hi - 0xd0));
-  if (hi === 0xf9) return new Variant("hF9", UNIT);
-  if (hi >= 0xfa && hi <= 0xfb) return new Variant("hFA_FB", bitsProduct(1, hi - 0xfa));
-  if (hi >= 0xfc && hi <= 0xfd) return new Variant("hFC_FD", bitsProduct(1, hi - 0xfc));
-  if (hi >= 0xfe && hi <= 0xff) return new Variant("hFE_FF", bitsProduct(1, hi - 0xfe));
+  if (hi >= 0x08 && hi <= 0x0f) return Value.variant("h08_0F", bitsProduct(3, hi - 0x08));
+  if (hi >= 0x10 && hi <= 0x7f) return Value.variant("h10_7F", bitsProduct(7, hi - 0x10));
+  if (hi >= 0x80 && hi <= 0xcf) return Value.variant("h80_CF", bitsProduct(7, hi - 0x80));
+  if (hi >= 0xd0 && hi <= 0xd7) return Value.variant("hD0_D7", bitsProduct(3, hi - 0xd0));
+  if (hi === 0xf9) return Value.variant("hF9", UNIT);
+  if (hi >= 0xfa && hi <= 0xfb) return Value.variant("hFA_FB", bitsProduct(1, hi - 0xfa));
+  if (hi >= 0xfc && hi <= 0xfd) return Value.variant("hFC_FD", bitsProduct(1, hi - 0xfc));
+  if (hi >= 0xfe && hi <= 0xff) return Value.variant("hFE_FF", bitsProduct(1, hi - 0xfe));
   throw new Error(`Unsupported BMP common hi byte: 0x${hi.toString(16)}`);
 }
 
@@ -77,9 +77,9 @@ function decodeBmpCommonHi(value) {
 }
 
 function encodeBmpPrivateHi(hi) {
-  if (hi >= 0xe0 && hi <= 0xef) return new Variant("hE0_EF", bitsProduct(4, hi - 0xe0));
-  if (hi >= 0xf0 && hi <= 0xf7) return new Variant("hF0_F7", bitsProduct(3, hi - 0xf0));
-  if (hi === 0xf8) return new Variant("hF8", UNIT);
+  if (hi >= 0xe0 && hi <= 0xef) return Value.variant("hE0_EF", bitsProduct(4, hi - 0xe0));
+  if (hi >= 0xf0 && hi <= 0xf7) return Value.variant("hF0_F7", bitsProduct(3, hi - 0xf0));
+  if (hi === 0xf8) return Value.variant("hF8", UNIT);
   throw new Error(`Unsupported BMP private-use hi byte: 0x${hi.toString(16)}`);
 }
 
@@ -92,10 +92,10 @@ function decodeBmpPrivateHi(value) {
 }
 
 function encodePlane2To16(plane) {
-  if (plane >= 2 && plane <= 3) return new Variant("p02_03", bitsProduct(1, plane - 2));
-  if (plane >= 4 && plane <= 7) return new Variant("p04_07", bitsProduct(2, plane - 4));
-  if (plane >= 8 && plane <= 15) return new Variant("p08_0F", bitsProduct(3, plane - 8));
-  if (plane === 16) return new Variant("p10", UNIT);
+  if (plane >= 2 && plane <= 3) return Value.variant("p02_03", bitsProduct(1, plane - 2));
+  if (plane >= 4 && plane <= 7) return Value.variant("p04_07", bitsProduct(2, plane - 4));
+  if (plane >= 8 && plane <= 15) return Value.variant("p08_0F", bitsProduct(3, plane - 8));
+  if (plane === 16) return Value.variant("p10", UNIT);
   throw new Error(`Plane out of range for supplementary_planes2_16: ${plane}`);
 }
 
@@ -117,34 +117,34 @@ function codePointToUnicodeValue(cp) {
   }
 
   if (cp <= 0x7f) {
-    return new Variant("ascii", bitsProduct(7, cp));
+    return Value.variant("ascii", bitsProduct(7, cp));
   }
 
   if (cp <= 0x7ff) {
-    return new Variant("plane0", bitsProduct(11, cp));
+    return Value.variant("plane0", bitsProduct(11, cp));
   }
 
   if (cp <= 0xffff) {
     const hi = (cp >> 8) & 0xff;
     const lo = cp & 0xff;
     if (hi >= 0xe0 && hi <= 0xf8) {
-      return new Variant("bmp_private_use", new Product({ hi: encodeBmpPrivateHi(hi), lo: byteProduct(lo) }));
+      return Value.variant("bmp_private_use", Value.product({ hi: encodeBmpPrivateHi(hi), lo: byteProduct(lo) }));
     }
-    return new Variant("bmp_common", new Product({ hi: encodeBmpCommonHi(hi), lo: byteProduct(lo) }));
+    return Value.variant("bmp_common", Value.product({ hi: encodeBmpCommonHi(hi), lo: byteProduct(lo) }));
   }
 
   const mid = (cp >> 8) & 0xff;
   const lo = cp & 0xff;
 
   if (cp <= 0x1ffff) {
-    return new Variant("supplementary_plane1", new Product({
+    return Value.variant("supplementary_plane1", Value.product({
       mid: byteProduct(mid),
       lo: byteProduct(lo)
     }));
   }
 
   const plane = cp >> 16;
-  return new Variant("supplementary_planes2_16", new Product({
+  return Value.variant("supplementary_planes2_16", Value.product({
     plane: encodePlane2To16(plane),
     mid: byteProduct(mid),
     lo: byteProduct(lo)
@@ -181,11 +181,11 @@ function unicodeValueToCodePoint(value) {
 }
 
 function textToStringValue(text) {
-  let out = new Variant("nil", UNIT);
+  let out = Value.variant("nil", UNIT);
   const chars = Array.from(text);
   for (let i = chars.length - 1; i >= 0; i--) {
     const cp = chars[i].codePointAt(0);
-    out = new Variant("cons", new Product({
+    out = Value.variant("cons", Value.product({
       car: codePointToUnicodeValue(cp),
       cdr: out
     }));

package/codecs/unit.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { stdin, stdout, argv, exit } from "node:process";
-import { Product } from "../Value.mjs";
+import { Value, isProduct } from "../Value.mjs";
 import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
 import { decodeWire, encodeToWire } from "./runtime/prefix-codec.mjs";
 
@@ -28,15 +28,15 @@ function readAll(stream) {
 }
 
 function unitEncoding() {
-  return encodeToWire(new Product({}), UNIT_PATTERN);
+  return encodeToWire(Value.product({}), UNIT_PATTERN);
 }
 
 function parse() {
-  return new Product({});
+  return Value.product({});
 }
 
 function print(value) {
-  if (!(value instanceof Product) || Object.keys(value.product).length !== 0) {
+  if (!isProduct(value) || Object.keys(value.product).length !== 0) {
     throw new Error("Input is not a unit value");
   }
   return "{}";

package/index.mjs

@@ -1,5 +1,5 @@
 import { parse } from "./parser.mjs";
-import { Value, fromObject } from "./Value.mjs";
+import { fromObject, isValue } from "./Value.mjs";
 import { parseValue } from "./valueIO.mjs";
 import { compileTypes } from "./compiler.mjs";
 import run from "./run.mjs";
@@ -19,7 +19,7 @@ compile.doc = "Transforms k-script (string) into a function";
 
 function runScriptOnData(script, data, options = {}) {
   let parsedData;
-  if (data instanceof Value) {
+  if (isValue(data)) {
     parsedData = data;
   } else if (typeof data === "string") {
     parsedData = parseValue(data, null, null);