@fraczak/k 6.3.2 → 6.4.0

package/package.json

@@ -1,41 +1,73 @@
 {
     "name": "@fraczak/k",
-    "version": "6.3.2",
+    "version": "6.4.0",
     "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",
+    "exports": {
+        ".": "./index.mjs",
+        "./*": "./*"
+    },
     "scripts": {
         "prepare": "jiwson -m es6 parser.jison -o parser.mjs; jiwson -m es6 valueParser.jison -o valueParser.mjs; ",
         "test": "node scripts/run-tests.mjs",
+        "test:backends": "node backends/llvm/scripts/run-tests.mjs && node backends/wasm/scripts/run-tests.mjs",
+        "test:llvm": "node backends/llvm/scripts/run-tests.mjs",
+        "test:wasm": "node backends/wasm/scripts/run-tests.mjs",
+        "test:arm64": "node backends/arm64/scripts/run-tests.mjs",
+        "conformance": "node conformance/run.mjs",
         "benchmark": "node scripts/benchmark.mjs",
         "benchmark:html": "node scripts/render-benchmark.mjs",
-        "hooks:install": "git config core.hooksPath scripts/git-hooks",
+        "perf:ieee": "node scripts/perf-ieee.mjs",
+        "perf:ieee:full": "node scripts/perf-ieee.mjs --full",
+        "perf:int": "node scripts/perf-int.mjs",
+        "perf:poly": "node scripts/perf-poly.mjs",
+        "perf:poly:trace": "node scripts/perf-poly.mjs --trace",
         "perf:idempotency": "node scripts/benchmark-idempotency.mjs",
-        "deps:graph": "node scripts/generate-dependency-graph.mjs"
+        "deps:graph": "node scripts/generate-dependency-graph.mjs",
+        "compare": "node harness/cli.mjs",
+        "build:repl-html": "node scripts/build-repl-html.mjs"
     },
     "repository": {
         "type": "git",
-        "url": "https://github.com/fraczak/k.git"
+        "url": "git+https://github.com/fraczak/k.git"
     },
     "author": "Wojciech Fraczak",
     "license": "ISC",
     "bin": {
-        "k": "./k.mjs",
-        "k-compile": "./objects/compile.mjs",
-        "k-decompile": "./objects/decompile.mjs",
-        "k-extract-aliases": "./objects/extract-aliases.mjs",
-        "k-ieee": "./codecs/ieee.mjs",
-        "k-int": "./codecs/int.mjs",
-        "k-json": "./codecs/json.mjs",
-        "k-parse": "./codecs/k-parse.mjs",
-        "k-print": "./codecs/k-print.mjs",
-        "k-repl": "./repl.mjs",
-        "k-show": "./codecs/show.mjs",
-        "k-unit": "./codecs/unit.mjs",
-        "k-utf16": "./codecs/utf16.mjs",
-        "k-utf8": "./codecs/utf8.mjs",
-        "k-vm": "./kvm.mjs"
+        "k": "k.mjs",
+        "k-compile": "objects/compile.mjs",
+        "k-decompile": "objects/decompile.mjs",
+        "k-extract-aliases": "objects/extract-aliases.mjs",
+        "k-inspect-object": "objects/inspect.mjs",
+        "k-validate-object": "objects/validate.mjs",
+        "k-kir": "kir.mjs",
+        "k-llvm-build": "backends/llvm/bin/k-llvm-build.mjs",
+        "k-llvm-compile": "backends/llvm/bin/k-llvm-compile.mjs",
+        "k-llvm-jit": "backends/llvm/bin/k-llvm-jit.mjs",
+        "k-llvm-run": "backends/llvm/bin/k-llvm-run.mjs",
+        "k-arm64": "backends/arm64/bin/k-arm64.mjs",
+        "k-arm64-compile": "backends/arm64/bin/k-arm64-compile.mjs",
+        "k-arm64-run": "backends/arm64/bin/k-arm64-run.mjs",
+        "k-wasm": "backends/wasm/bin/k-wasm.mjs",
+        "k-wasm-compile": "backends/wasm/bin/k-wasm-compile.mjs",
+        "k-wasm-run": "backends/wasm/bin/k-wasm-run.mjs",
+        "k-ieee": "codecs/ieee.mjs",
+        "k-int": "codecs/int.mjs",
+        "k-json": "codecs/json.mjs",
+        "k-parse": "codecs/k-parse.mjs",
+        "k-print": "codecs/k-print.mjs",
+        "k-repl": "repl.mjs",
+        "k-show": "codecs/show.mjs",
+        "k-unit": "codecs/unit.mjs",
+        "k-utf16": "codecs/utf16.mjs",
+        "k-utf8": "codecs/utf8.mjs",
+        "k-vm": "kvm.mjs"
+    },
+    "dependencies": {
+        "wabt": "^1.0.39"
     },
     "devDependencies": {
+        "esbuild": "^0.28.2",
         "jiwson": "^0.1.2"
     }
 }

package/repl-codecs.mjs

@@ -6,12 +6,28 @@ import { encodeToWire, decodeWire } from "./codecs/runtime/prefix-codec.mjs";
 import { deriveClosedPattern } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 import { finalize } from "./codes.mjs";
+import * as intCodec from "./codecs/int.mjs";
+import * as utf8Codec from "./codecs/utf8.mjs";
+import * as jsonCodec from "./codecs/json.mjs";
+import * as ieeeCodec from "./codecs/ieee.mjs";
+import * as unitCodec from "./codecs/unit.mjs";
+
+const BUILTIN_CODECS = {
+  int: intCodec,
+  utf8: utf8Codec,
+  json: jsonCodec,
+  ieee: ieeeCodec,
+  unit: unitCodec
+};
+
+const UNIVERSAL_CODE = "*";
+const NAME_RE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
 
 function isCanonicalCodeName(name) {
   return typeof name === "string" && name.startsWith("@");
 }
 
-function singletonPatternToCodeHash(pattern) {
+function closedPatternToCodeHash(pattern) {
   if (!Array.isArray(pattern) || pattern.length === 0) {
     return null;
   }
@@ -23,7 +39,7 @@ function singletonPatternToCodeHash(pattern) {
       return null;
     }
     if (!Array.isArray(edges)) {
-      throw new Error(`Invalid singleton pattern node ${i}`);
+      throw new Error(`Invalid closed pattern node ${i}`);
     }
 
     const code = kind === "closed-product" ? "product" : "union";
@@ -31,7 +47,7 @@ function singletonPatternToCodeHash(pattern) {
       code,
       [code]: Object.fromEntries(edges.map(([label, target]) => {
         if (!Number.isInteger(target) || target < 0 || target >= pattern.length) {
-          throw new Error(`Invalid singleton pattern edge target ${target}`);
+          throw new Error(`Invalid closed pattern edge target ${target}`);
         }
         return [label, `C${target}`];
       }))
@@ -64,17 +80,18 @@ function valueForCode(value, codeHash, findCode) {
 function normalizeCodecModule(mod, fallbackName) {
   const codec = mod.replCodec || mod.codec || mod.default || mod;
   const name = codec.name || mod.name || fallbackName;
+  const universal = codec.universal === true;
   const patterns = codec.patterns || (codec.pattern ? [codec.pattern] : null);
   const codes = codec.codes || codec.codeHashes || (codec.code ? [codec.code] : null) ||
     patterns?.map((pattern, index) => {
-      const codeHash = singletonPatternToCodeHash(pattern);
-      if (!codeHash) throw new Error(`Codec '${name}' pattern ${index} is not singleton`);
+      const codeHash = closedPatternToCodeHash(pattern);
+      if (!codeHash) throw new Error(`Codec '${name}' pattern ${index} must be a closed property-list pattern`);
       return codeHash;
     });
   if (!name || typeof name !== "string") {
     throw new Error("Codec module must export a string name");
   }
-  if (!Array.isArray(codes) || codes.length === 0) {
+  if (!universal && (!Array.isArray(codes) || codes.length === 0)) {
     throw new Error(`Codec '${name}' must export a non-empty codes array`);
   }
   if (codec.parse != null && typeof codec.parse !== "function") {
@@ -85,7 +102,8 @@ function normalizeCodecModule(mod, fallbackName) {
   }
   return {
     name,
-    codes,
+    codes: universal ? [UNIVERSAL_CODE] : codes,
+    universal,
     parse: codec.parse,
     print: codec.print
   };
@@ -96,17 +114,30 @@ function codecStore(state) {
   return state.codecs;
 }
 
+function resolveCanonicalCodeHash(codeHash, state = null) {
+  if (codeHash === UNIVERSAL_CODE) return UNIVERSAL_CODE;
+  if (isCanonicalCodeName(codeHash)) return codeHash;
+  if (state?.typeAliases) {
+    const clean = codeHash.startsWith("$") ? codeHash.slice(1) : codeHash;
+    if (state.typeAliases[clean]) return state.typeAliases[clean];
+  }
+  return codeHash;
+}
+
 function registerCodec(state, codec, source = null) {
   const registered = [];
   const store = codecStore(state);
-  for (const codeHash of codec.codes) {
-    if (!isCanonicalCodeName(codeHash)) {
+  for (const rawCodeHash of codec.codes) {
+    const codeHash = resolveCanonicalCodeHash(rawCodeHash, state);
+    const universal = codeHash === UNIVERSAL_CODE;
+    if (!universal && !isCanonicalCodeName(codeHash)) {
       throw new Error(`Codec '${codec.name}' has non-canonical code '${codeHash}'`);
     }
     if (!store[codeHash]) store[codeHash] = [];
     const entry = {
       name: codec.name,
       source,
+      universal,
       parse: codec.parse,
       print: codec.print
     };
@@ -118,18 +149,89 @@ function registerCodec(state, codec, source = null) {
     } else {
       store[codeHash][existingIndex] = entry;
     }
+    if (!universal && isCanonicalCodeName(codeHash) && state?.typeAliases && codec.name && NAME_RE.test(codec.name)) {
+      state.typeAliases[codec.name] = codeHash;
+    }
     registered.push({ codeHash, ...entry });
   }
   return registered;
 }
 
+function unregisterCodec(state, codecName) {
+  const store = codecStore(state);
+  let removedCount = 0;
+  for (const [codeHash, codecs] of Object.entries(store)) {
+    const remaining = codecs.filter((c) => c.name !== codecName);
+    if (remaining.length !== codecs.length) {
+      removedCount += codecs.length - remaining.length;
+      if (remaining.length === 0) {
+        delete store[codeHash];
+      } else {
+        store[codeHash] = remaining;
+      }
+    }
+  }
+  return removedCount;
+}
+
+function matchBuiltinCodec(target) {
+  const normalized = target.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+  const base = path.basename(normalized, path.extname(normalized));
+  if (BUILTIN_CODECS[base]) return { name: base, mod: BUILTIN_CODECS[base] };
+  return null;
+}
+
 async function loadCodecModule(state, filePath) {
+  const builtin = matchBuiltinCodec(filePath);
+  if (builtin) {
+    const codec = normalizeCodecModule(builtin.mod, builtin.name);
+    return registerCodec(state, codec, "built-in");
+  }
+
+  // Check if file exists on disk or in VFS
+  let source = null;
+  try {
+    if (fs.existsSync(filePath)) {
+      source = fs.readFileSync(filePath, "utf8");
+    }
+  } catch {}
+
   const resolved = path.resolve(filePath);
-  const url = pathToFileURL(resolved);
-  url.searchParams.set("mtime", String(fs.statSync(resolved).mtimeMs));
-  const mod = await import(url.href);
-  const codec = normalizeCodecModule(mod, path.basename(resolved, path.extname(resolved)));
-  return registerCodec(state, codec, resolved);
+  if (!source && fs.existsSync(resolved)) {
+    try {
+      source = fs.readFileSync(resolved, "utf8");
+    } catch {}
+  }
+
+  // If in Node environment with a real physical file on disk, try native dynamic import
+  if (typeof process !== "undefined" && process?.versions?.node && fs.existsSync(resolved)) {
+    try {
+      const url = pathToFileURL(resolved);
+      try {
+        const stats = fs.statSync(resolved);
+        if (stats?.mtimeMs) url.searchParams.set("mtime", String(stats.mtimeMs));
+      } catch {}
+      const mod = await import(url.href);
+      const codec = normalizeCodecModule(mod, path.basename(resolved, path.extname(resolved)));
+      return registerCodec(state, codec, resolved);
+    } catch (nodeErr) {
+      if (!source) throw nodeErr;
+    }
+  }
+
+  if (!source) {
+    throw new Error(`Cannot find codec file '${filePath}'`);
+  }
+
+  // Universal data URL loader (works in browser & Node, and in VFS)
+  const sanitized = source.replace(
+    /import\s+[^;]*from\s+['"][^'"]*['"];?/g,
+    "const { Value, isProduct, isVariant, NODE_KIND } = globalThis;"
+  );
+  const dataUrl = "data:text/javascript;charset=utf-8," + encodeURIComponent(sanitized);
+  const mod = await import(dataUrl);
+  const codec = normalizeCodecModule(mod, path.basename(filePath, path.extname(filePath)));
+  return registerCodec(state, codec, filePath);
 }
 
 function listCodecs(state) {
@@ -137,20 +239,27 @@ function listCodecs(state) {
     .flatMap(([codeHash, codecs]) => codecs.map((codec) => ({ codeHash, ...codec })))
     .sort((a, b) => a.name.localeCompare(b.name) || a.codeHash.localeCompare(b.codeHash));
   if (entries.length === 0) return "(none)";
-  return entries.map((entry) => `${entry.name} ${entry.codeHash}${entry.source ? ` (${entry.source})` : ""}`).join("\n");
+  return entries.map((entry) => `${entry.name} ${entry.codeHash === UNIVERSAL_CODE ? "all" : entry.codeHash}${entry.source ? ` (${entry.source})` : ""}`).join("\n");
 }
 
 function codecNames(state, codeHash = null) {
   const store = codecStore(state);
-  const codecs = codeHash ? (store[codeHash] || []) : Object.values(store).flat();
+  const codecs = codeHash
+    ? [...(store[codeHash] || []), ...(store[UNIVERSAL_CODE] || [])]
+    : Object.values(store).flat();
   return [...new Set(codecs.map((codec) => codec.name))].sort();
 }
 
 function resolveCodec(state, codeHash, codecName = null, capability = null) {
-  const matches = (codecStore(state)[codeHash] || []).filter((codec) =>
+  const store = codecStore(state);
+  const matchesCodec = (codec) =>
     (codecName == null || codec.name === codecName) &&
-    (capability == null || typeof codec[capability] === "function")
-  );
+    (capability == null || typeof codec[capability] === "function");
+  const exactMatches = (store[codeHash] || []).filter(matchesCodec);
+  const universalMatches = (store[UNIVERSAL_CODE] || []).filter(matchesCodec);
+  const matches = codecName == null && exactMatches.length > 0
+    ? exactMatches
+    : [...exactMatches, ...universalMatches];
   if (matches.length === 0) {
     const suffix = codecName ? ` named '${codecName}'` : "";
     throw new Error(`No ${capability || "usable"} codec${suffix} for ${codeHash}`);
@@ -162,12 +271,16 @@ function resolveCodec(state, codeHash, codecName = null, capability = null) {
 }
 
 export {
+  BUILTIN_CODECS,
   codecNames,
   codeHashToPattern,
   listCodecs,
   loadCodecModule,
+  normalizeCodecModule,
   registerCodec,
   resolveCodec,
-  singletonPatternToCodeHash,
+  unregisterCodec,
+  closedPatternToCodeHash,
+  UNIVERSAL_CODE,
   valueForCode
 };