@runtime-type-inspector/transpiler 4.0.6 → 5.0.1

package/index.mjs

@@ -1,6 +1,52 @@
 import { parse } from '@babel/parser';
 import ts from 'typescript';
 
+/**
+ * @typedef DocType
+ * @property {boolean} optional - Type is optional.
+ */
+/**
+ * Annotates a type with optionality for internal use (parseJSDoc navigation).
+ * Sets optionality on object types and wraps bare strings that need to be
+ * expandable containers (e.g. 'object', 'object[]', 'union') into objects
+ * so that parseJSDoc can later navigate into their properties.
+ * Does NOT recurse into compound types or delete properties — those are
+ * kept fully expanded so that parseJSDoc and JSDocAnnotator can still
+ * mutate them (e.g. appending nested @param lines).
+ * Literal types (numbers/booleans) pass through bare unless optional,
+ * mirroring the string path.
+ * @param {string | number | boolean | DocType} type - The type.
+ * @param {boolean} optional - Optionality
+ * @returns {string | number | boolean | DocType} The annotated type.
+ */
+function annotateOptional(type, optional) {
+  // If it's already an object, just set optionality.
+  if (type instanceof Object) {
+    type.optional = optional;
+  } else if (typeof type === 'number' || typeof type === 'boolean') {
+    if (!optional) {
+      return type;
+    }
+    type = {
+      type,
+      optional
+    };
+  } else if (typeof type === 'string') {
+    type = type.trim();
+    if (type !== 'object' && type !== 'object[]' && type !== 'union' && !optional) {
+      return type;
+    }
+    type = {
+      type,
+      optional
+    };
+  } else {
+    debugger;
+    console.warn("annotateOptional> neither object nor string for type", type);
+  }
+  return type;
+}
+
 /**
  * Transforms a type string into a structured type representation.
  *
@@ -157,6 +203,10 @@ function toSourceTS(node) {
     // parseType('keyof typeof obj'               ).kind                 === ts.SyntaxKind.TypeOperator
     KeyOfKeyword,
     // parseType('keyof typeof obj'               ).operator             === ts.SyntaxKind.KeyOfKeyword
+    ReadonlyKeyword,
+    // parseType('readonly number[]'              ).operator             === ts.SyntaxKind.ReadonlyKeyword
+    UniqueKeyword,
+    // parseType('unique symbol'                  ).operator             === ts.SyntaxKind.UniqueKeyword
     ConstructorType,
     // parseType('new (...args: any[]) => any'    ).kind                 === ts.SyntaxKind.ConstructorType
     NamedTupleMember,
@@ -165,7 +215,11 @@ function toSourceTS(node) {
     // parseType('{[K in TaskType]: 123}'         ).kind                 === ts.SyntaxKind.MappedType
     TypeParameter,
     // parseType('{[K in TaskType]: 123}'         ).typeParameter.kind   ===  ts.SyntaxKind.TypeParameter
-    QualifiedName // parseType("import('abc').x.y"              ).qualifier.kind       === ts.SyntaxKind.QualifiedName
+    QualifiedName,
+    // parseType("import('abc').x.y"              ).qualifier.kind       === ts.SyntaxKind.QualifiedName
+    TemplateLiteralType,
+    // parseType('`${A}_id`'                      ).kind                 === ts.SyntaxKind.TemplateLiteralType
+    NoSubstitutionTemplateLiteral // parseType('`id`'                  ).literal.kind         === ts.SyntaxKind.NoSubstitutionTemplateLiteral
   } = ts.SyntaxKind;
   // console.log({typeArguments, typeName, kind_, node});
   switch (node.kind) {
@@ -328,9 +382,15 @@ function toSourceTS(node) {
           argument: _argument
         };
       }
+      if (node.operator === ReadonlyKeyword) {
+        // readonly erased at runtime, same shape as the inner type.
+        return toSourceTS(node.type);
+      }
       console.warn("unimplemented TypeOperator", node);
+      return 'any';
     case TypeReference:
       {
+        var _typeName$text;
         if (!ts.isTypeReferenceNode(node)) {
           throw Error("Impossible");
         }
@@ -381,7 +441,8 @@ function toSourceTS(node) {
         if (!typeArguments) {
           return typeName.getText();
         }
-        const _name = typeName.text;
+        // Qualified names (e.g. `some.name.space.Array<T>`) have no `.text`.
+        const _name = (_typeName$text = typeName.text) != null ? _typeName$text : typeName.getText();
         const args = typeArguments.map(toSourceTS);
         return {
           type: 'reference',
@@ -390,10 +451,25 @@ function toSourceTS(node) {
         };
       }
     case NamedTupleMember:
-      if (!ts.isNamedTupleMember(node)) {
-        throw Error("Impossible");
+      {
+        if (!ts.isNamedTupleMember(node)) {
+          throw Error("Impossible");
+        }
+        const nName = toSourceTS(node.name);
+        const nType = toSourceTS(node.type);
+        const opt = !!node.questionToken;
+        const dot = !!node.dotDotDotToken;
+        // Preserve label for docs: [a: string, b: number] -> keep name
+        // Use tupleMember shape so stringify can round-trip
+        const mem = {
+          type: 'tupleMember',
+          name: nName,
+          elementType: nType
+        };
+        if (opt) mem.optional = true;
+        if (dot) mem.dotDot = true;
+        return mem;
       }
-      return toSourceTS(node.type);
     case IntersectionType:
       {
         if (!ts.isIntersectionTypeNode(node)) {
@@ -414,6 +490,34 @@ function toSourceTS(node) {
         type: 'tuple',
         elements
       };
+    case TemplateLiteralType:
+      {
+        if (!ts.isTemplateLiteralTypeNode(node)) {
+          throw Error("Impossible");
+        }
+        // A template literal type is a sequence of literal chunks (quasis) with
+        // type expressions (types) in between, e.g. `${A}_${B}` becomes:
+        //   {quasis: ['', '_', ''], types: [<A>, <B>]}
+        const quasis = [node.head.text];
+        /** @type {any[]} */
+        const types = [];
+        for (const span of node.templateSpans) {
+          types.push(toSourceTS(span.type));
+          quasis.push(span.literal.text);
+        }
+        return {
+          type: 'templateLiteral',
+          quasis,
+          types
+        };
+      }
+    case NoSubstitutionTemplateLiteral:
+      // A template literal type without interpolations, e.g. `id`
+      return {
+        type: 'templateLiteral',
+        quasis: [node.text],
+        types: []
+      };
     case UnionType:
       if (!ts.isUnionTypeNode(node)) {
         throw Error("Impossible");
@@ -441,7 +545,13 @@ function toSourceTS(node) {
               throw Error("Impossible");
             }
             const name = toSourceTS(member.name);
-            const type = toSourceTS(member.type);
+            let type = toSourceTS(member.type);
+            if (member.questionToken) {
+              if (type && typeof type === 'object') type.optional = true;else type = {
+                type,
+                optional: true
+              };
+            }
             properties[name] = type;
           } else {
             console.warn('TypeLiteral: unhandled member', member);
@@ -579,6 +689,71 @@ function toSourceTS(node) {
  * @property {(object | string)[]} [elements] - For tuples.
  * @property {object | string} [argument] - For typeof.
  */
+/**
+ * Splits a string by a delimiter, ignoring delimiters nested inside <>, {}, [], ().
+ * @param {string} str - The string to split.
+ * @param {string} delimiter - Single character delimiter.
+ * @returns {string[]} Top-level split parts.
+ */
+function splitTopLevel(str, delimiter) {
+  const parts = [];
+  let depthAngle = 0;
+  let depthCurly = 0;
+  let depthSquare = 0;
+  let depthParen = 0;
+  let current = '';
+  for (const c of str) {
+    if (c === '<') depthAngle++;else if (c === '>') depthAngle--;else if (c === '{') depthCurly++;else if (c === '}') depthCurly--;else if (c === '[') depthSquare++;else if (c === ']') depthSquare--;else if (c === '(') depthParen++;else if (c === ')') depthParen--;
+    if (c === delimiter && depthAngle === 0 && depthCurly === 0 && depthSquare === 0 && depthParen === 0) {
+      parts.push(current);
+      current = '';
+    } else {
+      current += c;
+    }
+  }
+  parts.push(current);
+  return parts;
+}
+/**
+ * Parses `Name<A, B>` into name + raw arg strings, respecting nested brackets.
+ * Returns undefined when input isn't a generic reference.
+ * @param {string} type - Trimmed type string.
+ * @returns {{name: string, args: string[]}|undefined} Parsed generic reference.
+ */
+function parseGenericReference(type) {
+  const openIndex = type.indexOf('<');
+  if (openIndex === -1 || !type.endsWith('>')) {
+    return;
+  }
+  const name = type.slice(0, openIndex).trim();
+  if (!/^[A-Za-z_$][A-Za-z0-9_$.]*$/.test(name)) {
+    return;
+  }
+  // Find matching '>' for the first '<' to ensure outermost brackets wrap the whole type.
+  let depth = 0;
+  let closeIndex = -1;
+  for (let i = openIndex; i < type.length; i++) {
+    if (type[i] === '<') depth++;else if (type[i] === '>') {
+      depth--;
+      if (depth === 0) {
+        closeIndex = i;
+        break;
+      }
+    }
+  }
+  if (closeIndex !== type.length - 1) {
+    return;
+  }
+  const inner = type.slice(openIndex + 1, closeIndex);
+  const args = splitTopLevel(inner, ',').map(_ => _.trim()).filter(_ => _.length);
+  if (!args.length) {
+    return;
+  }
+  return {
+    name,
+    args
+  };
+}
 /**
  * 'DepFree' refers to the fact that this function has no dependencies,
  * while `expandType` depends on TypeScript itself for maximum compatibility.
@@ -594,6 +769,26 @@ function toSourceTS(node) {
  */
 function expandTypeDepFree(type) {
   type = type.trim();
+  // JSDocNullableType (`T?` / `?T`): union with null, matching expandType().
+  if (type.endsWith('?') && type.length > 1) {
+    return {
+      type: 'union',
+      members: [expandTypeDepFree(type.slice(0, -1).trim()), 'null']
+    };
+  }
+  if (type.startsWith('?') && type.length > 1) {
+    return {
+      type: 'union',
+      members: [expandTypeDepFree(type.slice(1).trim()), 'null']
+    };
+  }
+  // `readonly T` erased at runtime, same shape as the inner type.
+  if (type.startsWith('readonly ') && type.length > 9) {
+    return expandTypeDepFree(type.slice(9).trim());
+  }
+  if (type === 'unique symbol') {
+    return 'any';
+  }
   // '(123)' -> '123'
   while (!type.includes('|') && type[0] === '(' && type[type.length - 1] === ')') {
     type = type.slice(1, -1).trim();
@@ -640,6 +835,39 @@ function expandTypeDepFree(type) {
       val: expandTypeDepFree(val)
     };
   }
+  // (3b) Map<...> / Set<...' for dep-free parity with expandType()
+  if (type.startsWith("Map<") && type.endsWith('>')) {
+    const inner = type.slice(4, -1);
+    const parts = splitTopLevel(inner, ',');
+    if (parts.length === 2) {
+      return {
+        type: "map",
+        key: expandTypeDepFree(parts[0].trim()),
+        val: expandTypeDepFree(parts[1].trim())
+      };
+    }
+  }
+  if (type.startsWith("Set<") && type.endsWith('>')) {
+    const inner = type.slice(4, -1);
+    return {
+      type: "set",
+      elementType: expandTypeDepFree(inner.trim())
+    };
+  }
+  // (3c) Generic reference types like ArrayLike<T>, ReadonlyArray<T> etc.
+  // Keep structured so the runtime can validate them instead of warning 'unchecked'.
+  const genericRef = parseGenericReference(type);
+  if (genericRef) {
+    const {
+      name,
+      args
+    } = genericRef;
+    return {
+      type: 'reference',
+      name,
+      args: args.map(expandTypeDepFree)
+    };
+  }
   // (4) {...}
   if (type[0] === '{' && type[type.length - 1] === '}') {
     const propertiesArray = type.slice(1, -1).split(','); // ['entity: Entity', ' app: AppBase']
@@ -697,96 +925,302 @@ function expandTypeDepFree(type) {
       properties: {}
     };
   }
+  // Literal normalization for parity with expandType():
+  // numeric literals become numbers, true/false become booleans.
+  if (type === 'true') {
+    return true;
+  }
+  if (type === 'false') {
+    return false;
+  }
+  if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(type)) {
+    return Number(type);
+  }
   return type;
 }
 
-/** @typedef {import('@babel/types').Node} Node */
-/** @typedef {import('@babel/types').Function} Function */
 /**
- * Checks if the provided node is a function-like structure.
- *
- * @param {Node} node - The Babel AST node to be tested.
- * @returns {node is Function} - `true` if the node is a function-like structure, otherwise `false`.
+ * Infers a parameter type from its default value AST node.
+ * Returns widened types like TypeScript does (`= 0` means `number`, not
+ * literal `0`; `= null` widens to `any`).
+ * Returns `undefined` when nothing useful can be inferred — the caller then
+ * emits no check, exactly like an undocumented parameter today.
+ * Shapes match what `expandType` produces so they can be embedded as-is.
+ * @param {import('@babel/types').Node} node - The default value AST node.
+ * @returns {string | object | undefined} Inferred type or `undefined` to skip.
  */
-function nodeIsFunction(node) {
+function inferTypeFromDefault$1(node) {
+  if (!node) {
+    return;
+  }
   switch (node.type) {
+    case 'NumericLiteral':
+      return 'number';
+    case 'StringLiteral':
+      return 'string';
+    case 'BooleanLiteral':
+      return 'boolean';
+    case 'BigIntLiteral':
+      return {
+        type: 'bigint'
+      };
+    case 'RegExpLiteral':
+      return 'RegExp';
+    case 'TemplateLiteral':
+      return 'string';
+    case 'ArrayExpression':
+      return {
+        type: 'array',
+        elementType: 'any'
+      };
+    case 'ObjectExpression':
+      return {
+        type: 'object',
+        properties: {}
+      };
     case 'ArrowFunctionExpression':
-    case 'ClassMethod':
-    case 'ClassPrivateMethod':
-    case 'FunctionDeclaration':
     case 'FunctionExpression':
-    case 'ObjectMethod':
-      return true;
+      return 'Function';
+    case 'NewExpression':
+      {
+        const {
+          callee
+        } = node;
+        if (callee.type === 'Identifier') {
+          return callee.name;
+        }
+        break;
+      }
+    case 'UnaryExpression':
+      {
+        const {
+          operator,
+          argument
+        } = node;
+        if (operator === '!') {
+          return 'boolean';
+        }
+        if (operator === 'void' || operator === 'typeof') {
+          return operator === 'void' ? 'undefined' : 'string';
+        }
+        if ((operator === '-' || operator === '+') && argument.type === 'NumericLiteral') {
+          return 'number';
+        }
+        if ((operator === '-' || operator === '+') && argument.type === 'BigIntLiteral') {
+          return {
+            type: 'bigint'
+          };
+        }
+        break;
+      }
   }
-  return false;
 }
 
 /**
- * @typedef DocType
- * @property {boolean} optional - Type is optional.
- */
-/**
- * @param {string | DocType} type - The type.
- * @param {boolean} optional - Optionality
- * @returns {string | DocType} The simplified type.
+ * Extracts the parameter name and its optionality from a JSDoc parameter string.
+ *
+ * This function takes a rest parameter string from a JSDoc comment, trims it, and determines the parameter's
+ * name and whether it is optional. The optionality is inferred based on the presence of square brackets around
+ * the parameter name.
+ *
+ * @param {string} rest - The rest part of a JSDoc parameter string to parse.
+ * @returns {[string, boolean]} A tuple where the first element is the name of the parameter,
+ * and the second element is a boolean indicating if the parameter is optional.
  */
-function simplifyType(type, optional) {
-  // If it's already an object, just set optionality.
-  if (type instanceof Object) {
-    type.optional = optional;
-  } else if (typeof type === 'string') {
-    type = type.trim();
-    if (type !== 'object' && type !== 'object[]' && type !== 'union' && !optional) {
-      // console.log("simplify", type);
-      return type;
-    }
-    type = {
-      type,
-      optional
-    };
-  } else {
-    debugger;
-    console.warn("simplifyType> neither object nor string for type", type);
-  }
-  if (type.type === 'object' && type.properties && Object.keys(type.properties).length === 0) {
-    delete type.properties;
-    // console.log("delete empty", type);
+function extractNameAndOptionality(rest) {
+  rest = rest.trim();
+  let optional = false;
+  // Examples:
+  //   name: [kwargs={}] The configuration parameters.
+  //   name: [d = 1.0] Sample spacing
+  if (rest[0] === '[') {
+    // Possible improvement: counting opening/closing brackets for perfect match
+    const closer = rest.lastIndexOf(']');
+    // Afterwards name will be: d = 1.0
+    rest = rest.substring(1, closer);
+    // mark it for the type:
+    optional = true;
   }
-
-  return type;
+  // Strip the rest (either leftover of optional value or description)
+  const name = rest.split(' ')[0].split('=')[0].trim();
+  return [name, optional];
 }
 
 /**
- * @typedef {ReturnType<typeof parseJSDoc>} ParseJSDocReturnType
- */
-/**
- * @typedef {typeof expandTypeDepFree} ExpandType
- * @typedef {ReturnType<ExpandType>} ExpandTypeReturnType
+ * Extracts the content of a string that is delimited by curly braces.
+ * @example
+ * extractCurlyContent('{ {inner} }'); // Returns: {content: ' {inner} ', nextIndex: 11}
+ * @param {string} line - The string to extract from.
+ * @returns {{content: string, nextIndex: number}} An object containing the extracted content,
+ * and the index of the character immediately following the closing curly brace.
  */
+function extractCurlyContent(line) {
+  const firstCurly = line.indexOf('{');
+  let k = firstCurly + 1;
+  let count = 0;
+  for (; k < line.length; k++) {
+    const c = line[k];
+    if (c === '{') {
+      count++;
+    } else if (c === '}') {
+      count--;
+    }
+    if (count === -1) {
+      break;
+    }
+  }
+  const content = line.substring(firstCurly + 1, k);
+  return {
+    content,
+    nextIndex: k + 1
+  };
+}
 /**
- * Parses JSDoc comments to extract parameter type information.
+ * Parses JSDoc comments to extract and expand typedefs and their associated properties.
  *
- * @param {string} src - The JSDoc comment string to parse.
- * @param {ExpandType} [expandType] - An optional function to process the types found in the JSDoc.
- * @returns {Record<string, ExpandTypeReturnType> | undefined} An object mapping parameter names to their parsed types, or undefined if no parameters are found.
+ * It iterates through the lines of a `CommentBlock` from the Babel AST, looking for `@typedef` and `@property`
+ * annotations. When it finds a typedef, it stores it in the `typedefs` record. When it finds a property,
+ * it adds it to the last found typedef if it is an object type.
+ * @param {Record<string, object>} typedefs - An object to store typedefs, mapping type names to their expanded definitions.
+ * @param {Console["warn"]} warn - A warn function used for emitting warnings about non-extensible types.
+ * @param {import("@babel/types").Comment} comment - A comment extracted from Babel's AST, expected to be a CommentBlock containing type definitions.
+ * @param {Function} expandType - A function that takes a type expression as a string and returns a structured representation of the type.
  */
-function parseJSDoc(src, expandType = expandTypeDepFree) {
-  // Parse something like: @param {Object} [kwargs={}] Optional arguments.
-  const regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\-\{\}\.'" ]+)/g;
-  const matches = [...src.matchAll(regex)];
-  /** @type {Record<string, ExpandTypeReturnType>} */
-  const params = Object.create(null);
-  matches.forEach(_ => {
-    const type = expandType(_[1].trim());
-    let name = _[2].trim();
-    let optional = false;
-    // Examples:
-    //   name: [kwargs={}] The configuration parameters.
-    //   name: [d = 1.0] Sample spacing
-    if (name[0] === '[') {
-      // Counting opening/closing brackets for perfect match
-      let openCloseCount = 1;
-      let i = 1;
+function parseJSDocTypedef(typedefs, warn, comment, expandType) {
+  const {
+    type,
+    value
+  } = comment;
+  if (type !== 'CommentBlock') {
+    return;
+  }
+  const lines = value.split('\n');
+  let lastTypedef;
+  for (let line of lines) {
+    line = line.trim();
+    if (line[0] === '*') {
+      line = line.slice(1).trim();
+    }
+    if (line.startsWith('@typedef')) {
+      const {
+        content: def,
+        nextIndex
+      } = extractCurlyContent(line);
+      let name = line.substring(nextIndex).trim();
+      // Drop description
+      name = name.split(' ')[0];
+      lastTypedef = expandType(def);
+      // Ignore @typedef's that only refer to themselves in another file (see typedef-overwrite test)
+      if (lastTypedef !== name) {
+        typedefs[name] = lastTypedef;
+      }
+    } else if (line.startsWith('@property')) {
+      var _lastTypedef;
+      // class @property
+      if (!lastTypedef) {
+        continue;
+      }
+      const {
+        content,
+        nextIndex
+      } = extractCurlyContent(line);
+      const rest = line.substring(nextIndex);
+      const propType = expandType(content);
+      const [name, optional] = extractNameAndOptionality(rest);
+      // console.log({name, optional, propType});
+      const finalType = annotateOptional(propType, optional);
+      if (((_lastTypedef = lastTypedef) == null ? void 0 : _lastTypedef.type) === 'object') {
+        lastTypedef.properties[name] = finalType;
+      } else {
+        warn("not an extensible type", lastTypedef);
+      }
+    } else if (line.startsWith('@callback')) {
+      const name = line.substring(9).trim();
+      typedefs[name] = 'Function';
+    }
+  }
+}
+
+/**
+ * Extracts an inline `/** @type {X} *\/` annotation from parameter comments,
+ * e.g. `function add(/** @type {number} *\/ a) {...}`.
+ * @param {Array<{value: string}>|undefined} leadingComments - Leading comments of a param node.
+ * @param {Function} expandType - Function expanding a type string.
+ * @returns {any} Expanded type or `undefined` when no inline `@type` found.
+ */
+function parseInlineParamType(leadingComments, expandType) {
+  if (!Array.isArray(leadingComments)) {
+    return;
+  }
+  for (let i = leadingComments.length - 1; i >= 0; i--) {
+    const {
+      value
+    } = leadingComments[i];
+    if (!value || !value.includes('@type')) {
+      continue;
+    }
+    const {
+      content
+    } = extractCurlyContent(value.slice(value.indexOf('@type')));
+    if (!content || !content.trim()) {
+      continue;
+    }
+    return expandType(content.trim());
+  }
+}
+
+/** @typedef {import('@babel/types').Node} Node */
+/** @typedef {import('@babel/types').Function} Function */
+/**
+ * Checks if the provided node is a function-like structure.
+ *
+ * @param {Node} node - The Babel AST node to be tested.
+ * @returns {node is Function} - `true` if the node is a function-like structure, otherwise `false`.
+ */
+function nodeIsFunctionLike(node) {
+  switch (node.type) {
+    case 'ArrowFunctionExpression':
+    case 'ClassMethod':
+    case 'ClassPrivateMethod':
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'ObjectMethod':
+      return true;
+  }
+  return false;
+}
+
+/**
+ * @typedef {ReturnType<typeof parseJSDoc>} ParseJSDocReturnType
+ */
+/**
+ * @typedef {typeof expandTypeDepFree} ExpandType
+ * @typedef {ReturnType<ExpandType>} ExpandTypeReturnType
+ */
+/**
+ * Parses JSDoc comments to extract parameter type information.
+ *
+ * @param {string} src - The JSDoc comment string to parse.
+ * @param {ExpandType} [expandType] - An optional function to process the types found in the JSDoc.
+ * @returns {Record<string, ExpandTypeReturnType> | undefined} An object mapping parameter names to their parsed types, or undefined if no parameters are found.
+ */
+function parseJSDoc(src, expandType = expandTypeDepFree) {
+  // Parse something like: @param {Object} [kwargs={}] Optional arguments.
+  const regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\-\{\}\.'" ]+)/g;
+  const matches = [...src.matchAll(regex)];
+  /** @type {Record<string, ExpandTypeReturnType>} */
+  const params = Object.create(null);
+  matches.forEach(_ => {
+    const type = expandType(_[1].trim());
+    let name = _[2].trim();
+    let optional = false;
+    // Examples:
+    //   name: [kwargs={}] The configuration parameters.
+    //   name: [d = 1.0] Sample spacing
+    if (name[0] === '[') {
+      // Counting opening/closing brackets for perfect match
+      let openCloseCount = 1;
+      let i = 1;
       for (; i < name.length; i++) {
         const c = name[i];
         if (c === '[') {
@@ -805,16 +1239,16 @@ function parseJSDoc(src, expandType = expandTypeDepFree) {
     }
     // Strip the rest (either leftover of optional value or description)
     name = name.split(' ')[0].split('=')[0].trim();
-    const simplifiedType = simplifyType(type, optional);
+    const annotatedType = annotateOptional(type, optional);
     // Turn "options.stats[].unitsName" into ['options', 'stats', 'unitsName'].
     const parts = name.split(/[\[\]]*\./);
     let properties = params;
     for (const part of parts) {
       const toptype = properties[part];
       if (!toptype) {
-        // No toptype means we resolved as far as possible, now we can add `simplifiedType`.
+        // No toptype means we resolved as far as possible, now we can add `annotatedType`.
         console.assert(part === parts.at(-1), 'Current part and last part should be the same.');
-        properties[part] = simplifiedType;
+        properties[part] = annotatedType;
       } else if (toptype.type === "union") {
         const typeObject = toptype.members.find(_ => (_ == null ? void 0 : _.type) === 'object');
         properties = typeObject.properties;
@@ -828,7 +1262,7 @@ function parseJSDoc(src, expandType = expandTypeDepFree) {
           src,
           toptype,
           parts,
-          simplifiedType
+          annotatedType
         });
       }
     }
@@ -851,8 +1285,8 @@ function parseJSDocSetter(src, expandType = expandTypeDepFree) {
   if (matches.length === 1) {
     const match = matches[0];
     const type = expandType(match[1]);
-    const simplifiedType = simplifyType(type, /* optional */false);
-    return simplifiedType;
+    const annotatedType = annotateOptional(type, /* optional */false);
+    return annotatedType;
   }
 }
 
@@ -884,129 +1318,99 @@ function parseJSDocTemplates(src, expandType = expandTypeDepFree) {
   return templates;
 }
 
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
 /**
- * Extracts the parameter name and its optionality from a JSDoc parameter string.
- *
- * This function takes a rest parameter string from a JSDoc comment, trims it, and determines the parameter's
- * name and whether it is optional. The optionality is inferred based on the presence of square brackets around
- * the parameter name.
- *
- * @param {string} rest - The rest part of a JSDoc parameter string to parse.
- * @returns {[string, boolean]} A tuple where the first element is the name of the parameter,
- * and the second element is a boolean indicating if the parameter is optional.
+ * Returns a new object with each value mapped by `fn`, leaving the original
+ * untouched.  Returns `obj` as-is if it is falsy.
+ * @param {Record<string, any>} obj - The source object.
+ * @param {(value: any, key: string) => any} fn - Mapping function.
+ * @returns {Record<string, any>} A new object with mapped values.
  */
-function extractNameAndOptionality(rest) {
-  rest = rest.trim();
-  let optional = false;
-  // Examples:
-  //   name: [kwargs={}] The configuration parameters.
-  //   name: [d = 1.0] Sample spacing
-  if (rest[0] === '[') {
-    // Possible improvement: counting opening/closing brackets for perfect match
-    const closer = rest.lastIndexOf(']');
-    // Afterwards name will be: d = 1.0
-    rest = rest.substring(1, closer);
-    // mark it for the type:
-    optional = true;
+function mapValues(obj, fn) {
+  if (!obj) return obj;
+  const result = {};
+  for (const key in obj) {
+    result[key] = fn(obj[key], key);
   }
-  // Strip the rest (either leftover of optional value or description)
-  const name = rest.split(' ')[0].split('=')[0].trim();
-  return [name, optional];
+  return result;
 }
 
 /**
- * Extracts the content of a string that is delimited by curly braces.
- * @example
- * extractCurlyContent('{ {inner} }'); // Returns: {content: ' {inner} ', nextIndex: 11}
- * @param {string} line - The string to extract from.
- * @returns {{content: string, nextIndex: number}} An object containing the extracted content,
- * and the index of the character immediately following the closing curly brace.
+ * @typedef DocType
+ * @property {boolean} optional - Type is optional.
  */
-function extractCurlyContent(line) {
-  const firstCurly = line.indexOf('{');
-  let k = firstCurly + 1;
-  let count = 0;
-  for (; k < line.length; k++) {
-    const c = line[k];
-    if (c === '{') {
-      count++;
-    } else if (c === '}') {
-      count--;
-    }
-    if (count === -1) {
-      break;
-    }
-  }
-  const content = line.substring(firstCurly + 1, k);
-  return {
-    content,
-    nextIndex: k + 1
-  };
-}
 /**
- * Parses JSDoc comments to extract and expand typedefs and their associated properties.
- *
- * It iterates through the lines of a `CommentBlock` from the Babel AST, looking for `@typedef` and `@property`
- * annotations. When it finds a typedef, it stores it in the `typedefs` record. When it finds a property,
- * it adds it to the last found typedef if it is an object type.
- * @param {Record<string, object>} typedefs - An object to store typedefs, mapping type names to their expanded definitions.
- * @param {Console["warn"]} warn - A warn function used for emitting warnings about non-extensible types.
- * @param {import("@babel/types").Comment} comment - A comment extracted from Babel's AST, expected to be a CommentBlock containing type definitions.
- * @param {Function} expandType - A function that takes a type expression as a string and returns a structured representation of the type.
+ * Recursively clones and simplifies a type for emission into source code.
+ * Strips empty `properties` and collapses empty `object` types to the bare
+ * string `'object'`.  Numbers/booleans (literal types) pass through.
+ * Non-destructive — the original type tree is never mutated.
+ * @param {string | DocType | number | boolean} type - The type.
+ * @returns {string | DocType | number | boolean} The simplified type.
  */
-function parseJSDocTypedef(typedefs, warn, comment, expandType) {
-  const {
-    type,
-    value
-  } = comment;
-  if (type !== 'CommentBlock') {
-    return;
+function simplifyType(type) {
+  if (!(type instanceof Object)) {
+    return type;
   }
-  const lines = value.split('\n');
-  let lastTypedef;
-  for (let line of lines) {
-    line = line.trim();
-    if (line[0] === '*') {
-      line = line.slice(1).trim();
-    }
-    if (line.startsWith('@typedef')) {
-      const {
-        content: def,
-        nextIndex
-      } = extractCurlyContent(line);
-      let name = line.substring(nextIndex).trim();
-      // Drop description
-      name = name.split(' ')[0];
-      lastTypedef = expandType(def);
-      // Ignore @typedef's that only refer to themselves in another file (see typedef-overwrite test)
-      if (lastTypedef !== name) {
-        typedefs[name] = lastTypedef;
-      }
-    } else if (line.startsWith('@property')) {
-      var _lastTypedef;
-      // class @property
-      if (!lastTypedef) {
-        continue;
-      }
-      const {
-        content,
-        nextIndex
-      } = extractCurlyContent(line);
-      const rest = line.substring(nextIndex);
-      const propType = expandType(content);
-      const [name, optional] = extractNameAndOptionality(rest);
-      // console.log({name, optional, propType});
-      const finalType = simplifyType(propType, optional);
-      if (((_lastTypedef = lastTypedef) == null ? void 0 : _lastTypedef.type) === 'object') {
-        lastTypedef.properties[name] = finalType;
-      } else {
-        warn("not an extensible type", lastTypedef);
-      }
-    } else if (line.startsWith('@callback')) {
-      const name = line.substring(9).trim();
-      typedefs[name] = 'Function';
+  const out = _extends({}, type);
+  if (out.properties) {
+    out.properties = mapValues(out.properties, simplifyType);
+    if (out.type === 'object' && !Object.keys(out.properties).length) {
+      delete out.properties;
     }
   }
+  if (out.indexSignatures && Array.isArray(out.indexSignatures)) {
+    out.indexSignatures = out.indexSignatures.map(simplifyType);
+  }
+  if (out.type === 'union' && out.members) {
+    out.members = out.members.map(simplifyType);
+  }
+  if (out.type === 'array' && out.elementType) {
+    out.elementType = simplifyType(out.elementType);
+  }
+  if (out.type === 'tuple' && out.elements) {
+    out.elements = out.elements.map(simplifyType);
+  }
+  if (out.type === 'promise' && out.elementType) {
+    out.elementType = simplifyType(out.elementType);
+  }
+  if (out.type === 'reference' && Array.isArray(out.args)) {
+    out.args = out.args.map(simplifyType);
+  }
+  if (out.type === 'record') {
+    if (out.key) out.key = simplifyType(out.key);
+    if (out.val) out.val = simplifyType(out.val);
+  }
+  if (out.type === 'typeof' && out.argument) {
+    out.argument = simplifyType(out.argument);
+  }
+  if (out.type === 'object' && !out.properties && !out.indexSignatures && !out.optional) {
+    return 'object';
+  }
+  return out;
+}
+
+/**
+ * Returns the pretty-printed JSON of the simplified type for embedding
+ * into generated source code.
+ * @param {import('./simplifyType.js').DocType | string | number | boolean} type - The type.
+ * @returns {string} JSON source ready for code generation.
+ */
+function simplifyTypeToSource(type) {
+  return JSON.stringify(simplifyType(type), null, 2);
 }
 
 /**
@@ -1345,7 +1749,8 @@ class Stringifier {
     return '';
   }
   /**
-   * @type {string} A string of two spaces per indentation.
+   * A string of two spaces per indentation.
+   * @type {string}
    */
   get spaces() {
     return '  '.repeat(this.numSpaces);
@@ -3111,6 +3516,9 @@ class Stringifier {
  * @typedef {object} Options
  * @property {boolean} [forceCurly] - Determines whether curly braces are enforced in Stringifier.
  * @property {boolean} [validateDivision] - Indicates whether division operations should be validated.
+ * @property {boolean} [inspectIndexedAccess] - Indicates whether indexed accesses
+ * like `arr[i]` should be wrapped for bounds and integer validation. Disable
+ * to drop indexed access inspection entirely. Defaults to true.
  * @property {import('./parseJSDoc.js').ExpandType} [expandType] - A function that expands shorthand types into full descriptions.
  * @property {string} [filename] - The name of a file to which the instance pertains.
  * @property {boolean} [addHeader] - Whether to add import declarations headers. Defaults to true.
@@ -3123,6 +3531,7 @@ class Asserter extends Stringifier {
   constructor({
     forceCurly = true,
     validateDivision = true,
+    inspectIndexedAccess = true,
     expandType = expandTypeDepFree,
     filename,
     addHeader = true,
@@ -3182,6 +3591,7 @@ class Asserter extends Stringifier {
     this.addLaterImportNamespaceSpecifier = [];
     this.forceCurly = forceCurly;
     this.validateDivision = validateDivision;
+    this.inspectIndexedAccess = inspectIndexedAccess;
     // @todo collect every type + manually validate as test set
     // + implement expandType using Babel Flow type parser aswell
     this.expandType = expandType;
@@ -3271,7 +3681,7 @@ class Asserter extends Stringifier {
       return '';
     }
     let header = super.getHeader();
-    header += "import {inspectType, inspectTypeWithTemplates, youCanAddABreakpointHere, registerVariable";
+    header += "import {inspectIndexedAccess, inspectType, inspectTypeWithTemplates, youCanAddABreakpointHere, registerVariable";
     if (this.validateDivision) {
       header += ", validateDivision";
     }
@@ -3308,10 +3718,21 @@ class Asserter extends Stringifier {
       //if (parent.type === 'CallExpression') {
       //  break;
       //}
-      if (nodeIsFunction(parent)) {
+      if (nodeIsFunctionLike(parent)) {
         break;
       }
       if (parent.leadingComments) {
+        if (parent.type === 'VariableDeclaration') {
+          const comments = parent.leadingComments;
+          const lastComment = comments[comments.length - 1];
+          const isStatementDoc = Boolean(parent.loc && (lastComment == null ? void 0 : lastComment.loc) && lastComment.loc.end.line + 1 === parent.loc.start.line);
+          if (isStatementDoc) {
+            const declarator = parents[i + 1];
+            if (!declarator || declarator.type !== 'VariableDeclarator' || declarator.init !== node) {
+              break;
+            }
+          }
+        }
         return parent;
       }
       i--;
@@ -3346,10 +3767,24 @@ class Asserter extends Stringifier {
       //if (parent.type === 'CallExpression') {
       //  break;
       //}
-      if (nodeIsFunction(parent)) {
+      if (nodeIsFunctionLike(parent)) {
         break;
       }
       if (parent.leadingComments) {
+        if (parent.type === 'VariableDeclaration') {
+          const comments = parent.leadingComments;
+          const lastComment = comments[comments.length - 1];
+          const isStatementDoc = Boolean(parent.loc && (lastComment == null ? void 0 : lastComment.loc) && lastComment.loc.end.line + 1 === parent.loc.start.line);
+          if (isStatementDoc) {
+            // Docblock directly above the statement: TypeScript-like cascade,
+            // only direct declarator initializers inherit it. Functions nested
+            // deeper (e.g. inside object literals) do not.
+            const declarator = parents[i + 1];
+            if (!declarator || declarator.type !== 'VariableDeclarator' || declarator.init !== node) {
+              break;
+            }
+          }
+        }
         return parent;
       }
       i--;
@@ -3497,7 +3932,7 @@ class Asserter extends Stringifier {
     const {
       stats
     } = this;
-    const type = nodeIsFunction(node) ? node.type : this.parentType;
+    const type = nodeIsFunctionLike(node) ? node.type : this.parentType;
     if (type === 'ClassMethod') {
       const parent = /** @type {ClassMethod} */
       this.parent;
@@ -3585,15 +4020,26 @@ class Asserter extends Stringifier {
     const {
       parent
     } = this;
-    if (node.type === 'BlockStatement' && !nodeIsFunction(parent)) {
+    if (node.type === 'BlockStatement' && !nodeIsFunctionLike(parent)) {
       return '';
     }
     const jsdoc = this.getJSDoc(node);
     // return '// ' + JSON.stringify(jsdoc) + '\n';
     const stat = this.getStatsForNode(node);
     if (!jsdoc) {
-      stat.unchecked++;
-      return '';
+      // No JSDoc at all: default-value inference is the only
+      // source of types. Emit nothing when nothing is inferable.
+      const inferred = this.collectDefaultChecks(node, new Set());
+      if (!inferred.length) {
+        stat.unchecked++;
+        return '';
+      }
+      const _loc = this.getName(node);
+      if (this.ignoreLocations.includes(_loc)) {
+        return '// IGNORE RTI TYPE VALIDATIONS, KNOWN ISSUES\n';
+      }
+      stat.checked++;
+      return this.emitDefaultChecks(node, inferred, true);
     }
     const {
       templates,
@@ -3659,7 +4105,7 @@ class Asserter extends Stringifier {
             // via arguments[paramIndex] anyway.
             name = `arguments[${paramIndex}]`;
           } else if (param.type === 'AssignmentPattern') {
-            const _loc = this.getName(node);
+            const _loc2 = this.getName(node);
             if (param.left.type === 'ArrayPattern' && type.type === 'array') {
               // Add a type assertion for each element of the ArrayPattern
               for (const element of param.left.elements) {
@@ -3674,12 +4120,12 @@ class Asserter extends Stringifier {
                   this.warn('Only Identifier case handled right now');
                   continue;
                 }
-                const _t = JSON.stringify(type.elementType, null, 2).replaceAll('\n', '\n' + spaces);
+                const _t = simplifyTypeToSource(type.elementType).replaceAll('\n', '\n' + spaces);
                 newlineBeforeFirst();
                 if (templates) {
-                  out += `${spaces}if (!inspectTypeWithTemplates(${element.name}, ${_t}, '${_loc}', '${nameFancy}', rtiTemplates)) {\n`;
+                  out += `${spaces}if (!inspectTypeWithTemplates(${element.name}, ${_t}, '${_loc2}', '${nameFancy}', rtiTemplates)) {\n`;
                 } else {
-                  out += `${spaces}if (!inspectType(${element.name}, ${_t}, '${_loc}', '${nameFancy}')) {\n`;
+                  out += `${spaces}if (!inspectType(${element.name}, ${_t}, '${_loc2}', '${nameFancy}')) {\n`;
                 }
                 out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
               }
@@ -3708,12 +4154,12 @@ class Asserter extends Stringifier {
                     this.warn("missing subtype information in JSDoc");
                     continue;
                   }
-                  const _t2 = JSON.stringify(subType, null, 2).replaceAll('\n', '\n' + spaces);
+                  const _t2 = simplifyTypeToSource(subType).replaceAll('\n', '\n' + spaces);
                   newlineBeforeFirst();
                   if (templates) {
-                    out += `${spaces}if (!inspectTypeWithTemplates(${keyName}, ${_t2}, '${_loc}', '${nameFancy}', rtiTemplates)) {\n`;
+                    out += `${spaces}if (!inspectTypeWithTemplates(${keyName}, ${_t2}, '${_loc2}', '${nameFancy}', rtiTemplates)) {\n`;
                   } else {
-                    out += `${spaces}if (!inspectType(${keyName}, ${_t2}, '${_loc}', '${nameFancy}')) {\n`;
+                    out += `${spaces}if (!inspectType(${keyName}, ${_t2}, '${_loc2}', '${nameFancy}')) {\n`;
                   }
                   out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
                 }
@@ -3723,17 +4169,17 @@ class Asserter extends Stringifier {
                 name = `arguments[${paramIndex}]`;
               }
             } else {
-              this.warn(`generateTypeChecks> ${_loc}> todo implement`, `AssignmentPattern for parameter ${name}`);
+              this.warn(`generateTypeChecks> ${_loc2}> todo implement`, `AssignmentPattern for parameter ${name}`);
               continue;
             }
           }
         } else {
-          const _loc2 = this.getName(node);
-          this.warn(`generateTypeChecks> ${_loc2}> Missing param: ${name}`);
+          const _loc3 = this.getName(node);
+          this.warn(`generateTypeChecks> ${_loc3}> Missing param: ${name}`);
           continue;
         }
       }
-      let t = JSON.stringify(type, null, 2).replaceAll('\n', '\n' + spaces);
+      let t = simplifyTypeToSource(type).replaceAll('\n', '\n' + spaces);
       if (type === 'this') {
         const classDecl = this.findParentOfType(node, 'ClassDeclaration');
         if (!(classDecl != null && classDecl.id)) {
@@ -3741,19 +4187,107 @@ class Asserter extends Stringifier {
         }
         t = '"' + this.toSource(classDecl.id) + '"';
       }
-      const _loc3 = this.getName(node);
+      const _loc4 = this.getName(node);
       let prevCheck = '';
       // JSDoc doesn't support multiple function signatures yet, but this is
       // exactly what we would need to deal with ObjectPool'ing
-      if (_loc3 === 'ContactPoint#constructor' || _loc3 === 'ContactResult#constructor' || _loc3 === 'SingleContactResult#constructor') {
+      if (_loc4 === 'ContactPoint#constructor' || _loc4 === 'ContactResult#constructor' || _loc4 === 'SingleContactResult#constructor') {
         prevCheck = 'arguments.length !== 0 && ';
       }
       newlineBeforeFirst();
       if (templates) {
-        out += `${spaces}if (${prevCheck}!inspectTypeWithTemplates(${name}, ${t}, '${_loc3}', '${nameFancy}', rtiTemplates)) {\n`;
+        out += `${spaces}if (${prevCheck}!inspectTypeWithTemplates(${name}, ${t}, '${_loc4}', '${nameFancy}', rtiTemplates)) {\n`;
       } else {
-        out += `${spaces}if (${prevCheck}!inspectType(${name}, ${t}, '${_loc3}', '${nameFancy}')) {\n`;
+        out += `${spaces}if (${prevCheck}!inspectType(${name}, ${t}, '${_loc4}', '${nameFancy}')) {\n`;
+      }
+      out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
+    }
+    // Params without JSDoc but with inferable defaults get synthesized
+    // optional checks; JSDoc types always win on conflict.
+    out += this.emitDefaultChecks(node, this.collectDefaultChecks(node, new Set(Object.keys(params))), out === '');
+    return out;
+  }
+  /**
+   * Collects type checks for undocumented params: inline
+   * `/** @type *\/` param comments first, default-value inference second.
+   * Only `Identifier` targets missing from `documented` are considered.
+   * @param {Node} node - The Babel AST node for which to generate type checks.
+   * @param {Set<string>} documented - Parameter names covered by JSDoc.
+   * @returns {{name: string, type: any}[]} Checks with optional-annotated types.
+   */
+  collectDefaultChecks(node, documented) {
+    let fnNode = node;
+    if (fnNode.type === 'BlockStatement') {
+      fnNode = this.parent;
+    }
+    const {
+      params
+    } = fnNode;
+    if (!Array.isArray(params)) {
+      return [];
+    }
+    if (fnNode.type === 'ArrowFunctionExpression' && !this.findParentOfType(fnNode, 'VariableDeclarator')) {
+      // Bare callbacks (e.g. `.forEach((x = 0) => ...)`) can't be named,
+      // synthesizing checks would spam unnameable-callback warnings.
+      return [];
+    }
+    const checks = [];
+    for (const param of params) {
+      var _parseInlineParamType;
+      if (!param) {
+        continue;
+      }
+      const isAssignment = param.type === 'AssignmentPattern';
+      const target = isAssignment ? param.left : param;
+      if (!target || target.type !== 'Identifier' || documented.has(target.name)) {
+        continue;
       }
+      // Inline `/** @type *\/` wins over default inference;
+      // a default still marks the check optional.
+      const inline = (_parseInlineParamType = parseInlineParamType(param.leadingComments, this.expandType)) != null ? _parseInlineParamType : parseInlineParamType(target.leadingComments, this.expandType);
+      if (inline !== undefined) {
+        checks.push({
+          name: target.name,
+          type: annotateOptional(inline, isAssignment)
+        });
+        continue;
+      }
+      if (!isAssignment) {
+        continue;
+      }
+      const inferred = inferTypeFromDefault$1(param.right);
+      if (inferred === undefined) {
+        continue;
+      }
+      checks.push({
+        name: target.name,
+        type: annotateOptional(inferred, true)
+      });
+    }
+    return checks;
+  }
+  /**
+   * Emits code for checks inferred from default values.
+   * @param {Node} node - The Babel AST node for which to generate type checks.
+   * @param {{name: string, type: any}[]} checks - Checks to emit.
+   * @param {boolean} prefixNewline - Separate from preceding code with newline.
+   * @returns {string} A string of code with type check assertions.
+   */
+  emitDefaultChecks(node, checks, prefixNewline) {
+    if (!checks.length) {
+      return '';
+    }
+    const {
+      spaces
+    } = this;
+    const loc = this.getName(node);
+    let out = prefixNewline ? '\n' : '';
+    for (const {
+      name,
+      type
+    } of checks) {
+      const t = simplifyTypeToSource(type).replaceAll('\n', '\n' + spaces);
+      out += `${spaces}if (!inspectType(${name}, ${t}, '${loc}', '${name}')) {\n`;
       out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
     }
     return out;
@@ -3783,6 +4317,11 @@ class Asserter extends Stringifier {
       }
       console.warn("Asserter#getNameForFunctionExpression> expression without left");
     }
+    const variableDeclarator = this.findParentOfType(node, 'VariableDeclarator');
+    if (variableDeclarator) {
+      // e.g. `var ScopeSpace = function (name) {...}` (issue #82)
+      return this.toSource(variableDeclarator.id);
+    }
     return 'unnamed function expression';
   }
   /**
@@ -3790,7 +4329,7 @@ class Asserter extends Stringifier {
    * @returns {string} Stringification of the node.
    */
   getName(node) {
-    var _node, _node2;
+    var _node, _node2, _node3;
     const toSource = this.toSource.bind(this);
     if (node.type === 'BlockStatement') {
       node = this.parent;
@@ -3833,10 +4372,93 @@ class Asserter extends Stringifier {
         }
         // top scope
         return `${this.filename}:${(_node = node) == null || (_node = _node.loc) == null || (_node = _node.start) == null ? void 0 : _node.line}`;
+      case 'MemberExpression':
+        if (node.computed) {
+          const memberGoodNames = ['FunctionDeclaration', 'ClassMethod', 'ClassPrivateMethod'];
+          const memberGoodParent = this.parents.findLast(_ => memberGoodNames.includes(_.type));
+          if (memberGoodParent) {
+            return this.getName(memberGoodParent);
+          }
+        }
+        // top scope
+        return `${this.filename}:${(_node2 = node) == null || (_node2 = _node2.loc) == null || (_node2 = _node2.start) == null ? void 0 : _node2.line}`;
     }
     this.warn('getName> unhandled type', type, 'for', node, this.path);
     //debugger;
-    return `${this.filename}:${(_node2 = node) == null || (_node2 = _node2.loc) == null || (_node2 = _node2.start) == null ? void 0 : _node2.line}`;
+    return `${this.filename}:${(_node3 = node) == null || (_node3 = _node3.loc) == null || (_node3 = _node3.start) == null ? void 0 : _node3.line}`;
+  }
+  /**
+   * @override
+   * @param {import("@babel/types").MemberExpression} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  MemberExpression(node) {
+    const {
+      computed,
+      object,
+      property
+    } = node;
+    if (!this.inspectIndexedAccess) {
+      return super.MemberExpression(node);
+    }
+    if (!computed || object.type === 'Super') {
+      return super.MemberExpression(node);
+    }
+    const parent = this.parent;
+    if (parent) {
+      // `a[i] = ...`, `a[i]++`/`--` and `delete a[i]` are handled by the statement
+      // itself, wrapping them here would produce invalid assignment to a call.
+      if (parent.type === 'AssignmentExpression' && parent.left === node) {
+        return super.MemberExpression(node);
+      }
+      if (parent.type === 'UpdateExpression' && parent.argument === node) {
+        return super.MemberExpression(node);
+      }
+      if (parent.type === 'UnaryExpression' && parent.operator === 'delete' && parent.argument === node) {
+        return super.MemberExpression(node);
+      }
+      // Destructuring, rest and loop targets are assigned to, never read.
+      if (parent.type === 'ArrayPattern') {
+        return super.MemberExpression(node);
+      }
+      if (parent.type === 'RestElement' && parent.argument === node) {
+        return super.MemberExpression(node);
+      }
+      if (parent.type === 'ObjectProperty' && parent.value === node) {
+        // `({p: a[i]})` reads but `({p: a[i]} = ...)` writes: bypass inside patterns only.
+        const grandparent = this.parents[this.parents.findLastIndex(_ => _ === parent) - 1];
+        if ((grandparent == null ? void 0 : grandparent.type) === 'ObjectPattern') {
+          return super.MemberExpression(node);
+        }
+      }
+      if (parent.type === 'AssignmentPattern' && parent.left === node) {
+        return super.MemberExpression(node);
+      }
+      if ((parent.type === 'ForOfStatement' || parent.type === 'ForInStatement') && parent.left === node) {
+        return super.MemberExpression(node);
+      }
+      // Method calls and tags carry their base as `this`; wrapping the callee
+      // would silently rebind it to undefined.
+      if ((parent.type === 'CallExpression' || parent.type === 'OptionalCallExpression') && parent.callee === node) {
+        return super.MemberExpression(node);
+      }
+      if (parent.type === 'TaggedTemplateExpression' && parent.tag === node) {
+        return super.MemberExpression(node);
+      }
+      // `new a[i](...)` must stay `new (inspectIndexedAccess(...))(...)`:
+      // without parens it parses as `(new inspectIndexedAccess(...))(...)`,
+      // constructing the wrapper instead of the accessed value.
+      if (parent.type === 'NewExpression' && parent.callee === node) {
+        const _object_ = this.toSource(object);
+        const _property_ = this.toSource(property);
+        const _loc5 = this.getName(node);
+        return `(inspectIndexedAccess(${_object_}, ${_property_}, ${JSON.stringify(_loc5)}))`;
+      }
+    }
+    const object_ = this.toSource(object);
+    const property_ = this.toSource(property);
+    const loc = this.getName(node);
+    return `inspectIndexedAccess(${object_}, ${property_}, ${JSON.stringify(loc)})`;
   }
   /**
    * @override
@@ -3881,7 +4503,7 @@ class Asserter extends Stringifier {
     let out = '';
     for (const name in this.typedefs) {
       const typedef = this.typedefs[name];
-      const json = JSON.stringify(typedef, null, 2);
+      const json = simplifyTypeToSource(typedef);
       out += `registerTypedef('${name}', ${json});\n`;
     }
     const code = this.toSource(program) + '\n';
@@ -4066,6 +4688,21 @@ function compareAST(left, right) {
  * @returns {string|object|undefined} - See `toSourceBabelTS`.
  */
 function expandTypeBabelTS(type) {
+  type = type.trim();
+  // JSDocNullableType (`T?` / `?T`): Babel has no support (babel/babel#16073),
+  // handle at string level to match expandType() union-with-null.
+  if (type.endsWith('?') && type.length > 1) {
+    return {
+      type: 'union',
+      members: [expandTypeBabelTS(type.slice(0, -1).trim()), 'null']
+    };
+  }
+  if (type.startsWith('?') && type.length > 1) {
+    return {
+      type: 'union',
+      members: [expandTypeBabelTS(type.slice(1).trim()), 'null']
+    };
+  }
   const ast = parseTypeBabelTS(type);
   return toSourceBabelTS(ast);
 }
@@ -4138,7 +4775,8 @@ function toSourceBabelTS(node) {
         const name = toSourceBabelTS(node.typeName);
         if (!node.typeParameters) {
           // console.log(`node.typeName.name=${node.typeName.name} name=${name}`, node);
-          return node.typeName.name;
+          // Bare reference: Identifier gives name, TSQualifiedName gives dotted path.
+          return name;
         }
         console.assert(node.typeParameters.type === 'TSTypeParameterInstantiation');
         const typeArguments = node.typeParameters.params;
@@ -4186,9 +4824,13 @@ function toSourceBabelTS(node) {
             elementType
           };
         }
-        console.warn('unhandled TypeReference', node);
+        // Parity with expandType(): generic references like ArrayLike<T>,
+        // ReadonlyArray<T>, NodeListOf<T> or user typedefs like MyBox<T>.
+        const args = typeArguments.map(toSourceBabelTS);
         return {
-          type: 'unhandled TypeReference'
+          type: 'reference',
+          name,
+          args
         };
       }
     case 'TSStringKeyword':
@@ -4241,7 +4883,7 @@ function toSourceBabelTS(node) {
       return 'boolean';
     // expandTypeBabelTS('true | false');
     case 'BooleanLiteral':
-      return node.value.toString();
+      return node.value;
     // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
     // But Babel-TS doesn't parse it atm
     //case 'JSDocAllType':
@@ -4250,6 +4892,7 @@ function toSourceBabelTS(node) {
       return 'null';
     // expandTypeBabelTS('123')
     case 'NumericLiteral':
+      return typeof node.value === 'number' ? node.value : Number(node.extra.raw);
     case 'StringLiteral':
       return node.extra.raw;
     // expandTypeBabelTS('undefined')
@@ -4281,10 +4924,3282 @@ function toSourceBabelTS(node) {
         type: 'typeof',
         argument
       };
+    case 'TSTypeOperator':
+      if (node.operator === 'readonly') {
+        // readonly erased at runtime, same shape as the inner type.
+        return toSourceBabelTS(node.typeAnnotation);
+      }
+      console.warn('unimplemented TSTypeOperator', node.operator);
+      return 'any';
+    case 'TSQualifiedName':
+      return `${toSourceBabelTS(node.left)}.${toSourceBabelTS(node.right)}`;
     default:
       console.warn('toSourceBabelTS> unhandled type', node.type, node);
       debugger;
   }
 }
 
-export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, capitalize, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, parseJSDocTemplates, parseJSDocTypedef, parseType, parseTypeBabelTS, parserOptions, requiredTypeofs, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };
+/**
+ * Map of Babel node types to their child keys that contain traversable AST nodes.
+ * @type {Record<string, string[]>}
+ */
+const nodeChildren = {
+  'ArrayExpression': ['elements'],
+  'ArrayPattern': ['elements'],
+  'ArrowFunctionExpression': ['params', 'body'],
+  'AssignmentExpression': ['left', 'right'],
+  'AssignmentPattern': ['left', 'right'],
+  'AwaitExpression': ['argument'],
+  'BinaryExpression': ['left', 'right'],
+  'BlockStatement': ['directives', 'body'],
+  'BreakStatement': ['label'],
+  'CallExpression': ['callee', 'arguments'],
+  'CatchClause': ['param', 'body'],
+  'ClassBody': ['body'],
+  'ClassDeclaration': ['id', 'superClass', 'body'],
+  'ClassExpression': ['id', 'superClass', 'body'],
+  'ClassMethod': ['key', 'params', 'body'],
+  'ClassPrivateMethod': ['key', 'params', 'body'],
+  'ClassPrivateProperty': ['key', 'value'],
+  'ClassProperty': ['key', 'value'],
+  'ConditionalExpression': ['test', 'consequent', 'alternate'],
+  'ContinueStatement': ['label'],
+  'DebuggerStatement': [],
+  'Directive': ['value'],
+  'DirectiveLiteral': [],
+  'DoWhileStatement': ['body', 'test'],
+  'EmptyStatement': [],
+  'ExportAllDeclaration': ['source'],
+  'ExportDefaultDeclaration': ['declaration'],
+  'ExportNamedDeclaration': ['declaration', 'specifiers', 'source'],
+  'ExportNamespaceSpecifier': ['exported'],
+  'ExportSpecifier': ['local', 'exported'],
+  'ExpressionStatement': ['expression'],
+  'File': ['program'],
+  'ForInStatement': ['left', 'right', 'body'],
+  'ForOfStatement': ['left', 'right', 'body'],
+  'ForStatement': ['init', 'test', 'update', 'body'],
+  'FunctionDeclaration': ['id', 'params', 'body'],
+  'FunctionExpression': ['id', 'params', 'body'],
+  'IfStatement': ['test', 'consequent', 'alternate'],
+  'Import': [],
+  'ImportDeclaration': ['specifiers', 'source'],
+  'ImportDefaultSpecifier': ['local'],
+  'ImportExpression': ['source'],
+  'ImportNamespaceSpecifier': ['local'],
+  'ImportSpecifier': ['imported', 'local'],
+  'JSXAttribute': ['name', 'value'],
+  'JSXElement': ['openingElement', 'children', 'closingElement'],
+  'JSXExpressionContainer': ['expression'],
+  'JSXFragment': ['openingFragment', 'children', 'closingFragment'],
+  'JSXIdentifier': [],
+  'JSXMemberExpression': ['object', 'property'],
+  'JSXNamespacedName': ['namespace', 'name'],
+  'JSXText': [],
+  'LabeledStatement': ['label', 'body'],
+  'LogicalExpression': ['left', 'right'],
+  'MemberExpression': ['object', 'property'],
+  'MetaProperty': ['meta', 'property'],
+  'NewExpression': ['callee', 'arguments'],
+  'ObjectExpression': ['properties'],
+  'ObjectMethod': ['key', 'params', 'body'],
+  'ObjectPattern': ['properties'],
+  'ObjectProperty': ['key', 'value'],
+  'OptionalCallExpression': ['callee', 'arguments'],
+  'OptionalMemberExpression': ['object', 'property'],
+  'ParenthesizedExpression': ['expression'],
+  'PrivateName': ['id'],
+  'Program': ['directives', 'body'],
+  'RegExpLiteral': [],
+  'RestElement': ['argument'],
+  'ReturnStatement': ['argument'],
+  'SequenceExpression': ['expressions'],
+  'SpreadElement': ['argument'],
+  'Super': [],
+  'SwitchCase': ['test', 'consequent'],
+  'SwitchStatement': ['discriminant', 'cases'],
+  'TaggedTemplateExpression': ['tag', 'quasi'],
+  'TemplateElement': [],
+  'TemplateLiteral': ['quasis', 'expressions'],
+  'ThisExpression': [],
+  'ThrowStatement': ['argument'],
+  'TryStatement': ['block', 'handler', 'finalizer'],
+  'UnaryExpression': ['argument'],
+  'UpdateExpression': ['argument'],
+  'VariableDeclaration': ['declarations'],
+  'VariableDeclarator': ['id', 'init'],
+  'WhileStatement': ['test', 'body'],
+  'YieldExpression': ['argument'],
+  'TSAsExpression': ['expression', 'typeAnnotation'],
+  'TSDeclareFunction': ['id', 'params', 'body'],
+  'TSEnumDeclaration': ['id', 'members'],
+  'TSEnumMember': ['id', 'initializer'],
+  'TSInterfaceDeclaration': ['id', 'body'],
+  'TSInterfaceBody': ['body'],
+  'TSModuleDeclaration': ['id', 'body'],
+  'TSModuleBlock': ['body'],
+  'TSNonNullExpression': ['expression'],
+  'TSParameterProperty': ['parameter'],
+  'TSInstantiationExpression': ['expression'],
+  'TSTypeAliasDeclaration': ['id', 'typeAnnotation'],
+  'TSTypeAssertion': ['expression'],
+  'TSTypeCastExpression': ['expression'],
+  'TSTypeAnnotation': ['typeAnnotation'],
+  'TSTypeParameterDeclaration': ['params'],
+  'TSTypeParameterInstantiation': ['params']
+};
+
+class JSDocAnnotator {
+  /**
+   * @param {Object} [options] - Options for the annotator.
+   * @param {import('./parseJSDoc.js').ExpandType} [options.expandType] - Function to expand types.
+   */
+  constructor(options = {}) {
+    /** @type {import('@babel/types').Node[]} */
+    this.parents = [];
+    /** @type {Record<string, object>} */
+    this.typedefs = {};
+    /** @type {import('./parseJSDoc.js').ExpandType} */
+    this.expandType = options.expandType || expandTypeDepFree;
+  }
+  /**
+   * Annotates the AST by adding 'jsdoc' properties to relevant nodes.
+   * @param {import('@babel/types').File|import('@babel/types').Program} ast - The Babel AST to annotate.
+   * @returns {import('@babel/types').File|import('@babel/types').Program} The annotated AST.
+   */
+  annotate(ast) {
+    if (ast.type === 'File') {
+      const {
+        comments
+      } = ast;
+      if (comments) {
+        for (const comment of comments) {
+          const warn = console.warn.bind(console);
+          parseJSDocTypedef(this.typedefs, warn, comment, this.expandType);
+        }
+      }
+      this.traverse(ast.program);
+      ast.program.typedefs = this.typedefs;
+    } else {
+      this.traverse(ast);
+      ast.typedefs = this.typedefs;
+    }
+    return ast;
+  }
+  /**
+   * Traverses the AST node and annotates where applicable.
+   * @param {import('@babel/types').Node} node - The node to traverse.
+   */
+  traverse(node) {
+    if (!node) return;
+    this.parents.push(node);
+    if (nodeIsFunctionLike(node)) {
+      const jsdoc = this.getJSDoc(node);
+      if (jsdoc) {
+        node.jsdoc = jsdoc;
+        const paramTypes = this.collectParamTypes(node);
+        if (Object.keys(paramTypes).length > 0) {
+          node.paramTypes = paramTypes;
+        }
+      }
+    }
+    const type = node.type;
+    const childrenKeys = nodeChildren[type] || [];
+    for (const key of childrenKeys) {
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const c of child) {
+          this.traverse(c);
+        }
+      } else if (child && typeof child === 'object' && child.type) {
+        this.traverse(child);
+      }
+    }
+    this.parents.pop();
+  }
+  /**
+   * Collects the parameter names into a map of names to types.
+   * @param {import('@babel/types').ArrowFunctionExpression | import('@babel/types').FunctionDeclaration | import('@babel/types').FunctionExpression | import('@babel/types').ObjectMethod | import('@babel/types').ClassMethod | import('@babel/types').ClassPrivateMethod} node - The function-like node.
+   * @returns {Record<string, string | object>} The map of parameter names to types.
+   */
+  collectParamTypes(node) {
+    var _node$jsdoc;
+    const jsdocParams = ((_node$jsdoc = node.jsdoc) == null ? void 0 : _node$jsdoc.params) || {};
+    const paramNames = Object.keys(jsdocParams);
+    const paramTypes = {};
+    node.params.forEach((paramNode, index) => {
+      const paramName = paramNames[index];
+      if (paramName) {
+        const typeInfo = jsdocParams[paramName];
+        this.collectParamNames(paramNode, typeInfo, paramTypes);
+      }
+    });
+    return paramTypes;
+  }
+  /**
+   * Recursively collects parameter names from a pattern with their types.
+   * @param {import('@babel/types').PatternLike} paramNode - The parameter node.
+   * @param {string | object} typeInfo - The type information.
+   * @param {Record<string, string | object>} map - The map to collect into.
+   */
+  collectParamNames(paramNode, typeInfo, map) {
+    if (!typeInfo) {
+      console.warn("!typeInfo", {
+        paramNode,
+        typeInfo
+      });
+      return;
+    }
+    const {
+      type
+    } = paramNode;
+    if (type === 'Identifier') {
+      map[paramNode.name] = typeInfo;
+    } else if (type === 'ObjectPattern') {
+      if (typeof typeInfo !== 'object' || typeInfo.type !== 'object' || !typeInfo.properties) {
+        console.warn("typeof typeInfo !== 'object' || typeInfo.type !== 'object' || !typeInfo.properties", {
+          paramNode,
+          typeInfo
+        });
+        return;
+      }
+      const propTypes = typeInfo.properties;
+      paramNode.properties.forEach(prop => {
+        if (prop.type !== 'ObjectProperty') {
+          console.warn("prop.type !== 'ObjectProperty'", {
+            paramNode,
+            typeInfo
+          });
+          return;
+        }
+        if (prop.key.type !== 'Identifier') {
+          console.warn("prop.key.type !== 'Identifier'", {
+            paramNode,
+            typeInfo
+          });
+          return;
+        }
+        const keyName = prop.key.name;
+        const subType = propTypes[keyName];
+        if (!subType) {
+          console.warn("!subType", {
+            paramNode,
+            typeInfo
+          });
+          return;
+        }
+        this.collectParamNames(prop.value, subType, map);
+      });
+    } else if (type === 'ArrayPattern') {
+      // console.log("ARRAY PATTERN", {type, typeInfo});
+      if (typeof typeInfo !== 'object') {
+        console.warn("typeof typeInfo !== 'object'", {
+          paramNode,
+          typeInfo
+        });
+        return;
+      }
+      switch (typeInfo.type) {
+        case 'array':
+          if (!typeInfo.elementType) {
+            console.warn("Expected array type, but missing 'elementType' property.", {
+              paramNode,
+              typeInfo
+            });
+            return;
+          }
+          const elementType = typeInfo.elementType;
+          paramNode.elements.forEach(el => {
+            if (!el) {
+              console.warn("!el", {
+                paramNode,
+                typeInfo
+              });
+              return;
+            }
+            this.collectParamNames(el, elementType, map);
+          });
+          break;
+        case 'tuple':
+          // console.log("TUPLE PATTERN", {type, typeInfo});
+          if (!typeInfo.elements) {
+            console.warn("Expected tuple type, but missing 'elements' property.", {
+              paramNode,
+              typeInfo
+            });
+            return;
+          }
+          const elements = typeInfo.elements;
+          paramNode.elements.forEach((el, i) => {
+            const elType = elements[i];
+            if (el === null) {
+              // Example missing 'd' param: function addStr(a, {b}, [c], [, e])
+              return;
+            }
+            // console.log(`paramNode.elements[${i}]`, el, "elType", elType);
+            this.collectParamNames(el, elType, map);
+          });
+          break;
+        default:
+          console.warn('Unsupported type for ArrayPattern:', typeInfo.type, {
+            paramNode,
+            typeInfo
+          });
+          break;
+      }
+    } else if (type === 'AssignmentPattern') {
+      this.collectParamNames(paramNode.left, typeInfo, map);
+    } else if (type === 'RestElement') {
+      this.collectParamNames(paramNode.argument, typeInfo, map);
+    }
+  }
+  /**
+   * Finds the closest ancestor of the given node that matches the specified type.
+   * @param {import('@babel/types').Node} node - The starting node.
+   * @param {string} type - The type to search for.
+   * @returns {import('@babel/types').Node|undefined} The ancestor node or undefined.
+   */
+  findParentOfType(node, type) {
+    const currentIndex = this.parents.findLastIndex(_ => _ === node);
+    return this.parents.findLast((_, i) => i <= currentIndex && _.type === type);
+  }
+  /**
+   * Gets the leading comment node for ArrowFunctionExpression.
+   * @param {import('@babel/types').Node} node - The node.
+   * @returns {import('@babel/types').Node|undefined} The node with leading comments.
+   */
+  getLeadingCommentsNodeForArrowFunctionExpression(node) {
+    let i = this.parents.findLastIndex(_ => _ === node);
+    let parent = this.parents[i];
+    if (parent.leadingComments) {
+      return parent;
+    }
+    i--;
+    while (i >= 0) {
+      parent = this.parents[i];
+      if (nodeIsFunctionLike(parent)) {
+        break;
+      }
+      if (parent.leadingComments) {
+        return parent;
+      }
+      i--;
+    }
+  }
+  /**
+   * Gets the leading comment node for FunctionExpression.
+   * @param {import('@babel/types').Node} node - The node.
+   * @returns {import('@babel/types').Node|undefined} The node with leading comments.
+   */
+  getLeadingCommentsNodeForFunctionExpression(node) {
+    let i = this.parents.findLastIndex(_ => _ === node);
+    let parent = this.parents[i];
+    if (parent.leadingComments) {
+      return parent;
+    }
+    i--;
+    while (i >= 0) {
+      parent = this.parents[i];
+      if (nodeIsFunctionLike(parent)) {
+        break;
+      }
+      if (parent.leadingComments) {
+        return parent;
+      }
+      i--;
+    }
+  }
+  /**
+   * Gets the leading comment string for a node.
+   * @param {import('@babel/types').Node} node - The node.
+   * @returns {string|undefined} The comment value.
+   */
+  getLeadingComment(node) {
+    let leadingComments = node.leadingComments;
+    if (!leadingComments) {
+      if (node.type === 'FunctionDeclaration') {
+        const exportNamedDeclaration = this.findParentOfType(node, 'ExportNamedDeclaration');
+        leadingComments = exportNamedDeclaration == null ? void 0 : exportNamedDeclaration.leadingComments;
+      } else if (node.type === 'ArrowFunctionExpression') {
+        const tmp = this.getLeadingCommentsNodeForArrowFunctionExpression(node);
+        leadingComments = tmp == null ? void 0 : tmp.leadingComments;
+      } else if (node.type === 'FunctionExpression') {
+        const tmp = this.getLeadingCommentsNodeForFunctionExpression(node);
+        leadingComments = tmp == null ? void 0 : tmp.leadingComments;
+      }
+    }
+    if (leadingComments && leadingComments.length) {
+      const lastComment = leadingComments[leadingComments.length - 1];
+      if (lastComment.type === 'CommentBlock') {
+        return lastComment.value;
+      }
+    }
+  }
+  /**
+   * Parses the JSDoc for a node.
+   * @param {import('@babel/types').Node} node - The node.
+   * @returns {{templates: any, params: any}|undefined} The parsed JSDoc.
+   */
+  getJSDoc(node) {
+    const comment = this.getLeadingComment(node);
+    if (!comment) {
+      return;
+    }
+    if (comment.includes('@event') || comment.includes('@ignoreRTI')) {
+      return;
+    }
+    if (node.type === 'ClassMethod' && node.kind === 'set') {
+      if (node.params.length !== 1) {
+        console.warn('getJSDoc> setters require exactly one argument');
+      }
+      const setterType = parseJSDocSetter(comment, this.expandType);
+      if (!setterType) {
+        return;
+      }
+      const paramName = node.params[0].type === 'Identifier' ? node.params[0].name : 'value';
+      const _params = {
+        [paramName]: setterType
+      };
+      return {
+        templates: undefined,
+        params: _params
+      };
+    }
+    const templates = parseJSDocTemplates(comment);
+    const params = parseJSDoc(comment, this.expandType);
+    if (!templates && !params) {
+      return;
+    }
+    return {
+      templates,
+      params
+    };
+  }
+}
+
+/** @typedef {import("@babel/types").Node} Node */
+const CONST_TYPE = {
+  f32: 'f32.const',
+  f64: 'f64.const',
+  i32: 'i32.const',
+  i64: 'i64.const'
+};
+const NEG_OP = {
+  f32: 'f32.neg',
+  f64: 'f64.neg'
+};
+const EQZ_OP = {
+  f32: 'f32.eqz',
+  f64: 'f64.eqz',
+  i32: 'i32.eqz',
+  i64: 'i64.eqz'
+};
+const NE_OP = {
+  f32: 'f32.ne',
+  f64: 'f64.ne',
+  i32: 'i32.ne',
+  i64: 'i64.ne'
+};
+const ARITH_OP = {
+  f32: {
+    add: 'f32.add',
+    sub: 'f32.sub',
+    mul: 'f32.mul',
+    div: 'f32.div'
+  },
+  f64: {
+    add: 'f64.add',
+    sub: 'f64.sub',
+    mul: 'f64.mul',
+    div: 'f64.div'
+  },
+  i32: {
+    add: 'i32.add',
+    sub: 'i32.sub',
+    mul: 'i32.mul',
+    div: 'i32.div_s'
+  },
+  i64: {
+    add: 'i64.add',
+    sub: 'i64.sub',
+    mul: 'i64.mul',
+    div: 'i64.div_s'
+  }
+};
+const CMP_OP = {
+  f32: {
+    lt: 'f32.lt',
+    gt: 'f32.gt',
+    le: 'f32.le',
+    ge: 'f32.ge',
+    eq: 'f32.eq',
+    ne: 'f32.ne'
+  },
+  f64: {
+    lt: 'f64.lt',
+    gt: 'f64.gt',
+    le: 'f64.le',
+    ge: 'f64.ge',
+    eq: 'f64.eq',
+    ne: 'f64.ne'
+  },
+  i32: {
+    lt: 'i32.lt_s',
+    gt: 'i32.gt_s',
+    le: 'i32.le_s',
+    ge: 'i32.ge_s',
+    eq: 'i32.eq',
+    ne: 'i32.ne'
+  },
+  i64: {
+    lt: 'i64.lt_s',
+    gt: 'i64.gt_s',
+    le: 'i64.le_s',
+    ge: 'i64.ge_s',
+    eq: 'i64.eq',
+    ne: 'i64.ne'
+  }
+};
+const MATH_OP = {
+  f32: {
+    abs: 'f32.abs',
+    sqrt: 'f32.sqrt',
+    min: 'f32.min',
+    max: 'f32.max',
+    floor: 'f32.floor',
+    ceil: 'f32.ceil',
+    trunc: 'f32.trunc'
+  },
+  f64: {
+    abs: 'f64.abs',
+    sqrt: 'f64.sqrt',
+    min: 'f64.min',
+    max: 'f64.max',
+    floor: 'f64.floor',
+    ceil: 'f64.ceil',
+    trunc: 'f64.trunc'
+  }
+};
+const CMP_OPERATORS = ['<', '<=', '>', '>=', '==', '!='];
+/**
+ * Class for converting a JavaScript AST into WebAssembly Text (WAT).
+ */
+class WATConverter extends Stringifier {
+  constructor(...args) {
+    super(...args);
+    /**
+     * Current numeric WAT type for emitted operations.
+     * @type {'f32'|'f64'|'i32'|'i64'}
+     */
+    this.currentType = 'f32';
+    /**
+     * Stack of enclosing loop labels used as break/continue targets.
+     * @type {Array<{exit: string, top: string, updateSrc: string}>}
+     */
+    this.loops = [];
+    /**
+     * Counter for unique loop label names.
+     * @type {number}
+     */
+    this.loopCounter = 0;
+    /**
+     * Linear-memory array allocations by variable name.
+     * @type {Object<string, {offset: number, values: number[], isObject: boolean, keys?: Map<string, number>}>}
+     */
+    this.arrays = {};
+    /**
+     * Declared classes by name, each with its instance fields, per-field byte offsets, methods and total size.
+     * @type {Object<string, {fields: string[], offsets: Object<string, number>, defaults: Object<string, Node>, methods: Set<string>, size: number}>}
+     */
+    this.classes = {};
+    /**
+     * Instance variable names mapped to their class names.
+     * @type {Object<string, string>}
+     */
+    this.instances = {};
+    /**
+     * Name of the class currently being converted, if any.
+     * @type {string|null}
+     */
+    this.currentClass = null;
+  }
+  /**
+   * Converts a Babel AST node to WAT source.
+   * @param {Node} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  toSource(node) {
+    if (node === null) {
+      return '';
+    }
+    const {
+      leadingComments,
+      trailingComments
+    } = node;
+    if (node.type === 'File') {
+      this.parents.length = 0;
+    }
+    this.parents.push(node);
+    let out = '';
+    if (leadingComments) {
+      out += this.leadingCommentsToSource(leadingComments);
+    }
+    out += this.toSource_(node);
+    if (trailingComments) {
+      out += this.trailingCommentsToSource(trailingComments);
+    }
+    this.parents.pop();
+    return out;
+  }
+  /**
+   * Dispatches a node to its handler method, emitting a warning comment for unhandled types.
+   * @param {Node} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  toSource_(node) {
+    if (!node) {
+      return '';
+    }
+    const {
+      type
+    } = node;
+    if (this[type]) {
+      return this[type](node);
+    }
+    console.warn(`TODO ADD METHOD: ${type}`);
+    return `;; Unhandled node type: ${type}\n`;
+  }
+  /**
+   * Converts leading comments to WAT.
+   * @param {import("@babel/types").Comment[]} comments - The comment nodes.
+   * @returns {string} WAT representation of comments.
+   */
+  leadingCommentsToSource(comments) {
+    return comments.map(comment => this.commentToSource(comment, 'leading')).join('');
+  }
+  /**
+   * Converts trailing comments to WAT.
+   * @param {import("@babel/types").Comment[]} comments - The comment nodes.
+   * @returns {string} WAT representation of comments.
+   */
+  trailingCommentsToSource(comments) {
+    return comments.map(comment => this.commentToSource(comment, 'trailing')).join('');
+  }
+  /**
+   * Converts a comment to WAT.
+   * @param {import("@babel/types").Comment} comment - The comment node.
+   * @param {'leading' | 'trailing'} pos - The position of the comment.
+   * @returns {string} WAT representation of the comment.
+   */
+  commentToSource(comment, pos) {
+    if (comment.type === 'CommentBlock') {
+      return this.CommentBlock(comment);
+    } else if (comment.type === 'CommentLine') {
+      return this.CommentLine(comment);
+    }
+    console.warn("Unknown comment type", comment);
+    return '';
+  }
+  /**
+   * Converts a CommentBlock to WAT.
+   * @param {import("@babel/types").CommentBlock} node - The comment node.
+   * @returns {string} WAT representation of the comment.
+   */
+  CommentBlock(node) {
+    const {
+      loc,
+      value
+    } = node;
+    if (this.lastCommentBlockIndex === loc.start.index) {
+      return '';
+    }
+    this.lastCommentBlockIndex = loc.start.index;
+    const spaces = this.spaces;
+    let out = '';
+    const dedicatedLine = spaces.length === loc.start.column;
+    if (dedicatedLine) {
+      out += spaces;
+    }
+    const multiLine = loc.start.line !== loc.end.line;
+    if (multiLine) {
+      out += '\n' + spaces;
+    }
+    out += ';;' + value.replace(/\n\s*\*/g, '\n' + spaces + ';;') + '\n';
+    if (!dedicatedLine) {
+      out += ' ';
+    }
+    return out;
+  }
+  /**
+   * Converts a CommentLine to WAT.
+   * @param {import("@babel/types").CommentLine} node - The comment node.
+   * @returns {string} WAT representation of the comment.
+   */
+  CommentLine(node) {
+    const {
+      value,
+      loc
+    } = node;
+    if (this.lastCommentLineIndex === loc.start.index) {
+      return '';
+    }
+    this.lastCommentLineIndex = loc.start.index;
+    const spaces = this.spaces;
+    const dedicatedLine = spaces.length === loc.start.column;
+    let out = dedicatedLine ? '\n' + spaces : ' ';
+    out += `;;${value}\n`;
+    return out;
+  }
+  /**
+   * Runs a function with a temporarily shifted indentation depth.
+   * @param {number} extra - Additional indentation depth.
+   * @param {() => string} fn - The function to run.
+   * @returns {string} The result of the function.
+   */
+  atDepth(extra, fn) {
+    this.numSpaces += extra;
+    const ret = fn();
+    this.numSpaces -= extra;
+    return ret;
+  }
+  /**
+   * Converts a Program node to WAT.
+   * @param {import("@babel/types").Program} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  Program(node) {
+    const {
+      body
+    } = node;
+    this.registerModuleData(body);
+    this.registerClasses(body);
+    const classNames = Object.keys(this.classes);
+    const {
+      spaces
+    } = this;
+    let out = `(module\n`;
+    this.numSpaces++;
+    const rest = body.filter(stmt => this.isModuleDataDeclaration(stmt) === false);
+    out += this.mapToSource(rest).join('');
+    const names = Object.keys(this.arrays);
+    if (classNames.length) {
+      out += `${this.spaces}(memory (export "m") 512)\n`;
+      names.forEach(name => {
+        const arr = this.arrays[name];
+        out += `${this.spaces}(data (i32.const ${arr.offset}) ${this.f32DataBytes(arr.values)})\n`;
+      });
+      out += this.allocatorSource();
+    } else if (names.length) {
+      out += `${this.spaces}(memory (export "m") 1)\n`;
+      names.forEach(name => {
+        const arr = this.arrays[name];
+        out += `${this.spaces}(data (i32.const ${arr.offset}) ${this.f32DataBytes(arr.values)})\n`;
+      });
+    }
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Registers top-level array/object literals as flat memory data.
+   * @param {import("@babel/types").Statement[]} body - Top-level statements.
+   */
+  registerModuleData(body) {
+    let offset = 0;
+    body.forEach(stmt => {
+      if (stmt.type !== 'VariableDeclaration' || stmt.kind !== 'const') {
+        return;
+      }
+      const decl = stmt.declarations[0];
+      if (!decl || decl.id.type !== 'Identifier') {
+        return;
+      }
+      const {
+        init
+      } = decl;
+      if (!init) {
+        return;
+      }
+      if (init.type === 'ArrayExpression') {
+        const values = init.elements.map(e => (e == null ? void 0 : e.type) === 'NumericLiteral' ? e.value : 0.0);
+        this.arrays[decl.id.name] = {
+          offset,
+          values,
+          isObject: false
+        };
+        offset += values.length * 4;
+      } else if (init.type === 'ObjectExpression') {
+        /** @type {Map<string, number>} */
+        const keys = new Map();
+        /** @type {number[]} */
+        const values = [];
+        init.properties.forEach((prop, i) => {
+          if (prop.type !== 'ObjectProperty' || prop.key.type !== 'Identifier' || prop.value.type !== 'NumericLiteral') {
+            return;
+          }
+          keys.set(prop.key.name, i);
+          values.push(prop.value.value);
+        });
+        this.arrays[decl.id.name] = {
+          offset,
+          values,
+          isObject: true,
+          keys
+        };
+        offset += values.length * 4;
+      }
+    });
+  }
+  /**
+   * Checks whether a statement is a module-level array/object constant declaration.
+   * @param {import("@babel/types").Statement} stmt - The statement.
+   * @returns {boolean} True if the statement is a module-level data declaration.
+   */
+  isModuleDataDeclaration(stmt) {
+    if (stmt.type !== 'VariableDeclaration' || stmt.kind !== 'const') {
+      return false;
+    }
+    const decl = stmt.declarations[0];
+    return !!decl && decl.id.type === 'Identifier' && !!this.arrays[decl.id.name];
+  }
+  /**
+   * Serializes the f32 values of an array into raw little-endian bytes for a data segment.
+   * @param {number[]} values - The f32 values.
+   * @returns {string} The escaped byte string.
+   */
+  f32DataBytes(values) {
+    const bytes = new Uint8Array(new Float32Array(values).buffer);
+    let out = '"';
+    for (let i = 0; i < bytes.length; i++) {
+      out += '\\' + bytes[i].toString(16).padStart(2, '0');
+    }
+    return out + '"';
+  }
+  /**
+   * Registers top-level class declarations and their instance memory layout.
+   * @param {import("@babel/types").Statement[]} body - Top-level statements.
+   */
+  registerClasses(body) {
+    body.forEach(stmt => {
+      let decl = stmt;
+      if (stmt.type === 'ExportNamedDeclaration' && stmt.declaration) {
+        decl = stmt.declaration;
+      }
+      if (decl.type === 'ClassDeclaration') {
+        this.registerClass(decl);
+      }
+    });
+  }
+  /**
+   * Scans one class for instance fields, defaults and methods and stores its memory layout.
+   * @param {import("@babel/types").ClassDeclaration} node - The class declaration.
+   */
+  registerClass(node) {
+    const {
+      id,
+      body
+    } = node;
+    const cls = {
+      fields: [],
+      offsets: {},
+      defaults: {},
+      methods: new Set(),
+      size: 0
+    };
+    body.body.forEach(member => {
+      if (member.static) {
+        return;
+      }
+      if (member.type === 'ClassMethod' || member.type === 'MethodDefinition') {
+        const name = member.key.type === 'Identifier' ? member.key.name : member.key.value;
+        if (member.kind === 'constructor') {
+          var _member$value;
+          const methodBody = ((_member$value = member.value) == null ? void 0 : _member$value.body) || member.body;
+          if (methodBody) {
+            this.collectConstructorFields(methodBody, cls);
+          }
+        } else {
+          cls.methods.add(name);
+        }
+      } else if (member.type === 'ClassProperty' || member.type === 'PropertyDefinition') {
+        const name = member.key.type === 'Identifier' ? member.key.name : member.key.value;
+        this.addClassField(cls, name);
+        if (member.value) {
+          cls.defaults[name] = member.value;
+        }
+      }
+    });
+    if (cls.size || cls.methods.size) {
+      this.classes[id.name] = cls;
+    }
+  }
+  /**
+   * Adds a class field at the next available byte offset.
+   * @param {Object} cls - The class layout.
+   * @param {string} name - The field name.
+   */
+  addClassField(cls, name) {
+    if (name in cls.offsets) {
+      return;
+    }
+    const index = cls.fields.length;
+    cls.offsets[name] = index * 4;
+    cls.fields.push(name);
+    cls.size = (index + 1) * 4;
+  }
+  /**
+   * Collects class fields assigned in a constructor from `this.name = ...` stores.
+   * @param {import("@babel/types").BlockStatement} body - The constructor body.
+   * @param {Object} cls - The class layout.
+   */
+  collectConstructorFields(body, cls) {
+    this.walk(body, node => {
+      const target = node.type === 'AssignmentExpression' ? node.left : node.type === 'UpdateExpression' ? node.argument : null;
+      if (!target || target.type !== 'MemberExpression') {
+        return;
+      }
+      const isThis = target.object.type === 'ThisExpression' || target.object.type === 'Identifier' && target.object.name === 'this';
+      if (!isThis) {
+        return;
+      }
+      const name = target.property.type === 'Identifier' ? target.property.name : target.property.value;
+      this.addClassField(cls, name);
+    });
+  }
+  /**
+   * Walks a Babel node tree, invoking a callback for every node.
+   * @param {Node} node - The node to walk.
+   * @param {(node: Node) => void} fn - The callback.
+   */
+  walk(node, fn) {
+    if (!node) {
+      return;
+    }
+    fn(node);
+    for (const key of Object.keys(node)) {
+      if (key === 'leadingComments' || key === 'trailingComments' || key === 'loc' || key === 'start' || key === 'end') {
+        continue;
+      }
+      const child = node[key];
+      if (Array.isArray(child)) {
+        child.forEach(c => this.walk(c, fn));
+      } else if (child && typeof child.type === 'string') {
+        this.walk(child, fn);
+      }
+    }
+  }
+  /**
+   * Computes the first unused byte, after all module-level array/object data.
+   * @returns {number} The heap start offset.
+   */
+  heapStart() {
+    let max = 0;
+    Object.values(this.arrays).forEach(arr => {
+      const end = arr.offset + arr.values.length * 4;
+      if (end > max) {
+        max = end;
+      }
+    });
+    return max;
+  }
+  /**
+   * Emits the bump allocator: a heap pointer global and an `$alloc` function.
+   * @returns {string} WAT source of the heap global and allocator.
+   */
+  allocatorSource() {
+    const {
+      spaces
+    } = this;
+    let out = `${spaces}(global $heapPtr (mut i32) (i32.const ${this.heapStart()}))\n`;
+    out += `${spaces}(func $alloc (param $size i32) (result i32)\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(local $result i32)\n`;
+    out += `${this.spaces}(local.set $result (global.get $heapPtr))\n`;
+    out += `${this.spaces}(global.set $heapPtr (i32.add (global.get $heapPtr) (local.get $size)))\n`;
+    out += `${this.spaces}(local.get $result)\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts an ExportNamedDeclaration node to WAT.
+   * @param {import("@babel/types").ExportNamedDeclaration} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  ExportNamedDeclaration(node) {
+    const {
+      declaration
+    } = node;
+    let out = '';
+    if (declaration && declaration.type === 'FunctionDeclaration') {
+      out += this.toSource(declaration);
+      const funcName = declaration.id.name;
+      out += `${this.spaces}(export "${funcName}" (func $${funcName}))\n`;
+    } else if (declaration && declaration.type === 'ClassDeclaration') {
+      out += this.toSource(declaration);
+    } else {
+      out += `;; Unsupported ExportNamedDeclaration: ${JSON.stringify(node)}\n`;
+    }
+    return out;
+  }
+  /**
+   * Extracts the numeric WAT type from JSDoc comments (e.g. `@param {i32} n`).
+   * Looks at the function itself and its ancestors, since Babel often attaches
+   * the comment to the wrapping ExportNamedDeclaration instead.
+   * @param {import("@babel/types").FunctionDeclaration} node - The function declaration.
+   * @returns {'f32'|'f64'|'i32'|'i64'} The numeric type.
+   */
+  getFuncNumericType(node) {
+    let comments = node.leadingComments || [];
+    if (!comments.length) {
+      for (const parent of this.parents) {
+        var _parent$leadingCommen;
+        if ((_parent$leadingCommen = parent.leadingComments) != null && _parent$leadingCommen.length) {
+          comments = parent.leadingComments;
+          break;
+        }
+      }
+    }
+    const text = comments.map(c => c.value).join('\n');
+    const regex = /@(?:param|returns)\s*\{([^}]+)\}/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      const found = this.jsTypeToWat(match[1].trim().toLowerCase());
+      if (found) {
+        return found;
+      }
+    }
+    return 'f32';
+  }
+  /**
+   * Maps a JSDoc type name to a WAT numeric type.
+   * @param {string} type - The JSDoc type name.
+   * @returns {'f32'|'f64'|'i32'|'i64'|null} The WAT type or null if not numeric.
+   */
+  jsTypeToWat(type) {
+    if (type === 'i32' || type === 'int' || type === 'integer') {
+      return 'i32';
+    }
+    if (type === 'i64' || type === 'long') {
+      return 'i64';
+    }
+    if (type === 'f64' || type === 'double') {
+      return 'f64';
+    }
+    if (type === 'f32' || type === 'float' || type === 'number') {
+      return 'f32';
+    }
+    return null;
+  }
+  /**
+   * Converts a FunctionDeclaration node to WAT.
+   * @param {import("@babel/types").FunctionDeclaration} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  FunctionDeclaration(node) {
+    const {
+      id,
+      params,
+      body
+    } = node;
+    const funcName = id.name;
+    const savedType = this.currentType;
+    this.currentType = this.getFuncNumericType(node);
+    const t = this.currentType;
+    const paramList = params.map(param => `(param $${param.name} ${t})`).join(' ');
+    const returnType = `(result ${t})`;
+    let out = `${this.spaces}(func $${funcName}${paramList ? ' ' + paramList : ''} ${returnType}\n`;
+    this.numSpaces++;
+    const localNames = this.collectLocalNames(body);
+    localNames.forEach(localName => {
+      out += `${this.spaces}(local $${localName} ${t})\n`;
+    });
+    this.parents.push({
+      type: 'BlockStatement'
+    });
+    out += `${this.spaces}(block $exit (result ${t})\n`;
+    this.numSpaces++;
+    out += body.body.map(statement => this.toSource(statement)).join('');
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.parents.pop();
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.currentType = savedType;
+    return out;
+  }
+  /**
+   * Converts a class constructor to a `$<Name>_new` factory that allocates a slot
+   * in the bump heap and returns the instance pointer (as f32).
+   * @param {import("@babel/types").ClassDeclaration} node - The class declaration.
+   * @param {Object} cls - The registered class layout.
+   * @returns {string} WAT source of the factory function.
+   */
+  classConstructorSource(node, cls) {
+    var _ctor$value;
+    const {
+      spaces
+    } = this;
+    const {
+      id,
+      body
+    } = node;
+    const clsName = id.name;
+    const ctor = body.body.find(m => (m.type === 'ClassMethod' || m.type === 'MethodDefinition') && m.kind === 'constructor' && !m.static);
+    const savedType = this.currentType;
+    this.currentType = 'f32';
+    const savedClass = this.currentClass;
+    this.currentClass = clsName;
+    const ctorParams = ctor ? ((_ctor$value = ctor.value) == null ? void 0 : _ctor$value.params) || ctor.params : [];
+    const paramList = ctorParams.map(p => `(param $${p.name} f32)`).join(' ');
+    let out = `${spaces}(func $${clsName}_new${paramList ? ' ' + paramList : ''} (result f32)\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(local $this f32)\n`;
+    if (ctor) {
+      var _ctor$value2;
+      const ctorBody = ((_ctor$value2 = ctor.value) == null ? void 0 : _ctor$value2.body) || ctor.body;
+      const localNames = this.collectLocalNames(ctorBody);
+      localNames.forEach(name => {
+        out += `${this.spaces}(local $${name} f32)\n`;
+      });
+    }
+    out += `${this.spaces}(local.set $this\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(f32.convert_i32_u\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(call $alloc\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(i32.const ${cls.size})\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    cls.fields.forEach(name => {
+      if (cls.defaults[name]) {
+        out += this.classFieldStoreSource('this', cls.defaults[name], name, cls);
+      }
+    });
+    if (ctor) {
+      var _ctor$value3;
+      const ctorBody = ((_ctor$value3 = ctor.value) == null ? void 0 : _ctor$value3.body) || ctor.body;
+      out += this.mapToSource(ctorBody.body).join('');
+    }
+    out += `${this.spaces}(local.get $this)\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    this.currentType = savedType;
+    this.currentClass = savedClass;
+    return out;
+  }
+  /**
+   * Converts a class method to a `$<Name>_<method>` function taking `$this` first.
+   * @param {string} clsName - The class name.
+   * @param {import("@babel/types").ClassMethod} method - The method definition.
+   * @returns {string} WAT source of the method function.
+   */
+  classMethodSource(clsName, method) {
+    var _method$value, _method$value2;
+    const {
+      spaces
+    } = this;
+    const methodName = method.key.type === 'Identifier' ? method.key.name : method.key.value;
+    const fnParams = ((_method$value = method.value) == null ? void 0 : _method$value.params) || method.params;
+    const fnBody = ((_method$value2 = method.value) == null ? void 0 : _method$value2.body) || method.body;
+    const savedType = this.currentType;
+    this.currentType = 'f32';
+    const paramNames = ['this', ...fnParams.map(p => p.name)];
+    const paramList = paramNames.map(name => `(param $${name} f32)`).join(' ');
+    let out = `${spaces}(func $${clsName}_${methodName} ${paramList} (result f32)\n`;
+    this.numSpaces++;
+    const localNames = this.collectLocalNames(fnBody);
+    localNames.forEach(name => {
+      out += `${this.spaces}(local $${name} f32)\n`;
+    });
+    out += `${this.spaces}(block $exit (result f32)\n`;
+    this.numSpaces++;
+    out += this.mapToSource(fnBody.body).join('');
+    const last = fnBody.body[fnBody.body.length - 1];
+    if (!(last && last.type === 'ReturnStatement')) {
+      out += `${this.spaces}(f32.const 0)\n`;
+    }
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.currentType = savedType;
+    return out;
+  }
+  /**
+   * Converts a ClassDeclaration node to its factory and method functions.
+   * @param {import("@babel/types").ClassDeclaration} node - The class declaration.
+   * @returns {string} WAT representation of the class.
+   */
+  ClassDeclaration(node) {
+    const clsName = node.id.name;
+    const cls = this.classes[clsName];
+    const {
+      spaces
+    } = this;
+    if (!cls) {
+      return `${spaces};; Unsupported class declaration: ${JSON.stringify(node)}\n`;
+    }
+    let out = this.classConstructorSource(node, cls);
+    node.body.body.forEach(member => {
+      if (member.type !== 'ClassMethod' && member.type !== 'MethodDefinition' || member.kind === 'constructor' || member.static) {
+        return;
+      }
+      const savedClass = this.currentClass;
+      this.currentClass = clsName;
+      out += this.classMethodSource(clsName, member);
+      this.currentClass = savedClass;
+    });
+    return out;
+  }
+  /**
+   * Collects the names of all variables declared inside a function body.
+   * @param {import("@babel/types").BlockStatement} body - The function body.
+   * @returns {string[]} Names of the declared locals.
+   */
+  collectLocalNames(body) {
+    /** @type {string[]} */
+    const localNames = [];
+    const visit = node => {
+      if (!node) {
+        return;
+      }
+      const {
+        type
+      } = node;
+      if (type === 'VariableDeclaration') {
+        node.declarations.forEach(decl => {
+          if (decl.id.type === 'Identifier' && !localNames.includes(decl.id.name)) {
+            localNames.push(decl.id.name);
+          }
+        });
+        return;
+      }
+      for (const key of Object.keys(node)) {
+        if (key === 'leadingComments' || key === 'trailingComments' || key === 'loc' || key === 'start' || key === 'end') {
+          continue;
+        }
+        const child = node[key];
+        if (Array.isArray(child)) {
+          child.forEach(visit);
+        } else if (child && typeof child.type === 'string') {
+          visit(child);
+        }
+      }
+    };
+    visit(body);
+    return localNames;
+  }
+  /**
+   * Converts a BlockStatement node to WAT.
+   * @param {import("@babel/types").BlockStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  BlockStatement(node) {
+    const {
+      body
+    } = node;
+    return this.mapToSource(body).join('');
+  }
+  /**
+   * Checks whether an expression already produces an i32 boolean test result,
+   * so it can be fed to `if`/`br_if` without a truthiness conversion.
+   * @param {Node} expr - The expression.
+   * @returns {boolean} True if the expression yields an i32 test result.
+   */
+  isBooleanI32(expr) {
+    if (expr.type === 'BinaryExpression') {
+      return CMP_OPERATORS.includes(expr.operator);
+    }
+    if (expr.type === 'UnaryExpression' && expr.operator === '!') {
+      return true;
+    }
+    if (expr.type === 'LogicalExpression') {
+      return this.isBooleanI32(expr.left) && this.isBooleanI32(expr.right);
+    }
+    return false;
+  }
+  /**
+   * Produces a WAT i32 test expression for an arbitrary numeric condition.
+   * @param {Node} expr - The condition expression.
+   * @returns {string} WAT source that pushes an i32.
+   */
+  getTestSource(expr) {
+    if (this.isBooleanI32(expr)) {
+      return this.toSource(expr);
+    }
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    let out = `${spaces}(${NE_OP[t]}\n`;
+    this.numSpaces++;
+    out += this.toSource(expr);
+    out += `${this.spaces}(${CONST_TYPE[t]} 0)\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts a loop/conditional body, accepting either a block or a single statement.
+   * @param {Node} body - The body (BlockStatement or single statement).
+   * @returns {string} WAT source of the body.
+   */
+  bodySource(body) {
+    if (body.type === 'BlockStatement') {
+      return this.mapToSource(body.body).join('');
+    }
+    return this.toSource(body);
+  }
+  /**
+   * Converts an IfStatement node to WAT.
+   * @param {import("@babel/types").IfStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  IfStatement(node) {
+    const {
+      test,
+      consequent,
+      alternate
+    } = node;
+    const {
+      spaces
+    } = this;
+    let out = `${spaces}(if\n`;
+    this.numSpaces++;
+    out += this.getTestSource(test);
+    out += `${this.spaces}(then\n`;
+    this.numSpaces++;
+    out += this.bodySource(consequent);
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    if (alternate) {
+      out += `${this.spaces}(else\n`;
+      this.numSpaces++;
+      out += this.bodySource(alternate);
+      this.numSpaces--;
+      out += `${this.spaces})\n`;
+    }
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Registers the current loop as innermost and returns its label names.
+   * @param {'while'|'for'|'do'} kind - The loop kind.
+   * @param {Node} [update] - The for-loop update expression, regenerated inline at each continue.
+   * @returns {{exit: string, top: string, updateSrc: string}} The loop labels.
+   */
+  pushLoop(kind, update) {
+    const id = this.loopCounter++;
+    const entry = {
+      exit: `$exit${id}`,
+      top: `$top${id}`,
+      updateSrc: kind === 'for' && update ? this.toSource(update) : ''
+    };
+    this.loops.push(entry);
+    return entry;
+  }
+  /**
+   * Removes the innermost loop from the stack.
+   * @returns {{exit: string, top: string, updateSrc: string}|undefined} The popped loop labels.
+   */
+  popLoop() {
+    return this.loops.pop();
+  }
+  /**
+   * Converts a WhileStatement node to WAT.
+   * @param {import("@babel/types").WhileStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  WhileStatement(node) {
+    const {
+      test,
+      body
+    } = node;
+    const {
+      spaces
+    } = this;
+    const labels = this.pushLoop('while');
+    let out = `${spaces}(block ${labels.exit}\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(loop ${labels.top}\n`;
+    this.numSpaces++;
+    out += this.getTestSource(test);
+    out += `${this.spaces}(i32.eqz)\n`;
+    out += `${this.spaces}(br_if ${labels.exit})\n`;
+    out += this.bodySource(body);
+    out += `${this.spaces}(br ${labels.top})\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    this.popLoop();
+    return out;
+  }
+  /**
+   * Converts a ForStatement node to WAT.
+   * @param {import("@babel/types").ForStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  ForStatement(node) {
+    const {
+      init,
+      test,
+      update,
+      body
+    } = node;
+    const {
+      spaces
+    } = this;
+    let out = init ? this.toSource(init) : '';
+    const labels = this.pushLoop('for', update);
+    out += `${spaces}(block ${labels.exit}\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(loop ${labels.top}\n`;
+    this.numSpaces++;
+    if (test) {
+      out += this.getTestSource(test);
+      out += `${this.spaces}(i32.eqz)\n`;
+      out += `${this.spaces}(br_if ${labels.exit})\n`;
+    }
+    out += this.bodySource(body);
+    if (labels.updateSrc) {
+      out += labels.updateSrc;
+    }
+    out += `${this.spaces}(br ${labels.top})\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    this.popLoop();
+    return out;
+  }
+  /**
+   * Converts a DoWhileStatement node to WAT.
+   * @param {import("@babel/types").DoWhileStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  DoWhileStatement(node) {
+    const {
+      test,
+      body
+    } = node;
+    const {
+      spaces
+    } = this;
+    const labels = this.pushLoop('do');
+    let out = `${spaces}(block ${labels.exit}\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(loop ${labels.top}\n`;
+    this.numSpaces++;
+    out += this.bodySource(body);
+    out += this.getTestSource(test);
+    out += `${this.spaces}(i32.eqz)\n`;
+    out += `${this.spaces}(br_if ${labels.exit})\n`;
+    out += `${this.spaces}(br ${labels.top})\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    this.popLoop();
+    return out;
+  }
+  /**
+   * Converts a BreakStatement node to WAT.
+   * @param {import("@babel/types").BreakStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  BreakStatement(node) {
+    const {
+      spaces
+    } = this;
+    if (node.label) {
+      return `${spaces}(br $exit) ;; Unsupported labeled break "${node.label.name}"\n`;
+    }
+    const labels = this.loops[this.loops.length - 1];
+    if (labels === undefined) {
+      return `${spaces};; Unsupported break outside loop\n`;
+    }
+    return `${spaces}(br ${labels.exit})\n`;
+  }
+  /**
+   * Converts a ContinueStatement node to WAT.
+   * @param {import("@babel/types").ContinueStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  ContinueStatement(node) {
+    const {
+      spaces
+    } = this;
+    if (node.label) {
+      return `${spaces};; Unsupported labeled continue "${node.label.name}"\n`;
+    }
+    const labels = this.loops[this.loops.length - 1];
+    if (labels === undefined) {
+      return `${spaces};; Unsupported continue outside loop\n`;
+    }
+    let out = '';
+    if (labels.updateSrc) {
+      out += labels.updateSrc;
+    }
+    out += `${spaces}(br ${labels.top})\n`;
+    return out;
+  }
+  /**
+   * Converts a ReturnStatement node to WAT.
+   * @param {import("@babel/types").ReturnStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  ReturnStatement(node) {
+    const {
+      argument
+    } = node;
+    const {
+      spaces
+    } = this;
+    let out = `${spaces}(return\n`;
+    this.numSpaces++;
+    let expr = '';
+    if (!argument) {
+      expr = `${this.spaces}(${CONST_TYPE[this.currentType]} 0)\n`;
+    } else {
+      expr = this.toSource(argument);
+    }
+    out += expr;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts a BinaryExpression node to WAT.
+   * @param {import("@babel/types").BinaryExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  BinaryExpression(node) {
+    const {
+      left,
+      operator,
+      right
+    } = node;
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    if (operator === '%') {
+      return this.percentToSource(node);
+    }
+    let opCode = '';
+    if (CMP_OPERATORS.includes(operator)) {
+      const opName = {
+        '<': 'lt',
+        '<=': 'le',
+        '>': 'gt',
+        '>=': 'ge',
+        '==': 'eq',
+        '!=': 'ne'
+      }[operator];
+      opCode = CMP_OP[t][opName];
+    } else {
+      const opName = {
+        '+': 'add',
+        '-': 'sub',
+        '*': 'mul',
+        '/': 'div'
+      }[operator];
+      if (!opName) {
+        return `${spaces}(${CONST_TYPE[t]} 0.0) ;; Unsupported operator: ${operator}\n`;
+      }
+      opCode = ARITH_OP[t][opName];
+    }
+    let out = `${spaces}(${opCode}\n`;
+    this.numSpaces++;
+    out += this.toSource(left) + this.toSource(right);
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts a `%` (modulo) expression, emulating float modulo via truncation.
+   * @param {import("@babel/types").BinaryExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  percentToSource(node) {
+    const {
+      left,
+      right
+    } = node;
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    if (t === 'i32' || t === 'i64') {
+      let _out = `${spaces}(${t}.rem_s\n`;
+      this.numSpaces++;
+      _out += this.toSource(left) + this.toSource(right);
+      this.numSpaces--;
+      _out += `${spaces})\n`;
+      return _out;
+    }
+    const a = ARITH_OP[t];
+    const leftDiv = this.atDepth(5, () => this.toSource(left));
+    const rightDiv = this.atDepth(5, () => this.toSource(right));
+    const leftTop = this.atDepth(1, () => this.toSource(left));
+    const rightMul = this.atDepth(2, () => this.toSource(right));
+    const indent = n => '  '.repeat(this.numSpaces + n);
+    let out = `${spaces}(${a.add}\n`;
+    out += leftTop;
+    out += `${indent(1)}(${NEG_OP[t]}\n`;
+    out += `${indent(2)}(${a.mul}\n`;
+    out += `${indent(3)}(${MATH_OP[t].trunc}\n`;
+    out += `${indent(4)}(${a.div}\n`;
+    out += leftDiv + rightDiv;
+    out += `${indent(4)})\n`;
+    out += `${indent(3)})\n`;
+    out += rightMul;
+    out += `${indent(2)})\n`;
+    out += `${indent(1)})\n`;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts an UnaryExpression node to WAT.
+   * @param {import("@babel/types").UnaryExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  UnaryExpression(node) {
+    const {
+      argument,
+      operator
+    } = node;
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    if (operator === '-') {
+      if (NEG_OP[t]) {
+        let _out2 = `${spaces}(${NEG_OP[t]}\n`;
+        this.numSpaces++;
+        _out2 += this.toSource(argument);
+        this.numSpaces--;
+        _out2 += `${spaces})\n`;
+        return _out2;
+      }
+      let out = `${spaces}(${ARITH_OP[t].sub}\n`;
+      this.numSpaces++;
+      out += `${this.spaces}(${CONST_TYPE[t]} 0)\n`;
+      out += this.toSource(argument);
+      this.numSpaces--;
+      out += `${spaces})\n`;
+      return out;
+    }
+    if (operator === '!') {
+      const op = this.isBooleanI32(argument) ? 'i32.eqz' : EQZ_OP[t];
+      let out = `${spaces}(${op}\n`;
+      this.numSpaces++;
+      out += this.toSource(argument);
+      this.numSpaces--;
+      out += `${spaces})\n`;
+      return out;
+    }
+    return `${spaces}(${CONST_TYPE[t]} 0.0) ;; Unsupported unary operator: ${operator}\n`;
+  }
+  /**
+   * Converts a VariableDeclaration node to WAT.
+   * @param {import("@babel/types").VariableDeclaration} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  VariableDeclaration(node) {
+    const {
+      declarations
+    } = node;
+    return declarations.map(decl => this.toSource(decl)).join('');
+  }
+  /**
+   * Converts a VariableDeclarator node to WAT.
+   * @param {import("@babel/types").VariableDeclarator} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  VariableDeclarator(node) {
+    const {
+      id,
+      init
+    } = node;
+    const {
+      spaces
+    } = this;
+    if (id.type === 'Identifier' && init && init.type === 'NewExpression' && init.callee.type === 'Identifier' && this.classes[init.callee.name]) {
+      this.instances[id.name] = init.callee.name;
+    }
+    let out = `${spaces}(local.set $${id.name}\n`;
+    this.numSpaces++;
+    if (init) {
+      out += this.toSource(init);
+    } else {
+      out += `${this.spaces}(${CONST_TYPE[this.currentType]} 0) ;; Initialized as zero.\n`;
+    }
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts an UpdateExpression node to WAT.
+   * @param {import("@babel/types").UpdateExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  UpdateExpression(node) {
+    const {
+      argument,
+      operator
+    } = node;
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    if (argument.type !== 'Identifier') {
+      return `${spaces}(${CONST_TYPE[t]} 0.0) ;; Unsupported UpdateExpression target ${argument.type}\n`;
+    }
+    const op = operator === '++' ? ARITH_OP[t].add : ARITH_OP[t].sub;
+    let out = `${spaces}(local.set $${argument.name}\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(${op}\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(local.get $${argument.name})\n`;
+    out += `${this.spaces}(${CONST_TYPE[t]} 1)\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts an AssignmentExpression node to WAT.
+   * @param {import("@babel/types").AssignmentExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  AssignmentExpression(node) {
+    const {
+      left,
+      operator,
+      right
+    } = node;
+    const {
+      spaces
+    } = this;
+    if (operator !== '=') {
+      return `${spaces}(${CONST_TYPE[this.currentType]} 0.0) ;; Unsupported assignment operator: ${operator}\n`;
+    }
+    if (left.type === 'Identifier') {
+      let out = `${spaces}(local.set $${left.name}\n`;
+      this.numSpaces++;
+      out += this.toSource(right);
+      this.numSpaces--;
+      out += `${spaces})\n`;
+      return out;
+    }
+    if (left.type === 'MemberExpression') {
+      const member = left;
+      const pointerName = this.instancePointerName(member.object);
+      const fieldName = member.property.type === 'Identifier' ? member.property.name : member.property.value;
+      if (pointerName) {
+        const clsName = this.resolveInstanceClass(member.object, fieldName);
+        if (clsName && fieldName in this.classes[clsName].offsets) {
+          return this.classFieldStoreSource(pointerName, right, fieldName, this.classes[clsName]);
+        }
+      }
+      const arr = member.object.type === 'Identifier' ? this.arrays[member.object.name] : null;
+      if (arr) {
+        const indexSrc = this.arrayIndexSource(arr, member);
+        let out = `${spaces}(f32.store\n`;
+        this.numSpaces++;
+        out += this.arrayAddressSource(arr, indexSrc);
+        out += this.toSource(right);
+        this.numSpaces--;
+        out += `${spaces})\n`;
+        return out;
+      }
+      const objectName = member.object.type === 'Identifier' ? member.object.name : member.object.type;
+      return `${spaces}(${CONST_TYPE[this.currentType]} 0.0) ;; Unsupported store target ${objectName}\n`;
+    }
+    return `${spaces}(${CONST_TYPE[this.currentType]} 0.0) ;; Unsupported assignment target ${left.type}\n`;
+  }
+  /**
+   * Produces an i32 source for the element index of an array/object member access.
+   * @param {Object} arr - The registered array/object data.
+   * @param {import("@babel/types").MemberExpression} member - The member expression.
+   * @returns {string} WAT source that pushes the element index.
+   */
+  arrayIndexSource(arr, member) {
+    if (!arr.isObject) {
+      if (!member.computed) {
+        return `${this.spaces};; Unsupported ${member.object.name}.${member.property.name} on array\n`;
+      }
+      return this.toI32(member.property);
+    }
+    const key = member.computed && member.property.type === 'StringLiteral' ? member.property.value : member.property.name;
+    const index = arr.keys.get(key);
+    if (index === undefined) {
+      return `${this.spaces}; Unknown key "${member.property.name}"\n`;
+    }
+    return `${this.spaces}(i32.const ${index})\n`;
+  }
+  /**
+   * Truncates a numeric index expression to i32, passing i32 values through.
+   * @param {Node} expr - The index expression.
+   * @returns {string} WAT source that pushes an i32 index.
+   */
+  toI32(expr) {
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    if (t === 'i32') {
+      return this.toSource(expr);
+    }
+    if (t !== 'f32' && t !== 'f64') {
+      return `${spaces};; Unsupported index type ${t}\n`;
+    }
+    const truncExpr = t === 'f32' ? 'i32.trunc_f32_s' : 'i32.trunc_f64_s';
+    let out = `${spaces}(${truncExpr}\n`;
+    this.numSpaces++;
+    out += this.toSource(expr);
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Computes the byte address of `baseOffset + elementIndex * 4`.
+   * @param {Object} arr - The registered array/object data.
+   * @param {string} indexSrc - The i32 element index source.
+   * @returns {string} WAT source that pushes the byte address.
+   */
+  arrayAddressSource(arr, indexSrc) {
+    const {
+      spaces
+    } = this;
+    let out = `${spaces}(i32.add\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(i32.const ${arr.offset})\n`;
+    out += `${this.spaces}(i32.mul\n`;
+    this.numSpaces++;
+    out += indexSrc;
+    out += `${this.spaces}(i32.const 4)\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Returns the WAT local name holding an instance pointer.
+   * @param {Node} objectNode - The object expression.
+   * @returns {string|null} The local name.
+   */
+  instancePointerName(objectNode) {
+    const isThis = objectNode.type === 'ThisExpression' || objectNode.type === 'Identifier' && objectNode.name === 'this';
+    return isThis ? 'this' : objectNode.type === 'Identifier' ? objectNode.name : null;
+  }
+  /**
+   * Finds the class of an instance via `this`, a tracked `new` variable, or a unique field-name match.
+   * @param {Node} objectNode - The member/call object expression.
+   * @param {string} propertyName - The accessed field or method name.
+   * @returns {string|null} The class name.
+   */
+  resolveInstanceClass(objectNode, propertyName) {
+    const pointerName = this.instancePointerName(objectNode);
+    if (pointerName === 'this') {
+      return this.currentClass;
+    }
+    if (pointerName === null) {
+      return null;
+    }
+    if (this.instances[pointerName]) {
+      return this.instances[pointerName];
+    }
+    if (pointerName in this.arrays) {
+      return null;
+    }
+    const clsNames = Object.keys(this.classes).filter(n => propertyName in this.classes[n].offsets);
+    return clsNames.length === 1 ? clsNames[0] : null;
+  }
+  /**
+   * Finds the class of the object a method call is dispatched on.
+   * @param {Node} objectNode - The call object expression.
+   * @param {string} methodName - The called method name.
+   * @returns {string|null} The class name.
+   */
+  resolveInstanceMethodClass(objectNode, methodName) {
+    const pointerName = this.instancePointerName(objectNode);
+    if (pointerName === 'this') {
+      return this.currentClass && this.classes[this.currentClass].methods.has(methodName) ? this.currentClass : null;
+    }
+    if (pointerName === null) {
+      return null;
+    }
+    if (this.instances[pointerName]) {
+      return this.instances[pointerName];
+    }
+    if (pointerName in this.arrays) {
+      return null;
+    }
+    const clsNames = Object.keys(this.classes).filter(n => this.classes[n].methods.has(methodName));
+    return clsNames.length === 1 ? clsNames[0] : null;
+  }
+  /**
+   * Produces the WAT source for the heap byte address of a class field.
+   * @param {string} pointerName - The local holding the instance pointer.
+   * @param {string} fieldName - The field name.
+   * @param {Object} cls - The class layout.
+   * @returns {string} WAT source that pushes the byte address.
+   */
+  classFieldAddressSource(pointerName, fieldName, cls) {
+    const {
+      spaces
+    } = this;
+    let out = `${spaces}(i32.add\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(i32.trunc_f32_s\n`;
+    this.numSpaces++;
+    out += `${this.spaces}(local.get $${pointerName})\n`;
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    out += `${this.spaces}(i32.const ${cls.offsets[fieldName]})\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Produces the WAT source for loading a class field from the heap.
+   * @param {string} pointerName - The local holding the instance pointer.
+   * @param {string} fieldName - The field name.
+   * @param {Object} cls - The class layout.
+   * @returns {string} WAT source that pushes the field value.
+   */
+  classFieldLoadSource(pointerName, fieldName, cls) {
+    const {
+      spaces
+    } = this;
+    let out = `${spaces}(f32.load\n`;
+    this.numSpaces++;
+    out += this.classFieldAddressSource(pointerName, fieldName, cls);
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Produces the WAT source for storing a value into a class field.
+   * @param {string} pointerName - The local holding the instance pointer.
+   * @param {Node} valueNode - The value expression.
+   * @param {string} fieldName - The field name.
+   * @param {Object} cls - The class layout.
+   * @returns {string} WAT source that performs the store.
+   */
+  classFieldStoreSource(pointerName, valueNode, fieldName, cls) {
+    const {
+      spaces
+    } = this;
+    let out = `${spaces}(f32.store\n`;
+    this.numSpaces++;
+    out += this.classFieldAddressSource(pointerName, fieldName, cls);
+    out += this.toSource(valueNode);
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts a MemberExpression node (array/object element read) to WAT.
+   * @param {import("@babel/types").MemberExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  MemberExpression(node) {
+    const {
+      object,
+      property
+    } = node;
+    const {
+      spaces
+    } = this;
+    const pointerName = this.instancePointerName(object);
+    const fieldName = property.type === 'Identifier' ? property.name : property.value;
+    if (pointerName === 'this') {
+      const _clsName = this.resolveInstanceClass(object, fieldName);
+      if (_clsName && fieldName in this.classes[_clsName].offsets) {
+        return this.classFieldLoadSource('this', fieldName, this.classes[_clsName]);
+      }
+    }
+    if (object.type !== 'Identifier') {
+      return `${spaces}(f32.const 0.0) ;; Unsupported member access on ${object.type}\n`;
+    }
+    const arr = this.arrays[object.name];
+    if (arr) {
+      const indexSrc = this.arrayIndexSource(arr, node);
+      let out = `${spaces}(f32.load\n`;
+      this.numSpaces++;
+      out += this.arrayAddressSource(arr, indexSrc);
+      this.numSpaces--;
+      out += `${spaces})\n`;
+      return out;
+    }
+    const clsName = this.resolveInstanceClass(object, fieldName);
+    if (clsName && fieldName in this.classes[clsName].offsets) {
+      return this.classFieldLoadSource(object.name, fieldName, this.classes[clsName]);
+    }
+    return `${spaces}(f32.const 0.0) ;; Unsupported member access on unknown "${object.name}"\n`;
+  }
+  /**
+   * Converts a ConditionalExpression (ternary) node to WAT.
+   * @param {import("@babel/types").ConditionalExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  ConditionalExpression(node) {
+    const {
+      test,
+      consequent,
+      alternate
+    } = node;
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    let out = `${spaces}(if (result ${t})\n`;
+    this.numSpaces++;
+    out += this.getTestSource(test);
+    out += `${this.spaces}(then\n`;
+    this.numSpaces++;
+    out += this.toSource(consequent);
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    out += `${this.spaces}(else\n`;
+    this.numSpaces++;
+    out += this.toSource(alternate);
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Lowers `&&`/`||` to an if/then/else that short-circuits on the left operand.
+   * @param {import("@babel/types").LogicalExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  LogicalExpression(node) {
+    const {
+      left,
+      operator,
+      right
+    } = node;
+    const {
+      spaces
+    } = this;
+    const resultType = this.isBooleanI32(left) && this.isBooleanI32(right) ? 'i32' : this.currentType;
+    const thenOperand = operator === '&&' ? right : left;
+    const elseOperand = operator === '&&' ? left : right;
+    let out = `${spaces}(if (result ${resultType})\n`;
+    this.numSpaces++;
+    out += this.getTestSource(left);
+    out += `${this.spaces}(then\n`;
+    this.numSpaces++;
+    out += this.toSource(thenOperand);
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    out += `${this.spaces}(else\n`;
+    this.numSpaces++;
+    out += this.toSource(elseOperand);
+    this.numSpaces--;
+    out += `${this.spaces})\n`;
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts an ExpressionStatement node to WAT, dropping unused values.
+   * @param {import("@babel/types").ExpressionStatement} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  ExpressionStatement(node) {
+    const {
+      expression
+    } = node;
+    if (expression.type === 'AssignmentExpression' || expression.type === 'UpdateExpression') {
+      return this.toSource(expression);
+    }
+    const {
+      spaces
+    } = this;
+    let out = `${spaces}(drop\n`;
+    this.numSpaces++;
+    out += this.toSource(expression);
+    this.numSpaces--;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts an Identifier node to WAT.
+   * @param {import("@babel/types").Identifier} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  Identifier(node) {
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    if (node.name === 'this') {
+      return `${spaces}(local.get $this)\n`;
+    }
+    if (t === 'f32' || t === 'f64') {
+      if (node.name === 'Infinity') {
+        return `${spaces}(${CONST_TYPE[t]} inf)\n`;
+      }
+      if (node.name === 'NaN') {
+        return `${spaces}(${CONST_TYPE[t]} nan)\n`;
+      }
+    }
+    return `${spaces}(local.get $${node.name})\n`;
+  }
+  /**
+   * Converts a NumericLiteral node to WAT.
+   * @param {import("@babel/types").NumericLiteral} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  NumericLiteral(node) {
+    const {
+      spaces
+    } = this;
+    const t = this.currentType;
+    const constExpr = CONST_TYPE[t];
+    const value = parseFloat(node.value);
+    if (isNaN(value)) {
+      return `${spaces}(${constExpr} 0.0) ;; Invalid literal value: ${node.value}\n`;
+    }
+    if (t === 'i32' || t === 'i64') {
+      return `${spaces}(${constExpr} ${Math.trunc(value)})\n`;
+    }
+    return `${spaces}(${constExpr} ${value})\n`;
+  }
+  /**
+   * Converts a CallExpression node to WAT.
+   * @param {import("@babel/types").CallExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  CallExpression(node) {
+    const {
+      callee,
+      arguments: args
+    } = node;
+    const {
+      spaces
+    } = this;
+    if (callee.type === 'MemberExpression') {
+      const methodName = callee.property.type === 'Identifier' ? callee.property.name : callee.property.value;
+      if (callee.object.type === 'Identifier' && callee.object.name === 'Math') {
+        var _MATH_OP$this$current;
+        const mathOp = (_MATH_OP$this$current = MATH_OP[this.currentType]) == null ? void 0 : _MATH_OP$this$current[methodName];
+        if (!mathOp) {
+          return `${spaces}(f32.const 0.0) ;; Unsupported Math.${methodName} for ${this.currentType}\n`;
+        }
+        let _out3 = `${spaces}(${mathOp}\n`;
+        this.numSpaces++;
+        _out3 += args.map(arg => this.toSource(arg)).join('');
+        this.numSpaces--;
+        _out3 += `${spaces})\n`;
+        return _out3;
+      }
+      const clsName = this.resolveInstanceMethodClass(callee.object, methodName);
+      if (clsName) {
+        const pointerName = this.instancePointerName(callee.object);
+        if (pointerName) {
+          let _out4 = `${spaces}(call $${clsName}_${methodName}\n`;
+          this.numSpaces++;
+          _out4 += `${this.spaces}(local.get $${pointerName})\n`;
+          _out4 += args.map(arg => this.toSource(arg)).join('');
+          this.numSpaces--;
+          _out4 += `${spaces})\n`;
+          return _out4;
+        }
+      }
+    }
+    const funcName = callee.name;
+    let out = `${spaces}(call $${funcName}\n`;
+    this.numSpaces++;
+    const argsCode = args.map(arg => this.toSource(arg)).join('');
+    this.numSpaces--;
+    out += argsCode;
+    out += `${spaces})\n`;
+    return out;
+  }
+  /**
+   * Converts a NewExpression node to a $<ClassName>_new factory call.
+   * @param {import("@babel/types").NewExpression} node - The Babel AST node.
+   * @returns {string} WAT representation of the node.
+   */
+  NewExpression(node) {
+    const {
+      callee,
+      arguments: args
+    } = node;
+    const {
+      spaces
+    } = this;
+    if (!this.classes[callee.name]) {
+      return `${spaces}(f32.const 0.0) ;; Unsupported new ${callee.name}\n`;
+    }
+    let out = `${spaces}(call $${callee.name}_new\n`;
+    this.numSpaces++;
+    const argsCode = args.map(arg => this.toSource(arg)).join('');
+    this.numSpaces--;
+    out += argsCode;
+    out += `${spaces})\n`;
+    return out;
+  }
+}
+
+/** @typedef {import('@babel/types').Node} Node */
+/**
+ * Converts a Babel-TS type AST node into a JSDoc compatible type string,
+ * e.g. `number`, `string[]`, `Map<string, number>` or `{a: number, b?: string}`.
+ *
+ * The produced strings are valid TypeScript types as well, so they can be fed
+ * back into `expandType`/`parseJSDoc` of this very project.
+ * @param {Node} node - The Babel-TS type node.
+ * @returns {string} The JSDoc-compatible type string.
+ */
+function tsTypeToJSDoc(node) {
+  if (!node) {
+    return 'any';
+  }
+  switch (node.type) {
+    case 'TSAnyKeyword':
+      return 'any';
+    case 'TSBigIntKeyword':
+      return 'bigint';
+    case 'TSBooleanKeyword':
+      return 'boolean';
+    case 'TSNeverKeyword':
+      return 'never';
+    case 'TSNullKeyword':
+      return 'null';
+    case 'TSNumberKeyword':
+      return 'number';
+    case 'TSObjectKeyword':
+      return 'object';
+    case 'TSStringKeyword':
+      return 'string';
+    case 'TSSymbolKeyword':
+      return 'symbol';
+    case 'TSUndefinedKeyword':
+      return 'undefined';
+    case 'TSUnknownKeyword':
+      return 'unknown';
+    case 'TSVoidKeyword':
+      return 'void';
+    case 'TSThisType':
+      return 'this';
+    case 'TSIntrinsicKeyword':
+      return 'intrinsic';
+    case 'TSParenthesizedType':
+      return '(' + tsTypeToJSDoc(node.typeAnnotation) + ')';
+    case 'TSLiteralType':
+      return literalToJSDoc(node.literal);
+    case 'TSArrayType':
+      return tsTypeToJSDoc(node.elementType) + '[]';
+    case 'TSTupleType':
+      return '[' + node.elementTypes.map(tsTypeToJSDoc).join(', ') + ']';
+    case 'TSUnionType':
+      return node.types.map(tsTypeToJSDoc).join('|');
+    case 'TSIntersectionType':
+      return node.types.map(tsTypeToJSDoc).join('&');
+    case 'TSOptionalType':
+      return tsTypeToJSDoc(node.typeAnnotation) + '?';
+    case 'TSRestType':
+      return '...' + tsTypeToJSDoc(node.typeAnnotation);
+    case 'TSNamedTupleMember':
+      return tsTypeToJSDoc(node.elementType);
+    case 'TSTypeReference':
+      {
+        var _node$typeParameters;
+        const name = simplifyReference(node.typeName);
+        const params = (_node$typeParameters = node.typeParameters) == null ? void 0 : _node$typeParameters.params;
+        if (params != null && params.length) {
+          return `${name}<${params.map(tsTypeToJSDoc).join(', ')}>`;
+        }
+        return name;
+      }
+    case 'TSQualifiedName':
+      return `${tsTypeToJSDoc(node.left)}.${tsTypeToJSDoc(node.right)}`;
+    case 'TSExpressionWithTypeArguments':
+      return simplifyReference(node.expression);
+    case 'Identifier':
+      return node.name;
+    case 'TSTypeAnnotation':
+      return tsTypeToJSDoc(node.typeAnnotation);
+    case 'TSTypeQuery':
+      return 'typeof ' + tsTypeToJSDoc(node.exprName);
+    case 'TSTypeOperator':
+      return node.operator + ' ' + tsTypeToJSDoc(node.typeAnnotation);
+    case 'TSIndexedAccessType':
+      return tsTypeToJSDoc(node.objectType) + '[' + tsTypeToJSDoc(node.indexType) + ']';
+    case 'TSTypeLiteral':
+      return typeLiteralMembersToJSDoc(node.members);
+    case 'TSPropertySignature':
+      return propertySignatureToJSDoc(node);
+    case 'TSIndexSignature':
+      {
+        const {
+          parameters,
+          typeAnnotation
+        } = node;
+        const pad = parameters.length ? `${tsTypeToJSDoc(parameters[0].typeAnnotation)}` : 'any';
+        return `[key: ${pad}]: ${tsTypeToJSDoc(typeAnnotation.typeAnnotation)}`;
+      }
+    case 'TSFunctionType':
+      return functionSignatureToJSDoc(node);
+    case 'TSConstructorType':
+      return `new ${functionSignatureToJSDoc(node)}`;
+    case 'TSCallSignatureDeclaration':
+      return functionSignatureToJSDoc(node);
+    case 'TSConstructSignatureDeclaration':
+      return `new ${functionSignatureToJSDoc(node)}`;
+    case 'TSTypePredicate':
+      return `${tsTypeToJSDoc(node.parameterName)} is ${tsTypeToJSDoc(node.typeAnnotation)}`;
+    case 'TSImportType':
+      {
+        var _typeArguments$params;
+        const {
+          argument,
+          qualifier,
+          typeArguments
+        } = node;
+        const arg = argument.type === 'StringLiteral' ? `'${jsImportSource(argument)}'` : tsTypeToJSDoc(argument);
+        let out = 'import(' + arg + ')';
+        if (qualifier) {
+          out += '.' + tsTypeToJSDoc(qualifier);
+        }
+        if (typeArguments != null && (_typeArguments$params = typeArguments.params) != null && _typeArguments$params.length) {
+          out += '<' + typeArguments.params.map(tsTypeToJSDoc).join(', ') + '>';
+        }
+        return out;
+      }
+    case 'TSMappedType':
+      {
+        const {
+          typeParameter,
+          typeAnnotation
+        } = node;
+        const name = tsTypeToJSDoc(typeParameter == null ? void 0 : typeParameter.name);
+        const constraint = typeParameter != null && typeParameter.constraint ? ' in ' + tsTypeToJSDoc(typeParameter.constraint) : '';
+        const optional = node.optional ? '?' : '';
+        const value = typeAnnotation ? tsTypeToJSDoc(typeAnnotation) : 'any';
+        return `{ [${name}${constraint}]${optional}: ${value} }`;
+      }
+    case 'TSConditionalType':
+      return `${tsTypeToJSDoc(node.checkType)} extends ${tsTypeToJSDoc(node.extendsType)} ? ${tsTypeToJSDoc(node.trueType)} : ${tsTypeToJSDoc(node.falseType)}`;
+    case 'TSTemplateLiteralType':
+      return templateLiteralToJSDoc(node);
+    default:
+      console.warn('ts2js> tsTypeToJSDoc unhandled type', node.type, node);
+      return 'any';
+  }
+}
+/**
+ * Reduces a possibly namespace-qualified type name to its local identifier,
+ * e.g. `Validation.StringValidator` becomes `StringValidator`, since flattened
+ * namespaces hoist their interfaces/classes to plain identifiers.
+ * @param {Node} node - The referenced name node.
+ * @returns {string} The simplified JSDoc type string.
+ */
+function simplifyReference(node) {
+  if ((node == null ? void 0 : node.type) === 'TSQualifiedName') {
+    return simplifyReference(node.right);
+  }
+  return tsTypeToJSDoc(node);
+}
+/**
+ * Converts a literal type node to its JSDoc representation.
+ * @param {Node} literal - The literal node.
+ * @returns {string} The JSDoc type string.
+ */
+function literalToJSDoc(literal) {
+  if (literal.type === 'UnaryExpression') {
+    return literal.operator + tsTypeToJSDoc(literal.argument);
+  }
+  if (literal.type === 'StringLiteral' || literal.type === 'NumericLiteral' || literal.type === 'BooleanLiteral') {
+    var _literal$extra$raw, _literal$extra;
+    return (_literal$extra$raw = (_literal$extra = literal.extra) == null ? void 0 : _literal$extra.raw) != null ? _literal$extra$raw : String(literal.value);
+  }
+  if (literal.type === 'BigIntLiteral') {
+    var _literal$extra$raw2, _literal$extra2;
+    return (_literal$extra$raw2 = (_literal$extra2 = literal.extra) == null ? void 0 : _literal$extra2.raw) != null ? _literal$extra$raw2 : literal.value;
+  }
+  return tsTypeToJSDoc(literal);
+}
+/**
+ * Converts a `TSTypeLiteral`'s members into a JSDoc object type string,
+ * e.g. `{a: number, b?: string}`.
+ * @param {Node[]} members - The members of the type literal.
+ * @returns {string} The JSDoc object type string.
+ */
+function typeLiteralMembersToJSDoc(members) {
+  const props = members.map(tsTypeToJSDoc);
+  return '{' + props.join(', ') + '}';
+}
+/**
+ * @param {Node} node - The `TSPropertySignature` node.
+ * @returns {string} The `name: type` (or optional `name?: type`) string.
+ */
+function propertySignatureToJSDoc(node) {
+  const key = tsTypeToJSDoc(node.key);
+  const optional = node.optional ? '?' : '';
+  const type = node.typeAnnotation ? tsTypeToJSDoc(node.typeAnnotation.typeAnnotation) : 'any';
+  return `${key}${optional}: ${type}`;
+}
+/**
+ * @param {Node} node - A function-like type node (`TSFunctionType`, `TSCallSignatureDeclaration`, ...).
+ * @returns {string} The `(a: A) => R` style JSDoc type string.
+ */
+function functionSignatureToJSDoc(node) {
+  const params = node.parameters.map(param => {
+    const name = param.type === 'Identifier' ? param.name : '';
+    const type = param.typeAnnotation ? tsTypeToJSDoc(param.typeAnnotation.typeAnnotation) : 'any';
+    return name && name !== 'this' ? `${name}: ${type}` : type;
+  }).join(', ');
+  const retType = node.typeAnnotation ? tsTypeToJSDoc(node.typeAnnotation.typeAnnotation) : 'void';
+  return `(${params}) => ${retType}`;
+}
+/**
+ * @param {Node} node - The `TSTemplateLiteralType` node.
+ * @returns {string} The template literal type as string.
+ */
+function templateLiteralToJSDoc(node) {
+  const {
+    quasis,
+    types
+  } = node;
+  let out = '`';
+  for (let i = 0; i < quasis.length; i++) {
+    out += quasis[i].value.raw;
+    if (types[i]) {
+      out += '${' + tsTypeToJSDoc(types[i]) + '}';
+    }
+  }
+  return out + '`';
+}
+/**
+ * Extracts param information and produces a `@param` JSDoc line,
+ * or nothing when nothing can be said about the parameter.
+ * @param {Node} param - The parameter node.
+ * @param {number} index - The index of the parameter.
+ * @returns {string|undefined} The `@param` line.
+ */
+function paramToJSDoc(param, index) {
+  if (param.type === 'TSParameterProperty') {
+    param = param.parameter;
+  }
+  let type;
+  let name;
+  let optional = false;
+  let rest = false;
+  let defaultText;
+  const typeAnnotationOf = value => {
+    var _value$typeAnnotation;
+    return value == null || (_value$typeAnnotation = value.typeAnnotation) == null ? void 0 : _value$typeAnnotation.typeAnnotation;
+  };
+  if (param.type === 'Identifier') {
+    name = param.name;
+    optional = param.optional;
+    type = typeAnnotationOf(param);
+  } else if (param.type === 'AssignmentPattern') {
+    var _param$right, _param$right2, _param$right3;
+    optional = true;
+    const left = param.left;
+    if (left.type === 'Identifier') {
+      name = left.name;
+      type = typeAnnotationOf(left);
+    } else {
+      var _left$id;
+      name = 'param' + index;
+      if (((_left$id = left.id) == null ? void 0 : _left$id.type) === 'Identifier') {
+        name = left.id.name;
+      }
+      type = typeAnnotationOf(left);
+    }
+    if (((_param$right = param.right) == null ? void 0 : _param$right.type) === 'StringLiteral' || ((_param$right2 = param.right) == null ? void 0 : _param$right2.type) === 'NumericLiteral' || ((_param$right3 = param.right) == null ? void 0 : _param$right3.type) === 'BooleanLiteral') {
+      var _param$right$extra$ra, _param$right$extra;
+      defaultText = (_param$right$extra$ra = (_param$right$extra = param.right.extra) == null ? void 0 : _param$right$extra.raw) != null ? _param$right$extra$ra : String(param.right.value);
+    }
+    if (!type) {
+      type = inferTypeFromDefault(param.right);
+    }
+  } else if (param.type === 'RestElement') {
+    rest = true;
+    const argument = param.argument;
+    if (argument.type === 'Identifier') {
+      name = argument.name;
+      type = typeAnnotationOf(param);
+    } else {
+      type = typeAnnotationOf(param);
+      name = 'param' + index;
+    }
+  } else {
+    // ObjectPattern / ArrayPattern
+    name = 'param' + index;
+    type = typeAnnotationOf(param);
+  }
+  let nameStr = name || 'param' + index;
+  if (optional) {
+    nameStr = '[' + nameStr + (defaultText !== undefined ? ' = ' + defaultText : '') + ']';
+  }
+  if (!type) {
+    return `@param {any} ${nameStr}`;
+  }
+  const typeStr = rest ? '...' + restElementType(tsTypeToJSDoc(type)) : tsTypeToJSDoc(type);
+  return `@param {${typeStr}} ${nameStr}`;
+}
+/**
+ * Unwraps the trailing `[]` of an array type in a rest parameter context,
+ * e.g. `@param {...string[]} rest` becomes `@param {...string} rest`.
+ * @param {string} typeStr - The JSDoc type string.
+ * @returns {string} The element type.
+ */
+function restElementType(typeStr) {
+  if (typeStr.endsWith('[]')) {
+    return typeStr.slice(0, -2);
+  }
+  return typeStr;
+}
+/**
+ * Infers a JSDoc type from a default value literal.
+ * @param {Node} node - The default value node.
+ * @returns {import('@babel/types').Node|undefined} A primitive keyword node or `undefined`.
+ */
+function inferTypeFromDefault(node) {
+  let keyword;
+  switch (node == null ? void 0 : node.type) {
+    case 'StringLiteral':
+      keyword = 'TSStringKeyword';
+      break;
+    case 'NumericLiteral':
+      keyword = 'TSNumberKeyword';
+      break;
+    case 'BooleanLiteral':
+      keyword = 'TSBooleanKeyword';
+      break;
+    case 'NullLiteral':
+      keyword = 'TSNullKeyword';
+      break;
+    case 'ArrayExpression':
+      keyword = 'TSArrayType';
+      break;
+    default:
+      return undefined;
+  }
+  return {
+    type: keyword
+  };
+}
+/**
+ * @param {Node} node - The function-like node.
+ * @returns {boolean} True if any parameter carries a type annotation.
+ */
+function hasTypedParams(node) {
+  return node.params.some(param => {
+    var _param$left, _param$argument;
+    if (param.type === 'TSParameterProperty') {
+      param = param.parameter;
+    }
+    return param.typeAnnotation || ((_param$left = param.left) == null ? void 0 : _param$left.typeAnnotation) || ((_param$argument = param.argument) == null ? void 0 : _param$argument.typeAnnotation);
+  });
+}
+/**
+ * Returns the JSDoc lines for a function-like node.
+ * @param {Node} node - The function-like node.
+ * @returns {string[]} The JSDoc lines (without `@param`/`@returns` separators).
+ */
+function jsdocLinesFromFunction(node) {
+  var _node$typeParameters2, _node$returnType;
+  const lines = [];
+  if ((_node$typeParameters2 = node.typeParameters) != null && _node$typeParameters2.params) {
+    for (const tp of node.typeParameters.params) {
+      const name = tp.name;
+      lines.push(`@template {${name}} ${name}`);
+    }
+  }
+  const addParams = node.type !== 'TSDeclareFunction' && node.kind !== 'get';
+  if (addParams && hasTypedParams(node)) {
+    node.params.forEach((param, i) => lines.push(paramToJSDoc(param, i)));
+  }
+  if ((_node$returnType = node.returnType) != null && _node$returnType.typeAnnotation) {
+    lines.push(`@returns {${tsTypeToJSDoc(node.returnType.typeAnnotation)}}`);
+  }
+  return lines;
+}
+/**
+ * Injects `this.prop = prop;` statements for constructor parameter properties
+ * (`constructor(public prop: number)`).
+ * @param {import('@babel/types').ClassMethod|import('@babel/types').ClassPrivateMethod} node - The constructor node.
+ */
+function injectParameterProperties(node) {
+  var _node$body;
+  const body = (_node$body = node.body) == null ? void 0 : _node$body.body;
+  if (!Array.isArray(body)) {
+    return;
+  }
+  const properties = node.params.filter(param => param.type === 'TSParameterProperty');
+  for (const property of properties) {
+    const parameter = property.parameter;
+    if (parameter.type !== 'Identifier' && parameter.type !== 'AssignmentPattern') {
+      console.warn('ts2js> unhandled parameter property', property);
+      continue;
+    }
+    const target = parameter.type === 'AssignmentPattern' ? parameter.left : parameter;
+    if (target.type !== 'Identifier') {
+      console.warn('ts2js> unhandled parameter property target', property);
+      continue;
+    }
+    const {
+      name
+    } = target;
+    const alreadyAssigned = body.some(stmt => {
+      if (stmt.type !== 'ExpressionStatement') return false;
+      const expr = stmt.expression;
+      return expr.type === 'AssignmentExpression' && expr.operator === '=' && expr.left.type === 'MemberExpression' && expr.left.object.type === 'ThisExpression' && expr.left.property.type === 'Identifier' && expr.left.property.name === name;
+    });
+    if (alreadyAssigned) {
+      continue;
+    }
+    const rightNode = target;
+    const assignment = {
+      type: 'ExpressionStatement',
+      expression: {
+        type: 'AssignmentExpression',
+        operator: '=',
+        left: {
+          type: 'MemberExpression',
+          object: {
+            type: 'ThisExpression'
+          },
+          property: {
+            type: 'Identifier',
+            name
+          },
+          computed: false,
+          optional: null
+        },
+        right: rightNode
+      }
+    };
+    body.unshift(assignment);
+  }
+}
+/**
+ * A Stringifier subclass which strips TypeScript-only syntax while emitting the
+ * JSDoc comments that were attached during the `annotate` pre-pass.
+ */
+class ToJS extends Stringifier {
+  // --- Unwrap type-only expressions ---
+  TSAsExpression(node) {
+    return this.toSource(node.expression);
+  }
+  TSNonNullExpression(node) {
+    return this.toSource(node.expression);
+  }
+  TSSatisfiesExpression(node) {
+    return this.toSource(node.expression);
+  }
+  TSTypeAssertion(node) {
+    return this.toSource(node.expression);
+  }
+  TSInstantiationExpression(node) {
+    return this.toSource(node.expression);
+  }
+  TSTypeCastExpression(node) {
+    return this.toSource(node.expression);
+  }
+  TSParameterProperty(node) {
+    return this.toSource(node.parameter);
+  }
+  TSExpressionWithTypeArguments(node) {
+    return this.toSource(node.expression);
+  }
+  TSImportEqualsDeclaration(node) {
+    var _node$moduleReference;
+    if (((_node$moduleReference = node.moduleReference) == null ? void 0 : _node$moduleReference.type) !== 'TSExternalModuleReference') {
+      return '';
+    }
+    const name = this.toSource(node.id);
+    const raw = jsImportSource(node.moduleReference.expression);
+    if (node.importKind === 'type') {
+      return `/** @import * as ${name} from '${raw}' */`;
+    }
+    return `import * as ${name} from '${raw}';`;
+  }
+  TSExportAssignment() {
+    return '';
+  }
+  TSUndefinedKeyword() {
+    return '';
+  }
+  // --- Drop type-only declarations, but keep interfaces/aliases as @typedef ---
+  /**
+   * @param {import('@babel/types').TSInterfaceDeclaration} node - The Babel AST node.
+   * @returns {string} A JSDoc typedef comment.
+   */
+  TSInterfaceDeclaration(node) {
+    return this.typedefComment(node);
+  }
+  /**
+   * @param {import('@babel/types').TSTypeAliasDeclaration} node - The Babel AST node.
+   * @returns {string} A JSDoc typedef comment.
+   */
+  TSTypeAliasDeclaration(node) {
+    return this.typedefComment(node);
+  }
+  /**
+   * Drop ambient declarations, they have no runtime representation.
+   * @returns {string} An empty string.
+   */
+  TSDeclareFunction() {
+    return '';
+  }
+  /**
+   * Converts a namespace (`namespace X { ... }`) into the classic IIFE
+   * pattern, exporting members via `X.member = member` assignments.
+   * @param {import('@babel/types').TSModuleDeclaration} node - The namespace declaration.
+   * @returns {string} The IIFE source.
+   */
+  TSModuleDeclaration(node) {
+    var _this$namespaceLevel;
+    const {
+      id,
+      body
+    } = node;
+    const name = (id == null ? void 0 : id.type) === 'Identifier' ? id.name : '';
+    if (!name || node.declare || node.global || !body || body.type !== 'TSModuleBlock') {
+      return '';
+    }
+    const saved = this.numSpaces;
+    const level = (_this$namespaceLevel = this.namespaceLevel) != null ? _this$namespaceLevel : 0;
+    this.namespaceLevel = level + 1;
+    this.numSpaces = 0;
+    const memberSource = this.namespaceMembers(body, name);
+    this.numSpaces = saved;
+    this.namespaceLevel = level;
+    const spaces = this.spaces;
+    const outer = '  '.repeat(level + 1);
+    const inner = memberSource.replace(/ \*\/ +(?=[a-zA-Z_$])/g, '*/\n').split('\n').map(line => line.trim() ? outer + line.trimEnd() : line).join('\n');
+    let out = spaces + `var ${name};\n`;
+    out += spaces + `(function (${name}) {\n`;
+    out += inner;
+    out += '\n' + spaces + `})(${name} || (${name} = {}));`;
+    return out;
+  }
+  /**
+   * Renders the statements of a namespace body at base indentation, emitting
+   * the local members and the trailing `Name.member = member;` assignments
+   * for exported value members.
+   * @param {import('@babel/types').TSModuleBlock} block - The namespace body.
+   * @param {string} name - The namespace identifier.
+   * @returns {string} The body source (joinable lines).
+   */
+  namespaceMembers(block, name) {
+    const lines = [];
+    const assignments = [];
+    for (const statement of block.body) {
+      if (statement.type === 'ExportNamedDeclaration') {
+        const {
+          code,
+          names
+        } = this.namespaceExport(statement);
+        if (code) {
+          lines.push(code.trimEnd());
+        }
+        for (const member of names) {
+          assignments.push(`${name}.${member} = ${member};`);
+        }
+      } else {
+        lines.push(this.toSource(statement).trimEnd());
+      }
+    }
+    return lines.concat(assignments).join('\n');
+  }
+  /**
+   * Renders an `export` statement inside a namespace: the declaration without
+   * the `export` keyword and the list of exported value names.
+   * @param {import('@babel/types').ExportNamedDeclaration} statement - The export statement.
+   * @returns {{code: string, names: string[]}} The declaration source and exported names.
+   */
+  namespaceExport(statement) {
+    var _declaration$id;
+    const {
+      declaration
+    } = statement;
+    if (!declaration) {
+      return {
+        code: '',
+        names: []
+      };
+    }
+    let names = [];
+    switch (declaration.type) {
+      case 'ClassDeclaration':
+      case 'FunctionDeclaration':
+      case 'TSEnumDeclaration':
+        if (declaration.id) {
+          names = [declaration.id.name];
+        }
+        break;
+      case 'VariableDeclaration':
+        names = declaration.declarations.map(declarator => declarator.id).filter(id => id && id.type === 'Identifier').map(id => id.name);
+        break;
+      case 'TSModuleDeclaration':
+        if ((_declaration$id = declaration.id) != null && _declaration$id.name) {
+          names = [declaration.id.name];
+        }
+        break;
+    }
+    return {
+      code: this.toSource(declaration),
+      names
+    };
+  }
+  /**
+   * Converts `enum` into a plain `const` object.
+   * @param {import('@babel/types').TSEnumDeclaration} node - The Babel AST node.
+   * @returns {string} The object literal.
+   */
+  TSEnumDeclaration(node) {
+    const spaces = this.spaces;
+    let running = 0;
+    const entries = node.members.map(member => {
+      const key = this.toSource(member.id);
+      let value;
+      if (member.initializer) {
+        value = this.toSource(member.initializer);
+        if (member.initializer.type === 'NumericLiteral') {
+          running = member.initializer.value + 1;
+        } else if (member.initializer.type === 'UnaryExpression') {
+          var _member$initializer$e;
+          const raw = (_member$initializer$e = member.initializer.extra) == null ? void 0 : _member$initializer$e.raw;
+          if (raw) {
+            const n = Number(raw);
+            running = Number.isNaN(n) ? running : n + 1;
+          }
+        }
+      } else {
+        value = String(running);
+        running++;
+      }
+      return `${key}: ${value}`;
+    });
+    let out = spaces + 'const ' + this.toSource(node.id) + ' = {\n';
+    this.numSpaces++;
+    const innerSpaces = this.spaces;
+    out += entries.map(_ => innerSpaces + _).join(',\n');
+    this.numSpaces--;
+    out += '\n' + spaces + '};';
+    return out;
+  }
+  /**
+   * Renders a typedef comment for interfaces/type aliases.
+   * @param {Node} node - The declaration node.
+   * @returns {string} The comment.
+   */
+  typedefComment(node) {
+    const lines = this.typedefLines(node);
+    return this.jsdocComment(lines);
+  }
+  /**
+   * Builds `@typedef` JSDoc lines for a declaration node.
+   * @param {Node} node - The declaration node.
+   * @returns {string[]} The JSDoc lines.
+   */
+  typedefLines(node) {
+    if (node.type === 'TSTypeAliasDeclaration') {
+      const _name = node.id.name;
+      return [`@typedef {${tsTypeToJSDoc(node.typeAnnotation)}} ${_name}`];
+    }
+    const name = node.id.name;
+    const lines = [`@typedef {Object} ${name}`];
+    for (const member of (_node$body$body = (_node$body2 = node.body) == null ? void 0 : _node$body2.body) != null ? _node$body$body : []) {
+      var _node$body$body, _node$body2;
+      if (member.type === 'TSPropertySignature') {
+        const propName = tsTypeToJSDoc(member.key);
+        const optional = member.optional;
+        const type = member.typeAnnotation ? tsTypeToJSDoc(member.typeAnnotation.typeAnnotation) : 'any';
+        lines.push(`@property {${type}} ${optional ? '[' + propName + ']' : propName}`);
+      } else if (member.type === 'TSMethodSignature') {
+        const methodName = tsTypeToJSDoc(member.key);
+        const optional = member.optional;
+        const type = functionSignatureToJSDoc(member);
+        lines.push(`@property {${type}} ${optional ? '[' + methodName + ']' : methodName}`);
+      }
+    }
+    return lines;
+  }
+  /**
+   * Builds a JSDoc comment block string with proper indentation.
+   * @param {string[]} lines - The comment body lines (e.g. `@param {number} a`).
+   * @returns {string} The comment string.
+   */
+  jsdocComment(lines) {
+    const spaces = this.spaces;
+    let out = spaces + '/**\n';
+    for (const line of lines) {
+      out += spaces + ' * ' + line + '\n';
+    }
+    out += spaces + ' */';
+    return out;
+  }
+  /**
+   * Converts type-only imports into `@import` JSDoc comments and keeps
+   * the value imports of mixed imports (`import {Value, type AlsoType}`).
+   * @override
+   * @param {import('@babel/types').ImportDeclaration} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  ImportDeclaration(node) {
+    const typeSpecifiers = node.specifiers.filter(_ => _.importKind === 'type');
+    const valueSpecifiers = node.specifiers.filter(_ => _.importKind !== 'type');
+    const fullyTypeOnly = node.importKind === 'type' || typeSpecifiers.length && valueSpecifiers.length === 0;
+    if (fullyTypeOnly) {
+      return importTypeToJSDoc(node.specifiers, node.source);
+    }
+    let out = '';
+    if (typeSpecifiers.length) {
+      out = importTypeToJSDoc(typeSpecifiers, node.source);
+    }
+    if (valueSpecifiers.length) {
+      const valueImport = super.ImportDeclaration(_extends({}, node, {
+        importKind: 'value',
+        specifiers: valueSpecifiers
+      }));
+      out = out ? out + '\n' + valueImport : valueImport;
+    }
+    return out;
+  }
+  /**
+   * Strips type-only exports and converts type declarations into typedef comments.
+   * @override
+   * @param {import('@babel/types').ExportNamedDeclaration} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  ExportNamedDeclaration(node) {
+    if (node.exportKind === 'type') {
+      if (node.declaration) {
+        return this.toSource(node.declaration);
+      }
+      return '';
+    }
+    if (node.specifiers.some(_ => _.exportKind === 'type')) {
+      const specifiers = node.specifiers.filter(_ => _.exportKind !== 'type');
+      if (specifiers.length === 0) {
+        return '';
+      }
+      return super.ExportNamedDeclaration(_extends({}, node, {
+        specifiers
+      }));
+    }
+    return super.ExportNamedDeclaration(node);
+  }
+  /**
+   * Strips the `declare` modifier from variable declarations.
+   * @override
+   * @param {import('@babel/types').VariableDeclaration} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  VariableDeclaration(node) {
+    if (node.declare) {
+      return '';
+    }
+    return super.VariableDeclaration(_extends({}, node, {
+      declare: false
+    }));
+  }
+}
+/**
+ * Renders a JSDoc `@import` comment for type-only import specifiers,
+ * e.g. `import type {OnlyType} from './types'` becomes the single line
+ * `@import { OnlyType } from './types.js'` and carries the type
+ * information without creating a runtime import.
+ * @param {import('@babel/types').ImportSpecifier[]|import('@babel/types').ImportDefaultSpecifier[]|import('@babel/types').ImportNamespaceSpecifier[]} specifiers - The import specifiers.
+ * @param {import('@babel/types').StringLiteral} source - The import source.
+ * @returns {string} The `@import` JSDoc comment (or an empty string).
+ */
+function importTypeToJSDoc(specifiers, source) {
+  const named = [];
+  let defaultName;
+  let namespaceName;
+  for (const specifier of specifiers) {
+    if (specifier.type === 'ImportSpecifier') {
+      var _specifier$local$name, _specifier$local, _specifier$imported;
+      named.push((_specifier$local$name = (_specifier$local = specifier.local) == null ? void 0 : _specifier$local.name) != null ? _specifier$local$name : (_specifier$imported = specifier.imported) == null ? void 0 : _specifier$imported.name);
+    } else if (specifier.type === 'ImportDefaultSpecifier') {
+      var _specifier$local2;
+      defaultName = (_specifier$local2 = specifier.local) == null ? void 0 : _specifier$local2.name;
+    } else if (specifier.type === 'ImportNamespaceSpecifier') {
+      var _specifier$local3;
+      namespaceName = (_specifier$local3 = specifier.local) == null ? void 0 : _specifier$local3.name;
+    }
+  }
+  const parts = [];
+  if (defaultName) {
+    parts.push(defaultName);
+  }
+  if (named.length) {
+    parts.push('{ ' + named.join(', ') + ' }');
+  }
+  if (namespaceName) {
+    parts.push('* as ' + namespaceName);
+  }
+  if (!parts.length) {
+    return '';
+  }
+  return `/** @import ${parts.join(', ')} from '${jsImportSource(source)}' */`;
+}
+/**
+ * Rewrites a TypeScript import specifier to its JavaScript counterpart,
+ * e.g. `./types` becomes `./types.js`.
+ * @param {import('@babel/types').StringLiteral} source - The import source.
+ * @returns {string} The JavaScript module specifier.
+ */
+function jsImportSource(source) {
+  const raw = source.value;
+  if (!raw.startsWith('.') && !raw.startsWith('/')) {
+    return raw;
+  }
+  if (/\.(ts|tsx|mts|cts)$/.test(raw)) {
+    return raw.replace(/\.(ts|tsx|mts|cts)$/, '.js');
+  }
+  if (!/\.[a-zA-Z][a-zA-Z0-9]*$/.test(raw)) {
+    return raw + '.js';
+  }
+  return raw;
+}
+/**
+ * Attaches JSDoc comment blocks to the AST nodes which carry TypeScript types.
+ * @param {Node} node - The node to annotate recursively.
+ * @param {Node[]} parents - The current parent stack.
+ */
+function annotate(node, parents) {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+  parents.push(node);
+  const {
+    type
+  } = node;
+  if (nodeIsFunctionLike(node)) {
+    if ((type === 'ClassMethod' || type === 'ClassPrivateMethod') && node.kind === 'constructor') {
+      injectParameterProperties(node);
+    }
+    const lines = jsdocLinesFromFunction(node);
+    if (lines.length) {
+      attachComment(node, lines, parents);
+    }
+  } else if (type === 'ClassProperty' || type === 'ClassPrivateProperty') {
+    var _node$typeAnnotation;
+    if ((_node$typeAnnotation = node.typeAnnotation) != null && _node$typeAnnotation.typeAnnotation && !node.declare) {
+      attachComment(node, [`@type {${tsTypeToJSDoc(node.typeAnnotation.typeAnnotation)}}`], parents);
+    }
+  } else if (type === 'ClassDeclaration' || type === 'ClassExpression') {
+    const interfaces = node.implements || [];
+    if (interfaces != null && interfaces.length) {
+      const lines = interfaces.map(imp => `@implements {${simplifyReference(imp.expression)}}`);
+      attachComment(node, lines, parents);
+    }
+  } else if (type === 'VariableDeclaration' && !node.declare) {
+    collectVariableTypeComments(node, parents);
+  }
+  // recurse into children based on the annotated keys
+  const keys = nodeChildren[type];
+  for (const key of keys != null ? keys : []) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const entry of child) {
+        annotate(entry, parents);
+      }
+    } else if (child && typeof child === 'object' && child.type) {
+      annotate(child, parents);
+    }
+  }
+  parents.pop();
+}
+/**
+ * Attaches a JSDoc comment (built from `lines`) to a suitable statement-level host node.
+ * @param {Node} node - The annotated node.
+ * @param {string[]} lines - The JSDoc lines.
+ * @param {Node[]} parents - The parent stack.
+ */
+function attachComment(node, lines, parents) {
+  let host = findCommentHost(node, parents);
+  if (!host) {
+    host = node;
+  }
+  const comment = makeComment(node, lines, parents);
+  host.leadingComments = [...(host.leadingComments || []), comment];
+}
+/**
+ * Finds the statement-ish node where a JSDoc comment should live.
+ * For `const f = (a) => {}` the comment belongs on the VariableDeclaration,
+ * for `export function f` it belongs on the ExportNamedDeclaration.
+ * @param {Node} node - The function/property node.
+ * @param {Node[]} parents - The parent stack.
+ * @returns {Node} The host node.
+ */
+function findCommentHost(node, parents) {
+  const index = parents.findLastIndex(_ => _ === node);
+  const parent = parents[index - 1];
+  if ((parent == null ? void 0 : parent.type) === 'ExportNamedDeclaration') {
+    var _parents;
+    // Inside namespaces the export wrapper is consumed by the namespace
+    // emitter, so the comment has to live on the declaration itself.
+    if (((_parents = parents[index - 2]) == null ? void 0 : _parents.type) === 'TSModuleBlock') {
+      return node;
+    }
+    return parent;
+  }
+  if ((parent == null ? void 0 : parent.type) === 'VariableDeclarator') {
+    const grand = parents[index - 2];
+    if ((grand == null ? void 0 : grand.type) === 'VariableDeclaration') {
+      var _parents2;
+      if (((_parents2 = parents[index - 3]) == null ? void 0 : _parents2.type) === 'ExportNamedDeclaration') {
+        return parents[index - 3];
+      }
+      return grand;
+    }
+  }
+  if ((parent == null ? void 0 : parent.type) === 'ExpressionStatement') {
+    return parent;
+  }
+  // Class-methods/properties and object-methods host the comment themselves.
+  return node;
+}
+/**
+ * Creates a Babel CommentBlock node with a fabricated `loc`.
+ * The column is derived from the renderer indentation depth of the annotated
+ * node (2 spaces per indenting ancestor) so that the comment aligns with the
+ * `spaces` of the node's rendered position, independent of the original
+ * (namespace-shifted) source column.
+ * @param {Node} node - The annotated node.
+ * @param {string[]} lines - The JSDoc lines.
+ * @param {Node[]} parents - The parent stack.
+ * @returns {import('@babel/types').CommentBlock} The comment node.
+ */
+function makeComment(node, lines, parents) {
+  var _ref, _node$start, _node$loc, _node$loc$start$line, _node$loc2, _node$loc$start$line2, _node$loc3;
+  const value = '*\n * ' + lines.join('\n * ');
+  const start = (_ref = (_node$start = node.start) != null ? _node$start : (_node$loc = node.loc) == null || (_node$loc = _node$loc.start) == null ? void 0 : _node$loc.index) != null ? _ref : 0;
+  const startColumn = 2 * renderIndentDepth(node, parents);
+  return {
+    type: 'CommentBlock',
+    value,
+    loc: {
+      start: {
+        index: start,
+        line: (_node$loc$start$line = (_node$loc2 = node.loc) == null || (_node$loc2 = _node$loc2.start) == null ? void 0 : _node$loc2.line) != null ? _node$loc$start$line : 1,
+        column: startColumn
+      },
+      end: {
+        index: start,
+        line: (_node$loc$start$line2 = (_node$loc3 = node.loc) == null || (_node$loc3 = _node$loc3.start) == null ? void 0 : _node$loc3.line) != null ? _node$loc$start$line2 : 1,
+        column: startColumn
+      }
+    }
+  };
+}
+/**
+ * Node types whose renderer increases the indentation level by one (`this.numSpaces++`).
+ * @type {Set<string>}
+ */
+const indentingNodeTypes = new Set(['ClassDeclaration', 'ClassExpression', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'ObjectMethod', 'ClassMethod', 'ClassPrivateMethod', 'BlockStatement', 'IfStatement', 'ObjectExpression', 'ArrayExpression', 'ObjectPattern', 'ParenthesizedExpression', 'JSXElement', 'JSXFragment', 'TSEnumDeclaration']);
+/**
+ * Counts the renderer indentation levels that nest `node`, so comments can be
+ * placed at the column the stringifier will use (`2` spaces per level).
+ * @param {Node} node - The annotated node.
+ * @param {Node[]} parents - The parent stack.
+ * @returns {number} The indentation depth of the node.
+ */
+function renderIndentDepth(node, parents) {
+  const index = parents.findLastIndex(_ => _ === node);
+  let depth = 0;
+  for (let i = index - 1; i >= 0; i--) {
+    if (indentingNodeTypes.has(parents[i].type)) {
+      depth++;
+    }
+  }
+  return depth;
+}
+/**
+ * Attaches `@type` comments for typed variable declarations.
+ * @param {import('@babel/types').VariableDeclaration} node - The declaration node.
+ * @param {Node[]} parents - The parent stack.
+ */
+function collectVariableTypeComments(node, parents) {
+  for (const declarator of node.declarations) {
+    var _declarator$id;
+    const type = (_declarator$id = declarator.id) == null || (_declarator$id = _declarator$id.typeAnnotation) == null ? void 0 : _declarator$id.typeAnnotation;
+    if (!type) {
+      continue;
+    }
+    attachComment(node, [`@type {${tsTypeToJSDoc(type)}}`], parents);
+    break; // only annotate once per declaration statement
+  }
+}
+/**
+ * A roundtrip between TypeScript code -> JavaScript code with JSDoc types.
+ * @param {string} code - The TypeScript code.
+ * @param {object} [options] - Options for the conversion.
+ * @param {boolean} [options.filename] - Unused placeholder, kept for API symmetry.
+ * @returns {string} The converted JavaScript code.
+ */
+function ts2js(code, options = {}) {
+  const ast = parseTS(code);
+  annotate(ast.program, []);
+  const stringifier = new ToJS();
+  const source = stringifier.toSource(ast);
+  return formatCommentBreaks(stringifier.getHeader() + source);
+}
+/**
+ * Moves a statement that follows a generated JSDoc block onto its own line,
+ * e.g. a closing comment marker directly followed by `export function f() {}`
+ * becomes the closing marker, a newline, then `export function f() {}`.
+ * @param {string} source - The generated source code.
+ * @returns {string} The source with fixed comment/statement breaks.
+ */
+function formatCommentBreaks(source) {
+  return source.replace(/ \*\/ +(?=[a-zA-Z_$])/g, '*/\n');
+}
+/**
+ * Parses TypeScript code, automatically falling back to TSX (JSX) mode
+ * when the input contains JSX elements.
+ * @param {string} code - The TypeScript code.
+ * @returns {import('@babel/parser').ParseResult<import('@babel/types').File>} The parsed AST.
+ */
+function parseTS(code) {
+  try {
+    return parse(code, {
+      sourceType: 'module',
+      plugins: ['typescript']
+    });
+  } catch (e) {
+    return parse(code, {
+      sourceType: 'module',
+      plugins: [['typescript', {
+        isTSX: true
+      }], 'jsx']
+    });
+  }
+}
+
+/**
+ * @file
+ * @todo Consider rendering nested namespaces leading flat, so their member
+ * columns align with the source indentation.
+ */
+
+export { Asserter, JSDocAnnotator, Stringifier, ToJS, WATConverter, addTypeChecks, annotateOptional, ast2json, ast2jsonForComparison, capitalize, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeChildren, nodeIsFunctionLike, parseJSDoc, parseJSDocSetter, parseJSDocTemplates, parseJSDocTypedef, parseType, parseTypeBabelTS, parserOptions, requiredTypeofs, simplifyType, simplifyTypeToSource, toSourceBabelTS, toSourceTS, trimEndSpaces, ts2js, tsTypeToJSDoc };