From 60dc436c3ac7d6cda00db4c1e24349f0cc866d0d Mon Sep 17 00:00:00 2001
From: Nathan Hedglin <nate@natescode.com>
Date: Sun, 14 Jun 2026 15:48:22 -0500
Subject: [PATCH 1/2] fix(playground): repair stale/broken examples + make the
 example verifier faithful
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The deployed playground examples had drifted from current Silicon syntax, and
several "examples" didn't actually do what they claimed:

- Snake: was a counter that never drew anything — now a real, playable snake
  (growing tail + self-collision + food) drawn on the canvas each tick. The body
  lives in raw linear memory (WASM::i32_store/load); arrow keys steer, Space
  restarts. Input is latched into a per-tick `pend` turn so two fast key presses
  can't fold the head 180° into the neck, and food is placed only after the body
  is fully advanced so it never lands on the snake or reads an unwritten slot.
- HTML list: only console-logged — now builds an HTML <ul> and renders it into
  the render panel via web::set_html.
- wasm_gc (Option): used the removed `pattern => body` @match arm — now the flat
  @match(o, $Some v, { v }, $None, { dflt }) form.
- INITIAL_SOURCE (default editor doc): used the dropped `&` call sigil + @local —
  now mirrors hello_world's paren-call syntax.
- Cheatsheet: documented the removed `=>` @match form — fixed to the flat form.
- gc_vec: was configured for --target=wasm-gc, but `@use 'vec'` is the
  linear-memory impl (alloc/realloc, rejected under wasm-gc), so it never
  compiled in the deployed playground. Relabeled to the host target.
- server.ts (local dev server): never inlined `@use`, so the five stdlib/vec
  examples failed at /compile. Now calls inlineStdlibUses() before parse,
  mirroring the browser build (web/entry.ts).

verify-examples.ts now extracts EXAMPLE_FEATURES/EXAMPLE_TARGETS and compiles
each example with the exact features + target the UI uses (it previously used
features:[] with no target, which masked the gc_vec break). All 19 examples pass
verify-examples and the headless-Chromium smoke test (compile + run-in-UI).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 playground/playground/index.html  | 225 ++++++++++++++++++++++--------
 playground/playground/server.ts   |   5 +-
 playground/web/verify-examples.ts |  73 ++++++----
 3 files changed, 223 insertions(+), 80 deletions(-)

diff --git a/playground/playground/index.html b/playground/playground/index.html
index 13dbd273..7d7b638c 100644
--- a/playground/playground/index.html
+++ b/playground/playground/index.html
@@ -390,7 +390,7 @@
       <option value="math_sampler">Math sampler</option>
     </optgroup>
     <optgroup label="Collections">
-      <option value="gc_vec">Vec[Int] (wasm-gc)</option>
+      <option value="gc_vec">Vec[Int]</option>
     </optgroup>
     <optgroup label="Platform / graphics">
       <option value="html_todo">HTML render</option>
@@ -461,7 +461,7 @@
 @loop(x, xs, { … });        <i># Vec elements</i>
 @loop({ … @break() });      <i># forever</i>
 @return(v);
-@match(s, $A v =&gt; v, $B =&gt; 0)</pre></details>
+@match(s, $A v, { v }, $B, { 0 })</pre></details>
 
       <details class="cheat-section"><summary>Functions</summary><pre>\\ add (Int, Int) -&gt; Int
 @fn add a, b := { a + b };
@@ -733,8 +733,8 @@
 
 \\\\ greet (String)
 @fn greet msg := {
-    @local result := ('Hello, ' ++ msg);
-    &web::console_log_str result;
+    result := ('Hello, ' ++ msg);
+    web::console_log_str(result);
     result
 };
 
@@ -1011,74 +1011,190 @@
 @export main;`,
 
     html_todo:
-`# String-building TODO list — console output via web::console_log_str.
-# Enable "run main" and compile.
-
-\\\\ done_item (String) -> String
-@fn done_item label := { '[x] ' ++ label };
-
-\\\\ todo_item (String) -> String
-@fn todo_item label := { '[ ] ' ++ label };
+`# HTML list — build an HTML string and render it into the panel via set_html.
+# Enable "run main" + compile; the list appears in the Render panel (right).
+
+\\\\ item (String, Int) -> String
+@fn item label, done := {
+    @if(done == 1,
+        { (('<li style="color:#3fb950">&#10003; ' ++ label) ++ '</li>') },
+        { (('<li style="color:#8b949e">&#9675; ' ++ label) ++ '</li>') })
+};
 
 @fn main := {
-    web::console_log_str('Sigil Milestones');
-    web::console_log_str(done_item('@fn keyword'));
-    web::console_log_str(done_item('web:: module system'));
-    web::console_log_str(done_item('Syntax highlighting'));
-    web::console_log_str(todo_item('HTML render panel'));
-    web::console_log_str(todo_item('Snake in Silicon'))
+    @mut html := '<h3 style="margin:0 0 8px;font:600 14px sans-serif">Silicon Milestones</h3>';
+    html = (html ++ '<ul style="list-style:none;padding:0;font:13px sans-serif;line-height:1.9">');
+    html = (html ++ item('@fn keyword + flat precedence', 1));
+    html = (html ++ item('web:: module system', 1));
+    html = (html ++ item('Syntax highlighting', 1));
+    html = (html ++ item('HTML render panel', 1));
+    html = (html ++ item('Snake in Silicon', 1));
+    html = (html ++ item('Self-hosted compiler', 0));
+    html = (html ++ '</ul>');
+    web::set_html(html);
+    0
 };
 
 @export main;`,
 
     snake:
-`# Snake counter — mutable globals, tick/handle_key export convention.
-# Enable "run main" and compile. Call tick() repeatedly to advance.
+`# Snake — a real, playable snake. Enable "run main", compile, then steer with
+# the arrow keys. Eat the red food to grow; you die on a wall or yourself.
+# Press Space to restart. The body lives in raw linear memory (WASM:: intrinsics).
+
+GRID := 16;        # 16x16 board
+CELL := 20;        # pixels per cell  (board = 320px)
+BODY := 16384;     # snake body: BODY[i] = the i-th segment's cell (y*GRID + x)
+
+@mut dir   := 0;   # 0=right 1=down 2=left 3=up
+@mut pend  := 0;   # queued turn — applied once per tick (input can't 180°)
+@mut len   := 3;
+@mut alive := 1;
+@mut score := 0;
+@mut food  := 0;   # food cell = y*GRID + x
+
+# Draw one grid cell as a rect (1px gap → grid look). Fill colour set by caller.
+\\\\ cell_rect (Int, Int)
+@fn cell_rect cx, cy := {
+    px := @toFloat(((cx * CELL) + 1));
+    py := @toFloat(((cy * CELL) + 1));
+    web::canvas_fill_rect(px, py, @toFloat((CELL - 2)), @toFloat((CELL - 2)));
+    0
+};
 
-GRID := 20;
+# Pick a new food cell that isn't on the snake (bounded retries).
+@fn place_food := {
+    @mut placed := 0;
+    @mut tries := 0;
+    @loop({
+        @if(placed == 1, { @break() });
+        @if(tries >= 30, { @break() });
+        fx := @toInt((web::math_random() * @toFloat(GRID)));
+        fy := @toInt((web::math_random() * @toFloat(GRID)));
+        cand := ((fy * GRID) + fx);
+        @mut on := 0;
+        @mut m := 0;
+        @loop(m < len, {
+            @if(WASM::i32_load((BODY + (m * 4))) == cand, { on = 1; });
+            m = m + 1;
+        });
+        @if(on == 0, { food = cand; placed = 1; });
+        tries = tries + 1;
+    });
+    0
+};
 
-@mut head_x := 10;
-@mut head_y := 10;
-@mut dir    := 0;   # 0=right 1=down 2=left 3=up
-@mut alive  := 1;
-@mut length := 3;
-@mut score  := 0;
-@mut food_x := 5;
-@mut food_y := 15;
+# Render the board: background, food, body (head brighter), death bar.
+@fn draw := {
+    web::canvas_set_fill(24, 28, 36);
+    web::canvas_fill_rect(0.0, 0.0, @toFloat((GRID * CELL)), @toFloat((GRID * CELL)));
+
+    fx := food % GRID;
+    fy := food / GRID;
+    web::canvas_set_fill(220, 70, 60);
+    cell_rect(fx, fy);
+
+    @mut i := (len - 1);
+    @loop(i >= 0, {
+        @if(i == 0, { web::canvas_set_fill(120, 230, 120); }, { web::canvas_set_fill(40, 170, 80); });
+        c := WASM::i32_load((BODY + (i * 4)));
+        cell_rect((c % GRID), (c / GRID));
+        i = i - 1;
+    });
 
-@fn main := {
-    head_x = 10; head_y = 10;
-    dir = 0; alive = 1; length = 3; score = 0;
-    food_x = 5; food_y = 15;
-    web::console_log_str('Snake started')
+    @if(alive == 0, {
+        web::canvas_set_fill(210, 50, 50);
+        web::canvas_fill_rect(0.0, 0.0, @toFloat((GRID * CELL)), 10.0);
+    });
+    0
+};
+
+# Reset state: length-3 snake laid horizontally near the middle, fresh food.
+@fn reset := {
+    dir = 0; pend = 0; len = 3; alive = 1; score = 0;
+    @mut i := 0;
+    @loop(i < len, {
+        WASM::i32_store((BODY + (i * 4)), (((8 * GRID) + 8) - i));
+        i = i + 1;
+    });
+    food = ((5 * GRID) + 11);
+    draw();
+    0
 };
 
 @fn tick := {
     @if(alive == 0, { @return(0) });
-    @if(dir == 0, { head_x = head_x + 1; });
-    @if(dir == 1, { head_y = head_y + 1; });
-    @if(dir == 2, { head_x = head_x - 1; });
-    @if(dir == 3, { head_y = head_y - 1; });
-    @if((head_x < 0) || (head_x >= GRID), { alive = 0; });
-    @if((head_y < 0) || (head_y >= GRID), { alive = 0; });
-    @if(alive == 0, { @return(0) });
-    @if(head_x == food_x, {
-        @if(head_y == food_y, {
-            length = length + 1;
-            score = score + 10;
-            food_x = (food_x + 7) % GRID;
-            food_y = (food_y + 13) % GRID;
-        })
+
+    # apply the queued turn once per tick — reject only a direct 180° reversal,
+    # so two fast key presses can never fold the head back into the neck.
+    @if(pend == 0, { @if(dir != 2, { dir = 0; }); });
+    @if(pend == 1, { @if(dir != 3, { dir = 1; }); });
+    @if(pend == 2, { @if(dir != 0, { dir = 2; }); });
+    @if(pend == 3, { @if(dir != 1, { dir = 3; }); });
+
+    head := WASM::i32_load(BODY);
+    hx := head % GRID;
+    hy := head / GRID;
+
+    @mut nx := hx;
+    @mut ny := hy;
+    @if(dir == 0, { nx = hx + 1; });
+    @if(dir == 1, { ny = hy + 1; });
+    @if(dir == 2, { nx = hx - 1; });
+    @if(dir == 3, { ny = hy - 1; });
+
+    @if(nx < 0,      { alive = 0; });
+    @if(nx >= GRID,  { alive = 0; });
+    @if(ny < 0,      { alive = 0; });
+    @if(ny >= GRID,  { alive = 0; });
+    @if(alive == 0, { draw(); @return(0) });
+
+    nhead := ((ny * GRID) + nx);
+
+    @mut hit := 0;
+    @mut j := 0;
+    @loop(j < (len - 1), {
+        @if(WASM::i32_load((BODY + (j * 4))) == nhead, { hit = 1; });
+        j = j + 1;
+    });
+    @if(hit == 1, { alive = 0; draw(); @return(0) });
+
+    @mut ate := 0;
+    @if(nhead == food, {
+        score = score + 10;
+        len = len + 1;
+        ate = 1;
+    });
+
+    # advance the body (len already grown if we ate), then write the new head
+    @mut k := (len - 1);
+    @loop(k > 0, {
+        WASM::i32_store((BODY + (k * 4)), WASM::i32_load((BODY + ((k - 1) * 4))));
+        k = k - 1;
     });
+    WASM::i32_store(BODY, nhead);
+
+    # place food only AFTER the body is fully updated, so it never lands on the
+    # snake (including the new head) and never reads an unwritten segment slot.
+    @if(ate == 1, { place_food(); });
+
+    draw();
     score
 };
 
+@fn main := {
+    reset();
+    web::console_log_str('Snake — arrow keys to steer, Space to restart');
+    0
+};
+
 \\\\ handle_key (Int)
 @fn handle_key key := {
-    @if(key == 37, { dir = 2; });
-    @if(key == 38, { dir = 3; });
-    @if(key == 39, { dir = 0; });
-    @if(key == 40, { dir = 1; });
+    @if(key == 37, { pend = 2; });   # left
+    @if(key == 38, { pend = 3; });   # up
+    @if(key == 39, { pend = 0; });   # right
+    @if(key == 40, { pend = 1; });   # down
+    @if(key == 32, { reset(); });
     0
 };
 
@@ -1111,7 +1227,7 @@
 @type Opt := $Some v Int | $None;
 
 \\\\ unwrap_or (Opt, Int)
-@fn unwrap_or o, dflt := @match(o, $Some v => v, $None => dflt);
+@fn unwrap_or o, dflt := @match(o, $Some v, { v }, $None, { dflt });
 
 \\\\ demo () -> Int
 @fn demo := unwrap_or(Some(42), 0);
@@ -1127,7 +1243,7 @@
 @fn sum_squares := {
     v := vec_new(4);
 
-    # Push 1², 2², … 5² into the GC-managed vector.
+    # Push 1², 2², … 5² into the growable vector.
     @mut i := 1;
     @loop(i <= 5, {
         vec_push_i32(v, (i * i));
@@ -1157,7 +1273,6 @@
 // Examples that compile with a non-default target (--target=wasm-gc, etc.).
 const EXAMPLE_TARGETS = {
     wasm_gc: 'wasm-gc',
-    gc_vec:  'wasm-gc',
 }
 
 // Cheatsheet side panel — collapse / expand.
diff --git a/playground/playground/server.ts b/playground/playground/server.ts
index ffdaff0f..89a9944c 100644
--- a/playground/playground/server.ts
+++ b/playground/playground/server.ts
@@ -17,7 +17,7 @@ import {
     compileToWasm,
     elaborate, buildStrataRegistry,
     typecheck, formatTypeError, formatType, wasmTypeOf, type FunctionSig,
-    loadModules,
+    loadModules, inlineStdlibUses,
     loadPlatform, getRequiredExports, type PlatformConfig,
 } from '@silicon/compiler/pipeline'
 
@@ -109,6 +109,9 @@ async function compileSilicon(source: string, platformConfig?: PlatformConfig, t
         : fallbackModuleRegistry
     const options = target && target !== 'host' ? { target: target as any } : undefined
 
+    // Inline bare-name stdlib `@use` directives before parsing — the raw parser
+    // doesn't understand `@use` (mirrors the browser build in web/entry.ts).
+    source = inlineStdlibUses(source)
     const ast = parse(source)
     const registry = buildStrataRegistry(ast as Program)
     const { program: elaborated, errors: elabErrors } = elaborate(ast as Program, registry)
diff --git a/playground/web/verify-examples.ts b/playground/web/verify-examples.ts
index a8dc605f..2a9de7e0 100644
--- a/playground/web/verify-examples.ts
+++ b/playground/web/verify-examples.ts
@@ -29,28 +29,50 @@ const browserSwap: BunPlugin = {
     },
 }
 
-// ── extract the EXAMPLES object literal from index.html ─────────────────────
+// ── extract object literals from index.html ─────────────────────────────────
 const html = readFileSync(join(WEB, '..', 'playground', 'index.html'), 'utf8')
-const start = html.indexOf('const EXAMPLES = {')
-if (start < 0) throw new Error('EXAMPLES object not found in index.html')
-// find the matching closing brace of the object literal
-let i = html.indexOf('{', start), depth = 0, end = -1, inStr = '', esc = false
-for (; i < html.length; i++) {
-    const c = html[i]
-    if (inStr) {
-        if (esc) { esc = false; continue }
-        if (c === '\\') { esc = true; continue }
-        if (c === inStr) inStr = ''
-        continue
+
+/** Balance-match the `{ … }` object literal that follows `marker` and eval it. */
+function extractObject<T>(marker: string, required = true): T {
+    const start = html.indexOf(marker)
+    if (start < 0) { if (required) throw new Error(`${marker} not found in index.html`); return {} as T }
+    let i = html.indexOf('{', start), depth = 0, end = -1, inStr = '', esc = false
+    for (; i < html.length; i++) {
+        const c = html[i]
+        if (inStr) {
+            if (esc) { esc = false; continue }
+            if (c === '\\') { esc = true; continue }
+            if (c === inStr) inStr = ''
+            continue
+        }
+        if (c === '"' || c === "'" || c === '`') { inStr = c; continue }
+        if (c === '{') depth++
+        else if (c === '}') { depth--; if (depth === 0) { end = i; break } }
+    }
+    if (end < 0) throw new Error(`could not balance ${marker} braces`)
+    // eslint-disable-next-line no-eval
+    return eval('(' + html.slice(html.indexOf('{', start), end + 1) + ')')
+}
+
+const EXAMPLES = extractObject<Record<string, string>>('const EXAMPLES = {')
+const EXAMPLE_FEATURES = extractObject<Record<string, string[]>>('const EXAMPLE_FEATURES = {')
+const EXAMPLE_TARGETS = extractObject<Record<string, string>>('const EXAMPLE_TARGETS = {')
+
+// Mirror index.html's example-picker: resolve the exact features + target each
+// example is compiled with in the UI, so this check matches real playground use.
+const VALID_FEATURES = new Set(['canvas', 'game', 'dom'])
+function featuresFor(key: string, src: string): string[] {
+    let feats: string[]
+    if (key in EXAMPLE_FEATURES) feats = EXAMPLE_FEATURES[key]
+    else if (key === 'empty') feats = []
+    else {
+        feats = []
+        if (src.includes('canvas_')) feats.push('canvas')
+        if (src.includes('@export tick')) feats.push('game')
+        if (src.includes('set_html')) feats.push('dom')
     }
-    if (c === '"' || c === "'" || c === '`') { inStr = c; continue }
-    if (c === '{') depth++
-    else if (c === '}') { depth--; if (depth === 0) { end = i; break } }
+    return feats.filter(f => VALID_FEATURES.has(f))
 }
-if (end < 0) throw new Error('could not balance EXAMPLES object braces')
-const objText = html.slice(html.indexOf('{', start), end + 1)
-// eslint-disable-next-line no-eval
-const EXAMPLES: Record<string, string> = eval('(' + objText + ')')
 
 // ── bundle entry.ts (browser target) exactly like verify.ts ─────────────────
 const outdir = join(tmpdir(), 'silicon-playground-verify-examples')
@@ -61,21 +83,24 @@ const result = await Bun.build({
 if (!result.success) { for (const log of result.logs) console.error(log); process.exit(1) }
 await import(result.outputs[0].path)
 const SiliconCompiler = (globalThis as any).SiliconCompiler as {
-    compile(req: { source: string; platform?: string; features?: string[] }): Promise<any>
+    compile(req: { source: string; platform?: string; features?: string[]; target?: string }): Promise<any>
 }
 if (!SiliconCompiler) throw new Error('globalThis.SiliconCompiler was not set by the bundle')
 
-// ── compile every non-empty example ─────────────────────────────────────────
+// ── compile every non-empty example with its real features + target ──────────
 let failed = 0, ok = 0
 for (const [name, source] of Object.entries(EXAMPLES)) {
     if (!source.trim()) continue
-    const data = await SiliconCompiler.compile({ source, platform: 'web', features: [] })
+    const features = featuresFor(name, source)
+    const target = EXAMPLE_TARGETS[name] ?? 'host'
+    const data = await SiliconCompiler.compile({ source, platform: 'web', features, target })
+    const tag = `[${features.join(',') || 'core'}${target !== 'host' ? ` · ${target}` : ''}]`
     if (data.success) {
         ok++
-        console.log(`✓ ${name} — ${data.exports.length} export(s)`)
+        console.log(`✓ ${name} ${tag} — ${data.exports.length} export(s)`)
     } else {
         failed++
-        console.error(`✗ ${name} FAILED:\n${(data.error || '').split('\n').map((l: string) => '    ' + l).join('\n')}`)
+        console.error(`✗ ${name} ${tag} FAILED:\n${(data.error || '').split('\n').map((l: string) => '    ' + l).join('\n')}`)
     }
 }
 console.log(`\nEXAMPLES: ${ok} compiled, ${failed} failed`)

From 074652f44e672d49016669a0c291e511c2631c21 Mon Sep 17 00:00:00 2001
From: Nathan Hedglin <nate@natescode.com>
Date: Sun, 14 Jun 2026 16:43:16 -0500
Subject: [PATCH 2/2] docs(playground): modernize plan-page Silicon snippets to
 ADR-0020 syntax
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The static design/roadmap pages served alongside the playground
(plan.html, features-plan.html, modules-plan.html) still showed
pre-ADR-0020 Silicon that the current compiler rejects. Modernized every
Silicon snippet (code blocks, inline <code> refs, and diff illustrations)
while preserving the HTML, syntax-highlight markup, and prose:

- dropped the retired `&` call sigil → parenthesised calls (foo(a, b))
- @let → @fn (functions) or bare `name := v` (consts); @var → @mut;
  @local → bare locals
- inline `name:Type` param annotations → bare params (inference)
- old `@extern name arg:Type;` / `@extern name (a:T) -> R;`
  → `\\ @extern name (Types) -> Ret;`
- `;`-style comments in Silicon blocks → `#` (Silicon's comment char)
- `A && B` (no && operator) → nested @if; retired `@stratum_operator`
  example → current `@stratum { Compiler::register::operator(...) }` form;
  grammar note now cites `ExprEnd = Primary { CallSuffix }`

Verified: each modernized <pre> Silicon block parses under the current
grammar (typecheck failures on fragments that reference undefined modules
are expected), HTML tags stay balanced, and the pages render correctly.
platforms-plan.html is unchanged — its `@platform` snippets are proposed
(not yet implemented) syntax, not retired forms.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 playground/playground/features-plan.html | 115 ++++++++++++-----------
 playground/playground/modules-plan.html  |  94 +++++++++---------
 playground/playground/plan.html          |  48 +++++-----
 3 files changed, 130 insertions(+), 127 deletions(-)

diff --git a/playground/playground/features-plan.html b/playground/playground/features-plan.html
index 40e8832d..bfe474da 100644
--- a/playground/playground/features-plan.html
+++ b/playground/playground/features-plan.html
@@ -430,18 +430,18 @@ <h3>A — Simple Main</h3>
 <pre>
 <span class="cm"># Entry point example — call helpers from main and print results.</span>
 
-<span class="kw">@fn</span> <span class="fn">add</span> a<span class="op">:</span><span class="ty">Int</span>, b<span class="op">:</span><span class="ty">Int</span> <span class="op">:=</span> { a <span class="op">+</span> b };
+<span class="kw">@fn</span> <span class="fn">add</span> a, b <span class="op">:=</span> { a <span class="op">+</span> b };
 
-<span class="kw">@fn</span> <span class="fn">factorial</span> n<span class="op">:</span><span class="ty">Int</span> <span class="op">:=</span> {
-    <span class="op">&</span><span class="fn">@if</span> n <span class="op">&lt;=</span> <span class="num">1</span>, { <span class="op">&</span><span class="fn">@return</span> <span class="num">1</span> };
-    n <span class="op">*</span> (<span class="op">&</span><span class="fn">factorial</span> (n <span class="op">-</span> <span class="num">1</span>))
+<span class="kw">@fn</span> <span class="fn">factorial</span> n <span class="op">:=</span> {
+    <span class="fn">@if</span>(n <span class="op">&lt;=</span> <span class="num">1</span>, { <span class="fn">@return</span>(<span class="num">1</span>) });
+    n <span class="op">*</span> <span class="fn">factorial</span>((n <span class="op">-</span> <span class="num">1</span>))
 };
 
 <span class="kw">@fn</span> <span class="fn">main</span> <span class="op">:=</span> {
-    <span class="kw">@local</span> sum     <span class="op">:=</span> (<span class="op">&</span><span class="fn">add</span> <span class="num">10</span>, <span class="num">32</span>);
-    <span class="kw">@local</span> fac10   <span class="op">:=</span> (<span class="op">&</span><span class="fn">factorial</span> <span class="num">10</span>);
-    <span class="op">&</span><span class="fn">web::console_log</span> sum;
-    <span class="op">&</span><span class="fn">web::console_log</span> fac10
+    sum     <span class="op">:=</span> <span class="fn">add</span>(<span class="num">10</span>, <span class="num">32</span>);
+    fac10   <span class="op">:=</span> <span class="fn">factorial</span>(<span class="num">10</span>);
+    <span class="fn">web::console_log</span>(sum);
+    <span class="fn">web::console_log</span>(fac10)
 };
 
 <span class="kw">@export</span> main;
@@ -463,27 +463,27 @@ <h3>B — HTML TODO List</h3>
 <span class="cm"># TODO list rendered into the HTML panel via web::set_html.</span>
 <span class="cm"># Check "run main" and click ▶ Compile.</span>
 
-<span class="kw">@fn</span> <span class="fn">item</span> label<span class="op">:</span><span class="ty">String</span>, done<span class="op">:</span><span class="ty">Int</span> <span class="op">:=</span> {
-    <span class="kw">@local</span> cls <span class="op">:=</span> (<span class="op">&</span><span class="fn">@if</span> done, { <span class="str">'done'</span> }, { <span class="str">'todo'</span> });
+<span class="kw">@fn</span> <span class="fn">item</span> label, done <span class="op">:=</span> {
+    cls <span class="op">:=</span> <span class="fn">@if</span>(done <span class="op">==</span> <span class="num">1</span>, { <span class="str">'done'</span> }, { <span class="str">'todo'</span> });
     <span class="str">'&lt;li class="'</span> <span class="op">++</span> cls <span class="op">++</span> <span class="str">'"&gt;'</span> <span class="op">++</span> label <span class="op">++</span> <span class="str">'&lt;/li&gt;'</span>
 };
 
 <span class="kw">@fn</span> <span class="fn">main</span> <span class="op">:=</span> {
-    <span class="kw">@local</span> html <span class="op">:=</span> (
+    html <span class="op">:=</span> (
         <span class="str">'&lt;style&gt;'</span>
         <span class="op">++</span> <span class="str">'body{font:16px system-ui;padding:20px;}'</span>
         <span class="op">++</span> <span class="str">'ul{list-style:none;padding:0}'</span>
         <span class="op">++</span> <span class="str">'li{padding:8px 12px;margin:4px 0;border-radius:6px;background:#21262d;color:#e6edf3}'</span>
         <span class="op">++</span> <span class="str">'li.done{opacity:0.5;text-decoration:line-through}'</span>
         <span class="op">++</span> <span class="str">'&lt;/style&gt;&lt;ul&gt;'</span>
-        <span class="op">++</span> (<span class="op">&</span><span class="fn">item</span> <span class="str">'Add @fn keyword'</span>,          <span class="num">1</span>)
-        <span class="op">++</span> (<span class="op">&</span><span class="fn">item</span> <span class="str">'Module system (web::)'</span>,    <span class="num">1</span>)
-        <span class="op">++</span> (<span class="op">&</span><span class="fn">item</span> <span class="str">'Syntax highlighting'</span>,      <span class="num">1</span>)
-        <span class="op">++</span> (<span class="op">&</span><span class="fn">item</span> <span class="str">'HTML render panel'</span>,        <span class="num">0</span>)
-        <span class="op">++</span> (<span class="op">&</span><span class="fn">item</span> <span class="str">'Snake in Silicon'</span>,          <span class="num">0</span>)
+        <span class="op">++</span> <span class="fn">item</span>(<span class="str">'Add @fn keyword'</span>,          <span class="num">1</span>)
+        <span class="op">++</span> <span class="fn">item</span>(<span class="str">'Module system (web::)'</span>,    <span class="num">1</span>)
+        <span class="op">++</span> <span class="fn">item</span>(<span class="str">'Syntax highlighting'</span>,      <span class="num">1</span>)
+        <span class="op">++</span> <span class="fn">item</span>(<span class="str">'HTML render panel'</span>,        <span class="num">0</span>)
+        <span class="op">++</span> <span class="fn">item</span>(<span class="str">'Snake in Silicon'</span>,          <span class="num">0</span>)
         <span class="op">++</span> <span class="str">'&lt;/ul&gt;'</span>
     );
-    <span class="op">&</span><span class="fn">web::set_html</span> html
+    <span class="fn">web::set_html</span>(html)
 };
 
 <span class="kw">@export</span> main;
@@ -517,67 +517,68 @@ <h3>C — Snake</h3>
 <span class="cm"># Snake — uses the tick + handle_key export convention.</span>
 <span class="cm"># Enable "run main" and compile.</span>
 
-<span class="kw">@let</span> GRID   <span class="op">:=</span> <span class="num">20</span>;    <span class="cm"># cells per side</span>
-<span class="kw">@let</span> CELL   <span class="op">:=</span> <span class="num">16</span>;    <span class="cm"># px per cell</span>
-
-<span class="kw">@var</span> head_x <span class="op">:=</span> <span class="num">10</span>;
-<span class="kw">@var</span> head_y <span class="op">:=</span> <span class="num">10</span>;
-<span class="kw">@var</span> dir    <span class="op">:=</span> <span class="num">0</span>;    <span class="cm"># 0=right 1=down 2=left 3=up</span>
-<span class="kw">@var</span> food_x <span class="op">:=</span> <span class="num">5</span>;
-<span class="kw">@var</span> food_y <span class="op">:=</span> <span class="num">15</span>;
-<span class="kw">@var</span> alive  <span class="op">:=</span> <span class="num">1</span>;
-<span class="kw">@var</span> length <span class="op">:=</span> <span class="num">3</span>;
-
-<span class="kw">@fn</span> <span class="fn">cell</span> x<span class="op">:</span><span class="ty">Int</span>, y<span class="op">:</span><span class="ty">Int</span>, r<span class="op">:</span><span class="ty">Int</span>, g<span class="op">:</span><span class="ty">Int</span>, b<span class="op">:</span><span class="ty">Int</span> <span class="op">:=</span> {
-    <span class="op">&</span><span class="fn">web::canvas_set_fill</span> r, g, b;
-    <span class="op">&</span><span class="fn">web::canvas_fill_rect</span>
-        (<span class="op">&</span><span class="fn">@toFloat</span> (x <span class="op">*</span> CELL)),
-        (<span class="op">&</span><span class="fn">@toFloat</span> (y <span class="op">*</span> CELL)),
-        <span class="num">15.0</span>, <span class="num">15.0</span>
+GRID   <span class="op">:=</span> <span class="num">20</span>;    <span class="cm"># cells per side</span>
+CELL   <span class="op">:=</span> <span class="num">16</span>;    <span class="cm"># px per cell</span>
+
+<span class="kw">@mut</span> head_x <span class="op">:=</span> <span class="num">10</span>;
+<span class="kw">@mut</span> head_y <span class="op">:=</span> <span class="num">10</span>;
+<span class="kw">@mut</span> dir    <span class="op">:=</span> <span class="num">0</span>;    <span class="cm"># 0=right 1=down 2=left 3=up</span>
+<span class="kw">@mut</span> food_x <span class="op">:=</span> <span class="num">5</span>;
+<span class="kw">@mut</span> food_y <span class="op">:=</span> <span class="num">15</span>;
+<span class="kw">@mut</span> alive  <span class="op">:=</span> <span class="num">1</span>;
+<span class="kw">@mut</span> length <span class="op">:=</span> <span class="num">3</span>;
+
+<span class="kw">@fn</span> <span class="fn">cell</span> x, y, r, g, b <span class="op">:=</span> {
+    <span class="fn">web::canvas_set_fill</span>(r, g, b);
+    <span class="fn">web::canvas_fill_rect</span>(
+        <span class="fn">@toFloat</span>((x <span class="op">*</span> CELL)),
+        <span class="fn">@toFloat</span>((y <span class="op">*</span> CELL)),
+        <span class="num">15.0</span>, <span class="num">15.0</span>)
 };
 
 <span class="kw">@fn</span> <span class="fn">draw</span> <span class="op">:=</span> {
     <span class="cm"># Background</span>
-    <span class="op">&</span><span class="fn">web::canvas_set_fill</span> <span class="num">13</span>, <span class="num">17</span>, <span class="num">23</span>;
-    <span class="op">&</span><span class="fn">web::canvas_fill_rect</span> <span class="num">0.0</span>, <span class="num">0.0</span>,
-        (<span class="op">&</span><span class="fn">@toFloat</span> (GRID <span class="op">*</span> CELL)),
-        (<span class="op">&</span><span class="fn">@toFloat</span> (GRID <span class="op">*</span> CELL));
+    <span class="fn">web::canvas_set_fill</span>(<span class="num">13</span>, <span class="num">17</span>, <span class="num">23</span>);
+    <span class="fn">web::canvas_fill_rect</span>(<span class="num">0.0</span>, <span class="num">0.0</span>,
+        <span class="fn">@toFloat</span>((GRID <span class="op">*</span> CELL)),
+        <span class="fn">@toFloat</span>((GRID <span class="op">*</span> CELL)));
     <span class="cm"># Snake head</span>
-    <span class="op">&</span><span class="fn">cell</span> head_x, head_y, <span class="num">63</span>, <span class="num">185</span>, <span class="num">80</span>;
+    <span class="fn">cell</span>(head_x, head_y, <span class="num">63</span>, <span class="num">185</span>, <span class="num">80</span>);
     <span class="cm"># Food</span>
-    <span class="op">&</span><span class="fn">cell</span> food_x, food_y, <span class="num">248</span>, <span class="num">81</span>, <span class="num">73</span>
+    <span class="fn">cell</span>(food_x, food_y, <span class="num">248</span>, <span class="num">81</span>, <span class="num">73</span>)
 };
 
 <span class="kw">@fn</span> <span class="fn">main</span> <span class="op">:=</span> {
     head_x <span class="op">=</span> <span class="num">10</span>; head_y <span class="op">=</span> <span class="num">10</span>;
     dir <span class="op">=</span> <span class="num">0</span>; alive <span class="op">=</span> <span class="num">1</span>; length <span class="op">=</span> <span class="num">3</span>;
-    <span class="op">&</span><span class="fn">draw</span>
+    <span class="fn">draw</span>()
 };
 
 <span class="kw">@fn</span> <span class="fn">tick</span> <span class="op">:=</span> {
-    <span class="op">&</span><span class="fn">@if</span> alive <span class="op">==</span> <span class="num">0</span>, { <span class="op">&</span><span class="fn">@return</span> };
+    <span class="fn">@if</span>(alive <span class="op">==</span> <span class="num">0</span>, { <span class="fn">@return</span>() });
     <span class="cm"># Move head</span>
-    <span class="op">&</span><span class="fn">@if</span> dir <span class="op">==</span> <span class="num">0</span>, { head_x <span class="op">=</span> head_x <span class="op">+</span> <span class="num">1</span> };
-    <span class="op">&</span><span class="fn">@if</span> dir <span class="op">==</span> <span class="num">1</span>, { head_y <span class="op">=</span> head_y <span class="op">+</span> <span class="num">1</span> };
-    <span class="op">&</span><span class="fn">@if</span> dir <span class="op">==</span> <span class="num">2</span>, { head_x <span class="op">=</span> head_x <span class="op">-</span> <span class="num">1</span> };
-    <span class="op">&</span><span class="fn">@if</span> dir <span class="op">==</span> <span class="num">3</span>, { head_y <span class="op">=</span> head_y <span class="op">-</span> <span class="num">1</span> };
+    <span class="fn">@if</span>(dir <span class="op">==</span> <span class="num">0</span>, { head_x <span class="op">=</span> head_x <span class="op">+</span> <span class="num">1</span> });
+    <span class="fn">@if</span>(dir <span class="op">==</span> <span class="num">1</span>, { head_y <span class="op">=</span> head_y <span class="op">+</span> <span class="num">1</span> });
+    <span class="fn">@if</span>(dir <span class="op">==</span> <span class="num">2</span>, { head_x <span class="op">=</span> head_x <span class="op">-</span> <span class="num">1</span> });
+    <span class="fn">@if</span>(dir <span class="op">==</span> <span class="num">3</span>, { head_y <span class="op">=</span> head_y <span class="op">-</span> <span class="num">1</span> });
     <span class="cm"># Wall collision</span>
-    <span class="op">&</span><span class="fn">@if</span> (head_x <span class="op">&lt;</span> <span class="num">0</span>) <span class="op">||</span> (head_x <span class="op">&gt;=</span> GRID), { alive <span class="op">=</span> <span class="num">0</span>; <span class="op">&</span><span class="fn">@return</span> };
-    <span class="op">&</span><span class="fn">@if</span> (head_y <span class="op">&lt;</span> <span class="num">0</span>) <span class="op">||</span> (head_y <span class="op">&gt;=</span> GRID), { alive <span class="op">=</span> <span class="num">0</span>; <span class="op">&</span><span class="fn">@return</span> };
-    <span class="cm"># Food pickup</span>
-    <span class="op">&</span><span class="fn">@if</span> (head_x <span class="op">==</span> food_x) <span class="op">&amp;&amp;</span> (head_y <span class="op">==</span> food_y), {
+    <span class="fn">@if</span>((head_x <span class="op">&lt;</span> <span class="num">0</span>) <span class="op">||</span> (head_x <span class="op">&gt;=</span> GRID), { alive <span class="op">=</span> <span class="num">0</span>; <span class="fn">@return</span>() });
+    <span class="fn">@if</span>((head_y <span class="op">&lt;</span> <span class="num">0</span>) <span class="op">||</span> (head_y <span class="op">&gt;=</span> GRID), { alive <span class="op">=</span> <span class="num">0</span>; <span class="fn">@return</span>() });
+    <span class="cm"># Food pickup (nested @if — there is no && operator)</span>
+    <span class="fn">@if</span>(head_x <span class="op">==</span> food_x, { <span class="fn">@if</span>(head_y <span class="op">==</span> food_y, {
         length <span class="op">=</span> length <span class="op">+</span> <span class="num">1</span>;
         food_x <span class="op">=</span> (food_x <span class="op">+</span> <span class="num">7</span>) <span class="op">%</span> GRID;
         food_y <span class="op">=</span> (food_y <span class="op">+</span> <span class="num">13</span>) <span class="op">%</span> GRID
-    };
-    <span class="op">&</span><span class="fn">draw</span>
+    }) });
+    <span class="fn">draw</span>()
 };
 
-<span class="kw">@fn</span> <span class="fn">handle_key</span> key<span class="op">:</span><span class="ty">Int</span> <span class="op">:=</span> {
-    <span class="op">&</span><span class="fn">@if</span> key <span class="op">==</span> <span class="num">37</span>, { dir <span class="op">=</span> <span class="num">2</span> };  <span class="cm"># ←</span>
-    <span class="op">&</span><span class="fn">@if</span> key <span class="op">==</span> <span class="num">38</span>, { dir <span class="op">=</span> <span class="num">3</span> };  <span class="cm"># ↑</span>
-    <span class="op">&</span><span class="fn">@if</span> key <span class="op">==</span> <span class="num">39</span>, { dir <span class="op">=</span> <span class="num">0</span> };  <span class="cm"># →</span>
-    <span class="op">&</span><span class="fn">@if</span> key <span class="op">==</span> <span class="num">40</span>, { dir <span class="op">=</span> <span class="num">1</span> }   <span class="cm"># ↓</span>
+<span class="op">\\</span> <span class="fn">handle_key</span> (<span class="ty">Int</span>)
+<span class="kw">@fn</span> <span class="fn">handle_key</span> key <span class="op">:=</span> {
+    <span class="fn">@if</span>(key <span class="op">==</span> <span class="num">37</span>, { dir <span class="op">=</span> <span class="num">2</span> });  <span class="cm"># ←</span>
+    <span class="fn">@if</span>(key <span class="op">==</span> <span class="num">38</span>, { dir <span class="op">=</span> <span class="num">3</span> });  <span class="cm"># ↑</span>
+    <span class="fn">@if</span>(key <span class="op">==</span> <span class="num">39</span>, { dir <span class="op">=</span> <span class="num">0</span> });  <span class="cm"># →</span>
+    <span class="fn">@if</span>(key <span class="op">==</span> <span class="num">40</span>, { dir <span class="op">=</span> <span class="num">1</span> })   <span class="cm"># ↓</span>
 };
 
 <span class="kw">@export</span> main;
diff --git a/playground/playground/modules-plan.html b/playground/playground/modules-plan.html
index 97d93d2b..722f3ba2 100644
--- a/playground/playground/modules-plan.html
+++ b/playground/playground/modules-plan.html
@@ -340,13 +340,13 @@ <h2>Goal</h2>
   <div class="goal-box">
     <div class="goal-item old">
       <span class="goal-label">Before (Round 45)</span>
-      @extern web_console_log_str ptr:String;<br>
-      &amp;web_console_log_str result;
+      \\ @extern web_console_log_str (String) -> Void;<br>
+      web_console_log_str(result);
     </div>
     <div class="goal-item arrow">→</div>
     <div class="goal-item new">
       <span class="goal-label">After (Round 46)</span>
-      &amp;web::console_log result;
+      web::console_log(result);
     </div>
   </div>
 
@@ -389,7 +389,7 @@ <h2>Design Decisions</h2>
     <div class="decision-body">
       <p>
         No <code>@use</code> declaration required. The namespace in the call site
-        <strong>is</strong> the import — <code>&amp;web::console_log</code> auto-resolves
+        <strong>is</strong> the import — <code>web::console_log</code> auto-resolves
         the <code>web</code> module. Namespaces must always be written in full;
         there is no aliasing (<code>use Draw as D</code> is a non-goal for this round).
         Compiler error if the namespace does not match any registered module.
@@ -468,35 +468,35 @@ <h3 style="margin-top:20px">Module file format</h3>
     the module name. Inside, functions are declared without the module prefix:
   </p>
 
-  <pre><span class="cmt">; src/strata/modules/web.si  — the built-in web:: environment module</span>
-<span class="cmt">; Functions here become (import "web" "name" …) in WAT.</span>
+  <pre><span class="cmt"># src/strata/modules/web.si  — the built-in web:: environment module</span>
+<span class="cmt"># Functions here become (import "web" "name" …) in WAT.</span>
 
-<span class="kw">@extern</span> <span class="fn">console_log</span>     v:<span class="type">Int</span>;
-<span class="kw">@extern</span> <span class="fn">console_log_f</span>   v:<span class="type">Float</span>;
-<span class="kw">@extern</span> <span class="fn">console_log_str</span> ptr:<span class="type">String</span>;
-<span class="kw">@extern</span> <span class="fn">console_error</span>   v:<span class="type">Int</span>;
-<span class="kw">@extern</span> <span class="fn">console_warn</span>    v:<span class="type">Int</span>;</pre>
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_log</span>     (<span class="type">Int</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_log_f</span>   (<span class="type">Float</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_log_str</span> (<span class="type">String</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_error</span>   (<span class="type">Int</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_warn</span>    (<span class="type">Int</span>) -> <span class="type">Void</span>;</pre>
 
-  <pre><span class="cmt">; modules/Draw.si  — a hypothetical third-party drawing module</span>
-<span class="cmt">; Host must provide { Draw: { clear, fill_rect, … } } in the WASM import object.</span>
+  <pre><span class="cmt"># modules/Draw.si  — a hypothetical third-party drawing module</span>
+<span class="cmt"># Host must provide { Draw: { clear, fill_rect, … } } in the WASM import object.</span>
 
-<span class="kw">@extern</span> <span class="fn">clear</span>      () -> <span class="type">Void</span>;
-<span class="kw">@extern</span> <span class="fn">fill_rect</span>  (x:<span class="type">Int</span>, y:<span class="type">Int</span>, w:<span class="type">Int</span>, h:<span class="type">Int</span>) -> <span class="type">Void</span>;
-<span class="kw">@extern</span> <span class="fn">set_color</span>  (r:<span class="type">Int</span>, g:<span class="type">Int</span>, b:<span class="type">Int</span>) -> <span class="type">Void</span>;</pre>
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">clear</span>      () -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">fill_rect</span>  (<span class="type">Int</span>, <span class="type">Int</span>, <span class="type">Int</span>, <span class="type">Int</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">set_color</span>  (<span class="type">Int</span>, <span class="type">Int</span>, <span class="type">Int</span>) -> <span class="type">Void</span>;</pre>
 
   <h3 style="margin-top:20px">Calling a module function</h3>
   <p>In user Silicon code, no extern declaration is needed — just use the namespaced call:</p>
-  <pre><span class="kw">@let</span> <span class="fn">greet</span> msg:<span class="type">String</span> := {
-    <span class="kw">@local</span> result := (<span class="str">'Hello, '</span> ++ msg);
-    &amp;<span class="ns">web</span>::<span class="fn">console_log_str</span> result;   <span class="cmt">; no @extern needed — compiler reads web.si</span>
+  <pre><span class="kw">@fn</span> <span class="fn">greet</span> msg := {
+    result := (<span class="str">'Hello, '</span> ++ msg);
+    <span class="ns">web</span>::<span class="fn">console_log_str</span>(result);   <span class="cmt"># no @extern needed — compiler reads web.si</span>
     result
 };</pre>
 
   <div class="callout info">
     <strong>Grammar note:</strong> The Silicon grammar's <code>namespace</code> rule already
     handles <code>web::console_log_str</code> via the <code>("::" | ".") identifier</code>
-    repetition. And <code>FunctionCall = "&amp;" FunctionCallBody</code> already accepts a
-    namespace as the callee. <strong>No grammar changes are needed.</strong>
+    repetition. And the always-parenthesised call form <code>ExprEnd = Primary { CallSuffix }</code>
+    already accepts a namespace as the callee. <strong>No grammar changes are needed.</strong>
   </div>
 </section>
 
@@ -554,12 +554,12 @@ <h2>Implementation Steps</h2>
           collect <code>@extern</code> nodes and extract their name and type signature via the
           same <code>siliconTypeNameToWasm</code> helper already used in <code>lower.ts</code>.
         </p>
-        <pre><span class="cmt">; src/strata/modules/web.si</span>
-<span class="kw">@extern</span> <span class="fn">console_log</span>     v:<span class="type">Int</span>;
-<span class="kw">@extern</span> <span class="fn">console_log_f</span>   v:<span class="type">Float</span>;
-<span class="kw">@extern</span> <span class="fn">console_log_str</span> ptr:<span class="type">String</span>;
-<span class="kw">@extern</span> <span class="fn">console_error</span>   v:<span class="type">Int</span>;
-<span class="kw">@extern</span> <span class="fn">console_warn</span>    v:<span class="type">Int</span>;</pre>
+        <pre><span class="cmt"># src/strata/modules/web.si</span>
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_log</span>     (<span class="type">Int</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_log_f</span>   (<span class="type">Float</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_log_str</span> (<span class="type">String</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_error</span>   (<span class="type">Int</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">console_warn</span>    (<span class="type">Int</span>) -> <span class="type">Void</span>;</pre>
       </div>
       <div class="dep-note">depends on step 1 (ModuleRegistry type)</div>
     </div>
@@ -629,7 +629,7 @@ <h2>Implementation Steps</h2>
       </div>
       <div class="step-body">
         <p>
-          When codegen sees <code>&amp;web::console_log_str msg</code>, the callee namespace
+          When codegen sees <code>web::console_log_str(msg)</code>, the callee namespace
           path is <code>['web', 'console_log_str']</code>. Look up <code>web</code> in the
           module registry → found as an env module → look up <code>console_log_str</code> →
           get its signature → emit <code>(import "web" "console_log_str" (func $web__console_log_str (param i32)))</code>.
@@ -639,7 +639,7 @@ <h2>Implementation Steps</h2>
           (double underscore avoids collision with user-defined functions). The call site
           emits <code>(call $web__console_log_str …)</code>.
         </p>
-        <pre><span class="cmt">; emitted WAT for &amp;web::console_log_str result</span>
+        <pre><span class="cmt">; emitted WAT for web::console_log_str(result)</span>
 (import <span class="str">"web"</span> <span class="str">"console_log_str"</span> (func $web__console_log_str (param i32)))
 …
 (call $web__console_log_str (local.get $result))</pre>
@@ -661,15 +661,15 @@ <h2>Implementation Steps</h2>
           web externs inline. After this step those go away — the compiler reads <code>web.si</code>
           automatically.
         </p>
-        <pre><span class="diff-rem">- @extern web_console_log_str ptr:String;</span>
-<span class="diff-rem">- @extern web_console_log_f   v:Float;</span>
+        <pre><span class="diff-rem">\\ @extern web_console_log_str (String) -> Void;</span>
+<span class="diff-rem">\\ @extern web_console_log_f   (Float) -> Void;</span>
 <span class="diff-ctx">
-</span><span class="diff-ctx">  @let greet msg:String := {</span>
-<span class="diff-ctx">      @local result := ('Hello, ' ++ msg);</span>
-<span class="diff-rem">-     &amp;web_console_log_str result;</span>
-<span class="diff-add">+     &amp;web::console_log_str result;</span>
-<span class="diff-ctx">      result</span>
-<span class="diff-ctx">  };</span></pre>
+</span><span class="diff-ctx">@fn greet msg := {</span>
+<span class="diff-ctx">    result := ('Hello, ' ++ msg);</span>
+<span class="diff-rem">    web_console_log_str(result);</span>
+<span class="diff-add">    web::console_log_str(result);</span>
+<span class="diff-ctx">    result</span>
+<span class="diff-ctx">};</span></pre>
         <p>
           Any e2e or integration tests that use <code>web_*</code> extern declarations need the
           same treatment.
@@ -714,15 +714,15 @@ <h2>Implementation Steps</h2>
           Demonstrate the module system with a hypothetical <code>Draw</code> module.
           This is documentation / test fixture only — no compiler changes.
         </p>
-        <pre><span class="cmt">; modules/Draw.si  — dropped in by the user, no install step needed</span>
-<span class="kw">@extern</span> <span class="fn">clear</span>      () -> <span class="type">Void</span>;
-<span class="kw">@extern</span> <span class="fn">fill_rect</span>  (x:<span class="type">Int</span>, y:<span class="type">Int</span>, w:<span class="type">Int</span>, h:<span class="type">Int</span>) -> <span class="type">Void</span>;
-<span class="kw">@extern</span> <span class="fn">set_color</span>  (r:<span class="type">Int</span>, g:<span class="type">Int</span>, b:<span class="type">Int</span>) -> <span class="type">Void</span>;</pre>
-        <pre><span class="cmt">; main.si — user code using the Draw module</span>
-<span class="kw">@let</span> <span class="fn">render</span> _ := {
-    &amp;<span class="ns">Draw</span>::<span class="fn">clear</span>;
-    &amp;<span class="ns">Draw</span>::<span class="fn">set_color</span> 255, 128, 0;
-    &amp;<span class="ns">Draw</span>::<span class="fn">fill_rect</span> 10, 10, 200, 100;
+        <pre><span class="cmt"># modules/Draw.si  — dropped in by the user, no install step needed</span>
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">clear</span>      () -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">fill_rect</span>  (<span class="type">Int</span>, <span class="type">Int</span>, <span class="type">Int</span>, <span class="type">Int</span>) -> <span class="type">Void</span>;
+<span class="op">\\</span> <span class="kw">@extern</span> <span class="fn">set_color</span>  (<span class="type">Int</span>, <span class="type">Int</span>, <span class="type">Int</span>) -> <span class="type">Void</span>;</pre>
+        <pre><span class="cmt"># main.si — user code using the Draw module</span>
+<span class="kw">@fn</span> <span class="fn">render</span> _ := {
+    <span class="ns">Draw</span>::<span class="fn">clear</span>();
+    <span class="ns">Draw</span>::<span class="fn">set_color</span>(255, 128, 0);
+    <span class="ns">Draw</span>::<span class="fn">fill_rect</span>(10, 10, 200, 100);
 };</pre>
         <p>
           The JS host provides <code>{ Draw: { clear: …, fill_rect: …, set_color: … } }</code>
@@ -790,7 +790,7 @@ <h2>File Change Summary</h2>
       <tr>
         <td>playground/index.html</td>
         <td><span class="tag rename">rename</span></td>
-        <td>Remove inline <code>@extern web_*</code>; change call sites to <code>&amp;web::*</code></td>
+        <td>Remove inline <code>@extern web_*</code>; change call sites to <code>web::*</code></td>
       </tr>
       <tr>
         <td>e2e / test fixtures</td>
diff --git a/playground/playground/plan.html b/playground/playground/plan.html
index 6b980741..e3ca2271 100644
--- a/playground/playground/plan.html
+++ b/playground/playground/plan.html
@@ -439,14 +439,14 @@ <h2>Implementation Steps</h2>
           is an <em>echo</em> — the function receives a String pointer and returns it unchanged.
           This proves the round-trip without requiring string manipulation in Silicon.
         </p>
-        <pre><span class="diff-rem">-@let greet n:Int := {</span>
-<span class="diff-rem">-    &amp;web_console_log_str 'Hello, World!';</span>
-<span class="diff-rem">-    n</span>
-<span class="diff-rem">-};</span>
-<span class="diff-add">+@let greet msg:String := {</span>
-<span class="diff-add">+    &amp;web_console_log_str msg;</span>
-<span class="diff-add">+    msg</span>
-<span class="diff-add">+};</span></pre>
+        <pre><span class="diff-rem">@fn greet n := {</span>
+<span class="diff-rem">    web_console_log_str('Hello, World!');</span>
+<span class="diff-rem">    n</span>
+<span class="diff-rem">};</span>
+<span class="diff-add">@fn greet msg := {</span>
+<span class="diff-add">    web_console_log_str(msg);</span>
+<span class="diff-add">    msg</span>
+<span class="diff-add">};</span></pre>
         <p>
           The WASM signature becomes <code>(param i32) (result i32)</code> — the pointer goes in
           and back out. JS writes the string before the call and reads the string after.
@@ -629,8 +629,10 @@ <h2>Implementation Steps</h2>
         <pre><span class="cmt"># src/strata/strings.si</span>
 <span class="cmt"># String operator strata for Silicon.</span>
 
-@stratum_operator Concat (<span class="str">'++'</span>, Node) :=
-    &amp;str_concat a, b;
+@stratum Concat := {
+    Compiler::register::operator(<span class="str">'++'</span>);
+    str_concat(a, b)
+};
 <span class="cmt"># `a` and `b` are the left- and right-hand operands injected by the elaborator.</span>
 <span class="cmt"># str_concat is resolved to $str_concat in std.wat at link time.</span></pre>
         <p>
@@ -658,7 +660,7 @@ <h2>Implementation Steps</h2>
       <div class="step-body">
         <p>
           The current strata loader recognises <code>WASM::opcode</code> and <code>IR::kind</code>
-          tokens in stratum bodies. To support calls like <code>&amp;str_concat a, b</code>, the
+          tokens in stratum bodies. To support calls like <code>str_concat(a, b)</code>, the
           loader must also handle plain Silicon function-call syntax and emit the appropriate IR
           <code>Call</code> node (or WAT <code>call $str_concat</code>) during expansion.
         </p>
@@ -686,7 +688,7 @@ <h2>Implementation Steps</h2>
         <p>
           This change is additive — existing WASM intrinsic strata continue to work unchanged.
           The parser for <code>.si</code> stratum files just needs to recognise
-          <code>&amp;fnName args…</code> as a <code>FunctionCall</code> node alongside the
+          <code>fnName(args…)</code> as a <code>FunctionCall</code> node alongside the
           existing <code>WASM::opcode</code> and <code>IR::kind</code> forms.
         </p>
       </div>
@@ -705,18 +707,18 @@ <h2>Implementation Steps</h2>
           Once steps 7–9 are complete, the playground example can produce a real greeting by
           concatenating the literal prefix <code>'Hello, '</code> with the caller-supplied name.
         </p>
-        <pre><span class="diff-rem">-@let greet msg:String := {</span>
-<span class="diff-rem">-    &amp;web_console_log_str msg;</span>
-<span class="diff-rem">-    msg</span>
-<span class="diff-rem">-};</span>
-<span class="diff-add">+@let greet msg:String := {</span>
-<span class="diff-add">+    <span class="kw">let</span> result := (<span class="str">'Hello, '</span> ++ msg);</span>
-<span class="diff-add">+    &amp;web_console_log_str result;</span>
-<span class="diff-add">+    result</span>
-<span class="diff-add">+};</span></pre>
+        <pre><span class="diff-rem">@fn greet msg := {</span>
+<span class="diff-rem">    web_console_log_str(msg);</span>
+<span class="diff-rem">    msg</span>
+<span class="diff-rem">};</span>
+<span class="diff-add">@fn greet msg := {</span>
+<span class="diff-add">    result := (<span class="str">'Hello, '</span> ++ msg);</span>
+<span class="diff-add">    web_console_log_str(result);</span>
+<span class="diff-add">    result</span>
+<span class="diff-add">};</span></pre>
         <p>
           The elaborator rewrites <code>'Hello, ' ++ msg</code> into
-          <code>&amp;str_concat 'Hello, ', msg</code>, which lowers to
+          <code>str_concat('Hello, ', msg)</code>, which lowers to
           <code>(call $str_concat (i32.const &lt;literal_ptr&gt;) (local.get $msg))</code> in WAT.
           The JS exports panel then reads the returned pointer with
           <code>webEnv.readString(result)</code> and displays <code>"Hello, Alice!"</code>.
@@ -773,7 +775,7 @@ <h2>Change Summary</h2>
       </tr>
       <tr>
         <td>src/strata/strings.si</td>
-        <td><strong>Define ++ as @stratum_operator Concat</strong> — body calls &amp;str_concat; no new WASM intrinsic needed (intrinsics map 1-to-1 to WASM ops only)</td>
+        <td><strong>Define ++ as @stratum_operator Concat</strong> — body calls str_concat; no new WASM intrinsic needed (intrinsics map 1-to-1 to WASM ops only)</td>
         <td>8</td>
       </tr>
       <tr>