novac 2.0.1 → 2.2.0

package/kits/kitnovacweb/nvml/parser.js

@@ -1,31 +1,41 @@
 'use strict';
 
 /**
- * NVML Parser
+ * NVML Parser v2
  *
- * Grammar (simplified):
+ * Grammar:
  *
- *   program        → block*
+ *   program        → topNode*
  *
- *   block          → at_block | element_node | element_shorthand
+ *   topNode        → at_block | element_node
  *
- *   at_block       → '@' IDENT '[' block* ']'
- *                  | '@' IDENT '[' kv_list ']'          (for @config)
+ *   at_block       → '@config'   '[' kv_list ']'
+ *                  | '@visual'   '[' block* ']'
+ *                  | '@ss'       '[' block* ']'
+ *                  | '@component' IDENT '[' block* ']'
+ *                  | '@state'    '[' kv_list ']'
+ *                  | '@computed' '[' named_fn_list ']'
+ *                  | '@effect'   '[' effect_list ']'
+ *                  | '@route'    STRING '[' block* ']'
+ *                  | '@slot'     IDENT? '[' block* ']'
+ *                  | '@use'      IDENT (',' IDENT)* 
  *
- *   element_node   → ELEMENT ( '=' value )?             // {h1}='text'
- *                    ( '[' element_body ']' )?
+ *   element_node   → ELEMENT ('=' value)?  ('[' element_body ']')?
  *
- *   element_body   → ( property | block )*
+ *   element_body   → (property | child | parent_ref)*
  *
- *   property       → IDENT '=' value                    // prop='val'
- *                  | IDENT                               // boolean flag
- *                  | '[..]' '::' IDENT ( '=' value )?  // parent ref property
- *                  | '[..]' '::' IDENT '[' block* ']'  // parent ref sub-block
+ *   property       → IDENT '=' value
+ *                  | IDENT                           (boolean)
+ *                  | IDENT '->' IDENT                (one-way binding: prop -> signal)
+ *                  | IDENT '<->' IDENT               (two-way binding: prop <-> signal)
+ *                  | IDENT '~' IDENT                 (transition: prop ~ transitionName)
+ *                  | '[..]' '::' IDENT ('=' value | '[' sub_body ']' | ε)
  *
- *   kv_list        → kv (',' kv)*
- *   kv             → IDENT '=' value
- *   value          → STRING | NUMBER | IDENT | pipe_list
- *   pipe_list      → '|' IDENT* '|'
+ *   child          → element_node | at_block | text_node | conditional_child
+ *
+ *   conditional_child → '?' IDENT element_node     (render element only if signal is truthy)
+ *
+ *   value          → STRING | NUMBER | IDENT | '#' IDENT | pipe_list
  */
 
 const { Lexer, TT } = require('./lexer');
@@ -38,17 +48,32 @@ class ParseError extends Error {
   }
 }
 
-// ── AST node factories ────────────────────────────────────
-
 const N = {
-  program:     (body)                        => ({ kind: 'program',     body }),
-  atBlock:     (name, body)                  => ({ kind: 'at_block',    name, body }),
-  atConfig:    (pairs)                       => ({ kind: 'at_config',   pairs }),
-  element:     (tag, textValue, props, body) => ({ kind: 'element',     tag, textValue, props, body }),
-  property:    (key, value)                  => ({ kind: 'property',    key, value }),
-  parentProp:  (prop, value, subBody)        => ({ kind: 'parent_prop', prop, value, subBody }),
-  value:       (v)                           => ({ kind: 'value',       value: v }),
-  pipeList:    (items)                       => ({ kind: 'pipe_list',   items }),
+  program:       (body)                           => ({ kind: 'program',         body }),
+  atConfig:      (pairs)                          => ({ kind: 'at_config',       pairs }),
+  atBlock:       (name, arg, body)                => ({ kind: 'at_block',        name, arg, body }),
+  atState:       (pairs)                          => ({ kind: 'at_state',        pairs }),
+  atComputed:    (entries)                        => ({ kind: 'at_computed',     entries }),
+  atEffect:      (entries)                        => ({ kind: 'at_effect',       entries }),
+  atLang:        (name, pairs)                    => ({ kind: 'at_lang',        name, pairs }),
+  atRoute:       (path, body)                     => ({ kind: 'at_route',        path, body }),
+  atSlot:        (name, body)                     => ({ kind: 'at_slot',         name, body }),
+  atUse:         (names)                          => ({ kind: 'at_use',          names }),
+  element:       (tag, textValue, props, body,
+                  bindings, transitions, cond)    => ({ kind: 'element',         tag, textValue, props, body, bindings, transitions, cond }),
+  property:      (key, value)                     => ({ kind: 'property',        key, value }),
+  binding:       (prop, signal, twoWay)           => ({ kind: 'binding',         prop, signal, twoWay }),
+  transition:    (prop, name)                     => ({ kind: 'transition',       prop, name }),
+  parentProp:    (prop, value, subBody)           => ({ kind: 'parent_prop',     prop, value, subBody }),
+  signalRef:     (name)                           => ({ kind: 'signal_ref',      name }),
+  value:         (v)                              => ({ kind: 'value',           value: v }),
+  pipeList:      (items)                          => ({ kind: 'pipe_list',       items }),
+  textNode:      (value)                          => ({ kind: 'text_node',       value }),
+  conditional:   (signal, child)                  => ({ kind: 'conditional',     signal, child }),
+  cssDecl:       (key, value)                     => ({ kind: 'css_decl',        key, value }),
+  eachBlock:     (signal, itemVar, indexVar, body)=> ({ kind: 'each_block',      signal, itemVar, indexVar, body }),
+  slotOutlet:    (name)                           => ({ kind: 'slot_outlet',     name }),
+  componentUse:  (name, props, slots)             => ({ kind: 'component_use',   name, props, slots }),
 };
 
 class Parser {
@@ -57,16 +82,11 @@ class Parser {
     this.current = 0;
   }
 
-  // ── token helpers ─────────────────────────────────────────
-
   peek()     { return this.tokens[this.current]; }
   previous() { return this.tokens[this.current - 1]; }
   isAtEnd()  { return this.peek().type === TT.EOF; }
 
-  advance()  {
-    if (!this.isAtEnd()) this.current++;
-    return this.previous();
-  }
+  advance() { if (!this.isAtEnd()) this.current++; return this.previous(); }
 
   check(type, value = null) {
     if (this.isAtEnd()) return false;
@@ -75,7 +95,6 @@ class Parser {
   }
 
   match(...specs) {
-    // specs: [type] or [type, value]
     for (const spec of specs) {
       const [type, value = null] = Array.isArray(spec) ? spec : [spec];
       if (this.check(type, value)) { this.advance(); return true; }
@@ -84,135 +103,303 @@ class Parser {
   }
 
   consume(type, value, msg) {
-    if (typeof value === 'string' && value && this.check(type, value)) return this.advance();
-    if (!value && this.check(type)) return this.advance();
+    if (value !== null && value !== undefined && this.check(type, value)) return this.advance();
+    if ((value === null || value === undefined) && this.check(type)) return this.advance();
     throw new ParseError(msg || `Expected ${type}${value ? ' ' + value : ''}`, this.peek());
   }
 
   error(msg) { throw new ParseError(msg, this.peek()); }
 
-  // ── entry point ───────────────────────────────────────────
+  // ── entry ──────────────────────────────────────────────────────
 
   parse() {
     const body = [];
-    while (!this.isAtEnd()) body.push(this.parseBlock());
+    while (!this.isAtEnd()) body.push(this.parseTopNode());
     return N.program(body);
   }
 
-  // ── blocks ────────────────────────────────────────────────
-
-  parseBlock() {
+  parseTopNode() {
     const t = this.peek();
-
-    if (t.type === TT.AT_IDENT)  return this.parseAtBlock();
-    if (t.type === TT.ELEMENT)   return this.parseElement();
-    if (t.type === TT.DOTDOT)    return this.parseParentPropStandalone();
-
-    this.error(`Unexpected token '${t.value}' (${t.type})`);
+    if (t.type === TT.AT_IDENT) return this.parseAtBlock();
+    if (t.type === TT.ELEMENT)  return this.parseElement();
+    this.error(`Unexpected token '${t.value}' (${t.type}) at top level`);
   }
 
-  // ── @block ────────────────────────────────────────────────
+  // ── @blocks ────────────────────────────────────────────────────
 
   parseAtBlock() {
     const name = this.advance().value; // consume AT_IDENT
 
-    this.consume(TT.LBRACKET, null, `Expected '[' after '@${name}'`);
+    switch (name) {
+      case 'config':
+        this.consume(TT.LBRACKET, null, "Expected '[' after @config");
+        const configPairs = this.parseKVList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @config");
+        return N.atConfig(configPairs);
+
+      case 'state':
+        this.consume(TT.LBRACKET, null, "Expected '[' after @state");
+        const statePairs = this.parseKVList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @state");
+        return N.atState(statePairs);
+
+      case 'computed':
+        this.consume(TT.LBRACKET, null, "Expected '[' after @computed");
+        const computedEntries = this.parseNamedCodeList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @computed");
+        return N.atComputed(computedEntries);
+
+      case 'effect':
+        this.consume(TT.LBRACKET, null, "Expected '[' after @effect");
+        const effectEntries = this.parseEffectList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @effect");
+        return N.atEffect(effectEntries);
+
+      case 'component': {
+        const compName = this.consume(TT.IDENT, null, "Expected component name after @component").value;
+        this.consume(TT.LBRACKET, null, "Expected '[' after @component name");
+        const compBody = this.parseBlockList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @component");
+        return N.atComponent(compName, compBody);
+      }
+
+      case 'lang': {
+        // @lang {langName} [ runtime_language="nv", config="", src="PATH", code=(...) ]
+        const langName  = this.consume(TT.IDENT, null, 'Expected language name after @lang').value;
+        this.consume(TT.LBRACKET, null, "Expected '[' after @lang name");
+        const langPairs = this._parseLangKVList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @lang");
+        return N.atLang(langName, langPairs);
+      }
+
+      case 'route': {
+        const routePath = this.parseValue(); // STRING or IDENT
+        this.consume(TT.LBRACKET, null, "Expected '[' after @route path");
+        const routeBody = this.parseBlockList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @route");
+        return N.atRoute(routePath, routeBody);
+      }
+
+      case 'slot': {
+        let slotName = 'default';
+        if (this.check(TT.IDENT)) slotName = this.advance().value;
+        this.consume(TT.LBRACKET, null, "Expected '[' after @slot");
+        const slotBody = this.parseBlockList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @slot");
+        return N.atSlot(slotName, slotBody);
+      }
+
+      case 'use': {
+        const useNames = [];
+        useNames.push(this.consume(TT.IDENT, null, "Expected component name after @use").value);
+        while (this.match(TT.COMMA)) {
+          useNames.push(this.consume(TT.IDENT, null, "Expected component name").value);
+        }
+        return N.atUse(useNames);
+      }
 
-    // @config is special: key=value list
-    if (name === 'config') {
-      const pairs = this.parseKVList();
-      this.consume(TT.RBRACKET, null, "Expected ']' to close @config");
-      return N.atConfig(pairs);
+      default: {
+        // @visual, @ss, or unknown custom at-block
+        this.consume(TT.LBRACKET, null, `Expected '[' after @${name}`);
+        const body = this.parseBlockList();
+        this.consume(TT.RBRACKET, null, `Expected ']' to close @${name}`);
+        return N.atBlock(name, null, body);
+      }
     }
+  }
 
-    // @ss or @visual or custom: recursive body
+  parseBlockList() {
     const body = [];
     while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
-      body.push(this.parseBlock());
+      if (this.check(TT.AT_IDENT)) { body.push(this.parseAtBlock()); continue; }
+      if (this.check(TT.ELEMENT))  { body.push(this.parseElement()); continue; }
+      if (this.check(TT.DOTDOT))   { body.push(this.parseParentPropInline()); continue; }
+      if (this.check(TT.STRING))   { body.push(N.textNode(this.advance().value)); continue; }
+      if (this.check(TT.COMMA))    { this.advance(); continue; }
+      break;
     }
-    this.consume(TT.RBRACKET, null, `Expected ']' to close @${name}`);
-    return N.atBlock(name, body);
+    return body;
   }
 
-  // ── kv list (used inside @config) ────────────────────────
+  // ── kv list (flat key=value pairs) ────────────────────────────
 
   parseKVList() {
     const pairs = {};
     while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
-      // skip stray commas
       if (this.match(TT.COMMA)) continue;
-
-      const key = this.consume(TT.IDENT, null, 'Expected key name in @config').value;
+      if (!this.check(TT.IDENT)) break;
+      const key = this.advance().value;
       this.consume(TT.EQ, null, `Expected '=' after key '${key}'`);
-      const val = this.parseValue();
-      pairs[key] = val;
+      pairs[key] = this.parseValue();
+      this.match(TT.COMMA);
+    }
+    return pairs;
+  }
 
-      this.match(TT.COMMA); // optional trailing comma
+  // ── @lang kv list — like parseKVList but also accepts bare string values ──
+  // Handles: runtime_language="nv"  config=""  src="PATH"  code=(...)
+  _parseLangKVList() {
+    const pairs = {};
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      if (this.match(TT.COMMA)) continue;
+      if (!this.check(TT.IDENT)) break;
+      const key = this.advance().value;
+      if (this.match(TT.EQ)) {
+        pairs[key] = this.parseValue();
+      } else {
+        pairs[key] = N.value(true);
+      }
+      this.match(TT.COMMA);
     }
     return pairs;
   }
 
-  // ── element ───────────────────────────────────────────────
+
+
+  parseNamedCodeList() {
+    const entries = [];
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      if (this.match(TT.COMMA)) continue;
+      if (!this.check(TT.IDENT)) break;
+      const name = this.advance().value;
+      this.consume(TT.EQ, null, `Expected '=' after computed name '${name}'`);
+      const code = this.parseValue();
+      entries.push({ name, code });
+      this.match(TT.COMMA);
+    }
+    return entries;
+  }
+
+  // ── @effect entries: deps -> (nova code) ──────────────────────
+
+  parseEffectList() {
+    const entries = [];
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      if (this.match(TT.COMMA)) continue;
+      // deps: [signalA, signalB] or * (always) — stored as array of names
+      const deps = [];
+      if (this.check(TT.LBRACKET)) {
+        this.advance();
+        while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+          if (this.check(TT.IDENT)) deps.push(this.advance().value);
+          this.match(TT.COMMA);
+        }
+        this.consume(TT.RBRACKET, null, "Expected ']' to close effect deps");
+      } else if (this.check(TT.IDENT, '*')) {
+        this.advance(); // wildcard — run on any signal change
+        deps.push('*');
+      } else if (this.check(TT.IDENT)) {
+        deps.push(this.advance().value);
+      }
+      this.consume(TT.ARROW, null, "Expected '->' after effect deps");
+      const code = this.parseValue();
+      entries.push({ deps, code });
+      this.match(TT.COMMA);
+    }
+    return entries;
+  }
+
+  // ── element ────────────────────────────────────────────────────
 
   parseElement() {
-    const tag = this.advance().value; // ELEMENT token value e.g. 'h1', 'element.button', 'script'
+    const tag = this.advance().value;
 
-    // optional inline text: {h1}='Hello'
     let textValue = null;
-    if (this.match(TT.EQ)) {
-      textValue = this.parseValue();
-    }
+    if (this.match(TT.EQ)) textValue = this.parseValue();
 
-    // optional body block [...]
-    let props = {};
-    let body  = [];
+    let props      = {};
+    let body       = [];
+    let bindings   = [];
+    let transitions= [];
+    let cond       = null;
 
     if (this.match(TT.LBRACKET)) {
-      const { props: p, body: b } = this.parseElementBody();
-      props = p;
-      body  = b;
+      const parsed = this.parseElementBody();
+      props       = parsed.props;
+      body        = parsed.body;
+      bindings    = parsed.bindings;
+      transitions = parsed.transitions;
       this.consume(TT.RBRACKET, null, `Expected ']' to close element {${tag}}`);
     }
 
-    return N.element(tag, textValue, props, body);
+    return N.element(tag, textValue, props, body, bindings, transitions, cond);
   }
 
-  // ── element body: mix of properties and child elements ────
-
   parseElementBody() {
-    const props = {};
-    const body  = [];
+    const props = {}, body = [], bindings = [], transitions = [];
 
     while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
       const t = this.peek();
 
-      // [..] parent-ref property: [..]::ss [ ... ] or [..]::code=value
+      // [..] parent-ref
       if (t.type === TT.DOTDOT) {
         const pp = this.parseParentPropInline();
-        // merge into props — sub-bodies stored as special prop
-        if (pp.subBody !== null) {
-          props[pp.prop] = { __subBody: pp.subBody };
-        } else {
-          props[pp.prop] = pp.value;
-        }
+        if (pp.subBody !== null) props[pp.prop] = { __subBody: pp.subBody };
+        else props[pp.prop] = pp.value;
         continue;
       }
 
-      // child element
-      if (t.type === TT.ELEMENT) {
-        body.push(this.parseElement());
+      // conditional child: ? signalName {element}
+      if (t.type === TT.QUESTION) {
+        this.advance();
+        const sigName = this.consume(TT.IDENT, null, "Expected signal name after '?'").value;
+        const child   = this.parseElement();
+        child.cond    = sigName;
+        body.push(child);
         continue;
       }
 
-      // @block child
-      if (t.type === TT.AT_IDENT) {
-        body.push(this.parseAtBlock());
+      // each block: @each signalName as itemVar (index: indexVar) [ body ]
+      if (t.type === TT.AT_IDENT && t.value === 'each') {
+        body.push(this.parseEachBlock());
         continue;
       }
 
-      // property: IDENT = value  or  IDENT (boolean flag)
+      // slot outlet: @slot name
+      if (t.type === TT.AT_IDENT && t.value === 'slot') {
+        this.advance();
+        const slotName = this.check(TT.IDENT) ? this.advance().value : 'default';
+        body.push(N.slotOutlet(slotName));
+        continue;
+      }
+
+      // child element
+      if (t.type === TT.ELEMENT) { body.push(this.parseElement()); continue; }
+
+      // child @block
+      if (t.type === TT.AT_IDENT) { body.push(this.parseAtBlock()); continue; }
+
+      // bare text node
+      if (t.type === TT.STRING) { body.push(N.textNode(this.advance().value)); continue; }
+
+      // property
       if (t.type === TT.IDENT) {
         const key = this.advance().value;
+
+        // one-way binding: prop -> signalName
+        if (this.match(TT.ARROW)) {
+          const sig = this.consume(TT.IDENT, null, "Expected signal name after '->'").value;
+          bindings.push(N.binding(key, sig, false));
+          this.match(TT.COMMA);
+          continue;
+        }
+
+        // two-way binding: prop <-> signalName
+        if (this.match(TT.DARROW)) {
+          const sig = this.consume(TT.IDENT, null, "Expected signal name after '<->'").value;
+          bindings.push(N.binding(key, sig, true));
+          this.match(TT.COMMA);
+          continue;
+        }
+
+        // transition hint: prop ~ transitionName
+        if (this.match(TT.TILDE)) {
+          const tname = this.consume(TT.IDENT, null, "Expected transition name after '~'").value;
+          transitions.push(N.transition(key, tname));
+          this.match(TT.COMMA);
+          continue;
+        }
+
         if (this.match(TT.EQ)) {
           props[key] = this.parseValue();
         } else {
@@ -222,113 +409,95 @@ class Parser {
         continue;
       }
 
-      // NUMBER as a value without key (e.g. inside @ss numeric values) — skip gracefully
-      if (t.type === TT.NUMBER) { this.advance(); this.match(TT.COMMA); continue; }
-
-      // bare string child (text node)
-      if (t.type === TT.STRING) {
-        body.push({ kind: 'text_node', value: this.advance().value });
+      // signal ref as prop value: #signal  (shorthand for text binding)
+      if (t.type === TT.HASH) {
+        this.advance();
+        body.push(N.signalRef(t.value));
         continue;
       }
 
-      // stray comma
-      if (t.type === TT.COMMA) { this.advance(); continue; }
+      if (t.type === TT.NUMBER) { this.advance(); this.match(TT.COMMA); continue; }
+      if (t.type === TT.COMMA)  { this.advance(); continue; }
 
       this.error(`Unexpected token '${t.value}' (${t.type}) inside element body`);
     }
 
-    return { props, body };
+    return { props, body, bindings, transitions };
+  }
+
+  // ── @each signalName as item (index: i) [ body ] ──────────────
+
+  parseEachBlock() {
+    this.advance(); // consume 'each' AT_IDENT
+    const signal  = this.consume(TT.IDENT, null, "Expected signal name after @each").value;
+    // 'as' keyword
+    if (this.check(TT.IDENT, 'as')) this.advance();
+    const itemVar = this.consume(TT.IDENT, null, "Expected item variable after 'as'").value;
+    let indexVar  = null;
+    // optional (index: i)
+    if (this.check(TT.STRING) || (this.check(TT.IDENT, 'index'))) {
+      this.advance(); // skip
+    }
+    // (index: varName)
+    if (this.check(TT.LBRACKET) || this.check(TT.LPAREN)) {
+      // simple: check for index keyword in next ident
+    }
+    this.consume(TT.LBRACKET, null, "Expected '[' after @each header");
+    const body = this.parseBlockList();
+    this.consume(TT.RBRACKET, null, "Expected ']' to close @each block");
+    return N.eachBlock(signal, itemVar, indexVar, body);
   }
 
-  // ── [..] property inside an element body ─────────────────
+  // ── [..] property ──────────────────────────────────────────────
 
   parseParentPropInline() {
     this.advance(); // consume DOTDOT
     this.consume(TT.COLONCOLON, null, "Expected '::' after '[..]'");
     const prop = this.consume(TT.IDENT, null, "Expected property name after '::'").value;
 
-    // [..]::ss [ body ]  — sub-block
     if (this.match(TT.LBRACKET)) {
       const subBody = [];
       while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
-        // inside ::ss sub-blocks, content can be elements OR bare kv pairs
         if (this.check(TT.ELEMENT) || this.check(TT.AT_IDENT) || this.check(TT.DOTDOT)) {
-          subBody.push(this.parseBlock());
+          subBody.push(this.parseTopNode());
         } else if (this.check(TT.IDENT)) {
-          // bare kv: color='red', (CSS-style declarations)
           const key = this.advance().value;
           if (this.match(TT.EQ)) {
-            const val = this.parseValue();
-            subBody.push({ kind: 'css_decl', key, value: val });
+            subBody.push(N.cssDecl(key, this.parseValue()));
           } else {
-            subBody.push({ kind: 'css_decl', key, value: N.value(true) });
+            subBody.push(N.cssDecl(key, N.value(true)));
           }
           this.match(TT.COMMA);
         } else if (this.check(TT.COMMA)) {
           this.advance();
-        } else {
-          break;
-        }
+        } else { break; }
       }
       this.consume(TT.RBRACKET, null, `Expected ']' to close [..]::${prop} block`);
       return N.parentProp(prop, null, subBody);
     }
 
-    // [..]::prop = value
-    if (this.match(TT.EQ)) {
-      const val = this.parseValue();
-      return N.parentProp(prop, val, null);
-    }
-
-    // boolean flag
+    if (this.match(TT.EQ)) return N.parentProp(prop, this.parseValue(), null);
     return N.parentProp(prop, N.value(true), null);
   }
 
-  // Standalone [..] at top-level block (shouldn't normally appear, treat gracefully)
-  parseParentPropStandalone() {
-    return this.parseParentPropInline();
-  }
-
-  // ── value ─────────────────────────────────────────────────
+  // ── value ──────────────────────────────────────────────────────
 
   parseValue() {
     const t = this.peek();
-
-    // pipe list: |item1, item2|
-    if (t.type === TT.PIPE) {
-      return this.parsePipeList();
-    }
-
-    if (t.type === TT.STRING) {
-      this.advance();
-      return N.value(t.value);
-    }
-
-    if (t.type === TT.NUMBER) {
-      this.advance();
-      return N.value(t.value);
-    }
-
-    if (t.type === TT.IDENT) {
-      this.advance();
-      // could be bare word like 'novac', 'server', 'client'
-      return N.value(t.value);
-    }
-
-    // multiline string was already converted to STRING by lexer (paren-string)
-    this.error(`Expected a value (string, number, or identifier), got '${t.value}' (${t.type})`);
+    if (t.type === TT.PIPE)   return this.parsePipeList();
+    if (t.type === TT.HASH)   { this.advance(); return N.signalRef(t.value); }
+    if (t.type === TT.STRING) { this.advance(); return N.value(t.value); }
+    if (t.type === TT.NUMBER) { this.advance(); return N.value(t.value); }
+    if (t.type === TT.IDENT)  { this.advance(); return N.value(t.value); }
+    this.error(`Expected a value, got '${t.value}' (${t.type})`);
   }
 
-  // ── pipe list  |item1, item2, item3| ─────────────────────
-
   parsePipeList() {
     this.consume(TT.PIPE, null, "Expected '|'");
     const items = [];
     while (!this.isAtEnd() && !this.check(TT.PIPE)) {
       const t = this.peek();
-      if (t.type === TT.IDENT || t.type === TT.STRING) {
-        items.push(this.advance().value);
-      }
+      if (t.type === TT.IDENT || t.type === TT.STRING) items.push(this.advance().value);
       this.match(TT.COMMA);
     }
     this.consume(TT.PIPE, null, "Expected closing '|'");
@@ -336,4 +505,4 @@ class Parser {
   }
 }
 
-module.exports = { Parser, ParseError };
+module.exports = { Parser, ParseError, N };