rip-lang 3.9.3 → 3.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.9.3",
+  "version": "3.10.0",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",

package/src/browser.js

@@ -32,6 +32,7 @@ async function processRipScripts() {
 
   for (const script of scripts) {
     if (script.hasAttribute('data-rip-processed')) continue;
+    if (script.hasAttribute('data-name')) continue;
 
     try {
       let ripCode;

package/src/compiler.js

@@ -3141,7 +3141,9 @@ export class Compiler {
     this.options = { showTokens: false, showSExpr: false, ...options };
   }
 
-  compile(source) {
+  compile(source, options) {
+    if (options) this.options = { ...this.options, ...options };
+
     // Handle __DATA__ marker
     let dataSection = null;
     let lines = source.split('\n');

package/src/components.js

@@ -57,6 +57,14 @@ function getMemberName(target) {
   return null;
 }
 
+/**
+ * Check if target uses @property syntax (public prop).
+ * [".", "this", name] = @prop (public), plain string = private.
+ */
+function isPublicProp(target) {
+  return Array.isArray(target) && target[0] === '.' && target[1] === 'this';
+}
+
 /**
  * Detect fragment root and collect direct child variables for proper removal.
  * After insertBefore, a DocumentFragment is empty — .remove() is a no-op.
@@ -527,6 +535,19 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       return ['=>', ...sexpr.slice(1).map(item => this.transformComponentMembers(item))];
     }
 
+    // Object literals: transform values but leave bare string keys untouched
+    if (sexpr[0] === 'object') {
+      return ['object', ...sexpr.slice(1).map(pair => {
+        if (Array.isArray(pair) && pair.length >= 2) {
+          let key = pair[0];
+          let newKey = Array.isArray(key) ? this.transformComponentMembers(key) : key;
+          let newValue = this.transformComponentMembers(pair[1]);
+          return [newKey, newValue, pair[2]];
+        }
+        return this.transformComponentMembers(pair);
+      })];
+    }
+
     return sexpr.map(item => this.transformComponentMembers(item));
   };
 
@@ -566,7 +587,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       if (op === 'state') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          stateVars.push({ name: varName, value: stmt[2] });
+          stateVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]) });
           memberNames.add(varName);
           reactiveMembers.add(varName);
         }
@@ -580,7 +601,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       } else if (op === 'readonly') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          readonlyVars.push({ name: varName, value: stmt[2] });
+          readonlyVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]) });
           memberNames.add(varName);
         }
       } else if (op === '=') {
@@ -594,7 +615,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
               methods.push({ name: varName, func: val });
               memberNames.add(varName);
             } else {
-              stateVars.push({ name: varName, value: val });
+              stateVars.push({ name: varName, value: val, isPublic: isPublicProp(stmt[1]) });
               memberNames.add(varName);
               reactiveMembers.add(varName);
             }
@@ -634,15 +655,19 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     lines.push('  _init(props) {');
 
     // Constants (readonly)
-    for (const { name, value } of readonlyVars) {
+    for (const { name, value, isPublic } of readonlyVars) {
       const val = this.generateInComponent(value, 'value');
-      lines.push(`    this.${name} = props.${name} ?? ${val};`);
+      lines.push(isPublic
+        ? `    this.${name} = props.${name} ?? ${val};`
+        : `    this.${name} = ${val};`);
     }
 
     // State variables (__state handles signal passthrough)
-    for (const { name, value } of stateVars) {
+    for (const { name, value, isPublic } of stateVars) {
       const val = this.generateInComponent(value, 'value');
-      lines.push(`    this.${name} = __state(props.${name} ?? ${val});`);
+      lines.push(isPublic
+        ? `    this.${name} = __state(props.${name} ?? ${val});`
+        : `    this.${name} = __state(${val});`);
     }
 
     // Computed (derived)
@@ -1100,14 +1125,17 @@ export function installComponentSupport(CodeGenerator, Lexer) {
 
         // Smart two-way binding for value/checked when bound to reactive state
         if ((key === 'value' || key === 'checked') && this.hasReactiveDeps(value)) {
-          // Reactive effect: signal → DOM property
           this._setupLines.push(`__effect(() => { ${elVar}.${key} = ${valueCode}; });`);
-          // Event listener: DOM → signal (two-way)
-          const event = key === 'checked' ? 'change' : 'input';
-          const accessor = key === 'checked' ? 'e.target.checked'
-            : (inputType === 'number' || inputType === 'range') ? 'e.target.valueAsNumber'
-            : 'e.target.value';
-          this._createLines.push(`${elVar}.addEventListener('${event}', (e) => { ${valueCode} = ${accessor}; });`);
+          // Only generate reverse binding when the value is a simple assignable
+          // target (plain reactive member or @prop), not a complex expression
+          // like selected.includes(opt) which can't be assigned to.
+          if (this.isSimpleAssignable(value)) {
+            const event = key === 'checked' ? 'change' : 'input';
+            const accessor = key === 'checked' ? 'e.target.checked'
+              : (inputType === 'number' || inputType === 'range') ? 'e.target.valueAsNumber'
+              : 'e.target.value';
+            this._createLines.push(`${elVar}.addEventListener('${event}', (e) => { ${valueCode} = ${accessor}; });`);
+          }
           continue;
         }
 
@@ -1605,6 +1633,19 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     return false;
   };
 
+  // isSimpleAssignable — check if value is a plain reactive member (assignable target)
+  // --------------------------------------------------------------------------
+
+  proto.isSimpleAssignable = function(sexpr) {
+    if (typeof sexpr === 'string') {
+      return !!(this.reactiveMembers && this.reactiveMembers.has(sexpr));
+    }
+    if (Array.isArray(sexpr) && sexpr[0] === '.' && sexpr[1] === 'this' && typeof sexpr[2] === 'string') {
+      return !!(this.reactiveMembers && this.reactiveMembers.has(sexpr[2]));
+    }
+    return false;
+  };
+
   // _rootsAtThis — check if a property-access chain is rooted at 'this'
   // --------------------------------------------------------------------------
 

package/src/sourcemaps.js

@@ -1,8 +1,8 @@
-// Source Map V3 Generator — zero dependencies
+// Source Map V3 — zero dependencies
 //
 // Implements the ECMA-426 Source Map specification (V3).
-// Generates .map JSON files that map compiled JavaScript
-// back to original Rip source positions.
+// Generates and parses .map JSON files that map compiled
+// JavaScript back to original Rip source positions.
 
 const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
@@ -118,4 +118,72 @@ class SourceMapGenerator {
   }
 }
 
-export { SourceMapGenerator, vlqEncode };
+// Decode a Base64-VLQ string back to signed integers
+function vlqDecode(str) {
+  const values = [];
+  let i = 0;
+  while (i < str.length) {
+    let value = 0, shift = 0, digit;
+    do {
+      digit = B64.indexOf(str[i++]);
+      value |= (digit & 0x1F) << shift;
+      shift += 5;
+    } while (digit & 0x20);
+    values.push(value & 1 ? -(value >> 1) : value >> 1);
+  }
+  return values;
+}
+
+// Parse a Source Map V3 JSON string into a generated-line → source-line Map
+function parseSourceMap(mapJSON) {
+  const map = JSON.parse(mapJSON);
+  const genToSrc = new Map();
+  let srcLine = 0, srcCol = 0, genCol = 0;
+
+  const lines = map.mappings.split(';');
+  for (let genLine = 0; genLine < lines.length; genLine++) {
+    genCol = 0;
+    if (!lines[genLine]) continue;
+    for (const seg of lines[genLine].split(',')) {
+      const fields = vlqDecode(seg);
+      if (fields.length < 4) continue;
+      genCol += fields[0];
+      srcLine += fields[2];
+      srcCol += fields[3];
+      if (!genToSrc.has(genLine)) genToSrc.set(genLine, srcLine);
+    }
+  }
+  return genToSrc;
+}
+
+// Build bidirectional line maps from compiler output.
+// Tries reverseMap first (detailed mapping from the compiler), falls back
+// to decoding the VLQ source map JSON. Keys in the returned maps are
+// adjusted by headerLines so they correspond to tsContent line numbers.
+function buildLineMap(reverseMap, mapJSON, headerLines) {
+  const srcToGen = new Map();
+  const genToSrc = new Map();
+
+  let hasEntries = false;
+  if (reverseMap) {
+    for (const [srcLine, { genLine }] of reverseMap) {
+      const adj = genLine + headerLines;
+      srcToGen.set(srcLine, adj);
+      genToSrc.set(adj, srcLine);
+      hasEntries = true;
+    }
+  }
+
+  if (!hasEntries && mapJSON) {
+    const vlqMap = parseSourceMap(mapJSON);
+    for (const [genLine, srcLine] of vlqMap) {
+      const adj = genLine + headerLines;
+      srcToGen.set(srcLine, adj);
+      genToSrc.set(adj, srcLine);
+    }
+  }
+
+  return { srcToGen, genToSrc };
+}
+
+export { SourceMapGenerator, vlqEncode, vlqDecode, parseSourceMap, buildLineMap };

package/src/typecheck.js

@@ -0,0 +1,367 @@
+// Shared type-checking infrastructure for Rip
+//
+// Used by both the CLI type-checker (bin/rip check) and the
+// VS Code language server (packages/vscode/src/lsp.js).
+//
+// compileForCheck() — the shared compilation pipeline that transforms
+//   .rip source into TypeScript content suitable for type-checking.
+//
+// runCheck() — the CLI batch type-checker that compiles all .rip files
+//   in a directory, creates a TypeScript language service, and reports
+//   type errors mapped back to Rip source positions.
+
+import { Compiler } from './compiler.js';
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { resolve, relative, dirname } from 'path';
+import { buildLineMap } from './sourcemaps.js';
+
+// ── Shared helpers ─────────────────────────────────────────────────
+
+// Detect type annotations (:: followed by space or =) ignoring comments
+// and prototype syntax (Class::method).
+export function hasTypeAnnotations(source) {
+  return source.split('\n').some(line => /::[ \t=]/.test(line.replace(/#.*$/, '')));
+}
+
+export function countLines(str) {
+  let n = 0;
+  for (let i = 0; i < str.length; i++) if (str[i] === '\n') n++;
+  return n;
+}
+
+export function toVirtual(p) { return p + '.ts'; }
+export function fromVirtual(p) { return p.endsWith('.rip.ts') ? p.slice(0, -3) : p; }
+
+// TS error codes to skip — Rip resolves modules differently and
+// treats async return types transparently.
+export const SKIP_CODES = new Set([
+  2307, // Cannot find module
+  2304, // Cannot find name
+  1064, // Return type of async function must be Promise
+  2582, // Cannot find name 'test' (test runner globals)
+  2593, // Cannot find name 'describe' (test runner globals)
+]);
+
+// Base TypeScript compiler settings for type-checking. Callers can
+// pass overrides (e.g. { noImplicitAny: true } for the CLI).
+export function createTypeCheckSettings(ts, overrides = {}) {
+  return {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    allowJs: true,
+    strict: false,
+    strictNullChecks: true,
+    noEmit: true,
+    skipLibCheck: true,
+    ...overrides,
+  };
+}
+
+// ── Shared compilation pipeline ────────────────────────────────────
+
+// Compile a .rip file for type-checking. Merges .d.ts declarations into
+// the compiled JS, detects type annotations, and builds bidirectional
+// source maps. Returns everything both the CLI and LSP need.
+export function compileForCheck(filePath, source, compiler) {
+  const result = compiler.compile(source, { sourceMap: true, types: true });
+  let code = result.code || '';
+  let dts = result.dts ? result.dts.trimEnd() + '\n' : '';
+
+  // Strip .d.ts imports — compiled JS already has them
+  dts = dts.replace(/^import\s.*;\s*\n/gm, '');
+
+  // Extract well-formed function signatures and merge into JS.
+  // Leaving them as bare declarations causes TypeScript to treat
+  // them as overload signatures that conflict with the implementations.
+  const funcSigs = new Map();
+  dts = dts.replace(
+    /^(?:export|declare)\s+function\s+(\w+)\(([^)]*)\):\s*(.+);\s*$/gm,
+    (_m, name, params, ret) => { funcSigs.set(name, { params, ret }); return ''; },
+  );
+  dts = dts.replace(/^\s*\n/gm, '');
+
+  // Strip remaining malformed multi-line declarations
+  dts = dts.replace(/(?:export|declare)\s+function\s+\w+\([\s\S]*?\);\s*/g, '');
+  dts = dts.replace(/^\s*\n/gm, '');
+
+  for (const [name, { params, ret }] of funcSigs) {
+    const paramTypes = new Map();
+    if (params.trim()) {
+      for (const p of params.split(',')) {
+        const colon = p.indexOf(':');
+        if (colon !== -1) paramTypes.set(p.slice(0, colon).trim(), p.slice(colon + 1).trim());
+      }
+    }
+    const funcRe = new RegExp(
+      `((?:export\\s+)?(?:async\\s+)?function\\s+${name})\\(([^)]*)\\)(\\s*\\{)`,
+    );
+    code = code.replace(funcRe, (_match, prefix, codeParams, brace) => {
+      const typed = codeParams.split(',').map(p => {
+        const n = p.trim();
+        const t = paramTypes.get(n);
+        return t ? `${n}: ${t}` : n;
+      }).join(', ');
+      return `${prefix}(${typed}): ${ret}${brace}`;
+    });
+  }
+
+  // Remove bare `let x;` declarations when the DTS already declares
+  // `let x: Type;` — avoids "Cannot redeclare" conflicts. Handles
+  // both single (`let x;`) and comma-separated (`let x, y;`) forms.
+  const dtsVars = new Set();
+  for (const m of dts.matchAll(/^(?:let|var)\s+(\w+)\s*:/gm)) dtsVars.add(m[1]);
+  if (dtsVars.size) {
+    code = code.replace(/^(let|var)\s+([\w\s,]+);[ \t]*$/gm, (_m, kw, vars) => {
+      const kept = vars.split(',').map(v => v.trim()).filter(v => !dtsVars.has(v));
+      return kept.length ? `${kw} ${kept.join(', ')};` : '';
+    });
+  }
+
+  // Determine if this file should be type-checked
+  const hasOwnTypes = hasTypeAnnotations(source);
+  let importsTyped = false;
+  if (!hasOwnTypes) {
+    const ripImports = [...source.matchAll(/from\s+['"]([^'"]*\.rip)['"]/g)];
+    for (const m of ripImports) {
+      const imported = resolve(dirname(filePath), m[1]);
+      try {
+        const impSrc = readFileSync(imported, 'utf8');
+        if (hasTypeAnnotations(impSrc)) { importsTyped = true; break; }
+      } catch {}
+    }
+  }
+  const hasTypes = hasOwnTypes || importsTyped;
+  if (!hasTypes) code = '// @ts-nocheck\n' + code;
+
+  // Ensure every file is treated as a module (not a global script)
+  if (!/\bexport\b/.test(code) && !/\bimport\b/.test(code)) code += '\nexport {};\n';
+
+  const tsContent = (hasTypes ? dts + '\n' : '') + code;
+  const headerLines = hasTypes ? countLines(dts + '\n') : 1;
+
+  // Build bidirectional line maps
+  const { srcToGen, genToSrc } = buildLineMap(result.reverseMap, result.map, headerLines);
+
+  // Map DTS variable declaration lines back to their source lines.
+  // TypeScript may report errors on the `let x: Type;` line in the
+  // DTS header, which has no entry in genToSrc. Fix by matching
+  // variable names to source lines with `x::`.
+  if (hasTypes && dts) {
+    const dtsLines = dts.split('\n');
+    const srcLines = source.split('\n');
+    for (let i = 0; i < dtsLines.length; i++) {
+      const m = dtsLines[i].match(/^(?:let|var)\s+(\w+)\s*:/);
+      if (!m) continue;
+      const varName = m[1];
+      for (let s = 0; s < srcLines.length; s++) {
+        if (new RegExp('\\b' + varName + '\\s*::').test(srcLines[s])) {
+          genToSrc.set(i, s);
+          break;
+        }
+      }
+    }
+  }
+
+  return { tsContent, headerLines, hasTypes, srcToGen, genToSrc, source };
+}
+
+// ── Source mapping helpers ──────────────────────────────────────────
+
+export function offsetToLine(text, offset) {
+  let line = 0;
+  for (let i = 0; i < offset && i < text.length; i++) {
+    if (text[i] === '\n') line++;
+  }
+  return line;
+}
+
+// Map a TypeScript diagnostic offset back to a Rip source line number.
+// Returns -1 if the offset falls in the DTS header.
+export function mapToSource(entry, offset) {
+  const tsLine = offsetToLine(entry.tsContent, offset);
+  if (tsLine < entry.headerLines) return -1;
+
+  if (entry.genToSrc.has(tsLine)) return entry.genToSrc.get(tsLine);
+  for (let d = 1; d <= 3; d++) {
+    if (entry.genToSrc.has(tsLine - d)) return entry.genToSrc.get(tsLine - d);
+    if (entry.genToSrc.has(tsLine + d)) return entry.genToSrc.get(tsLine + d);
+  }
+  return tsLine - entry.headerLines;
+}
+
+// ── CLI batch type-checker ─────────────────────────────────────────
+
+function findRipFiles(dir, files = []) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    const full = resolve(dir, entry.name);
+    if (entry.isDirectory()) findRipFiles(full, files);
+    else if (entry.name.endsWith('.rip')) files.push(full);
+  }
+  return files;
+}
+
+const isColor = process.stdout.isTTY !== false;
+const red     = (s) => isColor ? `\x1b[31m${s}\x1b[0m` : s;
+const yellow  = (s) => isColor ? `\x1b[33m${s}\x1b[0m` : s;
+const cyan    = (s) => isColor ? `\x1b[36m${s}\x1b[0m` : s;
+const dim     = (s) => isColor ? `\x1b[2m${s}\x1b[0m`  : s;
+const bold    = (s) => isColor ? `\x1b[1m${s}\x1b[0m`  : s;
+
+export async function runCheck(targetDir, opts = {}) {
+  const ts = await import('typescript').then(m => m.default || m);
+  const rootPath = resolve(targetDir);
+
+  if (!existsSync(rootPath)) {
+    console.error(red(`Error: directory not found: ${targetDir}`));
+    return 1;
+  }
+
+  const allFiles = findRipFiles(rootPath);
+  if (allFiles.length === 0) {
+    console.error(red(`No .rip files found in ${targetDir}`));
+    return 1;
+  }
+
+  // Compile all files
+  const compiled = new Map();
+  const compiler = new Compiler();
+  let compileErrors = 0;
+
+  for (const fp of allFiles) {
+    try {
+      const source = readFileSync(fp, 'utf8');
+      compiled.set(fp, compileForCheck(fp, source, compiler));
+    } catch (e) {
+      compileErrors++;
+      const rel = relative(rootPath, fp);
+      console.error(`${red('error')} ${cyan(rel)}: compile error — ${e.message}`);
+    }
+  }
+
+  // Also compile any .rip files imported from typed files that aren't in rootPath
+  for (const [fp, entry] of [...compiled.entries()]) {
+    if (!entry.hasTypes) continue;
+    const ripImports = [...entry.source.matchAll(/from\s+['"]([^'"]*\.rip)['"]/g)];
+    for (const m of ripImports) {
+      const imported = resolve(dirname(fp), m[1]);
+      if (!compiled.has(imported) && existsSync(imported)) {
+        try {
+          const impSrc = readFileSync(imported, 'utf8');
+          compiled.set(imported, compileForCheck(imported, impSrc, compiler));
+        } catch {}
+      }
+    }
+  }
+
+  // Create TypeScript language service
+  const settings = createTypeCheckSettings(ts, { noImplicitAny: true });
+
+  const host = {
+    getScriptFileNames: () => [...compiled.keys()].map(toVirtual),
+    getScriptVersion: () => '1',
+    getScriptSnapshot(f) {
+      const c = compiled.get(fromVirtual(f));
+      if (c) return ts.ScriptSnapshot.fromString(c.tsContent);
+      try { return ts.ScriptSnapshot.fromString(readFileSync(f, 'utf8')); } catch { return undefined; }
+    },
+    getCompilationSettings: () => settings,
+    getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+    getCurrentDirectory: () => rootPath,
+    fileExists(f) { return compiled.has(fromVirtual(f)) || ts.sys.fileExists(f); },
+    readFile(f) { return compiled.get(fromVirtual(f))?.tsContent || ts.sys.readFile(f); },
+    readDirectory: (...a) => ts.sys.readDirectory(...a),
+    getDirectories: (...a) => ts.sys.getDirectories(...a),
+    directoryExists: (...a) => ts.sys.directoryExists(...a),
+
+    resolveModuleNames(names, containingFile) {
+      return names.map((name) => {
+        if (name.endsWith('.rip')) {
+          const resolved = resolve(dirname(fromVirtual(containingFile)), name);
+          if (compiled.has(resolved)) {
+            return { resolvedFileName: toVirtual(resolved), extension: '.ts', isExternalLibraryImport: false };
+          }
+        }
+        const r = ts.resolveModuleName(name, containingFile, settings, {
+          fileExists: host.fileExists,
+          readFile: host.readFile,
+          directoryExists: host.directoryExists,
+          getCurrentDirectory: host.getCurrentDirectory,
+          getDirectories: host.getDirectories,
+        });
+        return r.resolvedModule;
+      });
+    },
+  };
+
+  const service = ts.createLanguageService(host, ts.createDocumentRegistry());
+
+  // Collect diagnostics
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  const fileResults = [];
+
+  for (const [fp, entry] of compiled) {
+    if (!entry.hasTypes) continue;
+
+    const vf = toVirtual(fp);
+    let diags;
+    try {
+      const sem = service.getSemanticDiagnostics(vf);
+      const syn = service.getSyntacticDiagnostics(vf);
+      diags = [...syn, ...sem];
+    } catch {
+      continue;
+    }
+
+    const errors = [];
+    for (const d of diags) {
+      if (d.start === undefined) continue;
+      if (SKIP_CODES.has(d.code)) continue;
+
+      const srcLine = mapToSource(entry, d.start);
+      if (srcLine < 0) continue;
+
+      const message = ts.flattenDiagnosticMessageText(d.messageText, '\n');
+      const severity = d.category === 1 ? 'error' : d.category === 0 ? 'warning' : 'info';
+
+      errors.push({ line: srcLine + 1, message, severity, code: d.code });
+      if (severity === 'error') totalErrors++;
+      else if (severity === 'warning') totalWarnings++;
+    }
+
+    if (errors.length > 0) {
+      fileResults.push({ file: fp, errors });
+    }
+  }
+
+  // Print results
+  for (const { file, errors } of fileResults) {
+    const rel = relative(rootPath, file);
+    for (const e of errors) {
+      const loc = `${cyan(rel)}${dim(':')}${yellow(String(e.line))}`;
+      const sev = e.severity === 'error' ? red('error') : yellow('warning');
+      console.log(`${loc} ${sev} ${e.message} ${dim(`TS${e.code}`)}`);
+    }
+  }
+
+  // Summary
+  const typedFiles = [...compiled.values()].filter(e => e.hasTypes).length;
+  const totalFiles = compiled.size;
+
+  if (totalErrors === 0 && totalWarnings === 0) {
+    console.log(`\n${bold('✓')} ${typedFiles} typed file${typedFiles !== 1 ? 's' : ''} checked, no errors found`);
+    if (compileErrors > 0) {
+      console.log(dim(`  (${compileErrors} file${compileErrors !== 1 ? 's' : ''} had compile errors)`));
+    }
+    return compileErrors > 0 ? 1 : 0;
+  }
+
+  const parts = [];
+  if (totalErrors > 0) parts.push(red(`${totalErrors} error${totalErrors !== 1 ? 's' : ''}`));
+  if (totalWarnings > 0) parts.push(yellow(`${totalWarnings} warning${totalWarnings !== 1 ? 's' : ''}`));
+  console.log(`\n${bold('✗')} ${parts.join(', ')} in ${fileResults.length} file${fileResults.length !== 1 ? 's' : ''} (${typedFiles} typed / ${totalFiles} total)`);
+
+  return totalErrors > 0 ? 1 : 0;
+}