rip-lang 3.15.4 → 3.16.1

package/src/{types-emit.js → dts.js}

@@ -1,9 +1,12 @@
-import { SCHEMA_INTRINSIC_DECLS, emitSchemaTypes } from "./schema/dts-emit.js";
+import { SCHEMA_INTRINSIC_DECLS, emitSchemaTypes } from "./schema/dts.js";
 import { setTypesEmitter } from "./compiler.js";
 
 // Type System — .d.ts emission for Rip (CLI / typecheck only).
 //
-// This module is a CLI/editor-only sidecar:
+// This module is the type system's sibling to src/schema/dts.js —
+// both are CLI/editor-only `.d.ts` emitters for their respective
+// subsystem. The `dts` name signals "compile-time .d.ts emitter,
+// never reachable from the browser bundle."
 //
 //   emitTypes(tokens, sexpr, source) — generates .d.ts from annotated
 //     tokens and the parsed s-expression tree.
@@ -31,12 +34,13 @@ export const INTRINSIC_TYPE_DECLS = [
   "type __RipBrowserElement = Omit<HTMLElement, 'querySelector' | 'querySelectorAll' | 'closest' | 'setAttribute' | 'hidden'> & { hidden: boolean | 'until-found'; setAttribute(qualifiedName: string, value: any): void; querySelector(selectors: string): __RipBrowserElement | null; querySelectorAll(selectors: string): NodeListOf<__RipBrowserElement>; closest(selectors: string): __RipBrowserElement | null; };",
   "type __RipDomEl<K extends __RipTag> = Omit<__RipElementMap[K], 'querySelector' | 'querySelectorAll' | 'closest' | 'setAttribute' | 'hidden'> & __RipBrowserElement;",
   "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 in keyof HTMLElementEventMap as `@${K}`]?: ((event: HTMLElementEventMap[K]) => void) | null };',
-  'type __RipClassValue = string | boolean | null | undefined | Record<string, boolean> | __RipClassValue[];',
-  'type __RipProps<K extends __RipTag> = { [P in __RipAttrKeys<__RipElementMap[K]>]?: __RipElementMap[K][P] } & __RipEvents & { ref?: string; class?: __RipClassValue | __RipClassValue[]; style?: string; [k: `data-${string}`]: any; [k: `aria-${string}`]: any };',
+  "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 | 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; };',
@@ -63,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
@@ -74,10 +89,13 @@ export function emitTypes(tokens, sexpr = null, source = '') {
   let indentStr = '  ';
   let indent = () => indentStr.repeat(indentLevel);
   let inClass = false;
+  let inSubclass = false; // Tracks whether the active class extends another
   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.
@@ -87,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
@@ -190,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);
         }
@@ -203,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;
@@ -254,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++;
@@ -268,7 +287,13 @@ export function emitTypes(tokens, sexpr = null, source = '') {
   };
 
   // Collect function parameters (handles simple, destructured, rest, defaults)
-  let collectParams = (tokens, startIdx) => {
+  //
+  // `subclassConstructor` mirrors the compiler's @-shorthand renaming:
+  // when a constructor lives inside `class Foo extends Bar`, the compiler
+  // rewrites `@name` params to `_name` so the assignment `this.name =
+  // _name` can run AFTER `super(...)`. The shadow TS must use the same
+  // `_name` binding or the body's `_name` references will be unresolved.
+  let collectParams = (tokens, startIdx, subclassConstructor = false) => {
     let params = [];
     let fields = []; // Track @param:: type for class field emission
     let j = startIdx;
@@ -296,8 +321,9 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         if (tokens[j]?.[0] === 'PROPERTY' || tokens[j]?.[0] === 'IDENTIFIER') {
           let name = tokens[j][1];
           let type = tokens[j].data?.type;
-          params.push(type ? `${name}: ${expandSuffixes(type)}` : name);
-          if (type) fields.push({ name, type: expandSuffixes(type) });
+          let paramName = subclassConstructor ? `_${name}` : name;
+          params.push(type ? `${paramName}: ${tsType(type)}` : paramName);
+          if (type) fields.push({ name, type: tsType(type) });
           j++;
         }
         continue;
@@ -309,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;
@@ -352,15 +378,19 @@ 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);
         }
         j++;
 
-        // Skip past default value expression
+        // Skip past default value expression. Stops at the next top-level
+        // comma, the matching CALL_END, or the matching PARAM_END — the
+        // last is critical for arrow-function param lists wrapped in
+        // PARAM_START/PARAM_END (e.g. `(input, opts = {}) -> ...`),
+        // because PARAM_END is the only sentinel that closes the list.
         if (hasDefault) {
           j++; // skip =
           let dd = 0;
@@ -368,7 +398,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
             let dt = tokens[j];
             if (dt[0] === '(' || dt[0] === '[' || dt[0] === '{') dd++;
             if (dt[0] === ')' || dt[0] === ']' || dt[0] === '}') dd--;
-            if (dd === 0 && (dt[1] === ',' || dt[0] === 'CALL_END')) break;
+            if (dd === 0 && (dt[1] === ',' || dt[0] === 'CALL_END' || dt[0] === 'PARAM_END')) break;
             j++;
           }
         }
@@ -381,10 +411,26 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     return { params, fields, endIdx: j };
   };
 
+  let paramDepth = 0;
+  // bodyDepth counts how deep we are inside `def`/`->` bodies. At
+  // bodyDepth === 0 we're at module scope and dts.js may emit
+  // `declare function NAME(...)` for arrow assignments. Inside a
+  // function body, those assignments would be locals (e.g.
+  // `inst = (input, opts) -> ...` inside `def makeInstance`) and
+  // emitting a module-scope declare for them is wrong — TypeScript
+  // would treat the local and the (synthetic) global as separate
+  // bindings, causing the local to lose its type info.
+  let bodyDepth = 0;
   for (let i = 0; i < tokens.length; i++) {
     let t = tokens[i];
     let tag = t[0];
 
+    // Skip tokens inside parameter lists — annotations there describe
+    // the params of an enclosing function/method, not a top-level binding.
+    if (tag === 'PARAM_START') { paramDepth++; continue; }
+    if (tag === 'PARAM_END')   { paramDepth--; continue; }
+    if (paramDepth > 0) continue;
+
     // Track export flag
     let exported = false;
     if (tag === 'EXPORT') {
@@ -394,18 +440,17 @@ export function emitTypes(tokens, sexpr = null, source = '') {
       t = tokens[i];
       tag = t[0];
 
-      // Export default
+      // Export default — runtime statement, not a type declaration.
+      // The compiled JS body already carries `export default x`; emitting
+      // a duplicate here puts two `export default` declarations in front
+      // of the TypeScript language service and triggers TS2528. Skip the
+      // entire `export default ...` clause and let the body provide it.
       if (tag === 'DEFAULT') {
         i++;
-        if (i >= tokens.length) break;
-        t = tokens[i];
-        tag = t[0];
-
-        // export default IDENTIFIER (re-export)
-        if (tag === 'IDENTIFIER') {
-          lines.push(`${indent()}export default ${t[1]};`);
+        if (i < tokens.length) {
+          t = tokens[i];
+          tag = t[0];
         }
-        // export default { ... } or other expressions — skip for now
         continue;
       }
     }
@@ -414,8 +459,21 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     if (tag === 'IMPORT') {
       let importTokens = [];
       let j = i + 1;
-      while (j < tokens.length && tokens[j][0] !== 'TERMINATOR') {
-        importTokens.push(tokens[j]);
+      let depth = 0;
+      while (j < tokens.length) {
+        const tk = tokens[j];
+        const tg = tk[0];
+        if (tg === '{' || tg === '[' || tg === '(') depth++;
+        else if (tg === '}' || tg === ']' || tg === ')') depth--;
+        // Stop at top-level TERMINATOR; skip inner TERMINATORs and the
+        // synthetic INDENT/OUTDENT pair the lexer inserts inside multi-line
+        // braced import lists.
+        if (tg === 'TERMINATOR') {
+          if (depth <= 0) break;
+          j++; continue;
+        }
+        if (tg === 'INDENT' || tg === 'OUTDENT') { j++; continue; }
+        importTokens.push(tk);
         j++;
       }
       // Reconstruct: join with spaces, then clean up spacing
@@ -442,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) {
@@ -454,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;
@@ -514,9 +572,11 @@ export function emitTypes(tokens, sexpr = null, source = '') {
 
       // Check for extends
       let ext = '';
+      let isSubclass = false;
       let j = i + 2;
       if (tokens[j]?.[0] === 'EXTENDS') {
         ext = ` extends ${tokens[j + 1]?.[1] || ''}`;
+        isSubclass = true;
         j += 2;
       }
 
@@ -534,6 +594,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         if (hasTypedMembers) {
           lines.push(`${indent()}${exp}declare class ${className}${ext} {`);
           inClass = true;
+          inSubclass = isSubclass;
           classFields.clear();
           indentLevel++;
         }
@@ -547,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);
@@ -556,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};`);
@@ -593,7 +654,12 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           let params = [];
           let fields = [];
           if (tokens[j]?.[0] === 'PARAM_START') {
-            let result = collectParams(tokens, j);
+            // The compiler renames `@name` → `_name` on subclass
+            // constructors so `this.name = _name` runs after super();
+            // mirror that here so the shadow TS body's `_name`
+            // references resolve to a real param binding.
+            let isSubCtor = inSubclass && methodName === 'constructor';
+            let result = collectParams(tokens, j, isSubCtor);
             params = result.params;
             fields = result.fields;
             j = result.endIdx + 1;
@@ -612,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) {
@@ -637,19 +703,41 @@ export function emitTypes(tokens, sexpr = null, source = '') {
 
     // Track INDENT/OUTDENT for class body
     if (tag === 'INDENT') {
+      bodyDepth++;
       continue;
     }
     if (tag === 'OUTDENT') {
+      if (bodyDepth > 0) bodyDepth--;
       if (inClass) {
         indentLevel--;
         lines.push(`${indent()}}`);
         inClass = false;
+        inSubclass = false;
       }
       continue;
     }
 
     // Arrow function assignment: name = (params) -> body
-    if (tag === 'IDENTIFIER' && !inClass && tokens[i + 1]?.[0] === '=' &&
+    //
+    // Emission shape depends on scope:
+    //   bodyDepth === 0  → `declare function name(...): R;` at module
+    //                       scope. typecheck.js attaches this as an
+    //                       overload and copies typed params into the
+    //                       impl line.
+    //   bodyDepth >  0   → `let name: (params) => R;` at module scope.
+    //                       typecheck.js's typed-local hoist pulls the
+    //                       `: (...) => R` into the body's `let name`,
+    //                       making the arrow contextually typed.
+    //
+    // The function-form is wrong inside bodies because it would create
+    // a phantom global that shadows / collides with the actual local.
+    //
+    // 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];
       let j = i + 2;
@@ -669,10 +757,22 @@ export function emitTypes(tokens, sexpr = null, source = '') {
 
       if (returnType || params.some(p => p.includes(':'))) {
         let exp = exported ? 'export ' : '';
-        let declare = exported ? '' : 'declare ';
-        let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
         let paramStr = params.join(', ');
-        lines.push(`${indent()}${exp}${declare}function ${fnName}(${paramStr})${ret};`);
+        if (bodyDepth === 0) {
+          let declare = exported ? '' : 'declare ';
+          let ret = returnType ? `: ${tsType(returnType)}` : '';
+          lines.push(`${indent()}${exp}${declare}function ${fnName}(${paramStr})${ret};`);
+        } else {
+          // `any` rather than `unknown` for the inferred-return case.
+          // The annotation's job is to give the body's `let X` a typed
+          // function shape so call-site param checks engage; we
+          // intentionally don't constrain the return type when the
+          // 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 ? tsType(returnType) : 'any';
+          lines.push(`${indent()}let ${fnName}: (${paramStr}) => ${ret};`);
+        }
         continue;
       }
     }
@@ -680,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) {
@@ -714,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};`);
@@ -779,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);
   }
@@ -799,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, ':');
 }
 
 // ============================================================================
@@ -911,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;
         }
@@ -930,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 ...))))
@@ -944,13 +1038,27 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
           if (fHead !== '->' && fHead !== '=>') continue;
           let params = funcDef[1];
           if (!Array.isArray(params)) continue;
-          let hasTypedParams = params.some(p => p?.type);
+          // Unwrap `['default', name, value]` AST nodes (params with defaults
+          // like `b = 1`) so we extract the underlying identifier rather than
+          // stringifying the whole array via Array.toString — which produced
+          // `default,b,1: any` in the emitted method signature.
+          let unwrapDefault = (p) => {
+            if (Array.isArray(p) && (p[0]?.valueOf?.() ?? p[0]) === 'default') {
+              return { inner: p[1], hasDefault: true };
+            }
+            return { inner: p, hasDefault: false };
+          };
+          let hasTypedParams = params.some(p => unwrapDefault(p).inner?.type);
           if (!hasTypedParams) continue;
           let paramStrs = [];
           for (let p of params) {
-            let pName = p?.valueOf?.() ?? p;
-            let pType = p?.type ? expandSuffixes(p.type) : 'any';
-            paramStrs.push(`${pName}: ${pType}`);
+            let { inner, hasDefault } = unwrapDefault(p);
+            let pName = inner?.valueOf?.() ?? inner;
+            let pType = inner?.type ? tsType(inner.type) : 'any';
+            // Defaulted params are optional in the type signature so callers
+            // may omit them.
+            let opt = hasDefault ? '?' : '';
+            paramStrs.push(`${pName}${opt}: ${pType}`);
           }
           bodyMembers.push(`  ${methName}(${paramStrs.join(', ')}): void;`);
         }
@@ -965,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}>;`);
@@ -1014,7 +1124,7 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
 // Registration — install emitTypes into the compiler at module load.
 // ============================================================================
 // The compiler exposes setTypesEmitter() as a no-op-friendly hook. When
-// nothing imports types-emit.js (browser bundle), the emitter stays null
+// nothing imports dts.js (browser bundle), the emitter stays null
 // and compile()s .d.ts output is silently skipped. CLI entry points and
 // typecheck.js import this module specifically to install the emitter.
 

package/src/grammar/README.md

@@ -140,7 +140,7 @@ names in the core generators:
 | `root` | Grammar start symbol | Root |
 | `body-list` | Left-recursive with TERMINATOR | Body, ComponentBody |
 | `comma-list` | Left-recursive with `,` | ArgList, ParamList |
-| `concat-list` | Left-recursive, no separator | Interpolations, Whens |
+| `concat-list` | Left-recursive, no separator | Interpolations, Cases |
 | `left-rec-loop` | Self-referential with terminal continuation | IfBlock |
 | `expression` | Contains the operation nonterminal | Expression |
 | `operation` | Has binary operator rules | Operation |