@fraczak/k 6.2.0 → 6.2.2

package/kvm.mjs

@@ -0,0 +1,523 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import { argv, stdin, exit, stdout } from "node:process";
+import { Product, Variant, composePattern, withPattern } from "./Value.mjs";
+import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
+import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
+import {
+  constrainWithPattern,
+  intersectPatterns,
+  projectionPattern,
+  verify,
+  run
+} from "./run.mjs";
+import { annotate } from "./index.mjs";
+import { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
+import { decodeObject, loadLibrary } from "./object.mjs";
+import codes from "./codes.mjs";
+import { isMainEntrypoint } from "./codecs/runtime/cli-entry.mjs";
+
+class KVMBuilder {
+  constructor(typePatternGraph) {
+    this.typePatternGraph = typePatternGraph;
+    this.regCount = 0;
+    this.instructions = [];
+  }
+
+  nextReg() {
+    return `%v${this.regCount++}`;
+  }
+
+  emit(inst) {
+    this.instructions.push(inst);
+  }
+
+  getStaticPattern(exp, index) {
+    if (!this.typePatternGraph || !exp.patterns) return null;
+    const patternId = this.typePatternGraph.find(exp.patterns[index]);
+    return patternToPropertyList(exportPatternGraph(this.typePatternGraph, patternId));
+  }
+}
+
+function compile(exp, inputReg, builder) {
+  switch (exp.op) {
+    case "identity": {
+      const dest = builder.nextReg();
+      builder.emit({ op: "id", dest, src: inputReg });
+      return dest;
+    }
+    case "empty": {
+      builder.emit({ op: "fail" });
+      return builder.nextReg();
+    }
+    case "filter": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "guard_pattern",
+        dest,
+        src: inputReg,
+        pattern: builder.getStaticPattern(exp, 0),
+        exp
+      });
+      return dest;
+    }
+    case "code": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "guard_code",
+        dest,
+        src: inputReg,
+        code: exp.code,
+        exp
+      });
+      return dest;
+    }
+    case "dot": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "project_field",
+        dest,
+        src: inputReg,
+        label: exp.dot,
+        pattern: builder.getStaticPattern(exp, 1),
+        exp
+      });
+      return dest;
+    }
+    case "div": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "project_variant",
+        dest,
+        src: inputReg,
+        tag: exp.div,
+        pattern: builder.getStaticPattern(exp, 1),
+        exp
+      });
+      return dest;
+    }
+    case "vid": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "make_variant",
+        dest,
+        tag: exp.vid,
+        src: inputReg
+      });
+      return dest;
+    }
+    case "ref": {
+      const dest = builder.nextReg();
+      if (exp.ref.startsWith("_")) {
+        builder.emit({
+          op: "call_intrinsic",
+          dest,
+          symbol: exp.ref,
+          src: inputReg,
+          pattern: builder.getStaticPattern(exp, 0),
+          exp
+        });
+      } else {
+        builder.emit({
+          op: "call",
+          dest,
+          func: exp.ref,
+          src: inputReg,
+          exp
+        });
+      }
+      return dest;
+    }
+    case "comp": {
+      let currentReg = inputReg;
+      const compInputPattern = builder.getStaticPattern(exp, 0);
+      if (compInputPattern) {
+        const guarded = builder.nextReg();
+        builder.emit({ op: "guard_pattern", dest: guarded, src: currentReg, pattern: compInputPattern, exp });
+        currentReg = guarded;
+      }
+      for (const subExp of exp.comp) {
+        currentReg = compile(subExp, currentReg, builder);
+      }
+      return currentReg;
+    }
+    case "product": {
+      const dest = builder.nextReg();
+      const branches = [];
+      for (const { label, exp: fieldExp } of exp.product) {
+        const branchBuilder = new KVMBuilder(builder.typePatternGraph);
+        const branchInput = "%in";
+        const branchOutput = compile(fieldExp, branchInput, branchBuilder);
+        branchBuilder.emit({ op: "return", src: branchOutput });
+        branches.push({
+          label,
+          body: branchBuilder.instructions
+        });
+      }
+      builder.emit({
+        op: "product",
+        dest,
+        src: inputReg,
+        branches,
+        pattern: builder.getStaticPattern(exp, 1),
+        exp
+      });
+      return dest;
+    }
+    case "union": {
+      const dest = builder.nextReg();
+      const branches = [];
+      for (const branchExp of exp.union) {
+        const branchBuilder = new KVMBuilder(builder.typePatternGraph);
+        const branchInput = "%in";
+        const branchOutput = compile(branchExp, branchInput, branchBuilder);
+        branchBuilder.emit({ op: "return", src: branchOutput });
+        branches.push({
+          body: branchBuilder.instructions
+        });
+      }
+      builder.emit({
+        op: "union",
+        dest,
+        src: inputReg,
+        branches,
+        exp
+      });
+      return dest;
+    }
+    default:
+      throw new Error(`Unsupported AST operation: ${exp.op}`);
+  }
+}
+
+export function lowerToKVM(relDef, name, options = {}) {
+  const typePatternGraph = relDef.typePatternGraph || null;
+  const builder = new KVMBuilder(typePatternGraph);
+  const inputReg = "%in";
+
+  let currentReg = inputReg;
+  const inputPattern = builder.getStaticPattern(relDef.def, 0);
+  if (inputPattern) {
+    const guarded = builder.nextReg();
+    builder.emit({ op: "guard_pattern", dest: guarded, src: currentReg, pattern: inputPattern, exp: relDef.def });
+    currentReg = guarded;
+  }
+
+  const bodyOutput = compile(relDef.def, currentReg, builder);
+
+  let finalReg = bodyOutput;
+  const outputPattern = builder.getStaticPattern(relDef.def, 1);
+  if (outputPattern) {
+    const guarded = builder.nextReg();
+    builder.emit({ op: "guard_pattern", dest: guarded, src: finalReg, pattern: outputPattern, exp: relDef.def });
+    finalReg = guarded;
+  }
+
+  builder.emit({ op: "return", src: finalReg });
+
+  return {
+    name,
+    inputPattern,
+    outputPattern,
+    isConverged: relDef.typeDerivation?.status === "converged",
+    body: builder.instructions
+  };
+}
+
+function executeBlock(instructions, inputVal, context) {
+  const registers = new Map();
+  registers.set("%in", inputVal);
+
+  for (const inst of instructions) {
+    const res = executeInstruction(inst, registers, context);
+    if (res === undefined) {
+      return undefined;
+    }
+    if (res.type === "return") {
+      return res.value;
+    }
+  }
+  return undefined;
+}
+
+function executeInstruction(inst, registers, context) {
+  const options = context.options || {};
+  switch (inst.op) {
+    case "id": {
+      registers.set(inst.dest, registers.get(inst.src));
+      return { type: "continue" };
+    }
+    case "fail": {
+      return undefined;
+    }
+    case "guard_pattern": {
+      const val = registers.get(inst.src);
+      if (options.envelopeFree) {
+        registers.set(inst.dest, val);
+        return { type: "continue" };
+      }
+      try {
+        const constrained = constrainWithPattern(val, inst.pattern, inst.exp);
+        registers.set(inst.dest, constrained);
+        return { type: "continue" };
+      } catch (err) {
+        if (err instanceof TypeError) {
+          throw err;
+        }
+        return undefined;
+      }
+    }
+    case "guard_code": {
+      const val = registers.get(inst.src);
+      if (options.envelopeFree) {
+        registers.set(inst.dest, val);
+        return { type: "continue" };
+      }
+      if (verify(context.findCode, inst.code, val)) {
+        registers.set(inst.dest, val);
+        return { type: "continue" };
+      }
+      return undefined;
+    }
+    case "project_field": {
+      const val = registers.get(inst.src);
+      if (!(val instanceof Product)) return undefined;
+      const fieldVal = val.product[inst.label];
+      if (fieldVal === undefined) return undefined;
+
+      if (options.envelopeFree) {
+        registers.set(inst.dest, fieldVal);
+      } else {
+        const pattern = projectionPattern(inst.pattern, val.pattern, inst.label, inst.exp);
+        registers.set(inst.dest, withPattern(fieldVal, pattern));
+      }
+      return { type: "continue" };
+    }
+    case "project_variant": {
+      const val = registers.get(inst.src);
+      if (!(val instanceof Variant) || val.tag !== inst.tag) return undefined;
+
+      if (options.envelopeFree) {
+        registers.set(inst.dest, val.value);
+      } else {
+        const pattern = projectionPattern(inst.pattern, val.pattern, inst.tag, inst.exp);
+        registers.set(inst.dest, withPattern(val.value, pattern));
+      }
+      return { type: "continue" };
+    }
+    case "make_variant": {
+      const val = registers.get(inst.src);
+      if (options.envelopeFree) {
+        registers.set(inst.dest, new Variant(inst.tag, val));
+      } else {
+        registers.set(
+          inst.dest,
+          new Variant(inst.tag, val, composePattern("open-union", [[inst.tag, val.pattern]]))
+        );
+      }
+      return { type: "continue" };
+    }
+    case "call": {
+      const val = registers.get(inst.src);
+      const relDef = context.rels[inst.func];
+      if (!relDef) {
+        throw new Error(`Unknown ref: '${inst.func}'`);
+      }
+      if (options.requireConverged && relDef.typeDerivation?.status !== "converged") {
+        throw new Error(`Cannot run '${inst.func}' without envelopes: type derivation is not converged`);
+      }
+      if (options.trace) {
+        console.log(`[Trace] Calling ${inst.func} with:`, val ? val.toString() : "null");
+      }
+      if (!relDef._kvmFunc) {
+        relDef._kvmFunc = lowerToKVM(relDef, inst.func);
+      }
+      const res = executeKVM(relDef._kvmFunc, val, context);
+      if (options.trace) {
+        console.log(`[Trace] Returned from ${inst.func} ->:`, res ? res.toString() : "fail");
+      }
+      if (res === undefined) return undefined;
+      registers.set(inst.dest, res);
+      return { type: "continue" };
+    }
+    case "call_intrinsic": {
+      const val = registers.get(inst.src);
+      const builtinFunc = run.builtin[inst.symbol];
+      if (!builtinFunc) {
+        throw new Error(`Unknown builtin: '${inst.symbol}'`);
+      }
+      if (!options.envelopeFree && inst.pattern) {
+        try {
+          const constrained = constrainWithPattern(val, inst.pattern, inst.exp);
+          const res = builtinFunc(constrained);
+          registers.set(inst.dest, res);
+          return { type: "continue" };
+        } catch (err) {
+          throw err;
+        }
+      } else {
+        const res = builtinFunc(val);
+        registers.set(inst.dest, res);
+        return { type: "continue" };
+      }
+    }
+    case "product": {
+      const val = registers.get(inst.src);
+      const result = {};
+      const patternEntries = [];
+      for (const branch of inst.branches) {
+        const branchRes = executeBlock(branch.body, val, context);
+        if (branchRes === undefined) return undefined;
+        result[branch.label] = branchRes;
+        if (!options.envelopeFree) {
+          patternEntries.push([branch.label, branchRes.pattern]);
+        }
+      }
+      let productValue;
+      if (options.envelopeFree) {
+        productValue = new Product(result);
+      } else {
+        const staticOutputPattern = inst.pattern;
+        if (staticOutputPattern) {
+          productValue = new Product(result, staticOutputPattern);
+        } else {
+          productValue = new Product(result, composePattern("closed-product", patternEntries));
+        }
+      }
+      registers.set(inst.dest, productValue);
+      return { type: "continue" };
+    }
+    case "union": {
+      const val = registers.get(inst.src);
+      for (const branch of inst.branches) {
+        const branchRes = executeBlock(branch.body, val, context);
+        if (branchRes !== undefined) {
+          registers.set(inst.dest, branchRes);
+          return { type: "continue" };
+        }
+      }
+      return undefined;
+    }
+    case "return": {
+      return { type: "return", value: registers.get(inst.src) };
+    }
+    default:
+      throw new Error(`Unknown instruction op: ${inst.op}`);
+  }
+}
+
+export function executeKVM(kvmFunc, inputVal, context) {
+  const options = context.options || {};
+  if (options.requireConverged && !kvmFunc.isConverged) {
+    throw new Error(`Cannot run '${kvmFunc.name}' without envelopes: type derivation is not converged`);
+  }
+
+  const result = executeBlock(kvmFunc.body, inputVal, context);
+  if (result === undefined) return undefined;
+
+  if (options.envelopeFree && kvmFunc.isConverged) {
+    return withPattern(result, kvmFunc.outputPattern);
+  }
+  return result;
+}
+
+export default {
+  lowerToKVM,
+  executeKVM
+};
+
+function usage() {
+  const prog = argv[1] || "kvm.mjs";
+  console.error(`Usage: node ${prog} [ options ] ( k-expr | -k file ) [ input-file ]`);
+  console.error("Options:");
+  console.error("  --lib file          Load a .klib dependency before compiling. May be repeated.");
+  console.error("  --envelope-free     Run the interpreter in envelope-free mode.");
+  console.error("  -h, --help          Show this help.");
+}
+
+async function main() {
+  const args = argv.slice(2);
+  if (args.includes("-h") || args.includes("--help")) {
+    usage();
+    return exit(0);
+  }
+
+  let envelopeFree = false;
+  const libraries = [];
+
+  // Parse options
+  while (args.length > 0) {
+    if (args[0] === "--envelope-free") {
+      envelopeFree = true;
+      args.shift();
+    } else 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 {
+      break;
+    }
+  }
+
+  let kScriptStr = (function (arg) {
+    if (arg == null) {
+      throw new Error("Missing script argument");
+    }
+    if (arg === "-k") {
+      const fileArg = args.shift();
+      if (!fileArg) throw new Error("-k requires a file argument");
+      return fs.readFileSync(fileArg, "utf8");
+    } else {
+      return arg;
+    }
+  })(args.shift());
+
+  const inputStream = (function (arg) {
+    if (arg == null) {
+      return stdin;
+    }
+    return fs.createReadStream(arg);
+  })(args.shift());
+
+  const defs = annotate(kScriptStr, { libraries });
+  const mainRel = defs.rels.__main__;
+  if (!mainRel) {
+    throw new Error("No main relation (__main__) defined in script");
+  }
+
+  const kvmFunc = lowerToKVM(mainRel, "__main__");
+
+  const buffer = [];
+  inputStream.on("data", (data) => buffer.push(Buffer.isBuffer(data) ? data : Buffer.from(data)));
+  inputStream.on("end", () => {
+    try {
+      const inputBuffer = Buffer.concat(buffer);
+      const { pattern: inputPattern, value } = decodeWire(inputBuffer);
+      const context = {
+        rels: defs.rels,
+        findCode: codes.find,
+        options: {
+          envelopeFree
+        }
+      };
+      const result = executeKVM(kvmFunc, value, context);
+      if (result === undefined) {
+        throw new Error("kVM expression evaluated to undefined");
+      }
+      stdout.write(encodeToWire(result, result.pattern));
+    } catch (error) {
+      console.error(error.stack || error.message || String(error));
+      exit(1);
+    }
+  });
+}
+
+if (isMainEntrypoint(import.meta.url, argv[1])) {
+  main().catch((error) => {
+    console.error(error.stack || error.message || String(error));
+    usage();
+    exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.2.0",
+    "version": "6.2.2",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "scripts": {
@@ -30,7 +30,8 @@
         "k-show": "./codecs/show.mjs",
         "k-unit": "./codecs/unit.mjs",
         "k-utf16": "./codecs/utf16.mjs",
-        "k-utf8": "./codecs/utf8.mjs"
+        "k-utf8": "./codecs/utf8.mjs",
+        "k-vm": "./kvm.mjs"
     },
     "devDependencies": {
         "jiwson": "^0.1.2"

package/run.mjs

@@ -483,4 +483,4 @@ run_converged.defs = null;
 const run_coverged = run_converged;
 
 export default run;
-export { run, run_rel, run_converged, run_coverged };
+export { run, run_rel, run_converged, run_coverged, constrainWithPattern, intersectPatterns, projectionPattern, verify };

package/scripts/run-tests.mjs

@@ -18,8 +18,10 @@ const tests = [
   ["tests/test-fingerprint.mjs", node, ["tests/test-fingerprint.mjs"]],
   ["tests/test-hash-fuzz.mjs", node, ["tests/test-hash-fuzz.mjs"]],
   ["tests/test-hash-normalization.mjs", node, ["tests/test-hash-normalization.mjs"]],
+  ["tests/test-deep-wire-value.mjs", node, ["tests/test-deep-wire-value.mjs"]],
   ["tests/test-k-object.mjs", node, ["tests/test-k-object.mjs"]],
   ["tests/test-repl.mjs", node, ["tests/test-repl.mjs"]],
+  ["tests/test-kvm.mjs", node, ["tests/test-kvm.mjs"]],
   ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.mjs"]],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
 ];

package/tests/README.md

@@ -0,0 +1,35 @@
+# k Test Suite
+
+This directory contains the automated tests, type-derivation validation cases, and integration test scripts for the `k` compiler and runtime.
+
+## Running the Tests
+
+### 1. Run Unit and Integration Test Suite
+To run all core unit tests, type-derivation checks, and integration tests:
+```bash
+npm test
+```
+This executes `node scripts/run-tests.mjs`, which discovers and runs the test scripts sequentially.
+
+## Test Directory Structure
+
+### Core Test Files
+- **[test.mjs](file:///Users/wojtek/gits/k/tests/test.mjs)**: Verifies basic parser and runtime execution behavior.
+- **[test-kvm.mjs](file:///Users/wojtek/gits/k/tests/test-kvm.mjs)**: Comprehensive conformance testing for the kVM register compiler and interpreter under both envelope-aware and envelope-free modes.
+- **[test-ieee-arithmetic.mjs](file:///Users/wojtek/gits/k/tests/test-ieee-arithmetic.mjs)**: Verifies IEEE-754 double precision float arithmetic implementation (`Examples/ieee.k`).
+- **[test-repl.mjs](file:///Users/wojtek/gits/k/tests/test-repl.mjs)**: Tests interactive REPL commands, state transitions, imports, and auto-completions.
+- **[test-k-object.mjs](file:///Users/wojtek/gits/k/tests/test-k-object.mjs)**: Tests serialization, compilation, and loading of `.ko` binary objects.
+- **[test-fingerprint.mjs](file:///Users/wojtek/gits/k/tests/test-fingerprint.mjs)**: Tests semantic expression and relation hashing/fingerprinting.
+- **[test-hash-normalization.mjs](file:///Users/wojtek/gits/k/tests/test-hash-normalization.mjs)**: Verifies consistent normalization of type pattern graphs and hashes.
+- **[test-hash-fuzz.mjs](file:///Users/wojtek/gits/k/tests/test-hash-fuzz.mjs)**: Fuzzes expression/relation hashing to guard against collisions.
+
+### WebAssembly Benchmarks
+
+The WebAssembly execution benchmark moved to the separate
+[`fraczak/k-wasm`](https://github.com/fraczak/k-wasm) backend repository.
+
+### Type Derivation Suites
+- **[code-derivation/](file:///Users/wojtek/gits/k/tests/code-derivation)**: Houses individual files (each containing a focused test scenario) validating type-derivation convergence and pattern-envelope generation.
+
+### Integration Scripts
+- **[integration.sh](file:///Users/wojtek/gits/k/tests/integration.sh)**: Shell script checking boundary data pipelines (`k-parse`, `k-show`, `k-print`) against binary outputs.

package/tests/code-derivation/codec-witness-pattern.mjs

@@ -20,7 +20,7 @@ const explicitProductWire = decodeWire(encodeToWire(value, [
   ["any", []]
 ]));
 assert.deepEqual(explicitProductWire.pattern, [
-  ["open-product", [["a", 1]]],
+  ["closed-product", [["a", 1]]],
   ["closed-product", [["b", 2], ["c", 3]]],
   ["open-union", [["x", 3]]],
   ["closed-product", []]

package/tests/integration.sh

@@ -5,6 +5,9 @@ set -euo pipefail
 
 echo "Running './tests/integration.sh' ..."
 
+TMP_DIR=`mktemp -d`
+trap 'rm -rf "$TMP_DIR"' EXIT
+
 echo '["zebara", "ela", "kupa", ala, owca]' | node ./codecs/k-parse.mjs | ./k.mjs '{.1 0,.3 1}' | node ./codecs/k-print.mjs
 echo 
 echo '-21' | node ./codecs/int.mjs --parse | node ./codecs/int.mjs --print | grep -qx -- '-21'
@@ -13,14 +16,14 @@ node ./codecs/unit.mjs --parse | node ./codecs/unit.mjs --print | grep -qx '{}'
 echo 
 printf 'A🙂\nBé~\t' | ./codecs/utf8.mjs --parse | ./k.mjs -k Examples/byte.k |./codecs/utf8.mjs --print
 echo
-./objects/compile-lib.mjs Examples/ieee.k ieee.klib
-MUL=`./objects/extract-aliases.mjs ieee.klib | grep '^mul = @' | sed 's/^mul = \(@[^;]*\);.*$/\1/'`
-DIV=`./objects/extract-aliases.mjs ieee.klib | grep '^div = @' | sed 's/^div = \(@[^;]*\);.*$/\1/'`
+./objects/compile-lib.mjs Examples/ieee.k "$TMP_DIR/ieee.klib"
+MUL=`./objects/extract-aliases.mjs "$TMP_DIR/ieee.klib" | grep '^mul = @' | sed 's/^mul = \(@[^;]*\);.*$/\1/'`
+DIV=`./objects/extract-aliases.mjs "$TMP_DIR/ieee.klib" | grep '^div = @' | sed 's/^div = \(@[^;]*\);.*$/\1/'`
 ARG=0.12
 printf "$ARG * $ARG = "
-echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib ieee.klib "{()x,()y} $MUL .result" | ./codecs/ieee.mjs --print
+echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib "$TMP_DIR/ieee.klib" "{()x,()y} $MUL .result" | ./codecs/ieee.mjs --print
 printf "$ARG / $ARG = "
-DIV_RESULT=`echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib ieee.klib "{()x,()y} $DIV .result" | ./codecs/ieee.mjs --print`
+DIV_RESULT=`echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib "$TMP_DIR/ieee.klib" "{()x,()y} $DIV .result" | ./codecs/ieee.mjs --print`
 echo "$DIV_RESULT"
 test "$DIV_RESULT" = "1"
 echo

package/tests/test-deep-wire-value.mjs

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { Product, Variant } from "../Value.mjs";
+import { decodeWire, encodeToWire } from "../codecs/runtime/prefix-codec.mjs";
+
+const depth = 12000;
+const pattern = [
+  ["closed-union", [["+", 1]]],
+  ["closed-union", [["_", 2], ["1", 1]]],
+  ["closed-product", []]
+];
+
+let bits = new Variant("_", new Product({}));
+for (let i = 0; i < depth; i++) {
+  bits = new Variant("1", bits);
+}
+
+const wire = encodeToWire(new Variant("+", bits), pattern);
+const decoded = decodeWire(wire).value;
+assert.equal(decoded.tag, "+");
+
+bits = decoded.value;
+for (let i = 0; i < depth; i++) {
+  assert.equal(bits.tag, "1");
+  bits = bits.value;
+}
+assert.equal(bits.tag, "_");
+assert.deepEqual(bits.value.product, {});
+
+console.log("deep wire value: ok");