@fraczak/k 7.1.0 → 8.0.0

package/repl.mjs

@@ -21,7 +21,7 @@ if (typeof globalThis !== "undefined") {
   globalThis.isVariant = isVariant;
   globalThis.patternFromFilter = patternFromFilter;
 }
-import { prettyCode } from "./pretty.mjs";
+import { prettyCode, prettyFilter } from "./pretty.mjs";
 import {
   compileObject,
   compileLibrary,
@@ -32,7 +32,11 @@ import {
   loadLibrary,
   prettyRelation
 } from "./object.mjs";
-import { propertyListToFilter, valueToK, valueWithEnvelopeToK } from "./codecs/runtime/show-value.mjs";
+import {
+  propertyListToFilter,
+  valueToK,
+  valueWithEnvelopeToK
+} from "./codecs/runtime/show-value.mjs";
 import {
   codecNames,
   codeHashToPattern,
@@ -48,9 +52,9 @@ import {
 
 const NAME_RE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
 const COMMAND_NAMES = [
-  "help", "rel",
+  "help", "rel", "pattern", "pat", "patterns", "pats",
   "codecs", "rels", "codec", "input", "reset", "klib", "ko", "load",
-  "engine", "wasm", "pkir", "js",
+  "engine", "wasm", "pkir", "js", "limit",
   "quit", "exit"
 ];
 const CODEC_COMMAND_NAMES = ["load", "unload", "list"];
@@ -87,6 +91,7 @@ function createState(options = {}) {
     rels: {},
     relAliases: {},
     typeAliases: {},
+    patterns: {},
     codecs: {},
     loadedFiles: new Set(),
     pendingInput: null,
@@ -95,7 +100,8 @@ function createState(options = {}) {
     lastResult: null,
     lastMain: null,
     lastTiming: null,
-    showTiming: true
+    showTiming: true,
+    printLimit: options.printLimit ?? Infinity
   };
 }
 
@@ -105,6 +111,7 @@ function stateLibrary(state) {
     codes: state.codes,
     rels: state.rels,
     relAlias: state.relAliases,
+    patterns: state.patterns,
     meta: state.meta,
     main: null
   };
@@ -226,6 +233,11 @@ 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.patterns = {
+    ...state.patterns,
+    ...(lib.patterns || lib.sourceDefs?.patterns ||
+      lib.defs?.patterns || {})
+  };
   mergeMeta(state, lib.meta);
 
   if (loadAliases) {
@@ -309,6 +321,7 @@ function savedLibrary(state) {
     rels,
     relAlias: state.relAliases,
     compileStats: { sccs: [], sccCount: 0 },
+    patterns: state.patterns || {},
     meta: Object.fromEntries(
       Object.entries(meta).filter(([hash]) => storedHashes.has(hash))
     ),
@@ -319,7 +332,10 @@ function savedLibrary(state) {
 function executableObject(state, mainExpression) {
   const main = (mainExpression || state.lastMain || "").trim();
   if (!main) {
-    throw new Error(":ko file expr requires a main expression unless one has already been evaluated or defined");
+    throw new Error(
+      ":ko file expr requires a main expression unless one has " +
+      "already been evaluated or defined"
+    );
   }
 
   restoreCodes(state);
@@ -327,7 +343,8 @@ function executableObject(state, mainExpression) {
   try {
     return compileObject([preamble, main].filter(Boolean).join("\n"), {
       source: "<repl>",
-      libraries: [stateLibrary(state)]
+      libraries: [stateLibrary(state)],
+      patterns: state.patterns
     });
   } catch (error) {
     throw remapError(error, preambleLineCount(preamble));
@@ -342,11 +359,72 @@ function resolveRel(state, name) {
 }
 
 function listAliases(aliases) {
-  const entries = Object.entries(aliases).sort(([a], [b]) => a.localeCompare(b));
+  const entries = Object.entries(aliases).sort(([a], [b]) =>
+    a.localeCompare(b)
+  );
   if (entries.length === 0) return "(none)";
   return entries.map(([name, hash]) => `${name} = ${hash}`).join("\n");
 }
 
+function resolvePatternCanonicalName(state, name, pat) {
+  if (!state || !pat) return null;
+  if (pat._canonical) return pat._canonical;
+  const params = pat.params || [];
+  const source = `? ${name}[${params.join(", ")}]`;
+  try {
+    restoreCodes(state);
+    const annotated = annotate(source, {
+      libraries: [stateLibrary(state)],
+      patterns: state.patterns
+    });
+    const mainRel = annotated.rels.__main__;
+    if (
+      mainRel?.typePatternGraph &&
+      mainRel?.def?.patterns?.[0] != null
+    ) {
+      const rootId = mainRel.typePatternGraph.find(
+        mainRel.def.patterns[0]
+      );
+      const propList = patternToPropertyList(
+        exportPatternGraph(mainRel.typePatternGraph, rootId)
+      );
+      const codeHash = closedPatternToCodeHash(propList);
+      if (codeHash) {
+        state.codes = codes.dump();
+        pat._canonical = codeHash;
+        return codeHash;
+      }
+    }
+    const relHash = annotated.relAlias?.__main__ || null;
+    if (relHash) {
+      pat._canonical = relHash;
+      return relHash;
+    }
+  } catch {
+    restoreCodes(state);
+    return null;
+  }
+  return null;
+}
+
+function prettyPattern(name, pat, state = null) {
+  const params = (pat?.params || []).join(", ");
+  const filterStr = pat?.filter ? prettyFilter(pat.filter) : "()";
+  const canonical = resolvePatternCanonicalName(state, name, pat);
+  const suffix = canonical ? `  -- ${canonical}` : "";
+  return `${name}[${params}] = ${filterStr};${suffix}`;
+}
+
+function listPatterns(patterns) {
+  const entries = Object.entries(patterns || {}).sort(([a], [b]) =>
+    a.localeCompare(b)
+  );
+  if (entries.length === 0) return "(none)";
+  return entries
+    .map(([name, pat]) => `${name}[${(pat?.params || []).join(", ")}]`)
+    .join("\n");
+}
+
 function formatCodecOutput(output) {
   if (typeof Buffer !== "undefined" && Buffer.isBuffer(output)) return output.toString("utf8");
   if (typeof Uint8Array !== "undefined" && output instanceof Uint8Array) return new TextDecoder().decode(output);
@@ -354,7 +432,8 @@ function formatCodecOutput(output) {
 }
 
 function printValue(value, state = null) {
-  const lines = [valueWithEnvelopeToK(value)];
+  const limit = state?.printLimit ?? Infinity;
+  const lines = [valueWithEnvelopeToK(value, limit)];
   if (!state || value === undefined) return lines[0];
 
   const store = state.codecs || {};
@@ -363,7 +442,11 @@ function printValue(value, state = null) {
     try {
       const output = codec.print(value, { state });
       if (output != null) {
-        lines.push(`${codec.name}: ${formatCodecOutput(output)}`);
+        let text = formatCodecOutput(output);
+        if (Number.isFinite(limit) && text.length > limit) {
+          text = text.slice(0, limit) + "...";
+        }
+        lines.push(`${codec.name}: ${text}`);
       }
     } catch {
       // Codec cannot format this value; silently skip
@@ -638,9 +721,16 @@ function resolveTypeExpressionHash(state, rawType) {
   ].filter(Boolean).join("\n");
 
   try {
-    const annotated = annotate(source, { libraries: [stateLibrary(state)] });
+    const annotated = annotate(source, {
+      libraries: [stateLibrary(state)],
+      patterns: state.patterns
+    });
     const hash = annotated.representatives[INPUT_TYPE_NAME];
-    if (!hash) throw new Error(":input type expression did not produce a code hash");
+    if (!hash) {
+      throw new Error(
+        ":input type expression did not produce a code hash"
+      );
+    }
     state.codes = codes.dump();
     return hash;
   } catch (error) {
@@ -666,7 +756,10 @@ function resolvePatternExpression(state, patternExpr) {
     patternExpr
   ].filter(Boolean).join("\n");
   try {
-    const annotated = annotate(source, { libraries: [stateLibrary(state)] });
+    const annotated = annotate(source, {
+      libraries: [stateLibrary(state)],
+      patterns: state.patterns
+    });
     const mainRel = annotated.rels.__main__;
     if (!mainRel || !mainRel.typePatternGraph) {
       throw new Error(`Invalid pattern expression '${patternExpr}'`);
@@ -765,6 +858,25 @@ function completeCommandArgument(line, state) {
   const argStart = 1 + firstSpace + 1;
   const arg = line.slice(argStart);
 
+  if (command === "pattern" || command === "pat") {
+    const trimmed = arg.trimStart();
+    const leadingWhitespace = arg.length - trimmed.length;
+    const prefix = line.slice(0, argStart + leadingWhitespace);
+    const names = Object.keys(state.patterns || {}).sort();
+    const matches = names
+      .filter((name) => name.startsWith(trimmed))
+      .map((name) => `${prefix}${name}`);
+    if (trimmed.startsWith("@")) {
+      for (const [name, p] of Object.entries(state.patterns || {})) {
+        const hash = resolvePatternCanonicalName(state, name, p);
+        if (hash && hash.startsWith(trimmed)) {
+          matches.push(`${prefix}${hash}`);
+        }
+      }
+    }
+    return [matches, line];
+  }
+
   if (command === "codec" || command === "codecs") {
     return completeCodecCommand(line, argStart, arg, state);
   }
@@ -871,7 +983,10 @@ function resolveKFilePath(filePath) {
     if (fs.existsSync(strippedEx)) return strippedEx;
   } catch {}
   try {
-    const fromRepoStripped = path.resolve(path.dirname(fileURLToPath(import.meta.url)), strippedEx);
+    const fromRepoStripped = path.resolve(
+      path.dirname(fileURLToPath(import.meta.url)),
+      strippedEx
+    );
     if (fs.existsSync(fromRepoStripped)) return fromRepoStripped;
   } catch {}
   return filePath;
@@ -902,7 +1017,8 @@ function loadSourceOrKlib(state, targetPath, options = {}) {
     const fullSource = [preamble, source].filter(Boolean).join("\n");
     const compileOptions = {
       source: targetPath,
-      libraries: [stateLibrary(state)]
+      libraries: [stateLibrary(state)],
+      patterns: state.patterns
     };
     try {
       const lib = compileWithOptionalIdentity(fullSource, compileOptions);
@@ -966,15 +1082,29 @@ function compileSnippetArtifacts(source, state, sourceName = "<repl>") {
   const fullSource = [preamble, source].filter(Boolean).join("\n");
   const options = {
     source: sourceName,
-    libraries: [stateLibrary(state)]
+    libraries: [stateLibrary(state)],
+    patterns: state.patterns
   };
   try {
     const lib = compileWithOptionalIdentity(fullSource, options);
-    const { relAlias, meta } = libraryOriginsFromSource(source, fullSource, lib, options);
+    const { relAlias, meta } = libraryOriginsFromSource(
+      source,
+      fullSource,
+      lib,
+      options
+    );
     const annotated = annotateWithOptionalIdentity(fullSource, options);
     return {
       annotated,
-      lib: { ...lib, relAlias, meta },
+      lib: {
+        ...lib,
+        relAlias,
+        meta,
+        patterns: {
+          ...(state.patterns || {}),
+          ...(annotated.sourceDefs?.patterns || {})
+        }
+      },
       lineOffset: preambleLineCount(preamble)
     };
   } catch (error) {
@@ -1227,14 +1357,49 @@ async function evaluateCommand(line, state) {
     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");
+        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}`];
+      const prettyRelStr = prettyRelation(
+        rel,
+        displayAliases(state),
+        state.relAliases
+      );
+      return [`${arg} = ${prettyRelStr};  -- ${hash}`];
     }
     case "rels":
       return [listAliases(state.relAliases)];
+    case "pattern":
+    case "pat": {
+      if (!arg) {
+        throw new Error(`${usagePrefix}pattern requires a pattern name`);
+      }
+      const rawName = arg.trim();
+      let patternName = rawName.replace(/\[.*\]$/, "").trim();
+      let pat = state.patterns?.[patternName];
+      if (!pat && patternName.startsWith("@")) {
+        for (const [name, p] of Object.entries(state.patterns || {})) {
+          if (
+            resolvePatternCanonicalName(state, name, p) === patternName
+          ) {
+            patternName = name;
+            pat = p;
+            break;
+          }
+        }
+      }
+      if (!pat) {
+        throw new Error(`Unknown pattern '${rawName}'`);
+      }
+      return [prettyPattern(patternName, pat, state)];
+    }
+    case "patterns":
+    case "pats":
+      return [listPatterns(state.patterns)];
     case "codec":
     case "codecs":
       return loadCodec(arg, state);
@@ -1265,9 +1430,34 @@ async function evaluateCommand(line, state) {
       state.engine = "js";
       return ["engine set to js"];
     }
+    case "limit": {
+      const mode = (arg || "").trim().toLowerCase();
+      if (!mode) {
+        const current = Number.isFinite(state.printLimit)
+          ? state.printLimit
+          : "none";
+        return [`Current output limit: ${current}`];
+      }
+      if (mode === "none" || mode === "infinity" || mode === "off") {
+        state.printLimit = Infinity;
+        return ["output limit disabled"];
+      }
+      const n = parseInt(mode, 10);
+      if (Number.isNaN(n) || n < 0) {
+        throw new Error(
+          `Invalid limit '${arg.trim()}'. Usage: :limit [num|none]`
+        );
+      }
+      state.printLimit = n;
+      return [`output limit set to ${n}`];
+    }
     case "reset": {
       const currentEngine = state.engine;
-      const fresh = createState({ engine: currentEngine });
+      const currentLimit = state.printLimit;
+      const fresh = createState({
+        engine: currentEngine,
+        printLimit: currentLimit
+      });
       Object.assign(state, fresh);
       return ["reset"];
     }
@@ -1302,18 +1492,23 @@ function helpText() {
     ":engine [wasm|pkir|js]   display or switch evaluation engine",
     ":rel name            show relation definition",
     ":rels                list relation aliases",
-    ":codec load file     load a codec module from file (e.g. :codec load codecs/int.mjs)",
+    ":pattern name        show named pattern definition (alias :pat)",
+    ":patterns            list defined named patterns (alias :pats)",
+    ":limit [num|none]    set maximum characters for value output",
+    ":codec load file     load a codec module from file",
     ":codec unload name   unload a registered codec",
     ":codec list          list loaded codecs (or simply :codecs)",
-    ":input <codec.mjs> [text]  parse input using specified codec",
-    ":load [--no-alias] file",
-    "                     load .k source or .klib",
+    ":input <codec> [txt] parse input using specified codec",
+    ":load [--no-alias] f load .k source or .klib",
     ":klib file           export state as a library",
     ":ko file expr        export executable .ko using expr as main",
     ":reset               clear state",
     ":help                show this help",
     "",
-    "Raw k input is compiled as a snippet on top of the current state.",
+    "Raw k input:",
+    "  name = expr;             define relation alias",
+    "  name[P1, ...] = filter;  define named pattern template",
+    "  ? name[...]              evaluate named pattern filter",
     "A line ending with ';' plus only spaces closes the snippet.",
     "Use '\\' to force continuation."
   ].join("\n");
@@ -1336,6 +1531,7 @@ function cliUsage() {
   console.log("  --pkir                   Shortcut for --engine=pkir.");
   console.log("  --wasm                   Shortcut for --engine=wasm.");
   console.log("  --js                     Shortcut for --engine=js.");
+  console.log("  --limit=<num>            Set maximum characters for output.");
   console.log("  -h, --help               Show this help.");
 }
 
@@ -1431,6 +1627,7 @@ function startRepl(options = {}) {
 if (isMainEntrypoint()) {
   const args = argv.slice(2);
   let engine = "wasm";
+  let printLimit = Infinity;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "-h" || arg === "--help") {
@@ -1461,13 +1658,30 @@ if (isMainEntrypoint()) {
         exit(1);
       }
       engine = val;
+    } else if (arg.startsWith("--limit=")) {
+      const val = parseInt(arg.slice("--limit=".length), 10);
+      if (Number.isNaN(val) || val < 0) {
+        console.error(
+          `Invalid limit '${arg.slice("--limit=".length)}'.`
+        );
+        exit(1);
+      }
+      printLimit = val;
+    } else if (arg === "--limit") {
+      i++;
+      const val = parseInt(args[i] || "", 10);
+      if (Number.isNaN(val) || val < 0) {
+        console.error(`Invalid limit '${args[i]}'.`);
+        exit(1);
+      }
+      printLimit = val;
     } else {
       console.error(`Unknown option '${arg}'.`);
       cliUsage();
       exit(1);
     }
   }
-  startRepl({ engine });
+  startRepl({ engine, printLimit });
 }
 
 export {
@@ -1502,5 +1716,8 @@ export {
   formatDuration,
   codecNames,
   ensureEnveloped,
-  patternFromFilter
+  patternFromFilter,
+  prettyPattern,
+  resolvePatternCanonicalName,
+  listPatterns
 };

package/scripts/build-repl-html.mjs

@@ -78,8 +78,16 @@ if (fs.existsSync(coreKPath)) {
   vfsFiles["core.k"] = fs.readFileSync(coreKPath, "utf8");
 }
 
-// Add verified k-code files: arithmetics.k, ieee.k, poly.k, karatsuba-mult.k
-const verifiedExamples = ["arithmetics.k", "ieee.k", "poly.k", "karatsuba-mult.k"];
+// Add verified k-code files
+const verifiedExamples = [
+  "arithmetics.k",
+  "ieee.k",
+  "poly.k",
+  "karatsuba-mult.k",
+  "djson.k",
+  "djson-btrie.k",
+  "djson-ptrie.k"
+];
 const examplesDir = path.join(projectRoot, "Examples");
 for (const filename of verifiedExamples) {
   const fullPath = path.join(examplesDir, filename);
@@ -91,7 +99,16 @@ for (const filename of verifiedExamples) {
 }
 
 // Bundle verified codecs for browser VFS as 100% self-contained ES modules
-const verifiedCodecs = ["json.mjs", "utf8.mjs", "int.mjs", "unit.mjs", "ieee.mjs"];
+const verifiedCodecs = [
+  "json.mjs",
+  "djson.mjs",
+  "djson-btrie.mjs",
+  "djson-ptrie.mjs",
+  "utf8.mjs",
+  "int.mjs",
+  "unit.mjs",
+  "ieee.mjs"
+];
 const codecsDir = path.join(projectRoot, "codecs");
 
 const browserCodecSdkShim = `
@@ -638,6 +655,12 @@ const htmlContent = `<!DOCTYPE html>
       text-overflow: ellipsis;
       white-space: nowrap;
       flex: 1;
+      min-width: 0;
+    }
+
+    .k-btn-copy {
+      flex-shrink: 0;
+      margin-left: auto;
     }
 
     .k-tree-section-body {
@@ -1674,6 +1697,9 @@ const htmlContent = `<!DOCTYPE html>
               <option value="ieee.k">ieee.k</option>
               <option value="poly.k">poly.k</option>
               <option value="karatsuba-mult.k">karatsuba-mult.k</option>
+              <option value="djson.k">djson.k</option>
+              <option value="djson-btrie.k">djson-btrie.k</option>
+              <option value="djson-ptrie.k">djson-ptrie.k</option>
             </optgroup>
             <optgroup label="Quick Expressions">
               <option value="expr:{} | ok">{} | ok</option>
@@ -1693,9 +1719,15 @@ const htmlContent = `<!DOCTYPE html>
               <option value="expr::codec load int.mjs">:codec load int.mjs</option>
               <option value="expr::codec load utf8.mjs">:codec load utf8.mjs</option>
               <option value="expr::codec load json.mjs">:codec load json.mjs</option>
+              <option value="expr::codec load djson.mjs">:codec load djson.mjs</option>
+              <option value="expr::codec load djson-btrie.mjs">:codec load djson-btrie.mjs</option>
+              <option value="expr::codec load djson-ptrie.mjs">:codec load djson-ptrie.mjs</option>
               <option value="expr::codec load ieee.mjs">:codec load ieee.mjs</option>
               <option value="expr::codec load unit.mjs">:codec load unit.mjs</option>
               <option value="expr::input json.mjs {&quot;a&quot;:12,&quot;b&quot;:&quot;hello&quot;}">:input json.mjs {"a":12,"b":"hello"}</option>
+              <option value="expr::input djson.mjs {&quot;a&quot;:12,&quot;b&quot;:&quot;hello&quot;}">:input djson.mjs {"a":12,"b":"hello"}</option>
+              <option value="expr::input djson-btrie.mjs {&quot;a&quot;:12,&quot;b&quot;:&quot;hello&quot;}">:input djson-btrie.mjs {"a":12,"b":"hello"}</option>
+              <option value="expr::input djson-ptrie.mjs {&quot;a&quot;:12,&quot;b&quot;:&quot;hello&quot;}">:input djson-ptrie.mjs {"a":12,"b":"hello"}</option>
               <option value="expr::input int.mjs [0,1,2]">:input int.mjs [0,1,2]</option>
             </optgroup>
           </select>
@@ -1830,6 +1862,16 @@ const htmlContent = `<!DOCTYPE html>
                   <td><code>name = relExpr;</code></td>
                   <td><b>Relation Alias:</b> Defines a local alias for a relation expression.<br><i>e.g.</i> <code>swap = { . y x, . x y };</code></td>
                 </tr>
+                <tr>
+                  <td><code>name[P1, ..., Pn] = filter;</code></td>
+                  <td>
+                    <b>Named Pattern Template:</b> Defines a reusable
+                    pattern template.<br>
+                    <i>e.g.</i><br>
+                    <code>bit[] = &lt; {} 0, {} 1 &gt;;</code> or<br>
+                    <code>list[X] = &lt; {} nil, ... &gt; = Y;</code>
+                  </td>
+                </tr>
               </tbody>
             </table>
 
@@ -1865,8 +1907,15 @@ const htmlContent = `<!DOCTYPE html>
                   <td><b>Variant Constructor:</b> Wraps document into variant <code>tag</code></td>
                 </tr>
                 <tr>
-                  <td><code>? filterExpr</code></td>
-                  <td><b>Pattern Filter:</b> Asserts input matches pattern; acts as partial identity and inductive termination witness (<i>e.g.</i> <code>?&lt; {} true, {} false &gt;</code>)</td>
+                  <td>
+                    <code>? filterExpr</code> /
+                    <code>? name[...]</code>
+                  </td>
+                  <td>
+                    <b>Pattern Filter:</b> Asserts input matches pattern;
+                    acts as partial identity and inductive witness
+                    (<i>e.g.</i> <code>? list[X]</code>)
+                  </td>
                 </tr>
                 <tr>
                   <td><code>name</code> / <code>@hash</code></td>
@@ -1881,6 +1930,20 @@ const htmlContent = `<!DOCTYPE html>
             <table class="help-table">
               <tr><td><code>:engine [wasm|pkir|js]</code></td><td>Display or switch evaluation engine (<code>wasm</code>, <code>pkir</code>, or <code>js</code>)</td></tr>
               <tr><td><code>:load &lt;file&gt;</code></td><td>Load a <code>.k</code> source or <code>.klib</code> library into current state</td></tr>
+              <tr>
+                <td><code>:pattern &lt;name&gt;</code></td>
+                <td>
+                  Display definition of named pattern
+                  <code>&lt;name&gt;</code> (alias <code>:pat</code>)
+                </td>
+              </tr>
+              <tr>
+                <td><code>:patterns</code></td>
+                <td>
+                  List defined named pattern templates
+                  (alias <code>:pats</code>)
+                </td>
+              </tr>
               <tr><td><code>:rel &lt;name&gt;</code></td><td>Display definition of relation <code>&lt;name&gt;</code></td></tr>
               <tr><td><code>:rels</code></td><td>List all relation aliases</td></tr>
               <tr><td><code>:codecs</code></td><td>List all loaded format codecs</td></tr>
@@ -1901,6 +1964,14 @@ const htmlContent = `<!DOCTYPE html>
               <li><code>not = &lt; / true | false, / false | true &gt;;</code> &mdash; Polymorphic negation via branch projections and ordered choice</li>
               <li><code>{} | true not</code> &mdash; Compose constant relation <code>{} | true</code> with <code>not</code> (evaluates to <code>{} | false</code>)</li>
               <li><code>bool? = ?&lt; {} true, {} false &gt;;</code> &mdash; Define a boolean pattern filter relation</li>
+              <li>
+                <code>bit[] = &lt; {} 0, {} 1 &gt;;</code>
+                &mdash; Define a 0-arity bit pattern
+              </li>
+              <li>
+                <code>? list[bool[]]</code>
+                &mdash; Instantiated pattern filter matching booleans
+              </li>
               <li><code>not = bool? ?X &lt; / true | false, {} | true &gt; ?X;</code> &mdash; Filtered boolean negation: guarded by <code>bool?</code>, defaulting to <code>{} | true</code></li>
               <li><code>swap = { . y x, . x y };</code> &mdash; Define a product field-swapping relation</li>
               <li><code>{ {} | ok x, {} | nil y } swap</code> &mdash; Construct a product and pass it through <code>swap</code></li>