@fraczak/k 6.0.2 → 6.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.0.2",
+    "version": "6.0.4",
     "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": {
@@ -18,6 +18,7 @@
         "k": "./k.mjs",
         "k-compile-object": "./objects/compile.mjs",
         "k-decompile-object": "./objects/decompile.mjs",
+        "k-extract-aliases": "./objects/extract-aliases.mjs",
         "k-parse": "./codecs/k-parse.mjs",
         "k-pattern": "./patterns/from-k.mjs",
         "k-print": "./codecs/k-print.mjs",

package/repl2.mjs

@@ -19,7 +19,8 @@ import {
   encodeObject,
   encodeLibrary,
   hydrateObject,
-  loadLibrary
+  loadLibrary,
+  prettyRelation
 } from "./object.mjs";
 import { propertyListToFilter, valueToK, valueWithEnvelopeToK } from "./codecs/runtime/show-value.mjs";
 
@@ -58,7 +59,6 @@ function createState() {
 function stateLibrary(state) {
   return {
     format: "k-object",
-    version: 2,
     codes: state.codes,
     rels: state.rels,
     relAlias: state.relAliases,
@@ -146,21 +146,23 @@ function annotateWithOptionalIdentity(source, options) {
 function mergeMeta(state, meta = {}) {
   for (const [hash, entry] of Object.entries(meta)) {
     const origins = entry?.origins || [];
-    if (!state.meta[hash]) state.meta[hash] = { origins: [] };
-    state.meta[hash].origins.push(...origins);
+    const entryType = entry?.type;
+    if (!state.meta[hash]) state.meta[hash] = { type: entryType, origins: [] };
+    if (state.meta[hash].type == null && entryType != null) state.meta[hash].type = entryType;
+    state.meta[hash].origins.push(...origins.map((origin) => ({ ...origin })));
   }
 }
 
-function rememberOrigin(state, hash, name, kind, source = "<repl>") {
-  if (!state.meta[hash]) state.meta[hash] = { origins: [] };
+function rememberOrigin(state, hash, name, type, source = "<repl>") {
+  if (!state.meta[hash]) state.meta[hash] = { type, origins: [] };
+  if (state.meta[hash].type == null) state.meta[hash].type = type;
   const exists = state.meta[hash].origins.some((origin) =>
-    origin.name === name && origin.kind === kind && origin.source === source
+    origin.name === name && state.meta[hash].type === type && origin.source === source
   );
   if (!exists) {
     state.meta[hash].origins.push({
       source,
       name,
-      kind,
       compiledAt: new Date().toISOString()
     });
   }
@@ -170,44 +172,50 @@ function recoverAliasesFromMeta(state, lib) {
   for (const [hash, entry] of Object.entries(lib.meta || {})) {
     for (const origin of entry?.origins || []) {
       if (!origin?.name || !NAME_RE.test(origin.name)) continue;
-      if (origin.kind === "code" || (!origin.kind && hash in state.codes && !(hash in state.rels))) {
+      const type = entry?.type;
+      if (type === "code" || (!type && hash in state.codes && !(hash in state.rels))) {
         state.typeAliases[origin.name] = hash;
-      } else if (origin.kind === "rel" || hash in state.rels) {
+      } else if (type === "rel" || hash in state.rels) {
         state.relAliases[origin.name] = hash;
       }
     }
   }
 }
 
-function mergeLibrary(state, lib, source = "<load>") {
+function mergeLibrary(state, lib, source = "<load>", options = {}) {
+  const loadAliases = options.loadAliases ?? true;
   state.codes = { ...state.codes, ...(lib.codes || {}) };
   state.rels = { ...state.rels, ...(lib.rels || {}) };
-  state.relAliases = { ...state.relAliases, ...(lib.relAlias || {}) };
   mergeMeta(state, lib.meta);
 
-  for (const [name, hash] of Object.entries(lib.relAlias || {})) {
-    if (name !== "__main__" && NAME_RE.test(name) && hash in state.rels) {
-      state.relAliases[name] = hash;
-      rememberOrigin(state, hash, name, "rel", source);
+  if (loadAliases) {
+    state.relAliases = { ...state.relAliases, ...(lib.relAlias || {}) };
+    for (const [name, hash] of Object.entries(lib.relAlias || {})) {
+      if (name !== "__main__" && NAME_RE.test(name) && hash in state.rels) {
+        state.relAliases[name] = hash;
+        rememberOrigin(state, hash, name, "rel", source);
+      }
     }
+    recoverAliasesFromMeta(state, lib);
   }
-  recoverAliasesFromMeta(state, lib);
   restoreCodes(state);
 }
 
 function savedLibrary(state) {
   const meta = cloneJSON(state.meta);
+  const now = new Date().toISOString();
   for (const [name, hash] of Object.entries(state.typeAliases)) {
-    if (!meta[hash]) meta[hash] = { origins: [] };
-    meta[hash].origins.push({ source: "<repl>", name, kind: "code" });
+    if (!meta[hash]) meta[hash] = { type: "code", origins: [] };
+    if (meta[hash].type == null) meta[hash].type = "code";
+    meta[hash].origins.push({ source: "<repl>", name, compiledAt: now });
   }
   for (const [name, hash] of Object.entries(state.relAliases)) {
-    if (!meta[hash]) meta[hash] = { origins: [] };
-    meta[hash].origins.push({ source: "<repl>", name, kind: "rel" });
+    if (!meta[hash]) meta[hash] = { type: "rel", origins: [] };
+    if (meta[hash].type == null) meta[hash].type = "rel";
+    meta[hash].origins.push({ source: "<repl>", name, compiledAt: now });
   }
   return {
     format: "k-object",
-    version: 2,
     codes: state.codes,
     rels: state.rels,
     relAlias: state.relAliases,
@@ -276,6 +284,16 @@ function userDefinedNames(source) {
   };
 }
 
+function originFromSourceNode(source, name, compiledAt, node) {
+  return {
+    source,
+    name,
+    compiledAt,
+    ...(node?.start ? { start: node.start } : {}),
+    ...(node?.end ? { end: node.end } : {})
+  };
+}
+
 function libraryOriginsFromSource(source, fullSource, lib, options) {
   const { typeNames, relNames } = userDefinedNames(source);
   const annotated = annotateWithOptionalIdentity(fullSource, options);
@@ -285,8 +303,13 @@ function libraryOriginsFromSource(source, fullSource, lib, options) {
   for (const name of typeNames) {
     const hash = annotated.representatives?.[name];
     if (!hash) continue;
-    if (!meta[hash]) meta[hash] = { origins: [] };
-    meta[hash].origins.push({ source: options.source || null, name, kind: "code", compiledAt: now });
+    if (!meta[hash]) meta[hash] = { type: "code", origins: [] };
+    meta[hash].origins.push(originFromSourceNode(
+      options.source || null,
+      name,
+      now,
+      annotated.sourceDefs?.codes?.[name]
+    ));
   }
 
   const relAlias = Object.fromEntries(
@@ -296,8 +319,13 @@ function libraryOriginsFromSource(source, fullSource, lib, options) {
   );
 
   for (const [name, hash] of Object.entries(relAlias)) {
-    if (!meta[hash]) meta[hash] = { origins: [] };
-    meta[hash].origins.push({ source: options.source || null, name, kind: "rel", compiledAt: now });
+    if (!meta[hash]) meta[hash] = { type: "rel", origins: [] };
+    meta[hash].origins.push(originFromSourceNode(
+      options.source || null,
+      name,
+      now,
+      annotated.rels?.[name]?.def
+    ));
   }
 
   return { relAlias, meta };
@@ -401,6 +429,26 @@ function commandArgIndex(arg) {
   return trimmed.split(/\s+/).length - 1;
 }
 
+function loadPathCompletionStart(argStart, arg) {
+  const leadingWhitespace = arg.length - arg.trimStart().length;
+  const trimmed = arg.trimStart();
+  if (trimmed === "" || !trimmed.startsWith("--no-alias")) {
+    if (commandArgIndex(arg) !== 0) return null;
+    return argStart + completionTokenStart(arg);
+  }
+  if (!"--no-alias".startsWith(trimmed) && !trimmed.startsWith("--no-alias ")) {
+    return null;
+  }
+  if (trimmed !== "--no-alias" && !trimmed.startsWith("--no-alias ")) {
+    return null;
+  }
+  if (trimmed === "--no-alias") return null;
+  const restStart = leadingWhitespace + "--no-alias".length;
+  const rest = arg.slice(restStart);
+  const restLeadingWhitespace = rest.length - rest.trimStart().length;
+  return argStart + restStart + restLeadingWhitespace + completionTokenStart(rest.trimStart());
+}
+
 function completeCommandArgument(line, state) {
   const body = line.slice(1);
   const firstSpace = body.search(/\s/);
@@ -410,8 +458,13 @@ function completeCommandArgument(line, state) {
   const argStart = 1 + firstSpace + 1;
   const arg = line.slice(argStart);
 
-  if (PATH_COMMANDS.has(command) && commandArgIndex(arg) === 0) {
-    const tokenStart = argStart + completionTokenStart(arg);
+  if (PATH_COMMANDS.has(command)) {
+    const tokenStart = command === "load"
+      ? loadPathCompletionStart(argStart, arg)
+      : commandArgIndex(arg) === 0
+        ? argStart + completionTokenStart(arg)
+        : null;
+    if (tokenStart == null) return [[], line];
     return completePath(line, tokenStart);
   }
 
@@ -460,6 +513,20 @@ function isEofParseError(error) {
   return /got 'EOF'|Unexpected end of input/.test(error.message || "");
 }
 
+function parseLoadArgs(arg, usagePrefix = ":") {
+  const trimmed = arg.trim();
+  if (!trimmed) throw new Error(`${usagePrefix}load requires a file path`);
+  if (trimmed === "--no-alias") {
+    throw new Error(`${usagePrefix}load --no-alias requires a file path`);
+  }
+  if (trimmed.startsWith("--no-alias ")) {
+    const path = trimmed.slice("--no-alias".length).trim();
+    if (!path) throw new Error(`${usagePrefix}load --no-alias requires a file path`);
+    return { path, loadAliases: false };
+  }
+  return { path: arg.trim(), loadAliases: true };
+}
+
 function lineForContinuation(line) {
   return line.replace(/\\\s*$/, "");
 }
@@ -703,28 +770,28 @@ async function evaluateCommand(line, state) {
       return [`saved ${path} (${main})`];
     }
     case "load": {
-      if (!arg) throw new Error(`${usagePrefix}load requires a file path`);
-      if (arg.endsWith(".klib")) {
-        const lib = loadLibrary(decodeLibrary(fs.readFileSync(arg)));
-        mergeLibrary(state, lib, arg);
+      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(arg, "utf8");
+        const source = fs.readFileSync(loadPath, "utf8");
         const preamble = aliasPreamble(state);
         const fullSource = [preamble, source].filter(Boolean).join("\n");
         const options = {
-          source: arg,
+          source: loadPath,
           libraries: [stateLibrary(state)]
         };
         try {
           const lib = compileWithOptionalIdentity(fullSource, options);
           const { relAlias, meta } = libraryOriginsFromSource(source, fullSource, lib, options);
-          mergeLibrary(state, { ...lib, relAlias, meta }, arg);
+          mergeLibrary(state, { ...lib, relAlias, meta }, loadPath, { loadAliases });
         } catch (error) {
           throw remapError(error, preambleLineCount(preamble));
         }
       }
-      return [`loaded ${arg}`];
+      return [`loaded ${loadPath}`];
     }
     case "t": {
       if (!arg) throw new Error(`${usagePrefix}t requires a relation name`);
@@ -736,7 +803,7 @@ async function evaluateCommand(line, state) {
       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} = ${prettyRel(rel.def)};  -- ${hash}`];
+      return [`${arg} = ${prettyRelation(rel)};  -- ${hash}`];
     }
     case "C": {
       if (!arg) throw new Error(`${usagePrefix}C requires a type name`);
@@ -759,7 +826,8 @@ function helpText() {
     ":type name           show type definition",
     ":codes               list type aliases",
     ":rels                list relation aliases",
-    ":load file           load .k source or .klib",
+    ":load [--no-alias] file",
+    "                     load .k source or .klib",
     ":klib file           export state as a library",
     ":ko file expr        export executable .ko using expr as main",
     ":val                 print current value",

package/run.mjs

@@ -166,7 +166,7 @@ function compiledExp(findCode, exp, typePatternGraph) {
       {
         const defn = run.defs.rels[exp.ref];
         if (defn != undefined) {
-          const refFn = compiledExp(findCode, defn.def, defn.typePatternGraph);
+          const refFn = compiledRel(findCode, defn, exp.ref);
           fn = (value) => {
             return value === undefined ? undefined : refFn(value);
           };
@@ -266,6 +266,161 @@ function compiledExp(findCode, exp, typePatternGraph) {
   return compiled.fn;
 }
 
+function compiledRel(findCode, relDef, name = "<anonymous>") {
+  const cached = relDef._compiledRunRel;
+  if (cached?.findCode === findCode && cached?.defs === run.defs) {
+    return cached.fn;
+  }
+
+  const compiled = {
+    findCode,
+    defs: run.defs,
+    target: null,
+    fn(value) {
+      return compiled.target(value);
+    }
+  };
+  relDef._compiledRunRel = compiled;
+
+  const exp = relDef.def;
+  const typePatternGraph = relDef.typePatternGraph || null;
+  const inputPattern = staticPattern(typePatternGraph, exp, 0);
+  const staticOutputPattern = outputPattern(typePatternGraph, exp);
+  const bodyFn = compiledExp(findCode, exp, typePatternGraph);
+
+  compiled.target = (value) => {
+    if (value === undefined) return undefined;
+    value = constrainWithPattern(value, inputPattern, exp);
+    const result = bodyFn(value);
+    if (result === undefined) return undefined;
+    try {
+      return constrainWithPattern(result, staticOutputPattern, exp);
+    } catch (error) {
+      error.message = `Type Error in output of '${name}'\n - ${error.message}`;
+      throw error;
+    }
+  };
+  return compiled.fn;
+}
+
+function assertConvergedRel(rel, name) {
+  const status = rel?.typeDerivation?.status || "unknown";
+  if (status !== "converged") {
+    throw new Error(`Cannot run '${name}' without envelopes: type derivation is ${status}`);
+  }
+}
+
+function compiledConvergedExp(findCode, exp, typePatternGraph, options = {}) {
+  const requireConverged = options.requireConverged === true;
+  const cached = exp._compiledConvergedRun;
+  if (
+    cached?.findCode === findCode &&
+    cached?.typePatternGraph === typePatternGraph &&
+    cached?.defs === run_converged.defs &&
+    cached?.requireConverged === requireConverged
+  ) {
+    return cached.fn;
+  }
+
+  const compiled = {
+    findCode,
+    typePatternGraph,
+    defs: run_converged.defs,
+    requireConverged,
+    target: null,
+    fn(value) {
+      return compiled.target(value);
+    }
+  };
+  exp._compiledConvergedRun = compiled;
+
+  let fn;
+  switch (exp.op) {
+    case "code":
+    case "filter":
+    case "identity":
+      fn = (value) => value;
+      break;
+    case "ref":
+      {
+        const defn = run_converged.defs?.rels?.[exp.ref];
+        if (defn != undefined) {
+          if (requireConverged) assertConvergedRel(defn, exp.ref);
+          const refFn = compiledConvergedExp(findCode, defn.def, defn.typePatternGraph, options);
+          fn = (value) => value === undefined ? undefined : refFn(value);
+        } else {
+          const builtin_func = builtin[exp.ref];
+          if (builtin_func != null) {
+            fn = (value) => value === undefined ? undefined : builtin_func(value);
+          } else {
+            fn = () => {
+              throw(`Unknown ref: '${exp.ref}'`);
+            };
+          }
+        }
+      }
+      break;
+    case "dot":
+      fn = (value) => {
+        if (value === undefined || !(value instanceof Product)) return undefined;
+        return Object.hasOwn(value.product, exp.dot) ? value.product[exp.dot] : undefined;
+      };
+      break;
+    case "div":
+      fn = (value) => {
+        if (value === undefined || !(value instanceof Variant) || value.tag !== exp.div) return undefined;
+        return value.value;
+      };
+      break;
+    case "comp": {
+      const parts = exp.comp.map((part) => compiledConvergedExp(findCode, part, typePatternGraph, options));
+      fn = (value) => {
+        for (let i = 0, len = parts.length; i < len; i++) {
+          value = parts[i](value);
+          if (value === undefined) return undefined;
+        }
+        return value;
+      };
+      break;
+    }
+    case "union": {
+      const parts = exp.union.map((part) => compiledConvergedExp(findCode, part, typePatternGraph, options));
+      fn = (value) => {
+        if (value === undefined) return undefined;
+        for (let i = 0, len = parts.length; i < len; i++) {
+          const result = parts[i](value);
+          if (result !== undefined) return result;
+        }
+        return undefined;
+      };
+      break;
+    }
+    case "product": {
+      const labels = exp.product.map(({ label }) => label);
+      const fieldFns = exp.product.map(({ exp: e }) => compiledConvergedExp(findCode, e, typePatternGraph, options));
+      fn = (value) => {
+        if (value === undefined) return undefined;
+        const result = {};
+        for (let i = 0, len = labels.length; i < len; i++) {
+          const r = fieldFns[i](value);
+          if (r === undefined) return undefined;
+          result[labels[i]] = r;
+        }
+        return new Product(result);
+      };
+      break;
+    }
+    case "vid":
+      fn = (value) => value === undefined ? undefined : new Variant(exp.vid, value);
+      break;
+    default:
+      assert(false,`Unknown operation: '${exp.op}'`);
+  }
+
+  compiled.target = fn;
+  return compiled.fn;
+}
+
 function verify(findCode, code, value) {
   "use strict";
   if (code == null) return false;
@@ -296,7 +451,22 @@ function run(findCode, exp, value, typePatternGraph) {
   return compiledExp(findCode, exp, typePatternGraph || null)(value);
 }
 
+function run_rel(findCode, relDef, value, name) {
+  return compiledRel(findCode, relDef, name)(value);
+}
+
+function run_converged(findCode, exp, value, typePatternGraph, options = {}) {
+  const graph = typePatternGraph || null;
+  const result = compiledConvergedExp(findCode, exp, graph, options)(value);
+  if (result === undefined) return undefined;
+  return withPattern(result, outputPattern(graph, exp));
+}
+
 run.builtin = builtin;
+run_converged.builtin = builtin;
+run_converged.defs = null;
+
+const run_coverged = run_converged;
 
 export default run;
-export { run  };
+export { run, run_rel, run_converged, run_coverged };

package/test-k-object.mjs

@@ -6,7 +6,15 @@ import { decodeWire, encodeToWire, CORE_PATTERN_PROPERTY_LIST } from "./codecs/r
 import { Product, Variant } from "./Value.mjs";
 import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
-import { compileObjectBuffer, decodeObject, objectToFunction, decompileObjectBuffer } from "./object.mjs";
+import {
+  compileObjectBuffer,
+  compileLibraryBuffer,
+  decodeObject,
+  objectToFunction,
+  runConvergedObject,
+  decompileObjectBuffer,
+  extractAliasesFromObject
+} from "./object.mjs";
 
 const value = parseValue("{a:{b:x,c:{}}}");
 const wire = encodeToWire(value, null);
@@ -47,10 +55,30 @@ const objectBuffer = compileObjectBuffer(`
   $ int = < bits +, bits - >;
   {}|_|0|1|+ $int
 `);
-const objectFn = objectToFunction(decodeObject(objectBuffer));
+assert.equal(objectBuffer.subarray(0, 5).toString("utf8"), "KOBJ\n");
+const object = decodeObject(objectBuffer);
+assert.equal("version" in object, false);
+assert(Object.values(object.codes).every((code) => code.typeDerivation == null));
+assert.equal(JSON.stringify(object.codes).includes('"start"'), false);
+assert.equal(JSON.stringify(object.codes).includes('"end"'), false);
+assert.equal(JSON.stringify(object.meta).includes('"spans"'), false);
+assert(Object.values(object.rels).every((rel) =>
+  JSON.stringify(Object.keys(rel.typeDerivation || {}).sort()) === JSON.stringify(["status"]) &&
+  rel.typeDerivation.status === "converged"
+));
+assert.notEqual(object.rels.__main__.def.comp?.[0]?.op, "filter");
+assert.equal(JSON.stringify(object.rels.__main__.def).includes('"start"'), false);
+assert(object.meta[object.relAlias.__main__]?.origins?.some((origin) =>
+  origin.name === "__main__" && origin.start && origin.end
+));
+
+const objectFn = objectToFunction(object);
 const objectResult = objectFn(new Product({}));
 assert.deepEqual(objectResult.pattern, INT_PATTERN);
 assert.deepEqual(objectResult.toJSON(), { "+": { "1": { "0": "_" } } });
+const convergedObjectResult = runConvergedObject(object, new Product({}));
+assert.deepEqual(convergedObjectResult.pattern, INT_PATTERN);
+assert.deepEqual(convergedObjectResult.toJSON(), objectResult.toJSON());
 
 const decompiledSource = decompileObjectBuffer(objectBuffer);
 const decompiledResult = k.compile(decompiledSource)(new Product({}));
@@ -71,4 +99,103 @@ const sccSource = decompileObjectBuffer(compileObjectBuffer("c = {}; b = c |x; a
 assert.match(sccSource, /----- rels -----\nPQgV = .+\n\naQAD = .+\n\nN9UH = /s);
 assert.deepEqual(k.compile(sccSource)(new Product({})).toJSON(), { y: "x" });
 
+const libraryBuffer = compileLibraryBuffer("$ nat = <{} zero, nat succ>;\nsucc = |succ;\n", { source: "defs-only.k" });
+assert.equal(libraryBuffer.subarray(0, 1).toString("utf8"), "{");
+const library = decodeObject(libraryBuffer);
+assert.equal("version" in library, false);
+assert.equal(library.main, null);
+assert(Object.values(library.codes).every((code) => code.typeDerivation == null));
+assert.equal(JSON.stringify(library.codes).includes('"start"'), false);
+assert.equal(JSON.stringify(library.codes).includes('"end"'), false);
+assert.equal(JSON.stringify(library.meta).includes('"spans"'), false);
+assert(Object.values(library.rels).every((rel) =>
+  JSON.stringify(Object.keys(rel.typeDerivation || {}).sort()) === JSON.stringify(["status"]) &&
+  rel.typeDerivation.status === "converged"
+));
+assert(Object.values(library.rels).every((rel) => rel.def.op !== "comp" || rel.def.comp[0]?.op !== "filter"));
+assert(Object.values(library.meta).some(({ type, origins }) =>
+  type === "code" &&
+  origins.some((origin) =>
+    origin.source === "defs-only.k" &&
+    origin.name === "nat" &&
+    typeof origin.compiledAt === "string" &&
+    origin.start &&
+    origin.end
+  )
+));
+assert(Object.values(library.meta).some(({ type, origins }) =>
+  type === "rel" &&
+  origins.some((origin) =>
+    origin.source === "defs-only.k" &&
+    origin.name === "succ" &&
+    typeof origin.compiledAt === "string" &&
+    origin.start &&
+    origin.end
+  )
+));
+
+const derivedLibrary = decodeObject(compileLibraryBuffer("other = |other;\n", {
+  source: "derived.k",
+  libraries: [library]
+}));
+const derivedAliases = extractAliasesFromObject(derivedLibrary);
+assert.match(derivedAliases, /^\$ nat = @/m);
+assert.match(derivedAliases, /^succ = @/m);
+assert.match(derivedAliases, /^other = @/m);
+assert(derivedAliases.indexOf("$ nat = @") < derivedAliases.indexOf("other = @"));
+assert(derivedAliases.indexOf("other = @") < derivedAliases.indexOf("succ = @"));
+
+{
+  const warn = console.warn;
+  console.warn = () => {};
+  try {
+    const nonConverged = decodeObject(compileObjectBuffer("f = .x f; f", {
+      convergence: { strategy: "fixed_point", maxIterations: 1 }
+    }));
+    assert.equal(nonConverged.rels.__main__.typeDerivation.status, "not-converged");
+    assert.throws(
+      () => runConvergedObject(nonConverged, new Product({ x: new Product({}) })),
+      /type derivation is not-converged/
+    );
+  } finally {
+    console.warn = warn;
+  }
+}
+
+const aliasSnippet = extractAliasesFromObject({
+  format: "k-object",
+  codes: {},
+  rels: {},
+  meta: {
+    "@relB": {
+      type: "rel",
+      origins: [
+        { source: "new.k", name: "times", compiledAt: "2026-04-12T06:08:10.390Z" },
+        { source: "core.k", name: "times", compiledAt: "2026-03-09T06:17:23.390Z" },
+        { source: "other.k", name: "plus", compiledAt: "2026-05-17T06:10:23.390Z" }
+      ]
+    },
+    "@codeB": {
+      type: "code",
+      origins: [
+        { source: "z.k", name: "edges", compiledAt: "2026-03-09T06:17:23.390Z" }
+      ]
+    },
+    "@codeA": {
+      type: "code",
+      origins: [
+        { source: "a.k", name: "bits", compiledAt: "2026-05-17T06:10:23.390Z" }
+      ]
+    }
+  },
+  main: null
+});
+assert.deepEqual(aliasSnippet.split("\n").filter(Boolean), [
+  '$ bits = @codeA; # {"source":"a.k","compiledAt":"2026-05-17T06:10:23.390Z"}',
+  '$ edges = @codeB; # {"source":"z.k","compiledAt":"2026-03-09T06:17:23.390Z"}',
+  'plus = @relB; # {"source":"other.k","compiledAt":"2026-05-17T06:10:23.390Z"}',
+  '# times = @relB; # {"source":"core.k","compiledAt":"2026-03-09T06:17:23.390Z"}',
+  'times = @relB; # {"source":"new.k","compiledAt":"2026-04-12T06:08:10.390Z"}'
+]);
+
 console.log("OK");

package/test-repl2.mjs

@@ -88,6 +88,8 @@ assert.equal(output[0], `saved ${libPath}`);
 
 completions = completeInput(`:load ${tmpDir}/ses`, state)[0];
 assert(completions.includes(`:load ${libPath}`));
+completions = completeInput(`:load --no-alias ${tmpDir}/ses`, state)[0];
+assert(completions.includes(`:load --no-alias ${libPath}`));
 
 output = await evaluateInput(`:ko ${koPath} succ`, state);
 assert.equal(output[0], `saved ${koPath} (succ)`);
@@ -125,6 +127,14 @@ assert.match(output[0], /^succ = @/m);
 output = await evaluateInput("succ", reloaded);
 assert.equal(output[0], "{}|succ ?<{} succ, ...>");
 
+const noAliasReloaded = createState();
+output = await evaluateInput(`:load --no-alias ${libPath}`, noAliasReloaded);
+assert.equal(output[0], `loaded ${libPath}`);
+output = await evaluateInput(":codes", noAliasReloaded);
+assert.equal(output[0], "(none)");
+output = await evaluateInput(":rels", noAliasReloaded);
+assert.equal(output[0], "(none)");
+
 const shorthand = createState();
 output = await evaluateInput("$ nat = <{} zero, nat succ>\n; succ = |succ\n;", shorthand);
 assert.deepEqual(output, []);