@fraczak/k 6.1.0 → 6.1.2

package/codecs/utf8.mjs

@@ -1,7 +1,25 @@
 #!/usr/bin/env node
 
 import { stdin, stdout, argv, exit } from "node:process";
-import { encodeText, decodeText } from "./string-codec.mjs";
+import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
+import {
+  STRING_PATTERN_PROPERTY_LIST,
+  encodeText,
+  decodeText,
+  textToStringValue,
+  stringValueToText
+} from "./string-codec.mjs";
+
+const name = "utf8";
+const patterns = [STRING_PATTERN_PROPERTY_LIST];
+
+function parse(text) {
+  return textToStringValue(text);
+}
+
+function print(value) {
+  return stringValueToText(value);
+}
 
 function usage(stream = console.error) {
   stream(`Usage: ${argv[1]} --parse | --print`);
@@ -41,7 +59,11 @@ async function main() {
   }
 }
 
-main().catch(err => {
-  console.error(err.message || String(err));
-  exit(1);
-});
+if (isMainEntrypoint(import.meta.url, argv[1])) {
+  main().catch(err => {
+    console.error(err.message || String(err));
+    exit(1);
+  });
+}
+
+export { name, patterns, parse, print };

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@fraczak/k",
-    "version": "6.1.0",
+    "version": "6.1.2",
     "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": {
         "prepare": "jiwson -m es6 parser.jison -o parser.mjs; jiwson -m es6 valueParser.jison -o valueParser.mjs; ",
-        "test": "node test.mjs; for f in Code-derivation-tests/*.mjs; do echo $f; node $f; done; node test-fingerprint.mjs; node test-hash-fuzz.mjs; node test-hash-normalization.mjs; node test-k-object.mjs; node test-repl.mjs; ./tests.sh",
+        "test": "node test.mjs; for f in Code-derivation-tests/*.mjs; do echo $f; node $f; done; node test-fingerprint.mjs; node test-hash-fuzz.mjs; node test-hash-normalization.mjs; node test-k-object.mjs; node test-repl.mjs; node test-ieee-arithmetic.mjs; ./tests.sh",
         "deps:graph": "node scripts/generate-dependency-graph.mjs"
     },
     "repository": {

package/repl-codecs.mjs

@@ -0,0 +1,173 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+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";
+
+function isCanonicalCodeName(name) {
+  return typeof name === "string" && name.startsWith("@");
+}
+
+function singletonPatternToCodeHash(pattern) {
+  if (!Array.isArray(pattern) || pattern.length === 0) {
+    return null;
+  }
+
+  const codeDefs = {};
+  for (let i = 0; i < pattern.length; i++) {
+    const [kind, edges] = pattern[i] || [];
+    if (kind !== "closed-product" && kind !== "closed-union") {
+      return null;
+    }
+    if (!Array.isArray(edges)) {
+      throw new Error(`Invalid singleton pattern node ${i}`);
+    }
+
+    const code = kind === "closed-product" ? "product" : "union";
+    codeDefs[`C${i}`] = {
+      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}`);
+        }
+        return [label, `C${target}`];
+      }))
+    };
+  }
+
+  return finalize(codeDefs).representatives.C0 || null;
+}
+
+function codeHashToPattern(codeHash, findCode) {
+  const code = findCode(codeHash);
+  if (!code || code.code === "undefined") {
+    throw new Error(`Unknown type '${codeHash}'`);
+  }
+  const resolveType = (name) => {
+    const resolved = findCode(name);
+    if (!resolved || resolved.code === "undefined") {
+      throw new Error(`Unknown type '${name}'`);
+    }
+    return resolved;
+  };
+  return patternToPropertyList(deriveClosedPattern(codeHash, code, resolveType));
+}
+
+function valueForCode(value, codeHash, findCode) {
+  const pattern = codeHashToPattern(codeHash, findCode);
+  return decodeWire(encodeToWire(value, pattern)).value;
+}
+
+function normalizeCodecModule(mod, fallbackName) {
+  const codec = mod.replCodec || mod.codec || mod.default || mod;
+  const name = codec.name || mod.name || fallbackName;
+  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`);
+      return codeHash;
+    });
+  if (!name || typeof name !== "string") {
+    throw new Error("Codec module must export a string name");
+  }
+  if (!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") {
+    throw new Error(`Codec '${name}' parse export must be a function`);
+  }
+  if (codec.print != null && typeof codec.print !== "function") {
+    throw new Error(`Codec '${name}' print export must be a function`);
+  }
+  return {
+    name,
+    codes,
+    parse: codec.parse,
+    print: codec.print
+  };
+}
+
+function codecStore(state) {
+  if (!state.codecs) state.codecs = {};
+  return state.codecs;
+}
+
+function registerCodec(state, codec, source = null) {
+  const registered = [];
+  const store = codecStore(state);
+  for (const codeHash of codec.codes) {
+    if (!isCanonicalCodeName(codeHash)) {
+      throw new Error(`Codec '${codec.name}' has non-canonical code '${codeHash}'`);
+    }
+    if (!store[codeHash]) store[codeHash] = [];
+    const entry = {
+      name: codec.name,
+      source,
+      parse: codec.parse,
+      print: codec.print
+    };
+    const existingIndex = store[codeHash].findIndex((existing) =>
+      existing.name === entry.name && existing.source === entry.source
+    );
+    if (existingIndex === -1) {
+      store[codeHash].push(entry);
+    } else {
+      store[codeHash][existingIndex] = entry;
+    }
+    registered.push({ codeHash, ...entry });
+  }
+  return registered;
+}
+
+async function loadCodecModule(state, filePath) {
+  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);
+}
+
+function listCodecs(state) {
+  const entries = Object.entries(codecStore(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");
+}
+
+function codecNames(state, codeHash = null) {
+  const store = codecStore(state);
+  const codecs = codeHash ? (store[codeHash] || []) : 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) =>
+    (codecName == null || codec.name === codecName) &&
+    (capability == null || typeof codec[capability] === "function")
+  );
+  if (matches.length === 0) {
+    const suffix = codecName ? ` named '${codecName}'` : "";
+    throw new Error(`No ${capability || "usable"} codec${suffix} for ${codeHash}`);
+  }
+  if (matches.length > 1 && codecName == null) {
+    throw new Error(`Multiple codecs for ${codeHash}; specify one of: ${matches.map((codec) => codec.name).join(", ")}`);
+  }
+  return matches[0];
+}
+
+export {
+  codecNames,
+  codeHashToPattern,
+  listCodecs,
+  loadCodecModule,
+  registerCodec,
+  resolveCodec,
+  singletonPatternToCodeHash,
+  valueForCode
+};

package/repl.mjs

@@ -23,15 +23,25 @@ import {
   prettyRelation
 } from "./object.mjs";
 import { propertyListToFilter, valueToK, valueWithEnvelopeToK } from "./codecs/runtime/show-value.mjs";
+import {
+  codecNames,
+  codeHashToPattern,
+  listCodecs,
+  loadCodecModule,
+  resolveCodec,
+  singletonPatternToCodeHash,
+  valueForCode
+} from "./repl-codecs.mjs";
 
 const NAME_RE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
 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", "reset", "klib", "ko", "load",
+  "codes", "rels", "val", "codec", "input", "reset", "klib", "ko", "load",
   "quit", "exit"
 ];
+const CODEC_COMMAND_NAMES = ["load", "list"];
 const PATH_COMMANDS = new Set(["klib", "ko", "load"]);
 const initialCodes = codes.dump();
 
@@ -50,6 +60,8 @@ function createState() {
     rels: {},
     relAliases: {},
     typeAliases: {},
+    codecs: {},
+    pendingInput: null,
     meta: {},
     value: emptyValue(),
     lastMain: null
@@ -261,8 +273,35 @@ function listAliases(aliases) {
   return entries.map(([name, hash]) => `${name} = ${hash}`).join("\n");
 }
 
-function printValue(value = null) {
-  return valueWithEnvelopeToK(value);
+function formatCodecOutput(output) {
+  if (Buffer.isBuffer(output)) return output.toString("utf8");
+  return String(output);
+}
+
+function printValue(value, state = null) {
+  const lines = [valueWithEnvelopeToK(value)];
+  if (!state || value === undefined) return lines[0];
+
+  const codeHash = singletonPatternToCodeHash(value.pattern);
+  if (!codeHash) return lines[0];
+
+  for (const codec of state.codecs?.[codeHash] || []) {
+    if (typeof codec.print !== "function") continue;
+    try {
+      lines.push(`${codec.name}: ${formatCodecOutput(codec.print(value, { codeHash, state }))}`);
+    } catch (error) {
+      lines.push(`${codec.name}: <error: ${error.message || String(error)}>`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function commitResult(state, result, lastMain) {
+  if (result !== undefined) {
+    state.value = result;
+    state.lastMain = lastMain;
+  }
+  return [printValue(result, state)];
 }
 
 function userDefinedNames(source) {
@@ -340,6 +379,13 @@ function canonicalNames(state) {
   ])].filter((name) => name.startsWith("@")).sort();
 }
 
+function canonicalCodeNames(state) {
+  return [...new Set([
+    ...Object.keys(state.codes),
+    ...Object.values(state.typeAliases)
+  ])].filter((name) => name.startsWith("@")).sort();
+}
+
 function aliasNames(state) {
   return [...new Set([
     ...Object.keys(state.typeAliases),
@@ -347,6 +393,17 @@ function aliasNames(state) {
   ])].sort();
 }
 
+function displayAliases(state) {
+  const aliases = {};
+  for (const [name, hash] of [
+    ...Object.entries(state.typeAliases),
+    ...Object.entries(state.relAliases)
+  ].sort(([a], [b]) => a.localeCompare(b))) {
+    if (!aliases[hash]) aliases[hash] = name;
+  }
+  return aliases;
+}
+
 function expandHome(input) {
   if (input === "~") return os.homedir();
   if (input.startsWith("~/")) return path.join(os.homedir(), input.slice(2));
@@ -378,6 +435,16 @@ function completeCanonical(line, state) {
   return [matches, line];
 }
 
+function completeCanonicalCode(line, state) {
+  const match = line.match(/^(.*?)(@[A-Za-z0-9_?!+-]*)$/);
+  if (!match) return [[], line];
+  const [, prefix, partial] = match;
+  const matches = canonicalCodeNames(state)
+    .filter((name) => name.startsWith(partial))
+    .map((name) => `${prefix}${name}`);
+  return [matches, line];
+}
+
 function completeIdentifier(line, state) {
   const match = line.match(/^(.*?)(\$?[A-Za-z0-9_+-][A-Za-z0-9_?!+-]*)$/);
   if (!match) return [[], line];
@@ -391,6 +458,19 @@ function completeIdentifier(line, state) {
   return [matches, line];
 }
 
+function completeTypeIdentifier(line, state) {
+  const match = line.match(/^(.*?)(\$?[A-Za-z0-9_+-][A-Za-z0-9_?!+-]*)$/);
+  if (!match) return [[], line];
+  const [, prefix, partial] = match;
+  const isTypeToken = partial.startsWith("$");
+  const barePartial = isTypeToken ? partial.slice(1) : partial;
+  const matches = Object.keys(state.typeAliases)
+    .sort()
+    .filter((name) => name.startsWith(barePartial))
+    .map((name) => `${prefix}${isTypeToken ? "$" : ""}${name}`);
+  return [matches, line];
+}
+
 function completePath(line, tokenStart) {
   const token = line.slice(tokenStart);
   const quote = token[0] === "\"" || token[0] === "'" ? token[0] : "";
@@ -449,6 +529,75 @@ function loadPathCompletionStart(argStart, arg) {
   return argStart + restStart + restLeadingWhitespace + completionTokenStart(rest.trimStart());
 }
 
+function completeCommandWord(line, argStart, arg, words) {
+  const leadingWhitespace = arg.length - arg.trimStart().length;
+  const trimmed = arg.trimStart();
+  if (/\s/.test(trimmed)) return [[], line];
+  const prefix = line.slice(0, argStart + leadingWhitespace);
+  const matches = words
+    .filter((word) => word.startsWith(trimmed))
+    .map((word) => `${prefix}${word}`);
+  return [matches, line];
+}
+
+function codecLoadPathCompletionStart(argStart, arg) {
+  const match = arg.match(/^(\s*)load(?:\s+(.*))?$/);
+  if (!match) return null;
+  if (match[2] == null) return null;
+  const [, leading, rest] = match;
+  const restLeadingWhitespace = rest.length - rest.trimStart().length;
+  return argStart + leading.length + "load".length + 1 + restLeadingWhitespace + completionTokenStart(rest.trimStart());
+}
+
+function completeCodecCommand(line, argStart, arg) {
+  const trimmed = arg.trimStart();
+  if (trimmed === "" || !/\s/.test(trimmed)) {
+    return completeCommandWord(line, argStart, arg, CODEC_COMMAND_NAMES);
+  }
+
+  const tokenStart = codecLoadPathCompletionStart(argStart, arg);
+  if (tokenStart == null) return [[], line];
+  return completePath(line, tokenStart);
+}
+
+function resolveTypeHash(state, rawName) {
+  const token = rawName.trim();
+  const bareName = token.startsWith("$") ? token.slice(1) : token;
+  const hash = state.typeAliases[bareName] || (token.startsWith("@") ? token : null);
+  if (!hash || !(hash in state.codes)) throw new Error(`Unknown type '${rawName}'`);
+  return hash;
+}
+
+function completeInputCommand(line, state, argStart, arg) {
+  const match = arg.match(/^(\s*)(\S+)?(\s+)?(\S*)?$/);
+  if (!match) return [[], line];
+  const [, leading, typeToken = "", afterTypeWhitespace = "", codecPartial = ""] = match;
+
+  if (!typeToken || !afterTypeWhitespace) {
+    if (/@[A-Za-z0-9_?!+-]*$/.test(line)) return completeCanonicalCode(line, state);
+    return completeTypeIdentifier(line, state);
+  }
+
+  if (typeToken) {
+    const prefix = line.slice(0, argStart + leading.length + typeToken.length + afterTypeWhitespace.length);
+    const names = (() => {
+      try {
+        return codecNames(state, resolveTypeHash(state, typeToken));
+      } catch {
+        return codecNames(state);
+      }
+    })();
+    return [
+      names
+        .filter((name) => name.startsWith(codecPartial))
+        .map((name) => `${prefix}${name}`),
+      line
+    ];
+  }
+
+  return [[], line];
+}
+
 function completeCommandArgument(line, state) {
   const body = line.slice(1);
   const firstSpace = body.search(/\s/);
@@ -458,6 +607,14 @@ function completeCommandArgument(line, state) {
   const argStart = 1 + firstSpace + 1;
   const arg = line.slice(argStart);
 
+  if (command === "codec") {
+    return completeCodecCommand(line, argStart, arg);
+  }
+
+  if (command === "input") {
+    return completeInputCommand(line, state, argStart, arg);
+  }
+
   if (PATH_COMMANDS.has(command)) {
     const tokenStart = command === "load"
       ? loadPathCompletionStart(argStart, arg)
@@ -659,14 +816,14 @@ async function runExpression(input, state) {
   }
   const mainRel = annotated.rels.__main__;
   run.defs = annotated;
+  let result;
   try {
-    state.value = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+    result = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
   } catch (error) {
     throw remapError(error, preambleLineCount(preamble));
   }
-  state.lastMain = expression;
   restoreCodes(state);
-  return [printValue(state.value)];
+  return commitResult(state, result, expression);
 }
 
 async function runSnippet(input, state, options = {}) {
@@ -685,17 +842,69 @@ async function runSnippet(input, state, options = {}) {
 
   const mainRel = annotated.rels.__main__;
   run.defs = annotated;
+  let result;
   try {
-    state.value = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+    result = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
   } catch (error) {
     throw remapError(error, lineOffset);
   }
-  state.lastMain = snippet;
   restoreCodes(state);
-  return [printValue(state.value)];
+  return commitResult(state, result, snippet);
+}
+
+async function loadCodec(input, state) {
+  const [subcommand, ...rest] = input.trim().split(/\s+/);
+  switch (subcommand) {
+    case "load": {
+      const filePath = rest.join(" ");
+      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}`);
+    }
+    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'");
+  }
+}
+
+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 codeHash = resolveTypeHash(state, parts[0]);
+  const codecName = parts[1] || null;
+  resolveCodec(state, codeHash, codecName, "parse");
+  state.pendingInput = { codeHash, codecName };
+  return [`input ${codeHash}${codecName ? ` using ${codecName}` : ""}: enter value text`];
+}
+
+async function consumeCodecInput(input, state) {
+  const pending = state.pendingInput;
+  if (!pending) return null;
+  state.pendingInput = null;
+
+  restoreCodes(state);
+  const codec = resolveCodec(state, pending.codeHash, pending.codecName, "parse");
+  const pattern = codeHashToPattern(pending.codeHash, codes.find);
+  const parsed = await codec.parse(input, {
+    codeHash: pending.codeHash,
+    pattern,
+    state
+  });
+  const value = valueForCode(parsed, pending.codeHash, codes.find);
+  state.value = value;
+  return [printValue(value, state)];
 }
 
 async function evaluateInput(input, state) {
+  if (state.pendingInput) {
+    return consumeCodecInput(input, state);
+  }
+
   const line = input.trim();
   if (line === "" || line.startsWith("#") || line.startsWith("//") || line.startsWith("--")) return [];
 
@@ -745,9 +954,13 @@ async function evaluateCommand(line, state) {
       return [listAliases(state.relAliases)];
     case "val":
       return [
-        printValue(state.value),
+        printValue(state.value, state),
         JSON.stringify(state.value, null, 2)
       ];
+    case "codec":
+      return loadCodec(arg, state);
+    case "input":
+      return requestCodecInput(arg, state);
     case "reset": {
       const fresh = createState();
       Object.assign(state, fresh);
@@ -803,13 +1016,13 @@ 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} = ${prettyRelation(rel)};  -- ${hash}`];
+      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);
       if (!hash || !(hash in state.codes)) throw new Error(`Unknown type '${arg}'`);
-      return [`$ ${arg} = ${prettyCode({}, codes.find, codes.find(hash))};  -- ${hash}`];
+      return [`$ ${arg} = ${prettyCode(displayAliases(state), codes.find, codes.find(hash))};  -- ${hash}`];
     }
     default:
       throw new Error(`Unknown command ':${command}'. Try :help`);
@@ -826,6 +1039,9 @@ function helpText() {
     ":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",
+    ":input type [codec]  read next line as codec input",
     ":load [--no-alias] file",
     "                     load .k source or .klib",
     ":klib file           export state as a library",
@@ -865,6 +1081,19 @@ function startRepl() {
   console.log("k interpreter (.klib-backed). Type :help for commands.");
   rl.prompt();
   async function handleLine(line) {
+    if (state.pendingInput && buffer.length === 0) {
+      rl.setPrompt("> ");
+      try {
+        for (const output of await consumeCodecInput(line, state)) {
+          console.log(output);
+        }
+      } catch (error) {
+        console.error(error.message || String(error));
+      }
+      if (!closed) rl.prompt();
+      return;
+    }
+
     if (lineHasExplicitContinuation(line)) {
       buffer.push(lineForContinuation(line));
       rl.setPrompt("  ");

package/run.mjs

@@ -122,6 +122,20 @@ function constrainWithPattern(value, constraint, exp) {
   return withPattern(value, pattern);
 }
 
+function projectionPattern(staticOutputPattern, valuePattern, label, exp) {
+  const dynamicOutputPattern = edgeSubpattern(valuePattern, label);
+  const pattern = intersectPatterns(staticOutputPattern, dynamicOutputPattern);
+  if (!pattern && staticOutputPattern && dynamicOutputPattern) {
+    throw new TypeError(
+      `Type Error in '${exp.op}'${expLocation(exp)}\n` +
+      ` - Projected value envelope does not intersect expression output pattern.\n` +
+      ` - output pattern: ${patternPreview(staticOutputPattern)}\n` +
+      ` - projected envelope: ${patternPreview(dynamicOutputPattern)}`
+    );
+  }
+  return pattern;
+}
+
 function compiledExp(findCode, exp, typePatternGraph) {
   const cached = exp._compiledRun;
   if (cached?.findCode === findCode && cached?.typePatternGraph === typePatternGraph && cached?.defs === run.defs) {
@@ -188,13 +202,13 @@ function compiledExp(findCode, exp, typePatternGraph) {
     case "dot":
       fn = (value) => {
         if (value === undefined) return undefined;
-        return withPattern(value.product[exp.dot], staticOutputPattern || edgeSubpattern(value.pattern, exp.dot));
+        return withPattern(value.product[exp.dot], projectionPattern(staticOutputPattern, value.pattern, exp.dot, exp));
       };
       break;
     case "div":
       fn = (value) => {
         if (value === undefined || value.tag !== exp.div) return undefined;
-        return withPattern(value.value, staticOutputPattern || edgeSubpattern(value.pattern, exp.div));
+        return withPattern(value.value, projectionPattern(staticOutputPattern, value.pattern, exp.div, exp));
       };
       break;
     case "comp": {