rip-lang 3.16.0 → 3.16.1

package/src/dts.js

@@ -36,11 +36,11 @@ export const INTRINSIC_TYPE_DECLS = [
   "type __RipAttrKeys<T> = { [K in keyof T]-?: K extends 'style' | 'classList' | 'className' | 'nodeValue' | 'textContent' | 'innerHTML' | 'innerText' | 'outerHTML' | 'outerText' | 'scrollLeft' | 'scrollTop' ? never : K extends `on${string}` | `aria${string}Element` | `aria${string}Elements` ? never : T[K] extends (...args: any[]) => any ? never : (<V>() => V extends Pick<T, K> ? 1 : 2) extends (<V>() => V extends { -readonly [P in K]: T[P] } ? 1 : 2) ? K : never }[keyof T] & string;",
   "type __RipEvents<K extends __RipTag> = { [E in keyof HTMLElementEventMap as `@${E}`]?: ((event: RipEvent<HTMLElementEventMap[E], __RipElementMap[K]>) => void) | null };",
   'type RipEvent<E extends Event, T extends EventTarget> = E & { readonly target: T; readonly currentTarget: T };',
-  'type __RipClassValue = string | boolean | null | undefined | Record<string, boolean> | __RipClassValue[];',
+  'type __RipClassValue = string | boolean | null | undefined | Record<string, boolean | null | undefined> | __RipClassValue[];',
   "type __RipProps<K extends __RipTag> = { [P in __RipAttrKeys<__RipElementMap[K]>]?: __RipElementMap[K][P] } & __RipEvents<K> & { ref?: string; class?: __RipClassValue | __RipClassValue[]; style?: string; [k: `data-${string}`]: any; [k: `aria-${string}`]: any };",
 ];
 
-export const INTRINSIC_FN_DECL = 'declare function __ripEl<K extends __RipTag>(tag: K, props?: __RipProps<K>): void;';
+export const INTRINSIC_FN_DECL = 'declare function __ripEl<K extends __RipTag>(tag: K, props?: __RipProps<K>): void;\ndeclare function __ripRoute<const T extends string>(s: T): T;';
 
 export const ARIA_TYPE_DECLS = [
   'type __RipAriaNavHandlers = { next?: () => void; prev?: () => void; first?: () => void; last?: () => void; select?: () => void; dismiss?: () => void; tab?: () => void; char?: () => void; };',
@@ -67,6 +67,17 @@ export const SIGNAL_FN = 'declare function __state<T>(value: T | Signal<T>): Sig
 export const COMPUTED_INTERFACE = 'interface Computed<T> { readonly value: T; read(): T; lock(): Computed<T>; free(): Computed<T>; kill(): T; }';
 export const COMPUTED_FN = 'declare function __computed<T>(fn: () => T): Computed<T>;';
 export const EFFECT_FN = 'declare function __effect(fn: () => void | (() => void)): () => void;';
+export const BATCH_FN = 'declare function __batch<T>(fn: () => T): T;';
+
+// Names destructured from `globalThis.__rip` in the source. The DTS
+// preamble and the post-compile `declare function` injection both need
+// to skip auto-declaring these names — the explicit binding shadows the
+// global and would otherwise trip TS2630.
+export function ripDestructuredNames(source) {
+  if (typeof source !== 'string') return new Set();
+  const inside = (source.match(/\{\s*([^}]*?)\s*\}\s*=\s*globalThis\.__rip\b/) || [])[1] || '';
+  return new Set(inside.split(',').map(s => s.trim().split(/[:\s]/)[0]).filter(Boolean));
+}
 
 // ============================================================================
 // emitTypes — generate .d.ts from annotated tokens + s-expression tree
@@ -82,7 +93,9 @@ export function emitTypes(tokens, sexpr = null, source = '') {
   let classFields = new Set(); // Track emitted field names to avoid duplicates
   let usesSignal = false;
   let usesComputed = false;
+  let usesBatch = false;
   let usesRipIntrinsicProps = false;
+  const explicitlyBound = ripDestructuredNames(source);
   const sourceLines = typeof source === 'string' ? source.split('\n') : [];
 
   // Pre-scan: detect reactive operators regardless of type annotations.
@@ -92,6 +105,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     const tag = tokens[i][0];
     if (tag === 'REACTIVE_ASSIGN') usesSignal = true;
     else if (tag === 'COMPUTED_ASSIGN') usesComputed = true;
+    else if (tag === 'IDENTIFIER' && tokens[i][1] === '__batch') usesBatch = true;
   }
 
   // Format { prop; prop } into multi-line block.  Only applies when the
@@ -195,7 +209,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           let type = tokens[j].data?.type;
           if (type) hasAnyType = true;
           let hasDefault = tokens[j + 1]?.[0] === '=';
-          props.push({ kind: 'rename', propName, localName, type: type ? expandSuffixes(type) : null, hasDefault });
+          props.push({ kind: 'rename', propName, localName, type: type ? tsType(type) : null, hasDefault });
           j++;
           if (hasDefault) j = skipDefault(tokens, j);
         }
@@ -208,7 +222,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let type = tokens[j].data?.type;
         if (type) hasAnyType = true;
         let hasDefault = tokens[j + 1]?.[0] === '=';
-        props.push({ kind: 'simple', propName: name, type: type ? expandSuffixes(type) : null, hasDefault });
+        props.push({ kind: 'simple', propName: name, type: type ? tsType(type) : null, hasDefault });
         j++;
         if (hasDefault) j = skipDefault(tokens, j);
         continue;
@@ -259,7 +273,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let name = tokens[j][1];
         let type = tokens[j].data?.type;
         names.push(name);
-        elemTypes.push(type ? expandSuffixes(type) : null);
+        elemTypes.push(type ? tsType(type) : null);
         if (type) hasAnyType = true;
       }
       j++;
@@ -308,8 +322,8 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           let name = tokens[j][1];
           let type = tokens[j].data?.type;
           let paramName = subclassConstructor ? `_${name}` : name;
-          params.push(type ? `${paramName}: ${expandSuffixes(type)}` : paramName);
-          if (type) fields.push({ name, type: expandSuffixes(type) });
+          params.push(type ? `${paramName}: ${tsType(type)}` : paramName);
+          if (type) fields.push({ name, type: tsType(type) });
           j++;
         }
         continue;
@@ -321,7 +335,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         if (tokens[j]?.[0] === 'IDENTIFIER') {
           let name = tokens[j][1];
           let type = tokens[j].data?.type;
-          params.push(type ? `...${name}: ${expandSuffixes(type)}` : `...${name}: any[]`);
+          params.push(type ? `...${name}: ${tsType(type)}` : `...${name}: any[]`);
           j++;
         }
         continue;
@@ -364,9 +378,9 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           hasDefault = true;
         }
 
-        let isOptional = hasDefault || tok.data?.predicate;
+        let isOptional = hasDefault || tok.data?.optional;
         if (paramType) {
-          params.push(`${paramName}${isOptional ? '?' : ''}: ${expandSuffixes(paramType)}`);
+          params.push(`${paramName}${isOptional ? '?' : ''}: ${tsType(paramType)}`);
         } else {
           params.push(paramName);
         }
@@ -486,7 +500,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let nameToken = ot[1]; // DEF is [0], name is [1]
         let { params: paramList } = collectParams(ot, 2);
         let returnType = nameToken.data?.returnType;
-        let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+        let ret = returnType ? `: ${tsType(returnType)}` : '';
         let declare = inClass ? '' : (exp ? '' : 'declare ');
         let typeParams = data.typeParams || '';
         if (inClass) {
@@ -498,7 +512,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let ext = data.extends ? ` extends ${data.extends}` : '';
         emitBlock(`${exp}interface ${data.name}${params}${ext} `, data.typeText || '{}', '');
       } else {
-        let typeText = expandSuffixes(data.typeText || '');
+        let typeText = tsType(data.typeText || '');
         emitBlock(`${exp}type ${data.name}${params} = `, typeText, ';');
       }
       continue;
@@ -594,7 +608,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
       if (!nameToken) continue;
       let fnName = nameToken[1];
       let returnType = nameToken.data?.returnType;
-      if (!returnType && nameToken.data?.await === true) returnType = 'void';
+      if (!returnType && nameToken.data?.bang === true) returnType = 'void';
       let typeParams = nameToken.data?.typeParams || '';
 
       let { params, endIdx } = collectParams(tokens, i + 2);
@@ -603,7 +617,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
       if (returnType || params.some(p => p.includes(':'))) {
         let exp = exported ? 'export ' : '';
         let declare = inClass ? '' : (exported ? '' : 'declare ');
-        let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+        let ret = returnType ? `: ${tsType(returnType)}` : '';
         let paramStr = params.join(', ');
         if (inClass) {
           lines.push(`${indent()}${fnName}${typeParams}(${paramStr})${ret};`);
@@ -664,7 +678,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           }
 
           if (returnType || params.some(p => p.includes(':'))) {
-            let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+            let ret = returnType ? `: ${tsType(returnType)}` : '';
             let paramStr = params.join(', ');
             // Emit field declarations for constructor @param:: type shorthand
             if (methodName === 'constructor' && fields.length) {
@@ -717,7 +731,12 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     //
     // The function-form is wrong inside bodies because it would create
     // a phantom global that shadows / collides with the actual local.
-    if (tag === 'IDENTIFIER' && !inClass &&
+    //
+    // If the IDENTIFIER carries an explicit `name:: T = arrow` annotation,
+    // skip this path and let the typed-variable-assignment path below
+    // emit the typed form (otherwise we'd lose the user's annotation in
+    // favor of inferred `any` rest-param emission).
+    if (tag === 'IDENTIFIER' && !inClass && !t.data?.type &&
         tokens[i + 1]?.[0] === '=' &&
         (tokens[i + 2]?.[0] === 'PARAM_START' || tokens[i + 2]?.[0] === '(')) {
       let fnName = t[1];
@@ -741,7 +760,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let paramStr = params.join(', ');
         if (bodyDepth === 0) {
           let declare = exported ? '' : 'declare ';
-          let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+          let ret = returnType ? `: ${tsType(returnType)}` : '';
           lines.push(`${indent()}${exp}${declare}function ${fnName}(${paramStr})${ret};`);
         } else {
           // `any` rather than `unknown` for the inferred-return case.
@@ -751,7 +770,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           // user didn't provide one. `unknown` would force callers to
           // narrow before using the result, creating new false
           // positives at every call site.
-          let ret = returnType ? expandSuffixes(returnType) : 'any';
+          let ret = returnType ? tsType(returnType) : 'any';
           lines.push(`${indent()}let ${fnName}: (${paramStr}) => ${ret};`);
         }
         continue;
@@ -761,7 +780,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     // Variable assignments with type annotations
     if (tag === 'IDENTIFIER' && t.data?.type) {
       let varName = t[1];
-      let type = expandSuffixes(t.data.type);
+      let type = tsType(t.data.type);
       let next = tokens[i + 1];
 
       if (next) {
@@ -795,7 +814,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           if (arrowToken && (arrowToken[0] === '->' || arrowToken[0] === '=>') &&
               arrowToken.data?.returnType) {
             // Typed arrow function assignment
-            let returnType = expandSuffixes(arrowToken.data.returnType);
+            let returnType = tsType(arrowToken.data.returnType);
             let { params } = collectParams(tokens, i + 2);
             let paramStr = params.join(', ');
             lines.push(`${indent()}${exp}${declare}function ${varName}(${paramStr}): ${returnType};`);
@@ -860,15 +879,18 @@ export function emitTypes(tokens, sexpr = null, source = '') {
   }
   if (usesSignal) {
     preamble.push(SIGNAL_INTERFACE);
-    preamble.push(SIGNAL_FN);
+    if (!explicitlyBound.has('__state')) preamble.push(SIGNAL_FN);
   }
   if (usesComputed) {
     preamble.push(COMPUTED_INTERFACE);
-    preamble.push(COMPUTED_FN);
+    if (!explicitlyBound.has('__computed')) preamble.push(COMPUTED_FN);
   }
-  if (usesSignal || usesComputed) {
+  if ((usesSignal || usesComputed) && !explicitlyBound.has('__effect')) {
     preamble.push(EFFECT_FN);
   }
+  if ((usesSignal || usesComputed || usesBatch) && !explicitlyBound.has('__batch')) {
+    preamble.push(BATCH_FN);
+  }
   if (hasSchemaDecls) {
     preamble.push(...SCHEMA_INTRINSIC_DECLS);
   }
@@ -880,25 +902,16 @@ export function emitTypes(tokens, sexpr = null, source = '') {
 }
 
 // ============================================================================
-// Suffix expansion — Rip type suffixes to TypeScript
+// Convert a Rip type expression to its TypeScript form.
 // ============================================================================
+//
+// Today this only strips the `::` annotation sigil to `:`. Kept as a
+// dedicated function so every call site routes through one place if the
+// conversion ever needs to grow.
 
-function expandSuffixes(typeStr) {
+function tsType(typeStr) {
   if (!typeStr) return typeStr;
-
-  // Convert :: to : (annotation sigil to type separator)
-  typeStr = typeStr.replace(/::/g, ':');
-
-  // T?? → T | null | undefined
-  typeStr = typeStr.replace(/(\w+(?:<[^>]+>)?)\?\?/g, '$1 | null | undefined');
-
-  // T? → T | undefined (but not ?. or ?: which are different)
-  typeStr = typeStr.replace(/(\w+(?:<[^>]+>)?)\?(?![.:])/g, '$1 | undefined');
-
-  // T! → NonNullable<T>
-  typeStr = typeStr.replace(/(\w+(?:<[^>]+>)?)\!/g, 'NonNullable<$1>');
-
-  return typeStr;
+  return typeStr.replace(/::/g, ':');
 }
 
 // ============================================================================
@@ -992,18 +1005,18 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
       if (!Array.isArray(member)) continue;
       let mHead = member[0]?.valueOf?.() ?? member[0];
 
-      let target, propName, isProp, type, hasDefault;
+      let target, propName, isProp, type, optional;
 
       if (mHead === 'state' || mHead === 'readonly' || mHead === 'computed') {
         target = member[1];
         isProp = Array.isArray(target) && (target[0]?.valueOf?.() ?? target[0]) === '.' && (target[1]?.valueOf?.() ?? target[1]) === 'this';
         propName = isProp ? (target[2]?.valueOf?.() ?? target[2]) : (target?.valueOf?.() ?? target);
         type = isProp ? target[2]?.type : target?.type;
-        hasDefault = true;
+        optional = isProp ? !!target[2]?.optional : !!target?.optional;
         if (!isProp) {
           componentVars.add(propName);
           let wrapper = (mHead === 'computed') ? 'Computed' : 'Signal';
-          let typeStr = type ? expandSuffixes(type) : (inferLiteralType(member[2]) || 'any');
+          let typeStr = type ? tsType(type) : (inferLiteralType(member[2]) || 'any');
           bodyMembers.push(`  ${propName}: ${wrapper}<${typeStr}>;`);
           continue;
         }
@@ -1011,7 +1024,7 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
         isProp = (member[1]?.valueOf?.() ?? member[1]) === 'this';
         propName = isProp ? (member[2]?.valueOf?.() ?? member[2]) : null;
         type = isProp ? member[2]?.type : null;
-        hasDefault = false;
+        optional = isProp ? !!member[2]?.optional : false;
         if (!isProp && propName) componentVars.add(propName);
       } else if (mHead === 'object') {
         // Method definitions: (object (: methodName (-> (params...) (block ...))))
@@ -1041,7 +1054,7 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
           for (let p of params) {
             let { inner, hasDefault } = unwrapDefault(p);
             let pName = inner?.valueOf?.() ?? inner;
-            let pType = inner?.type ? expandSuffixes(inner.type) : 'any';
+            let pType = inner?.type ? tsType(inner.type) : 'any';
             // Defaulted params are optional in the type signature so callers
             // may omit them.
             let opt = hasDefault ? '?' : '';
@@ -1060,9 +1073,11 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
 
       if (!isProp || !propName) continue;
 
-      let typeStr = type ? expandSuffixes(type) : 'any';
-      let opt = hasDefault ? '?' : '';
-      if (!hasDefault) hasRequired = true;
+      let typeStr = type ? tsType(type) : 'any';
+      // `?` on the prop name is the sole optionality marker;
+      // `:=` defaults do not imply optionality.
+      let opt = optional ? '?' : '';
+      if (!optional) hasRequired = true;
       publicProps.push(`    ${propName}${opt}: ${typeStr};`);
       if (mHead === 'state') {
         publicProps.push(`    __bind_${propName}__?: Signal<${typeStr}>;`);

package/src/lexer.js

@@ -7,7 +7,7 @@
 //
 // Design principles:
 //   - Every token carries .pre (whitespace count before it)
-//   - Every token carries .data (metadata: await, predicate, quote, etc.)
+//   - Every token carries .data (metadata: bang, optional, quote, etc.)
 //   - Every token carries .loc  (location: row, col, len)
 //   - Indentation is derived from .pre, not tracked during lexing
 //   - Token categories use Sets for O(1) membership tests
@@ -23,8 +23,8 @@
 //   token.newLine       — true if preceded by a newline
 //
 // Identifier suffixes:
-//   !  — dammit operator: fetch!() → await fetch()
-//   ?  — predicate:       empty?  → isEmpty (returns boolean convention)
+//   !  — bang: fetch!() → await fetch() (call site) | foo! = -> → void (definition)
+//   ?  — optional:        empty?  → (empty != null) (existence check / optional marker)
 //
 // The 9 tokenizer methods (in priority order):
 //   1. identifier  — variables, keywords, properties, ! and ? suffixes
@@ -246,7 +246,7 @@ let UNARY_MATH = new Set(['!', '~']);
 // Regex Patterns
 // ==========================================================================
 
-// Identifier: word chars + optional trailing ! (await) or ? (predicate)
+// Identifier: word chars + optional trailing ! (bang) or ? (optional)
 // The ? suffix is only captured when NOT followed by . ? ! [ ( to avoid
 // conflict with ?. (optional chaining), ?? (nullish), ?! (presence), ?.( and ?.[
 let IDENTIFIER_RE = /^(?!\d)((?:(?!\s)[$\w\x7f-\uffff])+(?:!|[?](?![.?![(]))?)([^\n\S]*:(?![=:]))?/;
@@ -519,8 +519,10 @@ export class Lexer {
   // Handles: variables, keywords, properties, aliases
   //
   // Suffix operators on identifiers:
-  //   !  → dammit operator (await): fetch!() → await fetch()
-  //   ?  → predicate (boolean):     empty?   → isEmpty
+  //   !  → bang: a neutral "trailing !" flag. Resolved by context downstream —
+  //        dammit/await at a call site (fetch!() → await fetch()), or the void
+  //        marker at a function definition (foo! = -> / def foo! → no return).
+  //   ?  → optional (existence):    empty?   → (empty != null)
   //
   // The ? suffix is captured by IDENTIFIER_RE only when NOT followed by
   // . ? [ ( — so x?.y (optional chaining) and x?? (nullish coalescing)
@@ -655,16 +657,20 @@ export class Lexer {
       }
     }
 
-    // --- Dammit operator: trailing ! → await ---
+    // --- Bang: trailing ! → context-resolved (await at call site / void at def) ---
     if (id.length > 1 && id.endsWith('!')) {
-      data.await = true;
+      data.bang = true;
       id = id.slice(0, -1);
     }
 
-    // --- Predicate operator: trailing ? → boolean convention ---
-    // empty? → isEmpty, active? → isActive, valid? → isValid
+    // --- Optional marker: trailing ? ---
+    // Identifier-position: existence check (`empty?` → `(empty != null)`).
+    // Property-name position: optional prop / type field (`@label?:: T`,
+    // `{ x?:: T }`, `def f(x?:: T)`). The flag is consumed by the type/
+    // component/schema emitters; the runtime semantics for `name?` as an
+    // existence check are unchanged.
     if (id.length > 1 && id.endsWith('?')) {
-      data.predicate = true;
+      data.optional = true;
       id = id.slice(0, -1);
     }
 
@@ -1519,9 +1525,42 @@ export class Lexer {
 
   // Walk back to tag parameters for arrow functions
   tagParameters() {
-    if (this.prevTag() !== ')') return this.tagDoIife();
+    let closeIdx = this.tokens.length - 1;
+    if (this.tokens[closeIdx]?.[0] !== ')') {
+      // Maybe a return-type annotation sits between `)` and the arrow:
+      // `(x:: T):: R ->`. Scan backward over the type expression (balanced
+      // brackets) looking for the trailing `TYPE_ANNOTATION` whose previous
+      // token is `)`. If found, treat that `)` as the param-list close.
+      let n = this.tokens.length;
+      let depth = 0;
+      let j = n - 1;
+      let found = -1;
+      while (j >= 0) {
+        let tk = this.tokens[j];
+        let tg = tk[0];
+        if (tg === ')' || tg === ']' || tg === '}' || tg === 'CALL_END' ||
+            tg === 'PARAM_END' || tg === 'INDEX_END' ||
+            (tg === 'COMPARE' && tk[1] === '>')) {
+          depth++;
+        } else if (tg === '(' || tg === '[' || tg === '{' || tg === 'CALL_START' ||
+                   tg === 'PARAM_START' || tg === 'INDEX_START' ||
+                   (tg === 'COMPARE' && tk[1] === '<')) {
+          depth--;
+        } else if (depth === 0) {
+          if (tg === 'TYPE_ANNOTATION') {
+            if (j > 0 && this.tokens[j - 1][0] === ')') found = j - 1;
+            break;
+          }
+          if (tg === 'TERMINATOR' || tg === 'INDENT' || tg === 'OUTDENT' ||
+              tg === '=' || tg === '->' || tg === '=>') break;
+        }
+        j--;
+      }
+      if (found < 0) return this.tagDoIife();
+      closeIdx = found;
+    }
 
-    let i = this.tokens.length - 1;
+    let i = closeIdx;
     let stack = [];
     this.tokens[i][0] = 'PARAM_END';
 
@@ -1536,7 +1575,7 @@ export class Lexer {
           tok[0] = 'PARAM_START';
           return this.tagDoIife(i - 1);
         } else {
-          this.tokens[this.tokens.length - 1][0] = 'CALL_END';
+          this.tokens[closeIdx][0] = 'CALL_END';
           return;
         }
       }
@@ -1562,10 +1601,14 @@ export class Lexer {
     this.closeMergeAssignments();
     this.closeOpenCalls();
     this.closeOpenIndexes();
+    // rewriteTypes must run BEFORE normalizeLines: otherwise a type-arrow
+    // `=>` inside `(...) => T` gets treated as a single-liner function and
+    // wrapped in spurious INDENT/OUTDENT, which then derails the type
+    // collector (it slurps the whole assignment body as part of the type).
+    this.rewriteTypes();
     this.normalizeLines();
     this.rewriteRender?.();
     this.rewriteSchema?.();
-    this.rewriteTypes();
     this.tagPostfixConditionals();
     this.rewriteTaggedTemplates();
     this.addImplicitBracesAndParens();

package/src/schema/schema.js

@@ -541,7 +541,7 @@ function parseFieldedLine(kind, line, entries, ctx) {
         dname === 'one' || dname === 'many' || dname === 'mixin') {
       let t0 = argTokens[0];
       if (t0 && (t0[0] === 'IDENTIFIER' || t0[0] === 'PROPERTY')) {
-        let optional = t0.data?.predicate === true;
+        let optional = t0.data?.optional === true;
         if (!optional && argTokens[1]?.[0] === '?') optional = true;
         args = [{ target: t0[1], optional }];
       }
@@ -1468,9 +1468,9 @@ function compileDirectiveArgsLiteral(name, tokens) {
     }
     let target = t0[1];
     // `@belongs_to User?` tokenizes as IDENTIFIER "User" with
-    // data.predicate=true. A trailing `?` in a later token position is
+    // data.optional=true. A trailing `?` in a later token position is
     // also accepted for robustness.
-    let optional = t0.data?.predicate === true;
+    let optional = t0.data?.optional === true;
     let pos = 1;
     if (!optional && tokens[pos]?.[0] === '?') { optional = true; pos++; }
     let parts = [`target: ${JSON.stringify(target)}`];
@@ -1673,8 +1673,8 @@ function parseBodyTokens(bodyTokens) {
 function collectModifiers(identToken) {
   let mods = [];
   let d = identToken.data;
-  if (d?.await === true) mods.push('!');
-  if (d?.predicate === true) mods.push('?');
+  if (d?.bang === true) mods.push('!');
+  if (d?.optional === true) mods.push('?');
   return mods;
 }