@fraczak/k 6.8.0 → 6.10.1

package/repl.mjs

@@ -8,18 +8,20 @@ import { fileURLToPath } from "node:url";
 import { argv, exit, stdin, stdout } from "node:process";
 
 import { annotate, parse } from "./index.mjs";
-import { constrainWithPattern } from "./run.mjs";
+import run, { constrainWithPattern, run_rel } from "./run.mjs";
 import { compileWasmArtifactFromObject, instantiateWasmArtifact } from "./backends/wasm/src/wasm.mjs";
 import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 import codes from "./codes.mjs";
 import { Value, isProduct, isVariant } from "./Value.mjs";
+import { patternFromFilter } from "./codecs/runtime/pattern-k.mjs";
 if (typeof globalThis !== "undefined") {
   globalThis.Value = Value;
   globalThis.isProduct = isProduct;
   globalThis.isVariant = isVariant;
+  globalThis.patternFromFilter = patternFromFilter;
 }
-import { patterns2filters, prettyCode, prettyRel } from "./pretty.mjs";
+import { prettyCode } from "./pretty.mjs";
 import {
   compileObject,
   compileLibrary,
@@ -39,18 +41,16 @@ import {
   registerCodec,
   resolveCodec,
   unregisterCodec,
-  BUILTIN_CODECS,
   closedPatternToCodeHash,
-  UNIVERSAL_CODE,
   valueForPattern,
-  matchBuiltinCodec
+  ensureEnveloped
 } from "./repl-codecs.mjs";
 
 const NAME_RE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
 const COMMAND_NAMES = [
-  "help", "type", "code", "run", "eval", "t", "d", "C",
-  "codes", "codecs", "rels", "codec", "input", "reset", "klib", "ko", "load",
-  "time",
+  "help", "type", "code", "rel", "C",
+  "types", "codecs", "rels", "codec", "input", "reset", "klib", "ko", "load",
+  "engine", "wasm", "js",
   "quit", "exit"
 ];
 const CODEC_COMMAND_NAMES = ["load", "unload", "list"];
@@ -73,9 +73,14 @@ function emptyValue() {
   return Value.product({}, [["closed-product", []]]);
 }
 
-function createState() {
+function createState(options = {}) {
   codes.load(cloneJSON(initialCodes));
+  const engine = (options.engine || "wasm").toLowerCase();
+  if (engine !== "wasm" && engine !== "js") {
+    throw new Error(`Invalid engine '${options.engine}'. Valid engines: wasm, js`);
+  }
   return {
+    engine,
     codes: codes.dump(),
     rels: {},
     relAliases: {},
@@ -337,11 +342,6 @@ function resolveRel(state, name) {
   return hash ? { hash, rel: state.rels[hash] } : { hash: null, rel: null };
 }
 
-function relTypeString(rel) {
-  const filters = patterns2filters(rel.typePatternGraph, ...rel.def.patterns);
-  return filters.map((filter) => prettyRel({ op: "filter", filter })).join("  -->  ");
-}
-
 function listAliases(aliases) {
   const entries = Object.entries(aliases).sort(([a], [b]) => a.localeCompare(b));
   if (entries.length === 0) return "(none)";
@@ -349,7 +349,8 @@ function listAliases(aliases) {
 }
 
 function formatCodecOutput(output) {
-  if (Buffer.isBuffer(output)) return output.toString("utf8");
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(output)) return output.toString("utf8");
+  if (typeof Uint8Array !== "undefined" && output instanceof Uint8Array) return new TextDecoder().decode(output);
   return String(output);
 }
 
@@ -357,19 +358,16 @@ function printValue(value, state = null) {
   const lines = [valueWithEnvelopeToK(value)];
   if (!state || value === undefined) return lines[0];
 
-  const codeHash = closedPatternToCodeHash(value.pattern);
-  const codecs = [
-    ...(codeHash ? state.codecs?.[codeHash] || [] : []),
-    ...(state.codecs?.[UNIVERSAL_CODE] || [])
-  ];
-  if (codecs.length === 0) return lines[0];
-  for (const codec of codecs) {
+  const store = state.codecs || {};
+  for (const codec of Object.values(store)) {
     if (typeof codec.print !== "function") continue;
     try {
-      lines.push(`${codec.name}: ${formatCodecOutput(codec.print(value, { codeHash, state }))}`);
-    } catch (error) {
-      if (codec.universal) continue;
-      lines.push(`${codec.name}: <error: ${error.message || String(error)}>`);
+      const output = codec.print(value, { state });
+      if (output != null) {
+        lines.push(`${codec.name}: ${formatCodecOutput(output)}`);
+      }
+    } catch {
+      // Codec cannot format this value; silently skip
     }
   }
   return lines.join("\n");
@@ -649,13 +647,7 @@ function completeCodecCommand(line, argStart, arg, state) {
   const tokenStart = codecLoadPathCompletionStart(argStart, arg);
   if (tokenStart == null) return [[], line];
   const [pathMatches] = completePath(line, tokenStart);
-  const match = arg.match(/^(\s*)load(?:\s+(.*))?$/);
-  const partial = match && match[2] != null ? match[2].trim() : "";
-  const prefix = line.slice(0, tokenStart);
-  const builtinMatches = ["int", "utf8", "json", "ieee"]
-    .filter((name) => name.startsWith(partial))
-    .map((name) => `${prefix}${name}`);
-  return [[...builtinMatches, ...pathMatches], line];
+  return [pathMatches, line];
 }
 
 function resolveTypeHash(state, rawName) {
@@ -785,37 +777,16 @@ function resolveInputPattern(state, rawExpr) {
 }
 
 function completeInputCommand(line, state, argStart, arg) {
-  const match = arg.match(/^(\s*)(\S+)?(\s+)?(\S*)?$/);
-  if (!match) return [[], line];
-  const [, leading, firstToken = "", afterWhitespace = "", secondPartial = ""] = match;
-
-  if (!firstToken || !afterWhitespace) {
-    if (/@[A-Za-z0-9_?!+-]*$/.test(line)) return completeCanonicalCode(line, state);
-    const [types] = completeTypeIdentifier(line, state);
+  const match = arg.match(/^(\s*)(\S*)$/);
+  if (match) {
+    const [, leading, partial] = match;
     const prefix = line.slice(0, argStart + leading.length);
-    const codecMatches = codecNames(state)
-      .filter((name) => name.startsWith(firstToken))
+    const names = codecNames(state);
+    const matches = names
+      .filter((name) => name.startsWith(partial))
       .map((name) => `${prefix}${name}`);
-    return [[...new Set([...types, ...codecMatches])], line];
-  }
-
-  if (firstToken) {
-    const prefix = line.slice(0, argStart + leading.length + firstToken.length + afterWhitespace.length);
-    const names = (() => {
-      try {
-        return codecNames(state, resolveTypeHash(state, firstToken));
-      } catch {
-        return codecNames(state);
-      }
-    })();
-    return [
-      names
-        .filter((name) => name.startsWith(secondPartial))
-        .map((name) => `${prefix}${name}`),
-      line
-    ];
+    return [matches, line];
   }
-
   return [[], line];
 }
 
@@ -832,6 +803,10 @@ function completeCommandArgument(line, state) {
     return completeCodecCommand(line, argStart, arg, state);
   }
 
+  if (command === "engine") {
+    return completeCommandWord(line, argStart, arg, ["wasm", "js"]);
+  }
+
   if (command === "input") {
     return completeInputCommand(line, state, argStart, arg);
   }
@@ -905,14 +880,6 @@ function parseLoadArgs(arg, usagePrefix = ":") {
   return { path: arg.trim(), loadAliases: true };
 }
 
-const CODEC_FILES = {
-  int: "arithmetics.k",
-  utf8: "core.k",
-  json: "core.k",
-  ieee: "ieee.k",
-  unit: "core.k"
-};
-
 function normalizeFilePath(p) {
   return p.replace(/\\/g, "/").replace(/^\.\//, "");
 }
@@ -983,24 +950,6 @@ function loadSourceOrKlib(state, targetPath, options = {}) {
   return targetPath;
 }
 
-function ensureCodecDependencies(state, codecTarget) {
-  const norm = normalizeFilePath(codecTarget).toLowerCase();
-  const base = path.basename(norm, path.extname(norm));
-  const depFile = CODEC_FILES[base] || CODEC_FILES[norm];
-  if (!depFile) return null;
-  if (!state.loadedFiles) state.loadedFiles = new Set();
-  const depNormKey = normalizeFilePath(depFile);
-  const baseName = path.basename(depNormKey);
-  const alreadyLoaded = state.loadedFiles.has(depNormKey) ||
-    state.loadedFiles.has(`Examples/${depNormKey}`) ||
-    Array.from(state.loadedFiles).some(f => path.basename(f) === baseName);
-  if (!alreadyLoaded) {
-    loadSourceOrKlib(state, depFile);
-    return depFile;
-  }
-  return null;
-}
-
 function lineForContinuation(line) {
   return line.replace(/\\\s*$/, "");
 }
@@ -1102,47 +1051,24 @@ async function executeExpressionWithWasm(annotated, state, lineOffset = 0) {
   return { result, wasmCompileMs, executeMs };
 }
 
-async function runExpression(input, state) {
-  const expression = input.trim();
-  if (!expression) throw new Error(":run requires an expression");
-
-  restoreCodes(state);
-  const preamble = aliasPreamble(state);
-  const lineOffset = preambleLineCount(preamble);
-  const source = [preamble, expression].filter(Boolean).join("\n");
-  const compileStart = performance.now();
-  let annotated;
-  try {
-    annotated = annotate(source, { libraries: [stateLibrary(state)] });
-  } catch (error) {
-    throw remapError(error, lineOffset);
-  }
-  const snippetCompileMs = performance.now() - compileStart;
+function executeExpressionWithJs(annotated, state, lineOffset = 0) {
+  const mainRel = annotated.rels.__main__;
+  if (!mainRel) return { result: undefined, wasmCompileMs: 0, executeMs: 0 };
 
-  let execRes;
-  try {
-    execRes = await executeExpressionWithWasm(annotated, state, lineOffset);
-  } catch (error) {
-    throw remapError(error, lineOffset);
+  let inputValue = state.value ?? emptyValue();
+  if (mainRel.typePatternGraph && mainRel.def.patterns) {
+    const graph = mainRel.typePatternGraph;
+    const nodeId = graph.find(mainRel.def.patterns[0]);
+    const inputPattern = patternToPropertyList(exportPatternGraph(graph, nodeId));
+    inputValue = constrainWithPattern(inputValue, inputPattern, mainRel.def);
   }
-  state.codes = codes.dump();
-  restoreCodes(state);
 
-  const compileMs = snippetCompileMs + execRes.wasmCompileMs;
-  const executeMs = execRes.executeMs;
-  state.lastTiming = {
-    compileMs,
-    executeMs,
-    totalMs: compileMs + executeMs,
-    snippetCompileMs,
-    wasmCompileMs: execRes.wasmCompileMs
-  };
+  const executeStart = performance.now();
+  run.defs = { rels: annotated.rels };
+  const result = run_rel(codes.find, mainRel, inputValue, "__main__");
+  const executeMs = performance.now() - executeStart;
 
-  const committed = commitResult(state, execRes.result, expression);
-  if (state.showTiming) {
-    committed.push(`/* comp: ${formatDuration(compileMs)}, exec: ${formatDuration(executeMs)} */`);
-  }
-  return committed;
+  return { result, wasmCompileMs: 0, executeMs };
 }
 
 async function runSnippet(input, state, options = {}) {
@@ -1163,7 +1089,8 @@ async function runSnippet(input, state, options = {}) {
       executeMs: 0,
       totalMs: snippetCompileMs,
       snippetCompileMs,
-      wasmCompileMs: 0
+      wasmCompileMs: 0,
+      engine: state.engine
     };
     if (state.showTiming) {
       return [`/* comp: ${formatDuration(snippetCompileMs)} */`];
@@ -1173,26 +1100,32 @@ async function runSnippet(input, state, options = {}) {
 
   let execRes;
   try {
-    execRes = await executeExpressionWithWasm(annotated, state, lineOffset);
+    if (state.engine === "js") {
+      execRes = executeExpressionWithJs(annotated, state, lineOffset);
+    } else {
+      execRes = await executeExpressionWithWasm(annotated, state, lineOffset);
+    }
   } catch (error) {
     throw remapError(error, lineOffset);
   }
   state.codes = codes.dump();
   restoreCodes(state);
 
-  const compileMs = snippetCompileMs + execRes.wasmCompileMs;
+  const wasmCompileMs = execRes.wasmCompileMs || 0;
+  const compileMs = snippetCompileMs + wasmCompileMs;
   const executeMs = execRes.executeMs;
   state.lastTiming = {
     compileMs,
     executeMs,
     totalMs: compileMs + executeMs,
     snippetCompileMs,
-    wasmCompileMs: execRes.wasmCompileMs
+    wasmCompileMs,
+    engine: state.engine
   };
 
   const committed = commitResult(state, execRes.result, snippet);
   if (state.showTiming) {
-    committed.push(`/* comp: ${formatDuration(compileMs)}, exec: ${formatDuration(executeMs)} */`);
+    committed.push(`/* comp: ${formatDuration(compileMs)}, exec: ${formatDuration(executeMs)} (${state.engine}) */`);
   }
   return committed;
 }
@@ -1206,13 +1139,10 @@ async function loadCodec(input, state) {
   const [subcommand, ...rest] = trimmed.split(/\s+/);
   switch (subcommand) {
     case "load": {
-      const filePath = rest.join(" ");
-      if (!filePath) throw new Error(":codec load requires a file path or codec name");
-      const autoLoaded = ensureCodecDependencies(state, filePath);
+      const filePath = rest.join(" ").trim();
+      if (!filePath) throw new Error(":codec load requires a file path");
       const registered = await loadCodecModule(state, expandHome(filePath));
-      return registered.map(({ name, codeHash }) =>
-        `loaded codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}${autoLoaded ? ` (auto-loaded ${autoLoaded})` : ""}`
-      );
+      return registered.map(({ name }) => `loaded codec ${name}`);
     }
     case "unload": {
       const codecName = rest.join(" ").trim();
@@ -1222,120 +1152,55 @@ async function loadCodec(input, state) {
       return [`unloaded codec ${codecName}`];
     }
     case "define":
-      throw new Error(":codec define has been removed; use :codec load <name|file> or the Custom Codec Studio UI");
+      throw new Error(":codec define has been removed; all codecs are loaded from files via :codec load <file.mjs>");
     case "list":
       if (rest.length > 0) throw new Error(":codec list does not accept arguments");
       return [listCodecs(state)];
     default: {
-      const autoLoaded = ensureCodecDependencies(state, trimmed);
       const registered = await loadCodecModule(state, expandHome(trimmed));
-      return registered.map(({ name, codeHash }) =>
-        `loaded codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}${autoLoaded ? ` (auto-loaded ${autoLoaded})` : ""}`
-      );
+      return registered.map(({ name }) => `loaded codec ${name}`);
     }
   }
 }
 
 async function requestCodecInput(input, state) {
-  const trimmed = input.trim() || "(...)";
-
-  let pattern = null;
-  let codeHash = null;
-  let codecName = null;
-  let targetDisplay = null;
-  let rawExpr = trimmed;
-
-  const isJustCodec = (() => {
-    if (trimmed.startsWith("?") || trimmed.startsWith("$") || trimmed.startsWith("{") || trimmed.startsWith("<") || trimmed.startsWith("(")) {
-      return false;
-    }
-    const allCodecs = codecNames(state);
-    const builtin = matchBuiltinCodec(trimmed);
-    const isCodecName = allCodecs.includes(trimmed) || builtin != null;
-    const isTypeAlias = Boolean(state.typeAliases && state.typeAliases[trimmed]);
-    return isCodecName && !isTypeAlias;
-  })();
-
-  if (isJustCodec) {
-    codecName = trimmed;
-    targetDisplay = trimmed;
-    ensureCodecDependencies(state, codecName);
-    if (!state.codecs?.[codecName] && matchBuiltinCodec(codecName)) {
-      await loadCodecModule(state, codecName);
-    }
-    if (state.typeAliases?.[codecName]) {
-      codeHash = state.typeAliases[codecName];
-      pattern = codeHashToPattern(codeHash, codes.find);
-      targetDisplay = codeHash;
-    }
-  } else {
-    let splitPattern = null;
-    let splitCodec = null;
-
-    const split = trimmed.match(/^(.*\S)\s+([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)$/);
-    if (split && split[1].trim() !== "?" && split[1].trim() !== "$") {
-      splitPattern = split[1];
-      splitCodec = split[2];
-    }
+  let trimmed = input.trim();
+  if (!trimmed) {
+    const loaded = Object.keys(state.codecs || {});
+    const loadedStr = loaded.length > 0 ? `Loaded: ${loaded.join(", ")}` : "None loaded";
+    return [
+      "Usage: :input <codec.mjs> [text]",
+      `Loaded codecs: ${loadedStr}`
+    ];
+  }
 
-    if (splitCodec) {
-      try {
-        const resolved = resolveInputPattern(state, splitPattern);
-        pattern = resolved.pattern;
-        codeHash = resolved.codeHash;
-        codecName = splitCodec;
-        targetDisplay = resolved.display;
-        rawExpr = splitPattern;
-      } catch (patternErr) {
-        const resolved = resolveInputPattern(state, trimmed);
-        pattern = resolved.pattern;
-        codeHash = resolved.codeHash;
-        targetDisplay = resolved.display;
-        rawExpr = trimmed;
-      }
-    } else {
-      const resolved = resolveInputPattern(state, trimmed);
-      pattern = resolved.pattern;
-      codeHash = resolved.codeHash;
-      targetDisplay = resolved.display;
-      rawExpr = trimmed;
-    }
+  if (trimmed.startsWith("$")) {
+    trimmed = trimmed.slice(1).trim();
   }
 
-  const explicitCodec = Boolean(codecName);
-  if (!codecName && codeHash) {
-    for (const [alias, hash] of Object.entries(state.typeAliases || {})) {
-      if (hash === codeHash && (matchBuiltinCodec(alias) || codecNames(state).includes(alias))) {
-        codecName = alias;
-        break;
-      }
-    }
+  const match = trimmed.match(/^([a-zA-Z0-9_?!+.-]+)(?:\s+([\s\S]*))?$/);
+  if (!match) {
+    throw new Error("Invalid :input syntax. Usage: :input <codec.mjs> [text]");
   }
 
-  if (codecName) {
-    ensureCodecDependencies(state, codecName);
-    if (!state.codecs?.[codecName] && matchBuiltinCodec(codecName)) {
-      await loadCodecModule(state, codecName);
-    }
-  } else {
-    const hasExactCodec = Boolean(codeHash && state.codecs?.[codeHash]?.some((c) => typeof c.parse === "function"));
-    const hasUniversal = Boolean(state.codecs?.[UNIVERSAL_CODE]?.some((c) => typeof c.parse === "function"));
-    if (!hasExactCodec && !hasUniversal && matchBuiltinCodec("json")) {
-      await loadCodecModule(state, "json");
-    }
+  const codecName = match[1];
+  const inlineText = match[2];
+
+  const codec = resolveCodec(state, codecName, "parse");
+
+  if (inlineText !== undefined) {
+    const parsed = await codec.parse(inlineText, { state, codecName: codec.name });
+    const value = ensureEnveloped(parsed, codec);
+    state.value = value;
+    state.lastResult = value;
+    return [printValue(value, state)];
   }
 
-  const codec = resolveCodec(state, codeHash, codecName, "parse");
   state.pendingInput = {
-    pattern,
-    codeHash,
     codecName: codec.name,
-    promptName: codec.name,
-    rawExpr
+    promptName: codec.name
   };
-
-  const usingPart = explicitCodec && codecName && codecName !== targetDisplay ? ` using ${codecName}` : "";
-  return [`input ${targetDisplay}${usingPart}: enter value text`];
+  return [];
 }
 
 async function consumeCodecInput(input, state) {
@@ -1344,14 +1209,12 @@ async function consumeCodecInput(input, state) {
   state.pendingInput = null;
 
   restoreCodes(state);
-  const codec = resolveCodec(state, pending.codeHash, pending.codecName, "parse");
-  const pattern = pending.pattern || (pending.codeHash ? codeHashToPattern(pending.codeHash, codes.find) : null);
+  const codec = resolveCodec(state, pending.codecName, "parse");
   const parsed = await codec.parse(input, {
-    codeHash: pending.codeHash,
-    pattern,
-    state
+    state,
+    codecName: codec.name
   });
-  const value = valueForPattern(parsed, pattern, input, codec.name);
+  const value = ensureEnveloped(parsed, codec);
   state.value = value;
   state.lastResult = value;
   return [printValue(value, state)];
@@ -1392,10 +1255,6 @@ async function evaluateCommand(line, state) {
       return [helpText()];
     case "timing":
       throw new Error(":timing has been removed; timing is now always enabled");
-    case "time": {
-      if (!arg) throw new Error(":time requires an expression");
-      return evaluateInput(arg, state);
-    }
     case "type": {
       if (!arg) throw new Error(":type requires a type name");
       if (arg.includes("=")) {
@@ -1405,13 +1264,18 @@ async function evaluateCommand(line, state) {
     }
     case "code":
       return evaluateCommand(`:C ${arg}`, state);
-    case "rel":
     case "def":
       throw new Error("Relation definitions use syntax: name = relExpr;");
-    case "run":
-    case "eval":
-      return runExpression(arg, state);
-    case "codes":
+    case "rel": {
+      if (!arg) throw new Error(`${usagePrefix}rel requires a relation name`);
+      if (arg.includes("=")) {
+        throw new Error("Relation definitions use syntax: name = relExpr; Use :rel <name> to show a relation definition");
+      }
+      const { hash, rel } = resolveRel(state, arg);
+      if (!rel) throw new Error(`Unknown relation '${arg}'`);
+      return [`${arg} = ${prettyRelation(rel, displayAliases(state), state.relAliases)};  -- ${hash}`];
+    }
+    case "types":
       return [listAliases(state.typeAliases)];
     case "rels":
       return [listAliases(state.relAliases)];
@@ -1420,8 +1284,28 @@ async function evaluateCommand(line, state) {
       return loadCodec(arg, state);
     case "input":
       return requestCodecInput(arg, state);
+    case "engine": {
+      const mode = (arg || "").trim().toLowerCase();
+      if (!mode) {
+        return [`Current engine: ${state.engine}`];
+      }
+      if (mode !== "wasm" && mode !== "js") {
+        throw new Error(`Invalid engine '${arg.trim()}'. Valid engines: wasm, js`);
+      }
+      state.engine = mode;
+      return [`engine set to ${mode}`];
+    }
+    case "wasm": {
+      state.engine = "wasm";
+      return ["engine set to wasm"];
+    }
+    case "js": {
+      state.engine = "js";
+      return ["engine set to js"];
+    }
     case "reset": {
-      const fresh = createState();
+      const currentEngine = state.engine;
+      const fresh = createState({ engine: currentEngine });
       Object.assign(state, fresh);
       return ["reset"];
     }
@@ -1446,18 +1330,6 @@ async function evaluateCommand(line, state) {
       loadSourceOrKlib(state, loadPath, { loadAliases });
       return [`loaded ${loadPath}`];
     }
-    case "t": {
-      if (!arg) throw new Error(`${usagePrefix}t requires a relation name`);
-      const { hash, rel } = resolveRel(state, arg);
-      if (!rel) throw new Error(`Unknown relation '${arg}'`);
-      return [`${arg} : ${relTypeString(rel)}  (${hash})`];
-    }
-    case "d": {
-      if (!arg) throw new Error(`${usagePrefix}d requires a relation name`);
-      const { hash, rel } = resolveRel(state, arg);
-      if (!rel) throw new Error(`Unknown relation '${arg}'`);
-      return [`${arg} = ${prettyRelation(rel, displayAliases(state), state.relAliases)};  -- ${hash}`];
-    }
     case "C": {
       if (!arg) throw new Error(`${usagePrefix}C requires a type name`);
       const hash = state.typeAliases[arg] || (arg.startsWith("@") ? arg : null);
@@ -1471,17 +1343,15 @@ async function evaluateCommand(line, state) {
 
 function helpText() {
   return [
-    ":run expr            run an expression on the current value",
-    ":time expr           run an expression and report compilation/execution time",
-    ":t name              show relation type",
-    ":d name              show relation definition",
+    ":engine [wasm|js]    display or switch evaluation engine (wasm or js)",
+    ":rel name            show relation definition",
     ":type name           show type definition",
-    ":codes               list type aliases",
+    ":types               list type aliases",
     ":rels                list relation aliases",
-    ":codec load file     load a REPL codec module (or built-in: int, utf8, json, ieee, unit)",
+    ":codec load file     load a codec module from file (e.g. :codec load codecs/int.mjs)",
     ":codec unload name   unload a registered codec",
     ":codec list          list loaded codecs (or simply :codecs)",
-    ":input [<filter=(...)> [codec]]  read next line as codec input",
+    ":input <codec.mjs> [text]  parse input using specified codec",
     ":load [--no-alias] file",
     "                     load .k source or .klib",
     ":klib file           export state as a library",
@@ -1501,17 +1371,19 @@ function promptForState(state) {
 }
 
 function cliUsage() {
-  console.log("Usage: k-repl");
-  console.log("       k-repl -h");
+  console.log("Usage: k-repl [options]");
   console.log("");
   console.log("Start the interactive k interpreter. Type :help inside the REPL for commands.");
   console.log("");
   console.log("Options:");
-  console.log("  -h, --help   Show this help.");
+  console.log("  --engine=<wasm|js>  Select evaluation engine (default: wasm)");
+  console.log("  --js                Shortcut for --engine=js");
+  console.log("  --wasm              Shortcut for --engine=wasm");
+  console.log("  -h, --help          Show this help.");
 }
 
-function startRepl() {
-  const state = createState();
+function startRepl(options = {}) {
+  const state = createState(options);
   const rl = readline.createInterface({
     input: stdin,
     output: stdout,
@@ -1522,7 +1394,7 @@ function startRepl() {
   let pending = Promise.resolve();
   let closed = false;
 
-  console.log("k interpreter (.klib-backed). Type :help for commands.");
+  console.log(`k interpreter (.klib-backed, ${state.engine}). Type :help for commands.`);
   rl.prompt();
   async function handleLine(line) {
     if (state.pendingInput && buffer.length === 0) {
@@ -1601,15 +1473,38 @@ function startRepl() {
 
 if (isMainEntrypoint()) {
   const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    cliUsage();
-    exit(0);
-  }
-  if (args.length > 0) {
-    cliUsage();
-    exit(1);
+  let engine = "wasm";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      cliUsage();
+      exit(0);
+    } else if (arg === "--js") {
+      engine = "js";
+    } else if (arg === "--wasm") {
+      engine = "wasm";
+    } else if (arg.startsWith("--engine=")) {
+      const val = arg.slice("--engine=".length).toLowerCase();
+      if (val !== "wasm" && val !== "js") {
+        console.error(`Invalid engine '${val}'. Valid engines: wasm, js`);
+        exit(1);
+      }
+      engine = val;
+    } else if (arg === "--engine") {
+      i++;
+      const val = (args[i] || "").toLowerCase();
+      if (val !== "wasm" && val !== "js") {
+        console.error(`Invalid engine '${val}'. Valid engines: wasm, js`);
+        exit(1);
+      }
+      engine = val;
+    } else {
+      console.error(`Unknown option '${arg}'.`);
+      cliUsage();
+      exit(1);
+    }
   }
-  startRepl();
+  startRepl({ engine });
 }
 
 export {
@@ -1635,13 +1530,14 @@ export {
   resolveInputPattern,
   valueForPattern,
   codeHashToPattern,
-  BUILTIN_CODECS,
   printValue,
   promptForState,
   propertyListToFilter,
   savedLibrary,
   loadSourceOrKlib,
-  ensureCodecDependencies,
   valueToK,
-  formatDuration
+  formatDuration,
+  codecNames,
+  ensureEnveloped,
+  patternFromFilter
 };