@fraczak/k 6.3.3 → 6.5.0

package/package.json

@@ -1,41 +1,73 @@
 {
     "name": "@fraczak/k",
-    "version": "6.3.3",
+    "version": "6.5.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,8 +6,22 @@ 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("@");
@@ -100,10 +114,21 @@ 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) {
+  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}'`);
@@ -124,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) {
@@ -175,12 +271,15 @@ function resolveCodec(state, codeHash, codecName = null, capability = null) {
 }
 
 export {
+  BUILTIN_CODECS,
   codecNames,
   codeHashToPattern,
   listCodecs,
   loadCodecModule,
+  normalizeCodecModule,
   registerCodec,
   resolveCodec,
+  unregisterCodec,
   closedPatternToCodeHash,
   UNIVERSAL_CODE,
   valueForCode