rip-lang 3.14.4 → 3.15.0

package/src/compiler.js

@@ -11,8 +11,12 @@
 import { Lexer } from './lexer.js';
 import { parser } from './parser.js';
 import { installComponentSupport } from './components.js';
-import { emitTypes, emitEnum } from './types.js';
-import { installSchemaSupport } from './schema.js';
+// Type emission is CLI/editor-only. types-emit.js registers itself via
+// setTypesEmitter() at module load. The browser never imports types-emit,
+// so _typesEmitter stays null and .d.ts output is silently skipped.
+let _typesEmitter = null;
+export function setTypesEmitter(fn) { _typesEmitter = fn; }
+import { installSchemaSupport } from '@rip-lang/schema';
 import { SourceMapGenerator } from './sourcemaps.js';
 import { RipError, toRipError } from './error.js';
 
@@ -1472,7 +1476,7 @@ export class CodeEmitter {
         let stmts = body.slice(1);
         this.indentLevel++;
         let lines = [];
-        if (!noVar) lines.push(`${itemVarPattern} = ${iterCode}[${idxName}];`);
+        if (!noVar) lines.push(`let ${itemVarPattern} = ${iterCode}[${idxName}];`);
         if (guard) {
           lines.push(`if (${this.emit(guard, 'value')}) {`);
           this.indentLevel++;
@@ -1492,8 +1496,8 @@ export class CodeEmitter {
           : loopHeader + `{ ${this.emit(body, 'statement')}; }`;
       }
       return guard
-        ? loopHeader + `{ ${itemVarPattern} = ${iterCode}[${idxName}]; if (${this.emit(guard, 'value')}) ${this.emit(body, 'statement')}; }`
-        : loopHeader + `{ ${itemVarPattern} = ${iterCode}[${idxName}]; ${this.emit(body, 'statement')}; }`;
+        ? loopHeader + `{ let ${itemVarPattern} = ${iterCode}[${idxName}]; if (${this.emit(guard, 'value')}) ${this.emit(body, 'statement')}; }`
+        : loopHeader + `{ let ${itemVarPattern} = ${iterCode}[${idxName}]; ${this.emit(body, 'statement')}; }`;
     }
 
     // Index variable → traditional for loop
@@ -1503,7 +1507,7 @@ export class CodeEmitter {
       if (this.is(body, 'block')) {
         code += '{\n';
         this.indentLevel++;
-        code += this.indent() + `${itemVarPattern} = ${iterCode}[${indexVar}];\n`;
+        code += this.indent() + `let ${itemVarPattern} = ${iterCode}[${indexVar}];\n`;
         if (guard) {
           code += this.indent() + `if (${this.unwrap(this.emit(guard, 'value'))}) {\n`;
           this.indentLevel++;
@@ -1517,8 +1521,8 @@ export class CodeEmitter {
         code += this.indent() + '}';
       } else {
         code += guard
-          ? `{ ${itemVarPattern} = ${iterCode}[${indexVar}]; if (${this.unwrap(this.emit(guard, 'value'))}) ${this.emit(body, 'statement')}; }`
-          : `{ ${itemVarPattern} = ${iterCode}[${indexVar}]; ${this.emit(body, 'statement')}; }`;
+          ? `{ let ${itemVarPattern} = ${iterCode}[${indexVar}]; if (${this.unwrap(this.emit(guard, 'value'))}) ${this.emit(body, 'statement')}; }`
+          : `{ let ${itemVarPattern} = ${iterCode}[${indexVar}]; ${this.emit(body, 'statement')}; }`;
       }
       return code;
     }
@@ -1542,8 +1546,7 @@ export class CodeEmitter {
     }
 
     // Default: for-of
-    let bind = noVar ? 'let ' : '';
-    let code = `for (${bind}${itemVarPattern} of ${this.emit(iterable, 'value')}) `;
+    let code = `for (let ${itemVarPattern} of ${this.emit(iterable, 'value')}) `;
     code += guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body);
     return code;
   }
@@ -1558,7 +1561,7 @@ export class CodeEmitter {
 
     let [keyVar, valueVar] = Array.isArray(vars) ? vars : [vars];
     let objCode = this.emit(obj, 'value');
-    let code = `for (${keyVar} in ${objCode}) `;
+    let code = `for (let ${keyVar} in ${objCode}) `;
 
     if (own && !valueVar && !guard) {
       if (this.is(body, 'block')) {
@@ -1576,7 +1579,7 @@ export class CodeEmitter {
         this.indentLevel++;
         let lines = [];
         if (own) lines.push(`if (!Object.hasOwn(${objCode}, ${keyVar})) continue;`);
-        lines.push(`${valueVar} = ${objCode}[${keyVar}];`);
+        lines.push(`let ${valueVar} = ${objCode}[${keyVar}];`);
         if (guard) {
           lines.push(`if (${this.emit(guard, 'value')}) {`);
           this.indentLevel++;
@@ -1591,7 +1594,7 @@ export class CodeEmitter {
       }
       let inline = '';
       if (own) inline += `if (!Object.hasOwn(${objCode}, ${keyVar})) continue; `;
-      inline += `${valueVar} = ${objCode}[${keyVar}]; `;
+      inline += `let ${valueVar} = ${objCode}[${keyVar}]; `;
       if (guard) inline += `if (${this.emit(guard, 'value')}) `;
       inline += `${this.emit(body, 'statement')};`;
       return code + `{ ${inline} }`;
@@ -1638,7 +1641,7 @@ export class CodeEmitter {
       itemVarPattern = this.emitDestructuringPattern(firstVar);
     else itemVarPattern = firstVar;
 
-    let code = `for ${awaitKw}(${itemVarPattern} of ${iterCode}) `;
+    let code = `for ${awaitKw}(let ${itemVarPattern} of ${iterCode}) `;
 
     if (needsTempVar && destructStmts.length > 0) {
       let stmts = this.unwrapBlock(body);
@@ -2012,17 +2015,16 @@ export class CodeEmitter {
       let header = isNeg
         ? `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${update})`
         : `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${update})`;
-      return { header, setup: noVar ? null : `${ivp} = ${ic}[${idxN}];` };
+      return { header, setup: noVar ? null : `let ${ivp} = ${ic}[${idxN}];` };
     }
     if (indexVar) {
       let ic = this.emit(iterable, 'value');
       return {
         header: `for (let ${indexVar} = 0; ${indexVar} < ${ic}.length; ${indexVar}++)`,
-        setup: `${ivp} = ${ic}[${indexVar}];`,
+        setup: `let ${ivp} = ${ic}[${indexVar}];`,
       };
     }
-    let bind = noVar ? 'let ' : '';
-    return { header: `for (${bind}${ivp} of ${this.emit(iterable, 'value')})`, setup: null };
+    return { header: `for (let ${ivp} of ${this.emit(iterable, 'value')})`, setup: null };
   }
 
   // Shared: parse a for-of (object) iterator and return { header, own, vv, oc, kvp }.
@@ -2032,7 +2034,7 @@ export class CodeEmitter {
     let kvp = (this.is(kv, 'array') || this.is(kv, 'object'))
       ? this.emitDestructuringPattern(kv) : kv;
     let oc = this.emit(iterable, 'value');
-    return { header: `for (${kvp} in ${oc})`, own, vv, oc, kvp };
+    return { header: `for (let ${kvp} in ${oc})`, own, vv, oc, kvp };
   }
 
   // Shared: parse a for-as (iterator) spec and return { header }.
@@ -2041,13 +2043,28 @@ export class CodeEmitter {
     let [fv] = va;
     let ivp = (this.is(fv, 'array') || this.is(fv, 'object'))
       ? this.emitDestructuringPattern(fv) : fv;
-    return { header: `for ${isAwait ? 'await ' : ''}(${ivp} of ${this.emit(iterable, 'value')})` };
+    return { header: `for ${isAwait ? 'await ' : ''}(let ${ivp} of ${this.emit(iterable, 'value')})` };
   }
 
   emitComprehension(head, rest, context) {
     let [expr, iterators, guards] = rest;
     if (context === 'statement') return this.emitComprehensionAsLoop(expr, iterators, guards);
-    if (this.comprehensionTarget) return this.emitComprehensionWithTarget(expr, iterators, guards, this.comprehensionTarget);
+    if (this.comprehensionTarget) {
+      // Consume-and-clear: the auto-return-loop logic sets comprehensionTarget
+      // expecting ONE consumer (the direct value-context comprehension being
+      // routed to the named target). Without clearing here, nested
+      // comprehensions inside this comprehension's body (call args, RHS
+      // expressions) would inherit the target and skip their own IIFE,
+      // producing malformed JS or wrong semantics. The body's own emit calls
+      // see comprehensionTarget = null and correctly produce IIFEs.
+      let target = this.comprehensionTarget;
+      this.comprehensionTarget = null;
+      try {
+        return this.emitComprehensionWithTarget(expr, iterators, guards, target);
+      } finally {
+        this.comprehensionTarget = target;
+      }
+    }
 
     // Enclosed: expr, iterators (iterable expressions), guards
     let hasAwait = this.containsAwait(expr) || iterators.some(i => this.containsAwait(i)) || guards.some(g => this.containsAwait(g));
@@ -2068,7 +2085,7 @@ export class CodeEmitter {
         code += this.indent() + header + ' {\n';
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kvp})) continue;\n`;
-        if (vv) code += this.indent() + `${vv} = ${oc}[${kvp}];\n`;
+        if (vv) code += this.indent() + `let ${vv} = ${oc}[${kvp}];\n`;
       } else if (iterType === 'for-as') {
         let { header } = this._forAsHeader(vars, iterable, iter[3]);
         code += this.indent() + header + ' {\n';
@@ -2132,10 +2149,10 @@ export class CodeEmitter {
       if (iterType === 'for-of') {
         let [kv, vv] = vars;
         let oc = this.emit(iterable, 'value');
-        code += this.indent() + `for (${kv} in ${oc}) {\n`;
+        code += this.indent() + `for (let ${kv} in ${oc}) {\n`;
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kv})) continue;\n`;
-        if (vv) code += this.indent() + `${vv} = ${oc}[${kv}];\n`;
+        if (vv) code += this.indent() + `let ${vv} = ${oc}[${kv}];\n`;
       }
     }
     for (let guard of guards) { code += this.indent() + `if (${this.emit(guard, 'value')}) {\n`; this.indentLevel++; }
@@ -2616,6 +2633,21 @@ export class CodeEmitter {
               code += this.indent() + this.addSemicolon(stmt, this.emit(stmt, 'statement')) + '\n';
               return;
             }
+            // Auto-return-loop: only for-in/for-of/for-as auto-collect into
+            // _result, because emitForIn/emitForOf/emitForAs at value-context
+            // wrap themselves in a comprehension that consumes
+            // comprehensionTarget. `loop` and `while` have no such wrapping —
+            // emitLoop/emitWhile just emit `while(...) { body }` and any
+            // comprehensionTarget set here would LEAK into nested
+            // expression-context comprehensions inside the body (causing
+            // them to be routed to the wrong target and skip their own
+            // IIFE). Loops with explicit `return X` inside their body
+            // already work correctly; emit them as plain statements.
+            let isCollectibleLoop = h === 'for-in' || h === 'for-of' || h === 'for-as';
+            if (!isCollectibleLoop) {
+              code += this.indent() + this.addSemicolon(stmt, this.emit(stmt, 'statement')) + '\n';
+              return;
+            }
             code += this.indent() + 'const _result = [];\n';
             this.comprehensionTarget = '_result';
             let saved = this._skipCompTargetInit;
@@ -2792,7 +2824,7 @@ export class CodeEmitter {
         code += this.indent() + header + ' {\n';
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kvp})) continue;\n`;
-        if (vv) code += this.indent() + `${vv} = ${oc}[${kvp}];\n`;
+        if (vv) code += this.indent() + `let ${vv} = ${oc}[${kvp}];\n`;
         if (guards?.length > 0) { code += this.indent() + `if (${guards.map(g => this.emit(g, 'value')).join(' && ')}) {\n`; this.indentLevel++; }
         emitBody();
         if (guards?.length > 0) { this.indentLevel--; code += this.indent() + '}\n'; }
@@ -2864,7 +2896,7 @@ export class CodeEmitter {
         code += header + ' {\n';
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kvp})) continue;\n`;
-        if (vv) code += this.indent() + `${vv} = ${oc}[${kvp}];\n`;
+        if (vv) code += this.indent() + `let ${vv} = ${oc}[${kvp}];\n`;
         emitBody();
         this.indentLevel--;
         code += this.indent() + '}';
@@ -3691,7 +3723,7 @@ export class Compiler {
 
     // If only terminators remain (type-only source), emit types and return early
     if (tokens.every(t => t[0] === 'TERMINATOR')) {
-      if (typeTokens) dts = emitTypes(typeTokens, ['program'], source);
+      if (typeTokens && _typesEmitter) dts = _typesEmitter(typeTokens, ['program'], source);
       return { tokens, sexpr: ['program'], code: '', dts, data: dataSection, reactiveVars: {} };
     }
 
@@ -3761,6 +3793,11 @@ export class Compiler {
       skipDataPart: this.options.skipDataPart,
       stubComponents: this.options.stubComponents,
       reactiveVars: this.options.reactiveVars,
+      // Schema runtime mode: 'browser' / 'validate' / 'server' / 'migration'.
+      // Default 'migration' covers the common case (CLI, server, tests) where
+      // the user might call any schema feature including .toSQL(). The browser
+      // bundle build script overrides to 'browser' for size reduction.
+      schemaMode: this.options.schemaMode,
       sourceMap,
     });
     let code = generator.compile(sexpr);
@@ -3768,15 +3805,28 @@ export class Compiler {
     let map = sourceMap ? sourceMap.toJSON() : null;
     let reverseMap = sourceMap ? sourceMap.toReverseMap() : null;
     if (map && this.options.sourceMap === 'inline') {
-      let b64 = typeof Buffer !== 'undefined' ? Buffer.from(map).toString('base64') : btoa(map);
+      // map is already a JSON string (sourceMaps.toJSON() stringifies). UTF-8
+      // safe encode: btoa() only handles Latin-1, so pre-encode non-ASCII via
+      // TextEncoder before base64 in browsers. Bun's Buffer handles utf-8
+      // directly. Source files containing emoji, em-dashes, accented chars,
+      // etc. would otherwise break with `Failed to execute 'btoa'`.
+      let b64;
+      if (typeof Buffer !== 'undefined') {
+        b64 = Buffer.from(map, 'utf8').toString('base64');
+      } else {
+        const bytes = new TextEncoder().encode(map);
+        let bin = '';
+        for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+        b64 = btoa(bin);
+      }
       code += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
     } else if (map && this.options.filename) {
       code += `\n//# sourceMappingURL=${this.options.filename}.js.map`;
     }
 
     // Step 5: Emit .d.ts from annotated tokens + parsed s-expression
-    if (typeTokens) {
-      dts = emitTypes(typeTokens, sexpr, source);
+    if (typeTokens && _typesEmitter) {
+      dts = _typesEmitter(typeTokens, sexpr, source);
     }
 
     return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars };
@@ -3793,10 +3843,36 @@ export class Compiler {
 installComponentSupport(CodeEmitter, Lexer);
 
 // =============================================================================
-// Type Support (enum generator)
+// Enum Codegen (CodeEmitter method)
 // =============================================================================
+// `enum` blocks compile to a runtime JavaScript object that maps both
+// forward (key → value) and reverse (value → key). This is real codegen,
+// not type machinery, so it lives with the rest of the emitter dispatch.
+
+CodeEmitter.prototype.emitEnum = function emitEnum(head, rest, context) {
+  let [name, body] = rest;
+  let enumName = name?.valueOf?.() ?? name;
+
+  let pairs = [];
+  if (Array.isArray(body)) {
+    let items = body[0] === 'block' ? body.slice(1) : [body];
+    for (let item of items) {
+      if (Array.isArray(item)) {
+        if (item[0]?.valueOf?.() === '=') {
+          let key = item[1]?.valueOf?.() ?? item[1];
+          let val = item[2]?.valueOf?.() ?? item[2];
+          pairs.push([key, val]);
+        }
+      }
+    }
+  }
+
+  if (pairs.length === 0) return `const ${enumName} = {}`;
 
-CodeEmitter.prototype.emitEnum = emitEnum;
+  let forward = pairs.map(([k, v]) => `${k}: ${v}`).join(', ');
+  let reverse = pairs.map(([k, v]) => `${v}: "${k}"`).join(', ');
+  return `const ${enumName} = {${forward}, ${reverse}}`;
+};
 
 // =============================================================================
 // Schema Support (prototype installation)

package/src/grammar/grammar.rip

@@ -808,7 +808,7 @@ grammar =
   # Schema
   # ============================================================================
   # `schema [:kind] INDENT ... OUTDENT` is parsed entirely by the schema
-  # sub-parser at lexer-rewrite time (src/schema.js). The rewriter emits
+  # sub-parser at lexer-rewrite time (packages/schema/src/schema.js). The rewriter emits
   # a synthetic SCHEMA_BODY token whose .data carries the full descriptor
   # (kind, entries, per-entry loc). The main grammar only sees these two
   # terminals, which keeps schema body syntax (`name! type`, `@directive`,

package/src/grammar/solar.rip

@@ -154,7 +154,6 @@ class Generator
       for handle in handles
         [symbols, action, precedence] = @_parseHandle handle
 
-        # Add symbols to grammar
         addSymbol symbol for symbol in symbols
 
         # Process semantic actions

package/src/lexer.js

@@ -40,7 +40,7 @@
 // ==========================================================================
 
 import { installTypeSupport } from './types.js';
-import { installSchemaSupport } from './schema.js';
+import { installSchemaSupport } from '@rip-lang/schema';
 
 // ==========================================================================
 // Token Category Sets
@@ -174,6 +174,15 @@ let TAGGABLE = new Set(['IDENTIFIER', 'PROPERTY', ')', 'CALL_END', ']', 'INDEX_E
 // Control flow tokens that don't end implicit calls/objects
 let CONTROL_IN_IMPLICIT = new Set(['IF', 'TRY', 'FINALLY', 'CATCH', 'CLASS', 'SWITCH', 'COMPONENT', 'FOR']);
 
+// Tokens that complete an expression value. Used to detect postfix-position
+// for keywords that exist in both prefix and postfix forms (FOR has no
+// dedicated POST_FOR token like POST_IF, so we infer it from context).
+let VALUE_END_TAGS = new Set([
+  'IDENTIFIER', 'PROPERTY', 'NUMBER', 'STRING', 'STRING_END', 'REGEX', 'REGEX_END',
+  ')', 'CALL_END', ']', 'INDEX_END', '}', 'MAP_END', 'PICK_END',
+  'BOOL', 'NULL', 'UNDEFINED', 'INFINITY', 'NAN', 'SUPER', 'THIS', '@', 'SYMBOL',
+]);
+
 // Single-liner keywords that get implicit INDENT/OUTDENT
 let SINGLE_LINERS = new Set(['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN']);
 
@@ -1782,8 +1791,21 @@ export class Lexer {
         i += 1;
       };
 
-      // Don't end implicit on INDENT for control flow inside implicit
-      if ((inImplicitCall() || inImplicitObject()) && CONTROL_IN_IMPLICIT.has(tag)) {
+      // Don't end implicit on INDENT for control flow inside implicit.
+      //
+      // Special case: FOR is the only entry in CONTROL_IN_IMPLICIT that can
+      // appear in postfix position (no POST_FOR token exists, unlike
+      // POST_IF / POST_UNLESS). When FOR follows a value-completing token
+      // on the same line (e.g. `addSymbol s for s in xs`), it's a postfix
+      // comprehension that should END the implicit call so the comprehension
+      // wraps the call rather than becoming the call's argument. Detect
+      // postfix FOR by: not at the start of a new line, AND the previous
+      // token is a value-completing token (IDENTIFIER, ), ], literal, etc.).
+      // Prefix FOR (after `:`, `=`, `->`, comma, etc.) keeps the existing
+      // CONTROL behaviour. Falling through lets the IMPLICIT_END handler
+      // below close the implicit call.
+      let isPostfixFor = tag === 'FOR' && !token.newLine && VALUE_END_TAGS.has(prevTag);
+      if ((inImplicitCall() || inImplicitObject()) && CONTROL_IN_IMPLICIT.has(tag) && !isPostfixFor) {
         stack.push(['CONTROL', i, {ours: true}]);
         return forward(1);
       }

package/src/parser.js

@@ -256,16 +256,16 @@ const parserInstance = {
     }
   },
   parse(input) {
-    let EOF, TERROR, action, errStr, expected, len, lex, lexer, loc, locs, newState, p, parseTable, preErrorSymbol, r, recovering, rv, sharedState, state, stk, symbol, tokenLen, tokenLine, tokenLoc, tokenText, vals;
+    let EOF, TERROR, action, errStr, expected, k, len, lex, lexer, loc, locs, newState, p, parseTable, preErrorSymbol, r, recovering, rv, sharedState, state, stk, symbol, tokenLen, tokenLine, tokenLoc, tokenText, v, vals;
     [stk, vals, locs] = [[0], [null], []];
     [parseTable, tokenText, tokenLine, tokenLen, recovering] = [this.parseTable, "", 0, 0, 0];
     [TERROR, EOF] = [2, 1];
     lexer = Object.create(this.lexer);
     sharedState = { ctx: {} };
-    for (const k in this.ctx) {
+    for (let k in this.ctx) {
       if (!Object.hasOwn(this.ctx, k))
         continue;
-      const v = this.ctx[k];
+      let v = this.ctx[k];
       sharedState.ctx[k] = v;
     }
     lexer.setInput(input, sharedState.ctx);
@@ -294,7 +294,7 @@ const parserInstance = {
         if (!recovering)
           expected = (() => {
             const result = [];
-            for (const p in parseTable[state]) {
+            for (let p in parseTable[state]) {
               if (!Object.hasOwn(parseTable[state], p))
                 continue;
               if (this.tokenNames[p] && p > TERROR)

package/src/typecheck.js

@@ -11,8 +11,9 @@
 //   type errors mapped back to Rip source positions.
 
 import { Compiler, getStdlibCode } from './compiler.js';
-import { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, ARIA_TYPE_DECLS, SIGNAL_INTERFACE, SIGNAL_FN, COMPUTED_INTERFACE, COMPUTED_FN, EFFECT_FN } from './types.js';
-import { hasSchemas } from './schema.js';
+import { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, ARIA_TYPE_DECLS, SIGNAL_INTERFACE, SIGNAL_FN, COMPUTED_INTERFACE, COMPUTED_FN, EFFECT_FN } from './types-emit.js';
+import { hasSchemas } from '@rip-lang/schema';
+import '@rip-lang/schema/loader-server';   // registers full schema runtime provider
 import { createRequire } from 'module';
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { resolve, relative, dirname } from 'path';