rip-lang 3.16.1 → 3.16.2

package/src/typecheck.js

@@ -132,6 +132,110 @@ export function findStashFile(filePath) {
   return result;
 }
 
+// ── Static gate-path validation ────────────────────────────────────
+//
+// `x <~ @app.data.path` requires the path to resolve to a source key —
+// the renderer enforces this with a deterministic mount-time error, and
+// `rip check` mirrors it at compile time by reading the stash module's
+// s-expressions: collect module-level bindings, find the `stash` object
+// literal, and classify each gate path's keys. The analysis is
+// CONSERVATIVE: only paths that provably land on a plain key (or on no
+// key) error; anything whose source-ness isn't statically visible —
+// imported cells, factory calls, spreads — stays silent and the mount
+// check backstops it. False positives are the failure mode to avoid;
+// false negatives just fall back to today's runtime error.
+
+function sexprName(v) {
+  return (typeof v === 'string' || v instanceof String) ? v.valueOf() : null;
+}
+
+// Walk a stash module's program s-expression into { stashObj, bindings }:
+// the `stash` object literal plus every module-level `name = value`
+// binding (so `orders: ordersSource` can chase `ordersSource = source …`).
+export function collectStashAnalysis(sexpr) {
+  if (!Array.isArray(sexpr) || sexpr[0] !== 'program') return null;
+  const bindings = new Map();
+  for (let stmt of sexpr.slice(1)) {
+    if (!Array.isArray(stmt)) continue;
+    if (stmt[0] === 'export' && Array.isArray(stmt[1])) stmt = stmt[1];
+    if (stmt[0] === '=' || stmt[0] === 'readonly') {
+      const name = sexprName(stmt[1]);
+      if (name) bindings.set(name, stmt[2]);
+    }
+  }
+  const stashObj = bindings.get('stash');
+  if (!Array.isArray(stashObj) || sexprName(stashObj[0]) !== 'object') return null;
+  return { stashObj, bindings };
+}
+
+// 'source' | 'plain' | 'unknown' | { kind: 'object', node } — what a stash
+// value provably is. Identifier references chase module-level bindings.
+function classifyStashValue(node, bindings, depth = 0) {
+  if (depth > 8) return 'unknown';
+  const name = sexprName(node);
+  if (name != null) {
+    if (/^["'\d]/.test(name) || name === 'true' || name === 'false' ||
+        name === 'null' || name === 'undefined') return 'plain';
+    if (bindings.has(name)) return classifyStashValue(bindings.get(name), bindings, depth + 1);
+    return 'unknown';   // imported or otherwise invisible
+  }
+  if (!Array.isArray(node)) return 'unknown';
+  const head = sexprName(node[0]);
+  if (head === 'source') return 'source';       // application of the source() declarator
+  if (head === 'object') return { kind: 'object', node };
+  if (head === 'array') return 'plain';
+  return 'unknown';
+}
+
+// Shared by `rip check` and the LSP: turn a file's hoisted gates into
+// diagnostic records against the stash analysis. Lines/cols are 1-based
+// (the LSP converts). Only provably-wrong paths produce records — see
+// validateGatePath below for the conservative verdict rules.
+export function collectGateDiagnostics(gates, source, analysis) {
+  const out = [];
+  if (!gates || !gates.length || !analysis) return out;
+  const srcLines = source.split('\n');
+  for (const g of gates) {
+    const verdict = validateGatePath(g.path, analysis);
+    if (verdict !== 'plain' && verdict !== 'missing') continue;
+    const lineText = srcLines[g.line - 1] ?? '';
+    const idx = lineText.indexOf('@app.data');
+    const detail = verdict === 'missing'
+      ? `'${g.path}' is not a key of the stash`
+      : `'${g.path}' is a plain key`;
+    out.push({
+      line: g.line,
+      col: (idx >= 0 ? idx : 0) + 1,
+      len: idx >= 0 ? '@app.data.'.length + String(g.path).length : Math.max(lineText.trim().length, 1),
+      message: `'${g.path} <~' does not resolve to a source (${detail}) — declare it with source() in app/stash.rip`,
+      srcLine: lineText,
+    });
+  }
+  return out;
+}
+
+// Verdict for one gate path against the stash literal:
+// 'source' (ok), 'unknown' (silent), 'plain' / 'missing' (error).
+// Walks segments through plain object literals; stops at the nearest
+// source on the path (subpath gates bind under the loaded value).
+export function validateGatePath(path, analysis) {
+  let node = analysis.stashObj;
+  for (const seg of String(path).split('.')) {
+    const entries = new Map();
+    let hasOpaqueEntries = false;
+    for (const e of node.slice(1)) {
+      const key = Array.isArray(e) && sexprName(e[0]) === ':' ? sexprName(e[1]) : null;
+      if (key != null) entries.set(key, e[2]);
+      else hasOpaqueEntries = true;   // spread / computed key — can't enumerate
+    }
+    if (!entries.has(seg)) return hasOpaqueEntries ? 'unknown' : 'missing';
+    const c = classifyStashValue(entries.get(seg), analysis.bindings);
+    if (c === 'source' || c === 'unknown' || c === 'plain') return c;
+    node = c.node;   // plain object literal — walk deeper
+  }
+  return 'plain';    // path exhausted inside plain literals, no source found
+}
+
 // ── Route tree discovery ───────────────────────────────────────────
 //
 // The project's routes live under `<projectRoot>/app/routes/` — a fixed
@@ -192,7 +296,10 @@ export function walkRoutesDir(routesDir) {
       // Skip _-prefixed files (_layout.rip etc.) and dirs (shared
       // helpers, not pages). Same rule as runtime buildRoutes.
       if (e.name.startsWith('_')) continue;
-      if (e.isDirectory()) walk(resolve(dir, e.name), [...segs, e.name]);
+      // Pathless route groups: a `(name)` directory organizes routes and
+      // shares a _layout.rip without contributing a URL segment. Recurse
+      // but don't add it to the path. Mirrors runtime fileToPattern.
+      if (e.isDirectory()) walk(resolve(dir, e.name), /^\(.+\)$/.test(e.name) ? segs : [...segs, e.name]);
       else if (e.isFile() && e.name.endsWith('.rip')) {
         const base = e.name.slice(0, -'.rip'.length);
         const fileSegs = base === 'index' ? segs : [...segs, base];
@@ -927,26 +1034,36 @@ export function createTypeCheckSettings(ts, overrides = {}) {
 // sub-package check would miss workspace-root ambients. Accepts symlinks
 // because bun's nested-package layout symlinks `@types/bun` to
 // `.bun/@types+bun@.../node_modules/@types/bun`.
+//
+// rip targets the Bun runtime, so `Bun`, `process`, `Buffer`, etc. are
+// always present — rip ships `@types/bun` as a dependency and includes
+// its own `node_modules/@types` last, so every project type-checks those
+// globals without installing anything. A workspace that installs its own
+// `@types/bun`/`@types/node` still wins: its dir is walked first and the
+// name dedup below keeps that copy.
 export function collectAmbientTypes(rootPath) {
   const typeRoots = [];
   const types = [];
+  const scan = (cand) => {
+    if (typeRoots.includes(cand) || !existsSync(cand)) return;
+    typeRoots.push(cand);
+    try {
+      for (const entry of readdirSync(cand, { withFileTypes: true })) {
+        if ((entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith('.') && !types.includes(entry.name)) {
+          types.push(entry.name);
+        }
+      }
+    } catch {}
+  };
   let dir = rootPath;
   while (true) {
-    const cand = resolve(dir, 'node_modules/@types');
-    if (existsSync(cand)) {
-      typeRoots.push(cand);
-      try {
-        for (const entry of readdirSync(cand, { withFileTypes: true })) {
-          if ((entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith('.') && !types.includes(entry.name)) {
-            types.push(entry.name);
-          }
-        }
-      } catch {}
-    }
+    scan(resolve(dir, 'node_modules/@types'));
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
+  // rip's own bundled ambients (this file lives at <rip-lang>/src/typecheck.js).
+  scan(resolve(import.meta.dirname, '../node_modules/@types'));
   return { typeRoots, types };
 }
 
@@ -1149,17 +1266,55 @@ function injectTypeParams(line, typeParams) {
 export function compileForCheck(filePath, source, compiler, opts = {}) {
   const result = compiler.compile(source, { sourceMap: true, types: 'emit', skipPreamble: true, stubComponents: true, inlineTypes: true });
   let code = result.code || '';
-  const dts = result.dts ? result.dts.trimEnd() + '\n' : '';
+  let dts = result.dts ? result.dts.trimEnd() + '\n' : '';
+
+  // ── Schema shadow reconciliation ──────────────────────────────────────
+  // The compiled body keeps its runtime `const Name = __schema({...})`
+  // bindings verbatim, so source maps stay exact. But in a `.ts` shadow that
+  // body references an undeclared `__schema` (skipPreamble drops the runtime
+  // import) and would also collide with the dts `declare const Name`. Rewrite
+  // each schema `const` declaration into a `__schema` overload keyed on the
+  // schema's `name` literal, so the body's `__schema({name:"Name",...})` call
+  // resolves to the precise Schema/ModelSchema type with no duplicate binding.
+  // The `type` aliases (NameValue/NameData/NameInstance) are kept untouched —
+  // importers and the body both reference them.
+  let usesSchemas = false;
+  if (dts) {
+    const overloads = [];
+    const kept = [];
+    for (const line of dts.split('\n')) {
+      const m = line.match(/^(?:export )?declare const (\w+): (.+);\s*$/);
+      if (m && /^(?:Schema<|ModelSchema<|\{ parse\()/.test(m[2])) {
+        usesSchemas = true;
+        overloads.push(`declare function __schema(d: { name: "${m[1]}"; [k: string]: any }): ${m[2]};`);
+      } else {
+        // Anonymous-schema overloads are emitted directly by the dts pass
+        // (keyed on the descriptor's `__anon` marker); keep them, but they
+        // still mark the file as schema-using so the `(d: any) => any`
+        // fallback and registry declares are appended.
+        if (/^declare function __schema\(/.test(line)) usesSchemas = true;
+        kept.push(line);
+      }
+    }
+    if (usesSchemas) {
+      overloads.push('declare function __schema(d: any): any;');
+      overloads.push('declare const SchemaError: any;');
+      overloads.push('declare const __SchemaRegistry: any;');
+      overloads.push('declare const __schemaSetAdapter: any;');
+      dts = kept.join('\n').trimEnd() + '\n' + overloads.join('\n') + '\n';
+    }
+  }
 
   // Determine if this file should be type-checked.
   // A `# @nocheck` comment near the top of the file opts out entirely.
   // In strict mode, all non-nocheck files are type-checked.
   const nocheck = /^#\s*@nocheck\b/m.test(source.slice(0, NOCHECK_SCAN_LIMIT));
-  // Must match the CLI predicate in runCheck. Don't add `hasSchemas(source)`:
-  // that probe is a raw-source regex that fires on `schema :input` inside
-  // heredoc string literals (e.g. test files), flooding the LSP with TS2304
-  // false positives. Schema files still get their DTS via the schema pass.
-  const hasOwnTypes = !nocheck && (hasTypeAnnotations(source) || !!opts.checkAll);
+  // A file that declares schemas has an exportable type surface (its
+  // `NameValue`/`NameInstance` aliases), so it must be checked even without
+  // explicit `::`/`type` annotations — otherwise importers can't resolve those
+  // names. `usesSchemas` is derived from the compiled dts, not a raw-source
+  // regex, so it never false-fires on `schema` inside heredoc literals.
+  const hasOwnTypes = !nocheck && (hasTypeAnnotations(source) || !!opts.checkAll || usesSchemas);
   let importsTyped = false;
   if (!hasOwnTypes && !nocheck) {
     const ripImports = [...source.matchAll(/from\s+['"]([^'"]*\.rip)['"]/g)];
@@ -1763,6 +1918,13 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
       if (needEffect) decls.push(EFFECT_FN);
       headerDts = decls.join('\n') + '\n' + headerDts;
     }
+    // Gated bindings (`x <~ @app.data.x`) stub as
+    // `__computed(() => __ripGate(this.app.data.x))`. __ripGate is the
+    // generic narrow — soundness is supplied by the runtime gate, which
+    // loads the source before the component is constructed.
+    if (/\b__ripGate\(/.test(code) && !/\bdeclare function __ripGate\b/.test(headerDts)) {
+      headerDts = 'declare function __ripGate<T>(v: T | null | undefined): T;\n' + headerDts;
+    }
   }
 
   // Inject declarations for Rip's stdlib globals (abort, assert, p, sleep, etc.)
@@ -2022,19 +2184,28 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
   const isStash = stashFile && stashFile === filePath;
 
   if (isStash) {
-    // The DTS header hoists `export let stash: <Type>;` so the type is
-    // visible everywhere. The body emits either `let stash; ... stash = {...}`
-    // (no export) or `export const stash = {...}` (with export). Both
-    // conflict with the typed hoist — TS sees a redeclaration and the
-    // un-annotated body wins, collapsing the inferred type to `{ items:
-    // never[], ... }`. Rewrite both forms into a bare assignment to the
-    // already-declared `stash`, preserving the contextual type.
-    const letRe = /^(\s*let\s+)([^;=]+);/m;
-    code = code.replace(letRe, (full, prefix, names) => {
-      const remaining = names.split(',').map(s => s.trim()).filter(n => n !== 'stash');
-      return remaining.length ? `${prefix}${remaining.join(', ')};` : '';
-    });
-    code = code.replace(/^(\s*)export\s+const\s+stash\s*=/m, '$1stash =');
+    // For an ANNOTATED stash (`stash:: T = ...`) the DTS header hoists
+    // `export let stash: <Type>;` so the type is visible everywhere. The
+    // body emits either `let stash; ... stash = {...}` (no export) or
+    // `export const stash = {...}` (with export). Both conflict with the
+    // typed hoist — TS sees a redeclaration and the un-annotated body
+    // wins, collapsing the inferred type to `{ items: never[], ... }`.
+    // Rewrite both forms into a bare assignment to the already-declared
+    // `stash`, preserving the contextual type.
+    //
+    // An UNANNOTATED stash (`export stash = ...`, the inference path —
+    // source() keys carry their own types) hoists nothing, so the
+    // body declaration must stay: removing it left `typeof stash` with no
+    // `stash` at all.
+    const stashHoisted = /(^|\n)\s*export\s+(let|const|var)\s+stash\s*:/.test(headerDts || '');
+    if (stashHoisted) {
+      const letRe = /^(\s*let\s+)([^;=]+);/m;
+      code = code.replace(letRe, (full, prefix, names) => {
+        const remaining = names.split(',').map(s => s.trim()).filter(n => n !== 'stash');
+        return remaining.length ? `${prefix}${remaining.join(', ')};` : '';
+      });
+      code = code.replace(/^(\s*)export\s+const\s+stash\s*=/m, '$1stash =');
+    }
     code += `\nexport type __RipStash = typeof stash;\n`;
   }
 
@@ -2042,7 +2213,10 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
     let typedApp = null;
     if (stashFile && !isStash) {
       const spec = entryImportSpec(filePath, stashFile);
-      typedApp = `declare app: { data: import('${spec}').__RipStash; components: any; routes: any; params: any; query: any; router: any }`;
+      // data intersects the stash shape with the reserved stash methods
+      // (inc/dec/…, peek/reset, and the source handle) so they carry
+      // signatures and completion in typed projects.
+      typedApp = `declare app: { data: import('${spec}').__RipStash & import('@rip-lang/app').StashMethods<import('${spec}').__RipStash>; components: any; routes: any; params: any; query: any; router: any }`;
     }
     if (typedApp) code = code.replace(/declare app: any/g, typedApp);
   }
@@ -2150,16 +2324,14 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
       );
     }
 
-    // (b) Narrow router.push argument to __RipRoutes for typo-catching
-    // on programmatic navigation. Leave `router.replace` accepting plain
-    // `string` (the base Router signature) — it's commonly used to
-    // mutate the current URL with query strings, where the result is
-    // built dynamically and can't satisfy a literal-route union. Use
-    // Omit + re-add instead of intersection because intersecting
-    // overloaded methods makes the parameter type a union
-    // (contravariance), which loses the narrowing.
+    // (b) Route-check router.push / router.replace the same way as <a href>:
+    // slash-prefixed string LITERALS must be a known route (typos caught, clean
+    // route-list errors); dynamic strings and external URLs fall through. Build
+    // query/hash URLs as `string` values rather than slash-prefixed literals.
+    // Omit + re-add instead of intersection: intersecting overloaded methods
+    // unions the parameter type (contravariance), which loses the narrowing.
     if (code.includes(`declare router: import('@rip-lang/app').Router`)) {
-      const typedRouter = `declare router: Omit<import('@rip-lang/app').Router, 'push'> & { push(url: ${inlineRoutesUnion}, opts?: NavOpts): void; }`;
+      const typedRouter = `declare router: Omit<import('@rip-lang/app').Router, 'push' | 'replace'> & { push<const P extends string>(url: P extends \`/\${string}\` ? ${inlineRoutesUnion} : P, opts?: NavOpts): void; replace<const U extends string>(url: U extends \`/\${string}\` ? ${inlineRoutesUnion} : U, opts?: NavOpts): void; }`;
       code = code.replace(
         /declare router: import\('@rip-lang\/app'\)\.Router(?![ &])/g,
         typedRouter,
@@ -2360,7 +2532,7 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
     }
   }
 
-  return { tsContent, headerLines, hasTypes, srcToGen, genToSrc, srcColToGen, source, dts };
+  return { tsContent, headerLines, hasTypes, srcToGen, genToSrc, srcColToGen, source, dts, sexpr: result.sexpr, gates: result.gates || [] };
 }
 
 // ── Source-position mapping helpers ────────────────────────────────
@@ -2948,6 +3120,38 @@ export function retargetObjectArgOffset(entry, srcLine, srcCol, genOffset) {
   return genOffset - lc.col + i;
 }
 
+// Completion-offset fixup for object-literal property *values* whose owning
+// object spans several source lines that collapse to a single generated line.
+// An implicit-object call block —
+//   use serve
+//     preload: '▮'
+// — compiles to `use(serve({ …, preload: '' }))`, so srcToOffset maps the
+// property's source line onto that one statement gen line but lands near the
+// statement start, not inside the value string. Given the source line, the
+// cursor column, and the gen offset srcToOffset produced, this finds the same
+// `key: <quote>` on the gen line and returns the absolute gen offset at the
+// matching spot inside the gen string — so TS can supply the contextually-typed
+// string-literal completions. Returns genOffset unchanged outside this context.
+export function retargetObjectValueOffset(entry, srcLine, srcCol, genOffset) {
+  if (!entry || genOffset == null || !srcLine) return genOffset;
+  const m = srcLine.match(/^(\s*)([\w$]+)(\s*:\s*)(["'])/);
+  if (!m) return genOffset;
+  const key = m[2];
+  const strStart = m[0].length;             // src index just inside the opening quote
+  if (srcCol < strStart) return genOffset;   // cursor isn't inside the value string
+  const inStr = srcCol - strStart;           // characters into the string content
+
+  const tsText = entry.tsContent;
+  const lc = offsetToLineCol(tsText, genOffset);
+  const genLine = tsText.split('\n')[lc.line];
+  if (genLine == null) return genOffset;
+  const re = new RegExp('\\b' + key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s*:\\s*["\']');
+  const gm = re.exec(genLine);
+  if (!gm) return genOffset;
+  const genStrInside = gm.index + gm[0].length;   // just inside the gen opening quote
+  return (genOffset - lc.col) + genStrInside + inStr;
+}
+
 // Map a Rip source (line, col) to a TypeScript virtual file byte offset.
 // This is the forward direction: source → generated (used for hover, definition, etc.)
 //
@@ -3250,15 +3454,16 @@ const bold    = (s) => isColor ? `\x1b[1m${s}\x1b[0m`  : s;
 export async function runCheck(targetDir, opts = {}) {
   const rootPath = resolve(targetDir);
 
+  // Use rip's own catalog-pinned TypeScript (a dependency), never the
+  // consumer's — so `rip check` and the editor type-check with the exact
+  // same version. import('typescript') resolves from this file's location
+  // (rip-lang's node_modules) regardless of the consumer's setup.
   let ts;
   try {
-    const req = createRequire(resolve(rootPath, 'package.json'));
-    ts = req('typescript');
+    ts = await import('typescript').then(m => m.default || m);
   } catch {
-    try { ts = await import('typescript').then(m => m.default || m); } catch {
-      console.error('TypeScript is required for type checking. Install with: bun add -d typescript');
-      return 1;
-    }
+    console.error('TypeScript could not be loaded. Reinstall rip-lang (it ships TypeScript as a dependency).');
+    return 1;
   }
 
   if (!existsSync(rootPath)) {
@@ -3477,7 +3682,19 @@ export async function runCheck(targetDir, opts = {}) {
     }
   }
 
-  // Check for unresolved relative imports in all files (not just typed ones)
+  // Check for unresolved relative imports in all files (not just typed ones),
+  // and validate render gates (<~) against the stash's source-key set.
+  const stashAnalyses = new Map();
+  const stashAnalysisFor = (fp) => {
+    const stashFile = findStashFile(fp);
+    if (!stashFile) return null;
+    if (!stashAnalyses.has(stashFile)) {
+      const entry = compiled.get(stashFile);
+      stashAnalyses.set(stashFile, entry?.sexpr ? collectStashAnalysis(entry.sexpr) : null);
+    }
+    return stashAnalyses.get(stashFile);
+  };
+
   const fileResults = [];
   let totalErrors = 0, totalWarnings = 0;
   for (const [fp, source] of sourcesByPath) {
@@ -3494,6 +3711,18 @@ export async function runCheck(targetDir, opts = {}) {
         totalErrors++;
       }
     }
+
+    // A gate whose path provably lands on a plain key (or no key)
+    // in app/stash.rip is the compile-time form of the renderer's
+    // deterministic mount error. Conservative — see validateGatePath.
+    const gates = compiled.get(fp)?.gates;
+    if (gates && gates.length) {
+      for (const d of collectGateDiagnostics(gates, source, stashAnalysisFor(fp))) {
+        errors.push({ line: d.line, col: d.col, len: d.len, message: d.message, severity: 'error', code: 'rip', srcLine: d.srcLine, related: [] });
+        totalErrors++;
+      }
+    }
+
     if (errors.length > 0) fileResults.push({ file: fp, errors });
   }
 
@@ -4202,15 +4431,14 @@ function joinPath(label, step, rest) {
 export async function runAudit(targetDir) {
   const rootPath = resolve(targetDir);
 
+  // Use rip's own catalog-pinned TypeScript (a dependency), never the
+  // consumer's — see runCheck above.
   let ts;
   try {
-    const req = createRequire(resolve(rootPath, 'package.json'));
-    ts = req('typescript');
+    ts = await import('typescript').then(m => m.default || m);
   } catch {
-    try { ts = await import('typescript').then(m => m.default || m); } catch {
-      console.error('TypeScript is required for --audit. Install with: bun add -d typescript');
-      return 1;
-    }
+    console.error('TypeScript could not be loaded. Reinstall rip-lang (it ships TypeScript as a dependency).');
+    return 1;
   }
 
   const pkgJsonPath = resolve(rootPath, 'package.json');

package/src/types.js

@@ -378,7 +378,7 @@ function collectTypeExpression(tokens, j) {
       }
       if (tTag === '=' || tTag === 'REACTIVE_ASSIGN' ||
           tTag === 'COMPUTED_ASSIGN' || tTag === 'READONLY_ASSIGN' ||
-          tTag === 'EFFECT' || tTag === 'TERMINATOR' ||
+          tTag === 'EFFECT' || tTag === 'GATE' || tTag === 'TERMINATOR' ||
           tTag === 'INDENT' || tTag === 'OUTDENT' ||
           tTag === '->' || tTag === ',') {
         break;
@@ -470,6 +470,10 @@ function buildTypeString(typeTokens) {
     if (t.data?.optional && next && (next[0] === 'TYPE_ANNOTATION' || next[0] === ':')) {
       return `${t[1]}?`;
     }
+    // Embedded-JS tokens are backtick literals with the delimiters stripped
+    // by the lexer. In type position they are TS template-literal types
+    // (e.g. `${number} min`) — re-wrap them so the emitted type is valid.
+    if (t[0] === 'JS') return '`' + t[1] + '`';
     return t[1];
   });
   let typeStr = parts.join(' ').replace(/\s+/g, ' ').trim();