@fraczak/k 6.10.5 → 7.0.0

package/scripts/build-repl-html.mjs

@@ -130,7 +130,7 @@ for (const filename of verifiedCodecs) {
       }]
     });
     const bundledContent = buildRes.outputFiles[0].text;
-    vfsFiles[`codecs/${filename}`] = bundledContent;
+    vfsFiles[filename] = bundledContent;
   }
 }
 
@@ -1666,13 +1666,10 @@ const htmlContent = `<!DOCTYPE html>
             </optgroup>
             <optgroup label="Quick Expressions">
               <option value="expr:{} | ok">{} | ok</option>
-              <option value="expr:()">()</option>
-              <option value="expr:$ bool = &lt; {} true, {} false &gt;; not = $ bool &lt; / true | false, {} | true &gt; $ bool; {} | true not">not (boolean relation with fallback)</option>
-              <option value="expr:{10 x, 5 y} plus">{10 x, 5 y} plus (bits)</option>
+              <option value="expr:not = &lt; / true | false, / false | true &gt;; {} | true not">not (boolean relation)</option>
               <option value="expr:1 succ">1 succ</option>
               <option value="expr:{10 int x, 5 int y} plus">{10 int x, 5 int y} plus (int)</option>
               <option value="expr:{10 int x, 5 int y} karatsuba">{10 int x, 5 int y} karatsuba</option>
-              <option value="expr::types">:types (list types)</option>
               <option value="expr::rels">:rels (list relations)</option>
               <option value="expr::engine">:engine (show engine)</option>
               <option value="expr::engine wasm">:engine wasm</option>
@@ -1681,21 +1678,21 @@ const htmlContent = `<!DOCTYPE html>
             <optgroup label="Codecs &amp; Format Adapters">
               <option value="expr::codecs">:codecs</option>
               <option value="expr::input">:input (interactive dialog)</option>
-              <option value="expr::codec load codecs/int.mjs">:codec load codecs/int.mjs</option>
-              <option value="expr::codec load codecs/utf8.mjs">:codec load codecs/utf8.mjs</option>
-              <option value="expr::codec load codecs/json.mjs">:codec load codecs/json.mjs</option>
-              <option value="expr::codec load codecs/ieee.mjs">:codec load codecs/ieee.mjs</option>
-              <option value="expr::codec load codecs/unit.mjs">:codec load codecs/unit.mjs</option>
-              <option value="expr::input codecs/json.mjs {&quot;a&quot;:12,&quot;b&quot;:&quot;hello&quot;}">:input codecs/json.mjs {"a":12,"b":"hello"}</option>
-              <option value="expr::input codecs/int.mjs [0,1,2]">:input codecs/int.mjs [0,1,2]</option>
+              <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 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 int.mjs [0,1,2]">:input int.mjs [0,1,2]</option>
             </optgroup>
           </select>
           <button id="btn-load-example" class="btn btn-primary">Load</button>
         </div>
 
         <!-- File Upload -->
-        <label class="btn btn-secondary btn-file" title="Upload local .k or .klib file into VFS">
-          <input type="file" id="file-upload" accept=".k,.klib,.wat,.ko" style="display:none;">
+        <label class="btn btn-secondary btn-file" title="Upload local file into VFS">
+          <input type="file" id="file-upload" accept=".k,.klib,.wat,.ko,.mjs,.js,.json" style="display:none;">
           <span>📁 Upload</span>
         </label>
 
@@ -1804,10 +1801,10 @@ const htmlContent = `<!DOCTYPE html>
           <div class="help-section">
             <h4>Language Overview</h4>
             <p style="margin-bottom: 8px; color: var(--text-muted); line-height: 1.45;">
-              <b>k</b> is a concise language of <b>types</b> and <b>relations</b> (functions) over tree-like (JSON-like) documents. Every expression denotes a relation that transforms an input document into an output document.
+              <b>k</b> is a concise language of <b>relations</b> (functions) over tree-like (JSON-like) documents. Every expression denotes a relation that transforms an input document into an output document.
             </p>
             <p style="margin-bottom: 10px; color: var(--text-muted); line-height: 1.45;">
-              <b>Content-Addressed:</b> Functions and types are identified by their canonical content hash (<code>@...</code>) derived directly from their structure. Local names are just temporary aliases used for recursion and readability.
+              <b>Content-Addressed:</b> Relations are identified by their canonical content hash (<code>@...</code>) derived directly from their structure. Local names are just temporary aliases used for recursion and readability.
             </p>
 
             <div class="help-category-title">1. Definitions (Local Aliases)</div>
@@ -1821,36 +1818,10 @@ 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 = typeExpr;</code></td>
-                  <td><b>Type Alias:</b> Defines a local alias for a type schema.<br><i>e.g.</i> <code>$ bool = &lt; {} true, {} false &gt;;</code></td>
-                </tr>
-              </tbody>
-            </table>
-
-            <div class="help-category-title">2. Type Expressions (<code>typeExpr</code>)</div>
-            <p style="margin-bottom: 6px; color: var(--text-muted); font-size: 12px;">Schemas describing tree-like documents:</p>
-            <table class="help-table">
-              <thead>
-                <tr><th style="width: 45%;">Syntax</th><th>Description</th></tr>
-              </thead>
-              <tbody>
-                <tr>
-                  <td><code>{ Type_1 label_1, ..., Type_k label_k }</code></td>
-                  <td><b>Product Type:</b> Labeled record of arity <i>k</i> (e.g. <code>{float64 x, string n}</code>; special case: <code>{}</code> is the 0-ary product)</td>
-                </tr>
-                <tr>
-                  <td><code>&lt; Type_1 tag_1, ..., Type_k tag_k &gt;</code></td>
-                  <td><b>Union Type:</b> Tagged sum of <i>k</i> variants (e.g. <code>&lt;int ok, string err&gt;</code>)</td>
-                </tr>
-                <tr>
-                  <td><code>name</code> / <code>@hash</code></td>
-                  <td><b>Type Reference:</b> References a type by local alias or canonical content hash</td>
-                </tr>
               </tbody>
             </table>
 
-            <div class="help-category-title">3. Relation Expressions (<code>relExpr</code>)</div>
+            <div class="help-category-title">2. Relation Expressions (<code>relExpr</code>)</div>
             <p style="margin-bottom: 6px; color: var(--text-muted); font-size: 12px;">Functions transforming an input document to an output document:</p>
             <table class="help-table">
               <thead>
@@ -1882,8 +1853,8 @@ const htmlContent = `<!DOCTYPE html>
                   <td><b>Variant Constructor:</b> Wraps document into variant <code>tag</code></td>
                 </tr>
                 <tr>
-                  <td><code>$ typeExpr</code></td>
-                  <td><b>Type Constraint:</b> Asserts input matches <code>typeExpr</code> (compile-time Type Error on mismatch)</td>
+                  <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>
                 </tr>
                 <tr>
                   <td><code>name</code> / <code>@hash</code></td>
@@ -1899,8 +1870,6 @@ const htmlContent = `<!DOCTYPE html>
               <tr><td><code>:engine [wasm|js]</code></td><td>Display or switch evaluation engine (<code>wasm</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>:rel &lt;name&gt;</code></td><td>Display definition of relation <code>&lt;name&gt;</code></td></tr>
-              <tr><td><code>:type &lt;name&gt;</code></td><td>Display definition of type <code>&lt;name&gt;</code></td></tr>
-              <tr><td><code>:types</code></td><td>List all type aliases and canonical hashes</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>
               <tr><td><code>:codec load &lt;file.mjs&gt;</code></td><td>Load a codec from file (or load through Files)</td></tr>
@@ -1919,8 +1888,8 @@ const htmlContent = `<!DOCTYPE html>
               <li><code>{} | ok</code> &mdash; Constant relation producing variant <code>ok</code> with empty document payload <code>{}</code></li>
               <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 union type schema</li>
-              <li><code>not = $ bool &lt; / true | false, {} | true &gt; $ bool;</code> &mdash; Typed boolean negation: guarded by <code>$ bool</code>, defaulting to <code>{} | true</code></li>
+              <li><code>bool = ?&lt; {} true, {} false &gt;;</code> &mdash; Define a boolean pattern filter relation</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>
             </ul>

package/tests/code-derivation/blowup.mjs

@@ -19,9 +19,7 @@ t(`
 `, (annotated) => {
     // console.log(JSON.stringify(annotated,null,2));
     const {input,output} = in_out(annotated);
-    console.log(input);
-    console.log(output);
-    assert.equal(output.type, annotated.representatives["bnat"]);
-    assert.equal(input.type, annotated.representatives["pair"]);
+    assert.equal(output.pattern, '(...)');
+    assert.equal(input.pattern, '<...>');
     console.log("OK");
 });

package/tests/code-derivation/bnat.mjs

@@ -5,8 +5,7 @@ import assert from 'assert';
 t(fs.readFileSync("./Examples/bnat.k", "utf8"), (annotated) => {
     // console.log(JSON.stringify(annotated,null,2));
     const {input,output} = in_out(annotated);
-    // console.log(output);
-    assert.equal(output.type, annotated.representatives["bnat"]);
-    assert.equal(input.type, annotated.representatives["pair"]);
+    assert.equal(output.type, "@VtPHxGf5GNMzzyVFxtv7gegFfJRYapBGtCeyV56bs5Zb");
+    assert.equal(input.type, "@R7RD2sgu6yPqpCQBBcJqkzxHQMZfEJLcNW4UKBcTiC3m");
     console.log("OK");
 });

package/tests/code-derivation/dot.mjs

@@ -3,24 +3,18 @@ import { hash } from '../../hash.mjs';
 import assert from 'assert';
 
 t(`
-$b = < {} true, {} false > ; 
-$pair = { b one, b two } ;
-$bit = <{} 0, {} 1> ;
-1 = {} |1 $bit;
-$b {1 one, () two, () c} .one
+1 = {} |1 ?< {} 0, {} 1 >;
+?< {} true, {} false > {1 one, () two, () c} .one
 
 `, (annotated) => {
     const {input,output} = in_out(annotated);
-    // console.log({input,output});
-    assert.equal(input.type, annotated.representatives["b"]);
-    assert.equal(output.type, annotated.representatives["bit"]);
+    assert.equal(input.type, "@GWnxJCupZr96BZfdpDsfQQKxKjCbjyDh7Qaur7y9enCY");
+    assert.equal(output.type, "@MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg");
     console.log("OK");
 });
 
 t(`
-    $bit = <{} 0, {} 1> ;
-    $a = < bit true, bit false > ;
-    $a /true
+    ?< <{} 0, {} 1> true, <{} 0, {} 1> false > /true
   `, (annotated) => {
   const {input,output} = in_out(annotated);
   console.log({input,output});

package/tests/code-derivation/nat.mjs

@@ -4,7 +4,7 @@ import assert from 'assert';
 
 t(fs.readFileSync("./Examples/nat.k", "utf8"), (annotated) => {
     const {input,output} = in_out(annotated);
-    assert.equal(output.type, annotated.representatives["nat"]);
-    assert.equal(input.type, annotated.representatives["nat"]);
+    assert.equal(output.type, input.type);
+    assert.equal(output.type, "@e9WP6QX6URfgnd9hHYrrYUBhiL7UcvbWErVmyQJfFcr8");
     console.log("OK");
 });

package/tests/code-derivation/not-not.mjs

@@ -1,14 +1,14 @@
 import { t, in_out } from './index.mjs';
 import assert from 'assert';
 
-t(`$b = < {} true, {} false > ;
-   true = {} |true $b;
-   false = {} |false $b; 
-   not = $b < /true false, /false true >;
+t(`
+   true = {} |true;
+   false = {} |false; 
+   not = ?< {} true, {} false > < /true false, /false true > ?< {} true, {} false >;
    not not
 `, (annotated) => {
    const {input,output} = in_out(annotated);
-   assert.equal(input.type, annotated.representatives["b"]);
-   assert.equal(output.type, annotated.representatives["b"]);
+   assert.equal(input.type, output.type);
+   assert.equal(input.type, "@GWnxJCupZr96BZfdpDsfQQKxKjCbjyDh7Qaur7y9enCY");
    console.log("OK");
    });

package/tests/code-derivation/pattern-envelope.mjs

@@ -12,9 +12,8 @@ const INT_PATTERN = [
 ];
 
 const script = `
-  $ bits = < {} _, bits 0, bits 1 >;
-  $ int = < bits +, bits - >;
-  {}|_|0|1|+ $int
+  int = ?< <bits 0, bits 1, {} _>=bits "+", bits "-" >;
+  {}|_|0|1|+ int
 `;
 
 const result = k.compile(script)(Value.product({}));
@@ -76,9 +75,8 @@ assert.throws(
 );
 
 const projectionScript = `
-  $ bits = < {} _, bits 0, bits 1 >;
-  $ int = < bits +, bits - >;
-  $int /+
+  int = ?< <bits 0, bits 1, {} _>=bits "+", bits "-" >;
+  int /+
 `;
 const annotated = k.annotate(projectionScript);
 run.defs = annotated;

package/tests/code-derivation/product.mjs

@@ -12,14 +12,11 @@ t('{}', (annotated) => {
 });
 
 t(`
-  $b = < {} true, {} false > ; 
-  $pair = { b one, b two } ;
-
-  {() one, () two} $pair
+  ?< {} true, {} false > {() one, () two} ?{ < {} true, {} false > one, < {} true, {} false > two }
 `, (annotated) => {
   const {input,output} = in_out(annotated);
 
-  assert.equal(input.type, annotated.representatives["b"]);
-  assert.equal(output.type, annotated.representatives["pair"]);
+  assert.equal(input.type, "@GWnxJCupZr96BZfdpDsfQQKxKjCbjyDh7Qaur7y9enCY");
+  assert.equal(output.type, "@ZR2yff4pdXTVqZdMu9x3t9GG5rwmhEfQuenbAwFnD2Nk");
   console.log("OK");
 });

package/tests/code-derivation/rlz.mjs

@@ -2,13 +2,12 @@ import { t, in_out } from './index.mjs';
 import assert from 'assert';
 
 t(`
- $nat = < {} _, nat 0, nat 1>;
- zero = {}|_|0 $nat;
- rlz =  </0/_ zero, /0 rlz, ()>;
+ zero = {}|_|0;
+ rlz = ?<X 0, X 1, {} _>=X </0/_ zero, /0 rlz, ()> ?X;
  rlz
  `, (annotated) => {
     const {input,output} = in_out(annotated);
-    assert.equal(output.type, annotated.representatives["nat"]);
-    assert.equal(input.type, annotated.representatives["nat"]);
+    assert.equal(output.type, input.type);
+    assert.equal(output.type, "@VtPHxGf5GNMzzyVFxtv7gegFfJRYapBGtCeyV56bs5Zb");
     console.log("OK");
  });

package/tests/test-codecs.mjs

@@ -171,7 +171,7 @@ console.log("6. Verifying pattern derivation via k type system (patternFromFilte
   assert.deepEqual(UnitCodec.UNIT_PATTERN, unitPat);
 
   const listPat = SDK.patternFromFilter(
-    '$ bits = < bits 0, bits 1, {} _ >; $ int = < bits "+", bits "-" >; ?< {} nil, { $int car, list cdr } cons > = list'
+    '?< {} nil, { < <bits 0, bits 1, {} _>=bits "+", bits "-" > car, list cdr } cons > = list'
   );
   assert.deepEqual(IntCodec.INT_LIST_PATTERN, listPat);
 

package/tests/test-fingerprint.mjs

@@ -1,43 +1,38 @@
-import k from '../index.mjs';
-import { encodeCodeToString, find } from '../codes.mjs';
+import codes, { encodeCodeToString } from '../codes.mjs';
 import hash from '../hash.mjs';
-[
-    `
-    $bits = < bits 0,  bits 1, {} _ >;
-    $nat = < {} zero, nat succ>;
-    $pair = {nat x, nat y};
-    $b = { bits"x", bits y};
-    $tree = < {nat value, tree left, tree right} binary, nat leaf, {nat value, tree tree} unary >;
-  
-    succ =  | succ $nat;
-    plus = $pair <
-      {.x/zero stop, .y result} .result,
-      {.x/succ x, .y succ y } plus
-    > $nat;
-  {}|zero succ succ {() x, () y} plus
-    `     
-  ].map(function (script) {
-    console.log("test-fingerprint:");
-    // console.log(`k_expression = '${script}';`);
-    const annotated = k.annotate(script);
-    // console.log(annotated);
-    let ERRORS = 0;
-    for (const code in annotated.representatives) {
-      // console.log(`CODE: ${code}`);
-      const s = encodeCodeToString(annotated.representatives[code]);
-      // console.log(` - DEFS: ${s}`);;
-      const annotated2 = k.annotate(s+" {}");;
-      const s2 = encodeCodeToString(annotated2.representatives["C0"]);
-      // console.log(` - reparsed FINGERPRINT: ${hash(s2)}`);
-      if (!((s === s2) && (hash(s) === hash(s2)))) {
-        ERRORS++;
-        console.log(` ERROR - reparsed FINGERPRINT for ${code} is different`);
-      } 
-    }
-    if (ERRORS === 0) {
-      console.log("OK");
-    } else {
-      console.log(" ----- ERRORS");
-    }
-  });
+import assert from 'assert';
+
+console.log("test-fingerprint:");
+const codeDefs = {
+  bits: { code: "union", union: { "0": "bits", "1": "bits", "_": "{}" } },
+  nat: { code: "union", union: { zero: "{}", succ: "nat" } },
+  pair: { code: "product", product: { x: "nat", y: "nat" } },
+  b: { code: "product", product: { x: "bits", y: "bits" } },
+  tree: { code: "union", union: {
+    binary: "binNode",
+    leaf: "nat",
+    unary: "unNode"
+  } },
+  binNode: { code: "product", product: { value: "nat", left: "tree", right: "tree" } },
+  unNode: { code: "product", product: { value: "nat", tree: "tree" } },
+  "{}": { code: "product", product: {} }
+};
+
+const reps = codes.register(codeDefs);
+let errors = 0;
+for (const code in reps) {
+  const rep = reps[code];
+  const s = encodeCodeToString(rep);
+  const h = hash(s);
+  if (rep !== h) {
+    errors++;
+    console.log(` ERROR - fingerprint mismatch for ${code}: ${rep} !== ${h}`);
+  }
+}
+
+if (errors === 0) {
+  console.log("OK");
+} else {
+  console.log(" ----- ERRORS");
+}
   

package/tests/test-hash-normalization.mjs

@@ -67,16 +67,14 @@ f
 // SCC order should not change hash
 {
   const scriptA = `
-$bit = < {} 0, {} 1 >;
-f = $bit < /0 |0 g, /1 >;
-g = $bit < /0 |0 f, /1 >;
+f = ?< {} 0, {} 1 > < /0 |0 g, /1 >;
+g = ?< {} 0, {} 1 > < /0 |0 f, /1 >;
 f
   `;
 
   const scriptB = `
-$bit = < {} 0, {} 1 >;
-g = $bit < /0 |0 f, /1 >;
-f = $bit < /0 |0 g, /1 >;
+g = ?< {} 0, {} 1 > < /0 |0 f, /1 >;
+f = ?< {} 0, {} 1 > < /0 |0 g, /1 >;
 f
   `;
 

package/tests/test-ieee-arithmetic.mjs

@@ -6,25 +6,25 @@ import codes from "../codes.mjs";
 import { parse as parseFloat64, print as printFloat64 } from "../codecs/ieee.mjs";
 import { closedPatternToCodeHash, valueForCode } from "../repl-codecs.mjs";
 
-const state = createState();
+const state = createState({ engine: "js" });
 await evaluateInput(":load Examples/ieee.k", state);
 
 for (const name of ["add", "sub", "mul", "div"]) {
   assert.ok(state.relAliases[name], `Expected public IEEE relation '${name}'`);
 }
 
-const float64Hash = state.typeAliases.float64;
-const floatPairHash = state.typeAliases.float_pair;
+const sampleFloat = parseFloat64("0");
+const float64Hash = closedPatternToCodeHash(sampleFloat.pattern);
 
 function float64(text) {
-  return valueForCode(parseFloat64(text), float64Hash, codes.find);
+  return parseFloat64(text);
 }
 
 function floatPair(x, y) {
-  return valueForCode(Value.product({
+  return Value.product({
     x: float64(x),
     y: float64(y)
-  }), floatPairHash, codes.find);
+  });
 }
 
 async function runOperation(op, x, y) {
@@ -40,7 +40,6 @@ async function runProjectedResult(op, x, y) {
 }
 
 function assertFloatResult(value, expected, label) {
-  assert.equal(closedPatternToCodeHash(value.pattern), float64Hash, `${label}: result should keep float64 envelope`);
   assert.equal(printFloat64(value), expected, label);
 }
 

package/tests/test-k-object.mjs

@@ -51,9 +51,7 @@ const INT_PATTERN = [
 ];
 
 const objectBuffer = compileObjectBuffer(`
-  $ bits = < {} _, bits 0, bits 1 >;
-  $ int = < bits +, bits - >;
-  {}|_|0|1|+ $int
+  {}|_|0|1|+ ?< <bits 0, bits 1, {} _>=bits "+", bits "-">
 `);
 assert.equal(objectBuffer.subarray(0, 5).toString("utf8"), "KOBJ\n");
 const object = decodeObject(objectBuffer);
@@ -84,19 +82,17 @@ const decompiledSource = decompileObjectBuffer(objectBuffer);
 const decompiledResult = k.compile(decompiledSource)(Value.product({}));
 assert.deepEqual(decompiledResult.pattern, INT_PATTERN);
 assert.deepEqual(decompiledResult.toJSON(), objectResult.toJSON());
-assert.match(decompiledSource, /^----- codes -----$/m);
 assert.match(decompiledSource, /^----- rels -----$/m);
 assert.match(decompiledSource, /^----- main -----$/m);
-assert.match(decompiledSource, /\$ Nws3 =/);
-assert.match(decompiledSource, /^7jfi = /m);
-assert.match(decompiledSource, /^----- main -----\n\?\(\.\.\.\) 7jfi \$Nws3$/m);
+assert.match(decompiledSource, /^[A-Za-z0-9_]+ = /m);
+assert.match(decompiledSource, /^----- main -----\n\?\(\.\.\.\) [A-Za-z0-9_]+ \?<<X0 0, X0 1, {} _>=X0 \+, X0 ->$/m);
 
 const natLibraryBuffer = compileLibraryBuffer(fs.readFileSync("Examples/nat.k", "utf8"), { source: "Examples/nat.k" });
 const natDecompiledSource = decompileObjectBuffer(natLibraryBuffer);
 const natRoundTripSource = decompileObjectBuffer(
   compileLibraryBuffer(natDecompiledSource, { source: "Examples/nat.decompiled.k" })
 );
-const recursiveNatPattern = /\$dTww <\{\.x PgmQ x, \.y h4Wg y\} re64, \.y> \$e9WP;/;
+const recursiveNatPattern = /\?\{<\{\} 0, X0 \+1>=X0 x, <X1 \+1, \.\.\.>=X1 y\} <\{\.x [A-Za-z0-9_]+ x, \.y [A-Za-z0-9_]+ y\} [A-Za-z0-9_]+, \.y> \?X1;/;
 assert.equal(natRoundTripSource, natDecompiledSource);
 assert.match(natDecompiledSource, recursiveNatPattern);
 
@@ -111,14 +107,14 @@ const arithmeticsRoundTripSource = decompileObjectBuffer(
 assert.equal(arithmeticsRoundTripSource, arithmeticsDecompiledSource);
 
 assert.throws(() => k.compile("@A = (); @A"), /Parse error/);
-assert.throws(() => k.compile("$ @A = {}; $@A"), /Parse error/);
+assert.throws(() => k.compile("$ @A = {}; $@A"), /Lexical error/);
 assert.deepEqual(k.compile("7jfi = ?X0; 7jfi")(Value.product({})).toJSON(), {});
 
 const sccSource = decompileObjectBuffer(compileObjectBuffer("c = {}; b = c |x; a = b |y; a"));
-assert.match(sccSource, /----- rels -----\nPQgV = .+\n\naQAD = .+\n\nN9UH = /s);
+assert.match(sccSource, /----- rels -----\n[A-Za-z0-9_]+ = .+\n\n[A-Za-z0-9_]+ = .+\n\n[A-Za-z0-9_]+ = /s);
 assert.deepEqual(k.compile(sccSource)(Value.product({})).toJSON(), { y: "x" });
 
-const libraryBuffer = compileLibraryBuffer("$ nat = <{} zero, nat succ>;\nsucc = |succ;\n", { source: "defs-only.k" });
+const libraryBuffer = compileLibraryBuffer("zero = {}|zero;\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);
@@ -133,10 +129,10 @@ assert(Object.values(library.rels).every((rel) =>
 ));
 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" &&
+  type === "rel" &&
   origins.some((origin) =>
     origin.source === "defs-only.k" &&
-    origin.name === "nat" &&
+    origin.name === "zero" &&
     typeof origin.compiledAt === "string" &&
     origin.start &&
     origin.end
@@ -158,11 +154,11 @@ const derivedLibrary = decodeObject(compileLibraryBuffer("other = |other;\n", {
   libraries: [library]
 }));
 const derivedAliases = extractAliasesFromObject(derivedLibrary);
-assert.match(derivedAliases, /^\$ nat = @/m);
+assert.match(derivedAliases, /^zero = @/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 = @"));
+assert(derivedAliases.indexOf("succ = @") < derivedAliases.indexOf("zero = @"));
 
 {
   const warn = console.warn;

package/tests/test-kir.mjs

@@ -9,7 +9,6 @@ import {
 import { validateKIRP } from "../objects/validate.mjs";
 
 const object = decodeObject(compileObjectBuffer(`
-  $ bit = < {} 0, {} 1 >;
   id = ();
   .x id
 `, { source: "kir-test.k" }));

package/tests/test-kvm-polymorphic.mjs

@@ -91,8 +91,7 @@ console.log("==> Starting Polymorphic kVM & Specialization Tests");
 // Test 3: Type Error on Envelope Mismatch
 {
   const script = `
-    $ bool = < {} true, {} false >;
-    check = $bool;
+    check = ?< {} true, {} false >;
     check
   `;
   const obj = decodeObject(compileObjectBuffer(script));

package/tests/test-kvm.mjs

@@ -84,8 +84,7 @@ console.log("==> Starting kVM Tests");
 // Test 7: Filters & Types
 {
   const script = `
-    $ bool = < {} true, {} false >;
-    $ bool
+    ?< {} true, {} false >
   `;
   const result1 = runKVM(script, { true: {} });
   assert.deepEqual(toJSON(result1), "true");
@@ -98,9 +97,8 @@ console.log("==> Starting kVM Tests");
 // Test 8: Recursive List traversal (Cons/Nil)
 {
   const script = `
-    $ bool = < {} true, {} false >;
-    true = {} | true $bool;
-    false = {} | false $bool;
+    true = {} | true;
+    false = {} | false;
     
     list? = ?< {} nil, {X car, Y cdr} cons > = Y;
     nil = {}|nil list?;
@@ -130,12 +128,11 @@ console.log("==> Starting kVM Tests");
 // Test 9: Comparing KVM execution vs Native JS run (Envelope-aware and Envelope-free)
 {
   const script = `
-    $ nat = < {} 0, nat +1 >;
-    0 = {} | 0 $ nat;
-    inc = | +1 $ nat;
-    dec = $ nat / +1;
-    add = $ { nat x, nat y } <
-      { . x dec x, . y inc y } add,
+    0 = {} | 0;
+    inc = | +1;
+    dec = / +1;
+    add = ?{ < {} 0, N +1 > = N x, ... } = X <
+      { . x dec x, . y inc y } ?X add,
       . y
     >;
   `;