@fraczak/k 6.3.2 → 6.4.0

package/repl.mjs

@@ -8,9 +8,17 @@ import { fileURLToPath } from "node:url";
 import { argv, exit, stdin, stdout } from "node:process";
 
 import { annotate, parse } from "./index.mjs";
-import run from "./run.mjs";
+import { constrainWithPattern } 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 } from "./Value.mjs";
+import { Value, isProduct, isVariant } from "./Value.mjs";
+if (typeof globalThis !== "undefined") {
+  globalThis.Value = Value;
+  globalThis.isProduct = isProduct;
+  globalThis.isVariant = isVariant;
+}
 import { patterns2filters, prettyCode, prettyRel } from "./pretty.mjs";
 import {
   compileObject,
@@ -28,8 +36,13 @@ import {
   codeHashToPattern,
   listCodecs,
   loadCodecModule,
+  normalizeCodecModule,
+  registerCodec,
   resolveCodec,
-  singletonPatternToCodeHash,
+  unregisterCodec,
+  BUILTIN_CODECS,
+  closedPatternToCodeHash,
+  UNIVERSAL_CODE,
   valueForCode
 } from "./repl-codecs.mjs";
 
@@ -38,13 +51,22 @@ const TYPE_DEF_RE = /^\s*\$\s*([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)\s*=/;
 const REL_DEF_RE = /^\s*([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)\s*=/;
 const COMMAND_NAMES = [
   "help", "type", "code", "rel", "def", "run", "eval", "t", "d", "C",
-  "codes", "rels", "val", "codec", "input", "reset", "klib", "ko", "load",
+  "codes", "codecs", "rels", "val", "codec", "input", "reset", "klib", "ko", "load",
+  "timing", "time",
   "quit", "exit"
 ];
-const CODEC_COMMAND_NAMES = ["load", "list"];
+const CODEC_COMMAND_NAMES = ["load", "unload", "list", "define"];
 const PATH_COMMANDS = new Set(["klib", "ko", "load"]);
+const INPUT_TYPE_NAME = "__input__";
 const initialCodes = codes.dump();
 
+function formatDuration(ms) {
+  if (ms < 1000) {
+    return `${ms < 10 ? ms.toFixed(1) : Math.round(ms)}ms`;
+  }
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
 function cloneJSON(value) {
   return JSON.parse(JSON.stringify(value));
 }
@@ -61,10 +83,13 @@ function createState() {
     relAliases: {},
     typeAliases: {},
     codecs: {},
+    loadedFiles: new Set(),
     pendingInput: null,
     meta: {},
     value: emptyValue(),
-    lastMain: null
+    lastMain: null,
+    lastTiming: null,
+    showTiming: false
   };
 }
 
@@ -209,6 +234,16 @@ function mergeLibrary(state, lib, source = "<load>", options = {}) {
       }
     }
     recoverAliasesFromMeta(state, lib);
+    if (state.typeAliases.string && !state.typeAliases.utf8) {
+      state.typeAliases.utf8 = state.typeAliases.string;
+    } else if (state.typeAliases.utf8 && !state.typeAliases.string) {
+      state.typeAliases.string = state.typeAliases.utf8;
+    }
+    if (state.typeAliases.float64 && !state.typeAliases.ieee) {
+      state.typeAliases.ieee = state.typeAliases.float64;
+    } else if (state.typeAliases.ieee && !state.typeAliases.float64) {
+      state.typeAliases.float64 = state.typeAliases.ieee;
+    }
   }
   restoreCodes(state);
 }
@@ -323,14 +358,19 @@ function printValue(value, state = null) {
   const lines = [valueWithEnvelopeToK(value)];
   if (!state || value === undefined) return lines[0];
 
-  const codeHash = singletonPatternToCodeHash(value.pattern);
+  const codeHash = closedPatternToCodeHash(value.pattern);
   if (!codeHash) return lines[0];
 
-  for (const codec of state.codecs?.[codeHash] || []) {
+  const codecs = [
+    ...(state.codecs?.[codeHash] || []),
+    ...(state.codecs?.[UNIVERSAL_CODE] || [])
+  ];
+  for (const codec of codecs) {
     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)}>`);
     }
   }
@@ -590,15 +630,33 @@ function codecLoadPathCompletionStart(argStart, arg) {
   return argStart + leading.length + "load".length + 1 + restLeadingWhitespace + completionTokenStart(rest.trimStart());
 }
 
-function completeCodecCommand(line, argStart, arg) {
+function completeCodecCommand(line, argStart, arg, state) {
   const trimmed = arg.trimStart();
   if (trimmed === "" || !/\s/.test(trimmed)) {
     return completeCommandWord(line, argStart, arg, CODEC_COMMAND_NAMES);
   }
 
+  const unloadMatch = arg.match(/^(\s*)unload(?:\s+(.*))?$/);
+  if (unloadMatch) {
+    const [, leading, partial = ""] = unloadMatch;
+    const prefix = line.slice(0, argStart + leading.length + "unload".length + 1);
+    const names = state ? codecNames(state) : [];
+    const matches = names
+      .filter((name) => name.startsWith(partial.trim()))
+      .map((name) => `${prefix}${name}`);
+    return [matches, line];
+  }
+
   const tokenStart = codecLoadPathCompletionStart(argStart, arg);
   if (tokenStart == null) return [[], line];
-  return completePath(line, tokenStart);
+  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];
 }
 
 function resolveTypeHash(state, rawName) {
@@ -609,6 +667,40 @@ function resolveTypeHash(state, rawName) {
   return hash;
 }
 
+function isSimpleTypeReference(rawType) {
+  return /^\$?[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/.test(rawType.trim());
+}
+
+function resolveTypeExpressionHash(state, rawType) {
+  restoreCodes(state);
+  const preamble = aliasPreamble(state, INPUT_TYPE_NAME);
+  const source = [
+    preamble,
+    ensureSemicolon(`$ ${INPUT_TYPE_NAME} = ${rawType.trim()}`),
+    "()"
+  ].filter(Boolean).join("\n");
+
+  try {
+    const annotated = annotate(source, { libraries: [stateLibrary(state)] });
+    const hash = annotated.representatives[INPUT_TYPE_NAME];
+    if (!hash) throw new Error(":input type expression did not produce a code hash");
+    state.codes = codes.dump();
+    return hash;
+  } catch (error) {
+    restoreCodes(state);
+    throw remapError(error, preambleLineCount(preamble));
+  }
+}
+
+function resolveInputTypeHash(state, rawType) {
+  try {
+    return resolveTypeHash(state, rawType);
+  } catch (error) {
+    if (isSimpleTypeReference(rawType)) throw error;
+  }
+  return resolveTypeExpressionHash(state, rawType);
+}
+
 function completeInputCommand(line, state, argStart, arg) {
   const match = arg.match(/^(\s*)(\S+)?(\s+)?(\S*)?$/);
   if (!match) return [[], line];
@@ -648,8 +740,8 @@ function completeCommandArgument(line, state) {
   const argStart = 1 + firstSpace + 1;
   const arg = line.slice(argStart);
 
-  if (command === "codec") {
-    return completeCodecCommand(line, argStart, arg);
+  if (command === "codec" || command === "codecs") {
+    return completeCodecCommand(line, argStart, arg, state);
   }
 
   if (command === "input") {
@@ -725,6 +817,102 @@ 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(/^\.\//, "");
+}
+
+function resolveKFilePath(filePath) {
+  try {
+    if (fs.existsSync(filePath)) return filePath;
+  } catch {}
+  try {
+    const fromRepo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), filePath);
+    if (fs.existsSync(fromRepo)) return fromRepo;
+  } catch {}
+  const withEx = filePath.startsWith("Examples/") ? filePath : `Examples/${filePath}`;
+  try {
+    if (fs.existsSync(withEx)) return withEx;
+  } catch {}
+  try {
+    const fromRepoEx = path.resolve(path.dirname(fileURLToPath(import.meta.url)), withEx);
+    if (fs.existsSync(fromRepoEx)) return fromRepoEx;
+  } catch {}
+  const strippedEx = filePath.startsWith("Examples/") ? filePath.slice("Examples/".length) : filePath;
+  try {
+    if (fs.existsSync(strippedEx)) return strippedEx;
+  } catch {}
+  try {
+    const fromRepoStripped = path.resolve(path.dirname(fileURLToPath(import.meta.url)), strippedEx);
+    if (fs.existsSync(fromRepoStripped)) return fromRepoStripped;
+  } catch {}
+  return filePath;
+}
+
+function loadSourceOrKlib(state, targetPath, options = {}) {
+  const loadAliases = options.loadAliases ?? true;
+  const normKey = normalizeFilePath(targetPath);
+  if (!state.loadedFiles) state.loadedFiles = new Set();
+
+  // If loading poly.k, auto-load arithmetics.k first if not already loaded
+  if (normKey === "Examples/poly.k" || normKey.endsWith("/poly.k") || normKey === "poly.k") {
+    const arithKey = "arithmetics.k";
+    const alreadyHasArith = Array.from(state.loadedFiles).some(f => path.basename(f) === "arithmetics.k");
+    if (!alreadyHasArith) {
+      loadSourceOrKlib(state, arithKey, { loadAliases });
+    }
+  }
+
+  const loadPath = resolveKFilePath(targetPath);
+  if (loadPath.endsWith(".klib")) {
+    const lib = loadLibrary(decodeLibrary(fs.readFileSync(loadPath)));
+    mergeLibrary(state, lib, targetPath, { loadAliases });
+  } else {
+    restoreCodes(state);
+    const source = fs.readFileSync(loadPath, "utf8");
+    const preamble = aliasPreamble(state);
+    const fullSource = [preamble, source].filter(Boolean).join("\n");
+    const compileOptions = {
+      source: targetPath,
+      libraries: [stateLibrary(state)]
+    };
+    try {
+      const lib = compileWithOptionalIdentity(fullSource, compileOptions);
+      const { relAlias, meta } = libraryOriginsFromSource(source, fullSource, lib, compileOptions);
+      mergeLibrary(state, { ...lib, relAlias, meta }, targetPath, { loadAliases });
+    } catch (error) {
+      throw remapError(error, preambleLineCount(preamble));
+    }
+  }
+  state.loadedFiles.add(normKey);
+  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*$/, "");
 }
@@ -842,29 +1030,82 @@ async function defineRelation(input, state) {
   return [`${name} = ${hash}`];
 }
 
+async function executeExpressionWithWasm(annotated, state, lineOffset = 0) {
+  const mainRel = annotated.rels.__main__;
+  if (!mainRel) return { result: undefined, wasmCompileMs: 0, executeMs: 0 };
+
+  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);
+  }
+
+  const obj = {
+    format: "k-object",
+    codes: { ...state.codes, ...codes.dump() },
+    rels: annotated.rels,
+    relAlias: annotated.relAlias,
+    compileStats: annotated.compileStats,
+    main: "__main__"
+  };
+
+  const wasmCompileStart = performance.now();
+  const wasmBytes = await compileWasmArtifactFromObject(obj, {
+    inputEnvelopePattern: inputValue?.pattern
+  });
+  const runner = await instantiateWasmArtifact(wasmBytes);
+  const wasmCompileMs = performance.now() - wasmCompileStart;
+
+  const executeStart = performance.now();
+  const result = runner.executeValue(inputValue);
+  const executeMs = performance.now() - executeStart;
+
+  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, preambleLineCount(preamble));
+    throw remapError(error, lineOffset);
   }
-  const mainRel = annotated.rels.__main__;
-  run.defs = annotated;
-  let result;
+  const snippetCompileMs = performance.now() - compileStart;
+
+  let execRes;
   try {
-    result = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+    execRes = await executeExpressionWithWasm(annotated, state, lineOffset);
   } catch (error) {
-    throw remapError(error, preambleLineCount(preamble));
+    throw remapError(error, lineOffset);
   }
+  state.codes = codes.dump();
   restoreCodes(state);
-  return commitResult(state, result, expression);
+
+  const compileMs = snippetCompileMs + execRes.wasmCompileMs;
+  const executeMs = execRes.executeMs;
+  state.lastTiming = {
+    compileMs,
+    executeMs,
+    totalMs: compileMs + executeMs,
+    snippetCompileMs,
+    wasmCompileMs: execRes.wasmCompileMs
+  };
+
+  const committed = commitResult(state, execRes.result, expression);
+  if (state.showTiming) {
+    committed.push(`/* comp: ${formatDuration(compileMs)}, exec: ${formatDuration(executeMs)} */`);
+  }
+  return committed;
 }
 
 async function runSnippet(input, state, options = {}) {
@@ -873,53 +1114,133 @@ async function runSnippet(input, state, options = {}) {
 
   const explicitTerminated = options.explicitTerminated ?? explicitSnippetTerminated(input);
   const analysis = analyzeAcceptedSnippet(snippet, explicitTerminated);
+  const compileStart = performance.now();
   const { annotated, lib, lineOffset } = compileSnippetArtifacts(snippet, state);
+  const snippetCompileMs = performance.now() - compileStart;
   mergeLibrary(state, lib, "<repl>");
 
   if (analysis.kind === "definitionsOnly") {
     restoreCodes(state);
+    state.lastTiming = {
+      compileMs: snippetCompileMs,
+      executeMs: 0,
+      totalMs: snippetCompileMs,
+      snippetCompileMs,
+      wasmCompileMs: 0
+    };
+    if (state.showTiming) {
+      return [`/* comp: ${formatDuration(snippetCompileMs)} */`];
+    }
     return [];
   }
 
-  const mainRel = annotated.rels.__main__;
-  run.defs = annotated;
-  let result;
+  let execRes;
   try {
-    result = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+    execRes = await executeExpressionWithWasm(annotated, state, lineOffset);
   } catch (error) {
     throw remapError(error, lineOffset);
   }
+  state.codes = codes.dump();
   restoreCodes(state);
-  return commitResult(state, result, snippet);
+
+  const compileMs = snippetCompileMs + execRes.wasmCompileMs;
+  const executeMs = execRes.executeMs;
+  state.lastTiming = {
+    compileMs,
+    executeMs,
+    totalMs: compileMs + executeMs,
+    snippetCompileMs,
+    wasmCompileMs: execRes.wasmCompileMs
+  };
+
+  const committed = commitResult(state, execRes.result, snippet);
+  if (state.showTiming) {
+    committed.push(`/* comp: ${formatDuration(compileMs)}, exec: ${formatDuration(executeMs)} */`);
+  }
+  return committed;
 }
 
 async function loadCodec(input, state) {
-  const [subcommand, ...rest] = input.trim().split(/\s+/);
+  const trimmed = input.trim();
+  if (!trimmed || trimmed === "list") {
+    return [listCodecs(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");
+      if (!filePath) throw new Error(":codec load requires a file path or codec name");
+      const autoLoaded = ensureCodecDependencies(state, filePath);
       const registered = await loadCodecModule(state, expandHome(filePath));
-      return registered.map(({ name, codeHash }) => `loaded codec ${name} for ${codeHash}`);
+      return registered.map(({ name, codeHash }) =>
+        `loaded codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}${autoLoaded ? ` (auto-loaded ${autoLoaded})` : ""}`
+      );
+    }
+    case "unload": {
+      const codecName = rest.join(" ").trim();
+      if (!codecName) throw new Error(":codec unload requires a codec name");
+      const removed = unregisterCodec(state, codecName);
+      if (removed === 0) throw new Error(`Codec '${codecName}' is not loaded`);
+      return [`unloaded codec ${codecName}`];
+    }
+    case "define": {
+      const match = rest.join(" ").match(/^([a-zA-Z0-9_+-]+)\s+(\S+)\s+([\s\S]+)$/);
+      if (!match) {
+        throw new Error(":codec define requires: name type { parse: ..., print: ... }");
+      }
+      const [, name, rawType, bodyStr] = match;
+      const fn = new Function("Value", "isProduct", "isVariant", "state", `return (${bodyStr});`);
+      const obj = fn(Value, isProduct, isVariant, state);
+      const codeHash = rawType === "*" ? UNIVERSAL_CODE : resolveInputTypeHash(state, rawType);
+      const codec = normalizeCodecModule({
+        name,
+        codes: [codeHash],
+        universal: codeHash === UNIVERSAL_CODE,
+        parse: obj.parse,
+        print: obj.print
+      }, name);
+      const registered = registerCodec(state, codec, "<inline>");
+      return registered.map(({ name, codeHash }) =>
+        `defined codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}`
+      );
     }
     case "list":
       if (rest.length > 0) throw new Error(":codec list does not accept arguments");
       return [listCodecs(state)];
-    default:
-      throw new Error(":codec requires 'load' or 'list'");
+    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})` : ""}`
+      );
+    }
   }
 }
 
 async function requestCodecInput(input, state) {
-  const parts = input.trim().split(/\s+/).filter(Boolean);
-  if (parts.length === 0 || parts.length > 2) {
-    throw new Error(":input requires a singleton type and optional codec name");
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error(":input requires a type and optional codec name");
   }
 
-  const codeHash = resolveTypeHash(state, parts[0]);
-  const codecName = parts[1] || null;
-  resolveCodec(state, codeHash, codecName, "parse");
-  state.pendingInput = { codeHash, codecName };
+  let codeHash;
+  let codecName = null;
+  try {
+    codeHash = resolveInputTypeHash(state, trimmed);
+  } catch (wholeError) {
+    const split = trimmed.match(/^(.*\S)\s+([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)$/);
+    if (!split) throw wholeError;
+    try {
+      codeHash = resolveInputTypeHash(state, split[1]);
+      codecName = split[2];
+    } catch (typeError) {
+      throw typeError;
+    }
+  }
+
+  const codec = resolveCodec(state, codeHash, codecName, "parse");
+  state.pendingInput = { codeHash, codecName, promptName: codec.name };
   return [`input ${codeHash}${codecName ? ` using ${codecName}` : ""}: enter value text`];
 }
 
@@ -942,6 +1263,7 @@ async function consumeCodecInput(input, state) {
 }
 
 async function evaluateInput(input, state) {
+  state.lastTiming = null;
   if (state.pendingInput) {
     return consumeCodecInput(input, state);
   }
@@ -972,6 +1294,29 @@ async function evaluateCommand(line, state) {
       exit(0);
     case "help":
       return [helpText()];
+    case "timing": {
+      const trimmed = arg.trim().toLowerCase();
+      if (trimmed === "on" || trimmed === "true" || trimmed === "1") {
+        state.showTiming = true;
+      } else if (trimmed === "off" || trimmed === "false" || trimmed === "0") {
+        state.showTiming = false;
+      } else if (!trimmed) {
+        state.showTiming = !state.showTiming;
+      } else {
+        throw new Error(":timing accepts 'on', 'off', or no arguments to toggle");
+      }
+      return [`timing reporting ${state.showTiming ? "enabled" : "disabled"}`];
+    }
+    case "time": {
+      if (!arg) throw new Error(":time requires an expression");
+      const wasTiming = state.showTiming;
+      state.showTiming = true;
+      try {
+        return await evaluateInput(arg, state);
+      } finally {
+        state.showTiming = wasTiming;
+      }
+    }
     case "type": {
       if (!arg) throw new Error(":type requires a name or definition");
       if (arg.includes("=")) {
@@ -999,6 +1344,7 @@ async function evaluateCommand(line, state) {
         JSON.stringify(state.value, null, 2)
       ];
     case "codec":
+    case "codecs":
       return loadCodec(arg, state);
     case "input":
       return requestCodecInput(arg, state);
@@ -1025,26 +1371,7 @@ async function evaluateCommand(line, state) {
     }
     case "load": {
       const { path: loadPath, loadAliases } = parseLoadArgs(arg, usagePrefix);
-      if (loadPath.endsWith(".klib")) {
-        const lib = loadLibrary(decodeLibrary(fs.readFileSync(loadPath)));
-        mergeLibrary(state, lib, loadPath, { loadAliases });
-      } else {
-        restoreCodes(state);
-        const source = fs.readFileSync(loadPath, "utf8");
-        const preamble = aliasPreamble(state);
-        const fullSource = [preamble, source].filter(Boolean).join("\n");
-        const options = {
-          source: loadPath,
-          libraries: [stateLibrary(state)]
-        };
-        try {
-          const lib = compileWithOptionalIdentity(fullSource, options);
-          const { relAlias, meta } = libraryOriginsFromSource(source, fullSource, lib, options);
-          mergeLibrary(state, { ...lib, relAlias, meta }, loadPath, { loadAliases });
-        } catch (error) {
-          throw remapError(error, preambleLineCount(preamble));
-        }
-      }
+      loadSourceOrKlib(state, loadPath, { loadAliases });
       return [`loaded ${loadPath}`];
     }
     case "t": {
@@ -1075,13 +1402,17 @@ function helpText() {
     ":type name = <...>   define a type",
     ":rel name = expr     define a relation",
     ":run expr            run an expression on the current value",
+    ":time expr           run an expression and report compilation/execution time",
+    ":timing [on|off]     toggle timing reporting after every evaluation",
     ":t name              show relation type",
     ":d name              show relation definition",
     ":type name           show type definition",
     ":codes               list type aliases",
     ":rels                list relation aliases",
-    ":codec load file     load a REPL codec module",
-    ":codec list          list loaded codecs",
+    ":codec load file     load a REPL codec module (or built-in: int, utf8, json, ieee)",
+    ":codec define n t b  define a custom codec: name type { parse: ..., print: ... }",
+    ":codec unload name   unload a registered codec",
+    ":codec list          list loaded codecs (or simply :codecs)",
     ":input type [codec]  read next line as codec input",
     ":load [--no-alias] file",
     "                     load .k source or .klib",
@@ -1097,6 +1428,11 @@ function helpText() {
   ].join("\n");
 }
 
+function promptForState(state) {
+  const promptName = state.pendingInput?.promptName;
+  return promptName ? `${promptName}> ` : "> ";
+}
+
 function cliUsage() {
   console.log("Usage: k-repl");
   console.log("       k-repl -h");
@@ -1151,6 +1487,7 @@ function startRepl() {
       } catch (error) {
         console.error(error.message || String(error));
       }
+      rl.setPrompt(promptForState(state));
       if (!closed) rl.prompt();
       return;
     }
@@ -1222,7 +1559,19 @@ export {
   isMainEntrypoint,
   lineHasExplicitContinuation,
   lineTerminatesSnippet,
+  listCodecs,
+  loadCodecModule,
+  registerCodec,
+  unregisterCodec,
+  resolveCodec,
+  codeHashToPattern,
+  BUILTIN_CODECS,
   printValue,
+  promptForState,
   propertyListToFilter,
-  valueToK
+  savedLibrary,
+  loadSourceOrKlib,
+  ensureCodecDependencies,
+  valueToK,
+  formatDuration
 };

package/run.mjs

@@ -2,14 +2,9 @@ import assert from "assert";
 import { Value, edgeSubpattern, composePattern, withPattern, isProduct, isVariant } from "./Value.mjs"
 import { exportPatternGraph, intersectPropertyListPatterns } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
+import { jsIntrinsicFunctions } from "./intrinsics.mjs";
 
-const builtin = {
-  "_log!": (arg) => {
-    console.error(`_log!: ${arg}`);
-
-    return arg;
-  }
-};
+const builtin = jsIntrinsicFunctions;
 
 const codes = { };
 const staticPatternCache = new WeakMap();