typenative 0.0.19 → 0.0.21

package/bin/transpiler.js

@@ -1,12 +1,269 @@
-import ts from 'typescript';
-import { customAlphabet } from 'nanoid';
-const goSafeId = customAlphabet('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 8);
-let TypeCheker;
+// Shim over the removed `typescript` import: predicates and kind names operate
+// on the normalized JSON AST ({kind: 'Xxx', ...} plain objects) produced by
+// src/parse-node.ts (Node) or the tsparser Go tool (self-hosted).
+// Kept as a `ts` object so the transpiler code keeps its shape.
+function isArrayBindingPattern(n) {
+    return n?.kind === 'ArrayBindingPattern';
+}
+function isArrayLiteralExpression(n) {
+    return n?.kind === 'ArrayLiteralExpression';
+}
+function isArrayTypeNode(n) {
+    return n?.kind === 'ArrayTypeNode';
+}
+function isArrowFunction(n) {
+    return n?.kind === 'ArrowFunction';
+}
+function isAsExpression(n) {
+    return n?.kind === 'AsExpression';
+}
+function isAwaitExpression(n) {
+    return n?.kind === 'AwaitExpression';
+}
+function isBinaryExpression(n) {
+    return n?.kind === 'BinaryExpression';
+}
+function isBlock(n) {
+    return n?.kind === 'Block';
+}
+function isBreakStatement(n) {
+    return n?.kind === 'BreakStatement';
+}
+function isCallExpression(n) {
+    return n?.kind === 'CallExpression';
+}
+function isCaseBlock(n) {
+    return n?.kind === 'CaseBlock';
+}
+function isCaseClause(n) {
+    return n?.kind === 'CaseClause';
+}
+function isClassDeclaration(n) {
+    return n?.kind === 'ClassDeclaration';
+}
+function isConditionalExpression(n) {
+    return n?.kind === 'ConditionalExpression';
+}
+function isConstructorDeclaration(n) {
+    return n?.kind === 'ConstructorDeclaration';
+}
+function isDefaultClause(n) {
+    return n?.kind === 'DefaultClause';
+}
+function isDoStatement(n) {
+    return n?.kind === 'DoStatement';
+}
+function isElementAccessExpression(n) {
+    return n?.kind === 'ElementAccessExpression';
+}
+function isEnumDeclaration(n) {
+    return n?.kind === 'EnumDeclaration';
+}
+function isExportAssignment(n) {
+    return n?.kind === 'ExportAssignment';
+}
+function isExportDeclaration(n) {
+    return n?.kind === 'ExportDeclaration';
+}
+function isExpressionStatement(n) {
+    return n?.kind === 'ExpressionStatement';
+}
+function isForInStatement(n) {
+    return n?.kind === 'ForInStatement';
+}
+function isForOfStatement(n) {
+    return n?.kind === 'ForOfStatement';
+}
+function isForStatement(n) {
+    return n?.kind === 'ForStatement';
+}
+function isFunctionDeclaration(n) {
+    return n?.kind === 'FunctionDeclaration';
+}
+function isFunctionExpression(n) {
+    return n?.kind === 'FunctionExpression';
+}
+function isFunctionTypeNode(n) {
+    return n?.kind === 'FunctionTypeNode';
+}
+function isGetAccessor(n) {
+    return n?.kind === 'GetAccessor';
+}
+function isIdentifier(n) {
+    return n?.kind === 'Identifier';
+}
+function isIfStatement(n) {
+    return n?.kind === 'IfStatement';
+}
+function isImportDeclaration(n) {
+    return n?.kind === 'ImportDeclaration';
+}
+function isInterfaceDeclaration(n) {
+    return n?.kind === 'InterfaceDeclaration';
+}
+function isLiteralTypeNode(n) {
+    return n?.kind === 'LiteralTypeNode';
+}
+function isMethodDeclaration(n) {
+    return n?.kind === 'MethodDeclaration';
+}
+function isMethodSignature(n) {
+    return n?.kind === 'MethodSignature';
+}
+function isNamedImports(n) {
+    return n?.kind === 'NamedImports';
+}
+function isNamespaceImport(n) {
+    return n?.kind === 'NamespaceImport';
+}
+function isNewExpression(n) {
+    return n?.kind === 'NewExpression';
+}
+function isNoSubstitutionTemplateLiteral(n) {
+    return n?.kind === 'NoSubstitutionTemplateLiteral';
+}
+function isNonNullExpression(n) {
+    return n?.kind === 'NonNullExpression';
+}
+function isNumericLiteral(n) {
+    return n?.kind === 'NumericLiteral';
+}
+function isObjectBindingPattern(n) {
+    return n?.kind === 'ObjectBindingPattern';
+}
+function isObjectLiteralExpression(n) {
+    return n?.kind === 'ObjectLiteralExpression';
+}
+function isOmittedExpression(n) {
+    return n?.kind === 'OmittedExpression';
+}
+function isParenthesizedExpression(n) {
+    return n?.kind === 'ParenthesizedExpression';
+}
+function isPostfixUnaryExpression(n) {
+    return n?.kind === 'PostfixUnaryExpression';
+}
+function isPrefixUnaryExpression(n) {
+    return n?.kind === 'PrefixUnaryExpression';
+}
+function isPropertyAccessExpression(n) {
+    return n?.kind === 'PropertyAccessExpression';
+}
+function isPropertyAssignment(n) {
+    return n?.kind === 'PropertyAssignment';
+}
+function isPropertyDeclaration(n) {
+    return n?.kind === 'PropertyDeclaration';
+}
+function isPropertySignature(n) {
+    return n?.kind === 'PropertySignature';
+}
+function isRegularExpressionLiteral(n) {
+    return n?.kind === 'RegularExpressionLiteral';
+}
+function isReturnStatement(n) {
+    return n?.kind === 'ReturnStatement';
+}
+function isSetAccessor(n) {
+    return n?.kind === 'SetAccessor';
+}
+function isShorthandPropertyAssignment(n) {
+    return n?.kind === 'ShorthandPropertyAssignment';
+}
+function isSourceFile(n) {
+    return n?.kind === 'SourceFile';
+}
+function isSpreadElement(n) {
+    return n?.kind === 'SpreadElement';
+}
+function isStringLiteral(n) {
+    return n?.kind === 'StringLiteral';
+}
+function isSwitchStatement(n) {
+    return n?.kind === 'SwitchStatement';
+}
+function isTemplateExpression(n) {
+    return n?.kind === 'TemplateExpression';
+}
+function isThrowStatement(n) {
+    return n?.kind === 'ThrowStatement';
+}
+function isTryStatement(n) {
+    return n?.kind === 'TryStatement';
+}
+function isTypeAliasDeclaration(n) {
+    return n?.kind === 'TypeAliasDeclaration';
+}
+function isTypeAssertionExpression(n) {
+    return n?.kind === 'TypeAssertionExpression';
+}
+function isTypeReferenceNode(n) {
+    return n?.kind === 'TypeReferenceNode';
+}
+function isUnionTypeNode(n) {
+    return n?.kind === 'UnionTypeNode';
+}
+function isVariableDeclaration(n) {
+    return n?.kind === 'VariableDeclaration';
+}
+function isVariableDeclarationList(n) {
+    return n?.kind === 'VariableDeclarationList';
+}
+function isVariableStatement(n) {
+    return n?.kind === 'VariableStatement';
+}
+function isWhileStatement(n) {
+    return n?.kind === 'WhileStatement';
+}
+function isToken(_n) {
+    return true;
+}
+const SyntaxKind = {
+    BooleanKeyword: 'BooleanKeyword',
+    ExclamationToken: 'ExclamationToken',
+    ExtendsKeyword: 'ExtendsKeyword',
+    FalseKeyword: 'FalseKeyword',
+    MinusMinusToken: 'MinusMinusToken',
+    MinusToken: 'MinusToken',
+    NullKeyword: 'NullKeyword',
+    NumberKeyword: 'NumberKeyword',
+    PlusPlusToken: 'PlusPlusToken',
+    PlusToken: 'PlusToken',
+    QuestionDotToken: 'QuestionDotToken',
+    QuestionQuestionToken: 'QuestionQuestionToken',
+    StaticKeyword: 'StaticKeyword',
+    StringKeyword: 'StringKeyword',
+    SuperKeyword: 'SuperKeyword',
+    ThisKeyword: 'ThisKeyword',
+    TildeToken: 'TildeToken',
+    TrueKeyword: 'TrueKeyword',
+    UndefinedKeyword: 'UndefinedKeyword',
+};
+// Local replacement for nanoid's customAlphabet — must stay transpilable by
+// TypeNative itself (no dependencies), only using mapped String methods.
+const GO_SAFE_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+function goSafeId() {
+    let id = '';
+    for (let i = 0; i < 8; i++) {
+        id += GO_SAFE_ALPHABET.charAt(Math.floor(Math.random() * GO_SAFE_ALPHABET.length));
+    }
+    return id;
+}
+let parseFunction;
 const importedPackages = new Set();
 let outsideNodes = [];
 const classNames = new Set();
 let promiseResolveName = '';
-const dangerousNames = new Set(['main']);
+// Go keywords that cannot be used as identifiers
+const dangerousNames = new Set([
+    'main',
+    // Go reserved keywords
+    'break', 'case', 'chan', 'const', 'continue',
+    'default', 'defer', 'else', 'fallthrough', 'for',
+    'func', 'go', 'goto', 'if', 'import',
+    'interface', 'map', 'package', 'range', 'return',
+    'select', 'struct', 'switch', 'type', 'var',
+]);
 const renamedFunctions = new Map();
 const variableTypes = new Map();
 const variableGoTypes = new Map();
@@ -19,6 +276,10 @@ const enumNames = new Set();
 const enumBaseTypes = new Map();
 // Maps local TS name → Go qualified name (e.g. 'Println' → 'fmt.Println', 'myFmt' → 'fmt')
 const importAliases = new Map();
+// Tracks static methods per class: Set of "ClassName.methodName" strings
+const classStaticMethods = new Set();
+// Tracks static properties per class: Set of "ClassName.propName" strings
+const classStaticProps = new Set();
 // Callback for resolving import specifiers to source code.
 // specifier: the raw import string (relative path or package name)
 // fromDir: directory of the file containing the import (null = main file's dir)
@@ -30,11 +291,108 @@ let currentFileDir = null;
 const includedLocalImports = new Set();
 // Collects Go source files generated from local TS imports (filename → content)
 let localImportFiles = new Map();
+// Token kind names → operator source text (JSON AST tokens carry kind names)
+const OPERATOR_TEXT = {
+    EqualsEqualsEqualsToken: '===',
+    ExclamationEqualsEqualsToken: '!==',
+    EqualsEqualsToken: '==',
+    ExclamationEqualsToken: '!=',
+    LessThanToken: '<',
+    LessThanEqualsToken: '<=',
+    GreaterThanToken: '>',
+    GreaterThanEqualsToken: '>=',
+    PlusToken: '+',
+    MinusToken: '-',
+    AsteriskToken: '*',
+    SlashToken: '/',
+    PercentToken: '%',
+    AsteriskAsteriskToken: '**',
+    AmpersandToken: '&',
+    BarToken: '|',
+    CaretToken: '^',
+    LessThanLessThanToken: '<<',
+    GreaterThanGreaterThanToken: '>>',
+    AmpersandAmpersandToken: '&&',
+    BarBarToken: '||',
+    EqualsToken: '=',
+    PlusEqualsToken: '+=',
+    MinusEqualsToken: '-=',
+    AsteriskEqualsToken: '*=',
+    SlashEqualsToken: '/=',
+    PercentEqualsToken: '%=',
+    CommaToken: ',',
+    QuestionQuestionToken: '??'
+};
+function operatorTokenText(token) {
+    return OPERATOR_TEXT[token?.kind] ?? token?.kind ?? '';
+}
+function defaultParseFunction(_code) {
+    throw new Error('transpileToNative: no parse function injected (options.parse)');
+}
+// Renders a type node's source text syntactically (no typechecker needed).
+function typeNodeToText(node) {
+    if (!node)
+        return 'any';
+    const keywordMap = {
+        NumberKeyword: 'number',
+        StringKeyword: 'string',
+        BooleanKeyword: 'boolean',
+        AnyKeyword: 'any',
+        UnknownKeyword: 'any',
+        VoidKeyword: 'void',
+        UndefinedKeyword: 'undefined',
+        NullKeyword: 'null',
+        NeverKeyword: 'never',
+        ObjectKeyword: 'object',
+        TrueKeyword: 'true',
+        FalseKeyword: 'false'
+    };
+    if (keywordMap[node.kind])
+        return keywordMap[node.kind];
+    if (node.kind === 'TypeReferenceNode' && node.typeName) {
+        return typeNodeToText(node.typeName);
+    }
+    if (node.kind === 'Identifier')
+        return node.text;
+    if (node.kind === 'ArrayTypeNode' && node.elementType) {
+        return `${'{'}${''}}typeNodeToText(node.elementType)[]`;
+    }
+    return 'any';
+}
+// Iterates the child nodes of a normalized JSON AST node (own enumerable
+function childNodes(node) {
+    const out = [];
+    for (const key of Object.keys(node ?? {})) {
+        if (key === 'kind' || key === 'text')
+            continue;
+        const v = node[key];
+        if (v && typeof v === 'object' && typeof v.kind === 'string') {
+            out.push(v);
+        }
+        else if (Array.isArray(v)) {
+            for (const el of v) {
+                if (el && typeof el === 'object' && typeof el.kind === 'string')
+                    out.push(el);
+            }
+        }
+    }
+    return out;
+}
+// Default import namespaces from npm/local packages (e.g. `import ts from 'typescript'` → 'ts')
+// Property accesses on these are stripped: ts.createSourceFile → createSourceFile
+const defaultImportNamespaces = new Set();
+// Go helper functions required by the current transpilation (e.g. 'exec', 'readFile').
+// Helper sources are appended to every generated Go file that references them.
+const usedHelpers = new Set();
+// Packages that were imported only because a helper needs them. Tracked so
+// per-file import lists can exclude them (helpers are emitted once, in the
+// main file, which carries these imports instead).
+const helperProvidedPackages = new Set();
 export function transpileToNative(code, options) {
     fileResolver = options?.readFile ?? null;
+    parseFunction = options?.parse ?? defaultParseFunction;
     currentFileDir = null;
-    const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
-    TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
+    const sourceFile = parseFunction(code);
     importedPackages.clear();
     outsideNodes = [];
     classNames.clear();
@@ -52,6 +410,11 @@ export function transpileToNative(code, options) {
     importAliases.clear();
     includedLocalImports.clear();
     localImportFiles = new Map();
+    defaultImportNamespaces.clear();
+    classStaticMethods.clear();
+    classStaticProps.clear();
+    usedHelpers.clear();
+    helperProvidedPackages.clear();
     const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
     const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
     const main = `package main
@@ -62,18 +425,19 @@ func main() {
     ${transpiledCode.trim()}
 }
 
-${transpiledCodeOutside.trim()}`;
+${transpiledCodeOutside.trim()}
+${emitGoHelpers()}`.trimEnd();
     return { main, files: localImportFiles };
 }
 export function visit(node, options = {}) {
     let code = '';
-    if (ts.isSourceFile(node)) {
-        return node.statements
+    if (isSourceFile(node)) {
+        return (node.statements ?? [])
             .map((n) => visit(n, { addFunctionOutside: true }))
             .filter((n) => !!n)
             .join(options.inline ? '' : '\n\t');
     }
-    else if (ts.isIdentifier(node)) {
+    else if (isIdentifier(node)) {
         if (node.text === 'undefined')
             return 'nil';
         const goAlias = importAliases.get(node.text);
@@ -81,31 +445,31 @@ export function visit(node, options = {}) {
             return goAlias;
         return getSafeName(node.text);
     }
-    else if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+    else if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
         return toGoStringLiteral(node.text);
     }
-    else if (ts.isAsExpression(node)) {
+    else if (isAsExpression(node)) {
         return visit(node.expression);
     }
-    else if (ts.isTypeAssertionExpression(node)) {
+    else if (isTypeAssertionExpression(node)) {
         return visit(node.expression);
     }
-    else if (ts.isTemplateExpression(node)) {
+    else if (isTemplateExpression(node)) {
         return visitTemplateExpression(node);
     }
-    else if (ts.isNumericLiteral(node)) {
+    else if (isNumericLiteral(node)) {
         return `float64(${node.text})`;
     }
-    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.TrueKeyword) {
+    else if (isToken(node) && node.kind === 'TrueKeyword') {
         return `true`;
     }
-    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.FalseKeyword) {
+    else if (isToken(node) && node.kind === 'FalseKeyword') {
         return `false`;
     }
-    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.NullKeyword) {
+    else if (isToken(node) && node.kind === 'NullKeyword') {
         return `nil`;
     }
-    else if (ts.isRegularExpressionLiteral(node)) {
+    else if (isRegularExpressionLiteral(node)) {
         importedPackages.add('regexp');
         const text = node.text; // e.g. /pattern/flags
         const lastSlash = text.lastIndexOf('/');
@@ -115,37 +479,86 @@ export function visit(node, options = {}) {
         const escaped = pattern.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
         return `regexp.MustCompile("${goFlags}${escaped}")`;
     }
-    else if (ts.isArrayLiteralExpression(node)) {
-        const type = ts.isVariableDeclaration(node.parent) ? getType(node.parent.type, true) : '';
-        return `[]${type} {${node.elements.map((e) => visit(e)).join(', ')}}`;
+    else if (isArrayLiteralExpression(node)) {
+        const type = isVariableDeclaration(node.parent) ? getType(node.parent.type, true) : '';
+        const hasSpread = (node.elements ?? []).some((e) => isSpreadElement(e));
+        if (hasSpread) {
+            return visitSpreadArrayLiteral(node, type);
+        }
+        return `[]${type} {${(node.elements ?? []).map((e) => visit(e)).join(', ')}}`;
     }
-    else if (ts.isBlock(node)) {
-        return `{\n\t\t${options.prefixBlockContent ?? ''}${node.statements
+    else if (isBlock(node)) {
+        return `{\n\t\t${options.prefixBlockContent ?? ''}${(node.statements ?? [])
             .map((n) => visit(n))
             .join('\t')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
     }
-    else if (ts.isElementAccessExpression(node)) {
+    else if (isElementAccessExpression(node)) {
         if (hasQuestionDot(node)) {
             return visitOptionalElementAccess(node);
         }
         return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
     }
-    else if (ts.isPropertyAccessExpression(node)) {
+    else if (isPropertyAccessExpression(node)) {
         if (hasQuestionDot(node)) {
             return visitOptionalPropertyAccess(node);
         }
-        if (ts.isIdentifier(node.expression) && enumNames.has(node.expression.text)) {
+        if (isIdentifier(node.expression) && enumNames.has(node.expression.text)) {
             return `${getSafeName(node.expression.text)}_${getEnumMemberName(node.name)}`;
         }
+        // Strip default import namespace: `ts.createSourceFile` → `createSourceFile`
+        if (isIdentifier(node.expression) && defaultImportNamespaces.has(node.expression.text)) {
+            return visit(node.name);
+        }
+        // Static member access: `Counter.count` → `Counter_count`
+        if (isIdentifier(node.expression)) {
+            const key = `${node.expression.text}.${node.name.text}`;
+            if (classStaticMethods.has(key) || classStaticProps.has(key)) {
+                return `${node.expression.text}_${node.name.text}`;
+            }
+        }
         const leftSide = visit(node.expression);
         const rightSide = visit(node.name);
         const objectType = resolveExpressionType(node.expression);
         return getAcessString(leftSide, rightSide, objectType);
     }
-    else if (ts.isVariableDeclaration(node)) {
+    else if (isVariableDeclaration(node)) {
+        // Object destructuring: const { x, y } = obj
+        if (isObjectBindingPattern(node.name) && node.initializer) {
+            const initExpr = visit(node.initializer);
+            const parts = node.name.elements.map((el) => {
+                const localName = visit(el.name);
+                const propName = el.propertyName ? visit(el.propertyName) : localName;
+                const defaultVal = el.initializer ? visit(el.initializer) : undefined;
+                if (defaultVal) {
+                    return `${localName} := func() interface{} { if ${initExpr}.${propName} == nil { return ${defaultVal} }; return ${initExpr}.${propName} }()`;
+                }
+                return `${localName} := ${initExpr}.${propName}`;
+            });
+            return parts.join(';\n\t');
+        }
+        // Array destructuring: const [a, b] = arr
+        if (isArrayBindingPattern(node.name) && node.initializer) {
+            const initExpr = visit(node.initializer);
+            const tmpVar = getTempName('arr');
+            const parts = [`${tmpVar} := ${initExpr}`];
+            node.name.elements.forEach((el, idx) => {
+                if (isOmittedExpression(el))
+                    return;
+                const bindEl = el;
+                const localName = visit(bindEl.name);
+                // Variables starting with _ are intentionally unused — use blank identifier
+                if (localName === '_' || localName.startsWith('_')) {
+                    parts.push(`_ = ${tmpVar}[${idx}]`);
+                }
+                else {
+                    parts.push(`${localName} := ${tmpVar}[${idx}]`);
+                }
+            });
+            return parts.join(';\n\t');
+        }
         const type = getType(node.type);
         // Track variable type for type-aware method dispatch
-        if (ts.isIdentifier(node.name)) {
+        if (isIdentifier(node.name)) {
             if (node.type) {
                 variableGoTypes.set(node.name.text, getType(node.type));
             }
@@ -160,8 +573,8 @@ export function visit(node, options = {}) {
                 }
             }
             else if (node.initializer &&
-                ts.isNewExpression(node.initializer) &&
-                ts.isIdentifier(node.initializer.expression)) {
+                isNewExpression(node.initializer) &&
+                isIdentifier(node.initializer.expression)) {
                 if (node.initializer.expression.text === 'RegExp') {
                     variableTypes.set(node.name.text, 'RegExp');
                 }
@@ -170,7 +583,7 @@ export function visit(node, options = {}) {
                     variableClassNames.set(node.name.text, node.initializer.expression.text);
                 }
             }
-            else if (node.initializer && ts.isRegularExpressionLiteral(node.initializer)) {
+            else if (node.initializer && isRegularExpressionLiteral(node.initializer)) {
                 variableTypes.set(node.name.text, 'RegExp');
             }
             if (!variableGoTypes.has(node.name.text) && node.initializer) {
@@ -192,17 +605,30 @@ export function visit(node, options = {}) {
         }
         return `${type === ':' ? '' : 'var '}${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
     }
-    else if (ts.isCallExpression(node)) {
+    else if (isCallExpression(node)) {
         if (hasQuestionDot(node) ||
-            (ts.isPropertyAccessExpression(node.expression) && hasQuestionDot(node.expression))) {
+            (isPropertyAccessExpression(node.expression) && hasQuestionDot(node.expression))) {
             return visitOptionalCall(node);
         }
+        // IIFE with named function expression: (function name() { ... })()
+        if (isParenthesizedExpression(node.expression) &&
+            isFunctionExpression(node.expression.expression)) {
+            const fn = node.expression.expression;
+            const parameterInfo = getFunctionParametersInfo(fn.parameters ?? []);
+            if (fn.body && isBlock(fn.body)) {
+                prescanVariableDeclarations(fn.body);
+            }
+            const inferredRetType = inferFunctionBodyReturnType(fn);
+            const returnType = inferredRetType ? ` ${inferredRetType}` : '';
+            const args = (node.arguments ?? []).map((a) => visit(a)).join(', ');
+            return `func(${parameterInfo.signature})${returnType} ${visit(fn.body, { prefixBlockContent: parameterInfo.prefixBlockContent })}(${args})`;
+        }
         // Handle setTimeout specially to get raw delay value
-        if (ts.isIdentifier(node.expression) && node.expression.text === 'setTimeout') {
+        if (isIdentifier(node.expression) && node.expression.text === 'setTimeout') {
             importedPackages.add('time');
-            const callback = visit(node.arguments[0]);
-            const delayNode = node.arguments[1];
-            const delay = ts.isNumericLiteral(delayNode) ? delayNode.text : visit(delayNode);
+            const callback = visit((node.arguments ?? [])[0]);
+            const delayNode = (node.arguments ?? [])[1];
+            const delay = isNumericLiteral(delayNode) ? delayNode.text : visit(delayNode);
             return `time.AfterFunc(${delay} * time.Millisecond, ${callback.trimEnd()})`;
         }
         const arrayHigherOrderCall = visitArrayHigherOrderCall(node);
@@ -211,56 +637,86 @@ export function visit(node, options = {}) {
         }
         const caller = visit(node.expression);
         const safeCaller = getSafeName(caller);
-        const typeArgs = getTypeArguments(node.typeArguments);
-        const args = node.arguments.map((a) => visit(a));
+        const typeArgs = getTypeArguments((node.typeArguments ?? []));
+        // Handle spread arguments: fn(...arr) → fn(arr...)
+        const hasSpreadArg = (node.arguments ?? []).some((a) => isSpreadElement(a));
+        const args = hasSpreadArg
+            ? (node.arguments ?? []).map((a) => isSpreadElement(a) ? `${visit(a.expression)}...` : visit(a))
+            : (node.arguments ?? []).map((a) => visit(a));
         // Resolve object type for type-aware method dispatch
         let objectType;
-        if (ts.isPropertyAccessExpression(node.expression)) {
+        if (isPropertyAccessExpression(node.expression)) {
             objectType = resolveExpressionType(node.expression.expression);
         }
         return getCallString(safeCaller, args, typeArgs, objectType);
     }
-    else if (ts.isPrefixUnaryExpression(node)) {
+    else if (isPrefixUnaryExpression(node)) {
         return `${getOperatorText(node.operator)}${visit(node.operand)}`;
     }
-    else if (ts.isPostfixUnaryExpression(node)) {
+    else if (isPostfixUnaryExpression(node)) {
         return `${visit(node.operand, { inline: true })}${getOperatorText(node.operator)}`;
     }
-    else if (ts.isConditionalExpression(node)) {
+    else if (isConditionalExpression(node)) {
         return visitConditionalExpression(node);
     }
-    else if (ts.isBinaryExpression(node)) {
-        if (node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+    else if (isBinaryExpression(node)) {
+        if (node.operatorToken.kind === 'QuestionQuestionToken') {
             return visitNullishCoalescingExpression(node);
         }
-        let op = node.operatorToken.getText();
+        let op = operatorTokenText(node.operatorToken);
         if (op === '===')
             op = '==';
         if (op === '!==')
             op = '!=';
+        // Go's % is not defined on float64 (TS numbers all map to float64)
+        if (op === '%') {
+            importedPackages.add('math');
+            return `math.Mod(${visit(node.left)}, ${visit(node.right)})`;
+        }
+        if (op === '%=') {
+            importedPackages.add('math');
+            const left = visit(node.left);
+            return `${left} = math.Mod(${left}, ${visit(node.right)})`;
+        }
         return `${visit(node.left)} ${op} ${visit(node.right)}`;
     }
-    else if (ts.isParenthesizedExpression(node)) {
+    else if (isParenthesizedExpression(node)) {
         return `(${visit(node.expression)})`;
     }
-    else if (ts.isAwaitExpression(node)) {
+    else if (isAwaitExpression(node)) {
         return `<-${visit(node.expression)}`;
     }
-    else if (ts.isVariableDeclarationList(node)) {
-        return (node.declarations.map((n) => visit(n)).join(options.inline ? ';' : ';\n\t') +
+    else if (isVariableDeclarationList(node)) {
+        return ((node.declarations ?? []).map((n) => visit(n)).join(options.inline ? ';' : ';\n\t') +
             (options.inline ? '' : ';\n\t'));
     }
-    else if (ts.isExpressionStatement(node)) {
+    else if (isExpressionStatement(node)) {
         return visit(node.expression) + (options.inline ? '' : ';\n\t');
     }
-    else if (ts.isForStatement(node)) {
+    else if (isForStatement(node)) {
         return `for ${visit(node.initializer, { inline: true })}; ${visit(node.condition, {
             inline: true
         })}; ${visit(node.incrementor, { inline: true })}${visit(node.statement)}`;
     }
-    else if (ts.isForOfStatement(node)) {
-        const iterExpr = visit(node.expression, { inline: true });
-        const iterType = inferExpressionType(node.expression);
+    else if (isForInStatement(node)) {
+        const varName = isVariableDeclarationList(node.initializer)
+            ? visit(node.initializer.declarations[0].name)
+            : visit(node.initializer);
+        return `for ${varName} := range ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
+    }
+    else if (isForOfStatement(node)) {
+        // Unwrap Object.entries(x) → treat x as the iterable
+        let iterNode = node.expression;
+        if (isCallExpression(iterNode) &&
+            isPropertyAccessExpression(iterNode.expression) &&
+            isIdentifier(iterNode.expression.expression) &&
+            iterNode.expression.expression.text === 'Object' &&
+            iterNode.expression.name.text === 'entries' &&
+            iterNode.arguments.length > 0) {
+            iterNode = iterNode.arguments[0];
+        }
+        const iterExpr = visit(iterNode, { inline: true });
+        const iterType = inferExpressionType(iterNode);
         if (iterType && iterType.startsWith('map[')) {
             const valueType = extractMapValueType(iterType);
             const isSet = valueType === 'struct{}';
@@ -277,50 +733,62 @@ export function visit(node, options = {}) {
         }
         return `for _,${visit(node.initializer, { inline: true })}= range ${iterExpr}${visit(node.statement)}`;
     }
-    else if (ts.isWhileStatement(node)) {
+    else if (isWhileStatement(node)) {
         return `for ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
     }
-    else if (ts.isDoStatement(node)) {
+    else if (isDoStatement(node)) {
         const condition = `\tif !(${visit(node.expression, {
             inline: true
         })}) {\n\t\t\tbreak \n\t\t}\n\t`;
         return `for ${visit(node.statement, { inline: true, extraBlockContent: condition })}`;
     }
-    else if (ts.isIfStatement(node)) {
-        const condition = `if ${visit(node.expression, { inline: true })} ${visit(node.thenStatement, {
-            inline: !!node.elseStatement
-        })}`;
+    else if (isIfStatement(node)) {
+        // Go requires the branch body to be a block even for single statements
+        // Go requires a block body; `} else` must stay on the same line, so the
+        // terminating ';' is only added when no else branch follows
+        const thenTerm = node.elseStatement ? '' : ';';
+        const thenCode = isBlock(node.thenStatement)
+            ? visit(node.thenStatement, { inline: !!node.elseStatement })
+            : `{\n${visit(node.thenStatement)}\n}${thenTerm}`;
+        const condition = `if ${visit(node.expression, { inline: true })} ${thenCode}`;
         if (node.elseStatement) {
-            return `${condition} else ${visit(node.elseStatement)}`;
+            if (isBlock(node.elseStatement)) {
+                return `${condition} else ${visit(node.elseStatement)}`;
+            }
+            // else-if chains stay chained; other single statements get a block
+            const elseCode = isIfStatement(node.elseStatement)
+                ? visit(node.elseStatement)
+                : `{\n${visit(node.elseStatement)}\n}`;
+            return `${condition} else ${elseCode}`;
         }
         return condition;
     }
-    else if (ts.isSwitchStatement(node)) {
+    else if (isSwitchStatement(node)) {
         return `switch ${visit(node.expression)} ${visit(node.caseBlock)}`;
     }
-    else if (ts.isCaseBlock(node)) {
-        return `{\n\t\t${node.clauses.map((c) => visit(c)).join('\n\t\t')}\n\t}`;
+    else if (isCaseBlock(node)) {
+        return `{\n\t\t${(node.clauses ?? []).map((c) => visit(c)).join('\n\t\t')}\n\t}`;
     }
-    else if (ts.isCaseClause(node)) {
-        const isFallThrough = !node.statements.some((c) => ts.isBreakStatement(c));
-        return `case ${visit(node.expression, { inline: true })}: \n\t\t\t${node.statements
-            .filter((n) => !ts.isBreakStatement(n))
+    else if (isCaseClause(node)) {
+        const isFallThrough = !(node.statements ?? []).some((c) => isBreakStatement(c));
+        return `case ${visit(node.expression, { inline: true })}: \n\t\t\t${(node.statements ?? [])
+            .filter((n) => !isBreakStatement(n))
             .map((s) => visit(s))
             .join('')}${isFallThrough ? 'fallthrough\n\t' : ''}`;
     }
-    else if (ts.isDefaultClause(node)) {
-        return `default: \n\t\t\t${node.statements
-            .filter((n) => !ts.isBreakStatement(n))
+    else if (isDefaultClause(node)) {
+        return `default: \n\t\t\t${(node.statements ?? [])
+            .filter((n) => !isBreakStatement(n))
             .map((s) => visit(s))
             .join('')}`;
     }
-    else if (ts.isBreakStatement(node)) {
+    else if (isBreakStatement(node)) {
         return 'break';
     }
-    else if (ts.isThrowStatement(node)) {
+    else if (isThrowStatement(node)) {
         const expr = node.expression;
-        if (ts.isNewExpression(expr) &&
-            ts.isIdentifier(expr.expression) &&
+        if (isNewExpression(expr) &&
+            isIdentifier(expr.expression) &&
             expr.expression.text === 'Error') {
             const args = expr.arguments ?? [];
             const msg = args.length > 0 ? visit(args[0]) : '""';
@@ -328,27 +796,27 @@ export function visit(node, options = {}) {
         }
         return `panic(${visit(expr)})` + (options.inline ? '' : ';\n\t');
     }
-    else if (ts.isTryStatement(node)) {
+    else if (isTryStatement(node)) {
         return visitTryStatement(node, options);
     }
-    else if (ts.isReturnStatement(node)) {
+    else if (isReturnStatement(node)) {
         // Handle return new Promise(...)
         if (node.expression &&
-            ts.isNewExpression(node.expression) &&
-            ts.isIdentifier(node.expression.expression) &&
+            isNewExpression(node.expression) &&
+            isIdentifier(node.expression.expression) &&
             node.expression.expression.text === 'Promise') {
             return visitPromiseReturn(node.expression, options);
         }
         return (`return ${node.expression ? visit(node.expression) : ''}` + (options.inline ? '' : ';\n\t'));
     }
-    else if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+    else if (isFunctionDeclaration(node) || isFunctionExpression(node)) {
         if (options.addFunctionOutside) {
             outsideNodes.push(node);
             return '';
         }
         const typeParams = getTypeParameters(node.typeParameters);
-        const parameterInfo = getFunctionParametersInfo(node.parameters);
-        if (node.body && ts.isBlock(node.body)) {
+        const parameterInfo = getFunctionParametersInfo((node.parameters ?? []));
+        if (node.body && isBlock(node.body)) {
             prescanVariableDeclarations(node.body);
         }
         const inferredRetType = inferFunctionBodyReturnType(node);
@@ -371,24 +839,24 @@ export function visit(node, options = {}) {
             prefixBlockContent: parameterInfo.prefixBlockContent
         })}`;
     }
-    else if (ts.isArrowFunction(node)) {
-        const parameterInfo = getFunctionParametersInfo(node.parameters);
+    else if (isArrowFunction(node)) {
+        const parameterInfo = getFunctionParametersInfo((node.parameters ?? []));
         const inferredRetType = inferFunctionBodyReturnType(node);
         const returnType = inferredRetType ? ` ${inferredRetType}` : '';
-        if (parameterInfo.prefixBlockContent && !ts.isBlock(node.body)) {
+        if (parameterInfo.prefixBlockContent && !isBlock(node.body)) {
             return `func(${parameterInfo.signature})${returnType} {\n\t\t${parameterInfo.prefixBlockContent}return ${visit(node.body)};\n\t}`;
         }
-        if (!ts.isBlock(node.body)) {
+        if (!isBlock(node.body)) {
             return `func(${parameterInfo.signature})${returnType} { return ${visit(node.body)}; }`;
         }
         return `func(${parameterInfo.signature})${returnType} ${visit(node.body, {
             prefixBlockContent: parameterInfo.prefixBlockContent
         })}`;
     }
-    else if (node.kind === ts.SyntaxKind.ThisKeyword) {
+    else if (node.kind === 'ThisKeyword') {
         return 'self';
     }
-    else if (ts.isEnumDeclaration(node)) {
+    else if (isEnumDeclaration(node)) {
         const enumName = node.name.text;
         enumNames.add(enumName);
         enumBaseTypes.set(enumName, getEnumBaseType(node));
@@ -398,16 +866,16 @@ export function visit(node, options = {}) {
         }
         return visitEnumDeclaration(node);
     }
-    else if (ts.isTypeAliasDeclaration(node)) {
+    else if (isTypeAliasDeclaration(node)) {
         typeAliases.set(node.name.text, node.type);
         return '';
     }
-    else if (ts.isInterfaceDeclaration(node)) {
+    else if (isInterfaceDeclaration(node)) {
         if (options.addFunctionOutside) {
             outsideNodes.push(node);
             const properties = new Map();
-            for (const member of node.members) {
-                if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+            for (const member of (node.members ?? [])) {
+                if (isPropertySignature(member) && isIdentifier(member.name)) {
                     properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
                 }
             }
@@ -419,10 +887,10 @@ export function visit(node, options = {}) {
         const name = visit(node.name);
         const typeParams = getTypeParameters(node.typeParameters);
         const extendedInterfaces = [];
-        if (node.heritageClauses) {
-            for (const clause of node.heritageClauses) {
-                if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-                    for (const type of clause.types) {
+        if ((node.heritageClauses ?? [])) {
+            for (const clause of (node.heritageClauses ?? [])) {
+                if (clause.token?.kind === 'ExtendsKeyword') {
+                    for (const type of (clause.types ?? [])) {
                         extendedInterfaces.push(visit(type.expression));
                     }
                 }
@@ -430,16 +898,16 @@ export function visit(node, options = {}) {
         }
         const methods = [];
         const properties = [];
-        for (const member of node.members) {
-            if (ts.isMethodSignature(member)) {
+        for (const member of (node.members ?? [])) {
+            if (isMethodSignature(member)) {
                 const methodName = visit(member.name);
-                const params = member.parameters
+                const params = (member.parameters ?? [])
                     .map((p) => `${visit(p.name)} ${getType(p.type)}`)
                     .join(', ');
                 const returnType = member.type ? ` ${getType(member.type)}` : '';
                 methods.push(`\t${methodName}(${params})${returnType}`);
             }
-            else if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+            else if (isPropertySignature(member) && isIdentifier(member.name)) {
                 properties.push(`\t${member.name.text} ${getOptionalNodeType(member.type, !!member.questionToken)}`);
             }
         }
@@ -450,19 +918,31 @@ export function visit(node, options = {}) {
         const members = [...extendedInterfaces.map((e) => `\t${e}`), ...methods];
         return `type ${name}${typeParams} interface {\n${members.join('\n')}\n}`;
     }
-    else if (ts.isClassDeclaration(node)) {
+    else if (isClassDeclaration(node)) {
         if (options.addFunctionOutside) {
             outsideNodes.push(node);
             const className = visit(node.name);
             classNames.add(className);
             const properties = new Map();
             const methods = new Map();
-            for (const member of node.members) {
-                if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
-                    properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+            for (const member of (node.members ?? [])) {
+                const memberModifiers = member.modifiers;
+                const isStatic = memberModifiers?.some((m) => m.kind === 'StaticKeyword');
+                if (isPropertyDeclaration(member) && isIdentifier(member.name)) {
+                    if (isStatic) {
+                        classStaticProps.add(`${className}.${member.name.text}`);
+                    }
+                    else {
+                        properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+                    }
                 }
-                if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name)) {
-                    methods.set(member.name.text, member.type ? getType(member.type) : 'interface{}');
+                if (isMethodDeclaration(member) && isIdentifier(member.name)) {
+                    if (isStatic) {
+                        classStaticMethods.add(`${className}.${member.name.text}`);
+                    }
+                    else {
+                        methods.set(member.name.text, member.type ? getType(member.type) : 'interface{}');
+                    }
                 }
             }
             classPropertyTypes.set(className, properties);
@@ -473,9 +953,9 @@ export function visit(node, options = {}) {
         const typeParams = getTypeParameters(node.typeParameters);
         const typeParamNames = getTypeParameterNames(node.typeParameters);
         let parentClass = null;
-        if (node.heritageClauses) {
-            for (const clause of node.heritageClauses) {
-                if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+        if ((node.heritageClauses ?? [])) {
+            for (const clause of (node.heritageClauses ?? [])) {
+                if (clause.token?.kind === 'ExtendsKeyword') {
                     parentClass = visit(clause.types[0].expression);
                 }
             }
@@ -484,11 +964,11 @@ export function visit(node, options = {}) {
         if (parentClass) {
             fields.push(`\t${parentClass}`);
         }
-        for (const member of node.members) {
-            if (ts.isPropertyDeclaration(member)) {
+        for (const member of (node.members ?? [])) {
+            if (isPropertyDeclaration(member)) {
                 const fieldName = visit(member.name);
                 let fieldType;
-                if (member.type && ts.isArrayTypeNode(member.type)) {
+                if (member.type && isArrayTypeNode(member.type)) {
                     fieldType = `[]${getType(member.type, true)}`;
                 }
                 else {
@@ -498,13 +978,13 @@ export function visit(node, options = {}) {
             }
         }
         let result = `type ${name}${typeParams} struct {\n${fields.join('\n')}\n}\n\n`;
-        const ctor = node.members.find((m) => ts.isConstructorDeclaration(m));
+        const ctor = (node.members ?? []).find((m) => isConstructorDeclaration(m));
         if (ctor) {
-            const ctorParameterInfo = getFunctionParametersInfo(ctor.parameters);
+            const ctorParameterInfo = getFunctionParametersInfo(ctor.parameters ?? []);
             const bodyStatements = ctor.body?.statements
                 .filter((s) => {
-                if (ts.isExpressionStatement(s) && ts.isCallExpression(s.expression)) {
-                    return s.expression.expression.kind !== ts.SyntaxKind.SuperKeyword;
+                if (isExpressionStatement(s) && isCallExpression(s.expression)) {
+                    return s.expression.expression.kind !== 'SuperKeyword';
                 }
                 return true;
             })
@@ -515,19 +995,46 @@ export function visit(node, options = {}) {
         else {
             result += `func New${name}${typeParams}() *${name}${typeParamNames} {\n\t\treturn &${name}${typeParamNames}{}\n\t}\n\n`;
         }
-        for (const member of node.members) {
-            if (ts.isMethodDeclaration(member)) {
+        for (const member of (node.members ?? [])) {
+            if (isMethodDeclaration(member)) {
                 const methodName = visit(member.name);
-                const methodParameterInfo = getFunctionParametersInfo(member.parameters);
+                const methodParameterInfo = getFunctionParametersInfo(member.parameters ?? []);
                 const returnType = member.type ? ` ${getType(member.type)}` : '';
-                result += `func (self *${name}${typeParamNames}) ${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, {
-                    prefixBlockContent: methodParameterInfo.prefixBlockContent
-                })}\n\n`;
+                const isStatic = member.modifiers?.some((m) => m.kind === 'StaticKeyword');
+                if (isStatic) {
+                    // Static methods become package-level functions named ClassName_methodName
+                    result += `func ${name}_${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, { prefixBlockContent: methodParameterInfo.prefixBlockContent })}\n\n`;
+                }
+                else {
+                    result += `func (self *${name}${typeParamNames}) ${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, { prefixBlockContent: methodParameterInfo.prefixBlockContent })}\n\n`;
+                }
+            }
+            else if (isGetAccessor(member)) {
+                // Getter: get prop() { ... } → func (self *T) Prop() RetType { ... }
+                const getterName = visit(member.name);
+                const returnType = member.type ? ` ${getType(member.type)}` : ' interface{}';
+                result += `func (self *${name}${typeParamNames}) Get_${getterName}()${returnType} ${visit(member.body)}\n\n`;
+            }
+            else if (isSetAccessor(member)) {
+                // Setter: set prop(val) { ... } → func (self *T) SetProp(val ValType) { ... }
+                const setterName = visit(member.name);
+                const parameterInfo = getFunctionParametersInfo(member.parameters ?? []);
+                result += `func (self *${name}${typeParamNames}) Set_${setterName}(${parameterInfo.signature}) ${visit(member.body, { prefixBlockContent: parameterInfo.prefixBlockContent })}\n\n`;
+            }
+        }
+        // Static property declarations → package-level vars named ClassName_propName
+        for (const member of (node.members ?? [])) {
+            if (isPropertyDeclaration(member) &&
+                member.modifiers?.some((m) => m.kind === 'StaticKeyword')) {
+                const fieldName = visit(member.name);
+                const fieldType = getOptionalNodeType(member.type, !!member.questionToken);
+                const initializer = member.initializer ? ` = ${visit(member.initializer)}` : '';
+                result += `var ${name}_${fieldName} ${fieldType}${initializer}\n\n`;
             }
         }
         return result.trim();
     }
-    else if (ts.isNewExpression(node)) {
+    else if (isNewExpression(node)) {
         const className = visit(node.expression);
         if (className === 'Promise') {
             return visitNewPromise(node);
@@ -535,7 +1042,7 @@ export function visit(node, options = {}) {
         if (className === 'RegExp') {
             importedPackages.add('regexp');
             const nodeArgs = node.arguments ?? [];
-            if (nodeArgs.length >= 2 && ts.isStringLiteral(nodeArgs[1])) {
+            if (nodeArgs.length >= 2 && isStringLiteral(nodeArgs[1])) {
                 const pattern = visit(nodeArgs[0]);
                 const flags = jsRegexFlagsToGo(nodeArgs[1].text);
                 return `regexp.MustCompile("${flags}" + ${pattern})`;
@@ -551,51 +1058,58 @@ export function visit(node, options = {}) {
         if (className === 'Set') {
             return visitNewSet(node);
         }
-        const typeArgs = getTypeArguments(node.typeArguments);
-        const args = node.arguments ? node.arguments.map((a) => visit(a)) : [];
+        const typeArgs = getTypeArguments((node.typeArguments ?? []));
+        const args = node.arguments ? (node.arguments ?? []).map((a) => visit(a)) : [];
         return `New${className}${typeArgs}(${args.join(', ')})`;
     }
-    else if (ts.isObjectLiteralExpression(node)) {
+    else if (isObjectLiteralExpression(node)) {
         let typeName = '';
-        if (ts.isVariableDeclaration(node.parent) && node.parent.type) {
+        if (isVariableDeclaration(node.parent) && node.parent.type) {
             typeName = getTypeText(node.parent.type);
         }
-        const properties = node.properties
+        const properties = (node.properties ?? [])
             .map((p) => {
-            if (ts.isPropertyAssignment(p)) {
+            if (isPropertyAssignment(p)) {
                 return `${visit(p.name)}: ${visit(p.initializer)}`;
             }
+            // Shorthand: { name } → name: name
+            if (isShorthandPropertyAssignment(p)) {
+                const name = visit(p.name);
+                return `${name}: ${name}`;
+            }
+            // Spread: { ...obj } — not easily supported in Go structs, omit
             return '';
         })
             .filter((p) => p)
             .join(', ');
         return `${typeName}{${properties}}`;
     }
-    else if (ts.isPropertyAssignment(node)) {
+    else if (isPropertyAssignment(node)) {
         return `${visit(node.name)}: ${visit(node.initializer)}`;
     }
-    else if (ts.isNonNullExpression(node)) {
+    else if (isNonNullExpression(node)) {
         return visit(node.expression);
     }
-    else if (ts.isImportDeclaration(node)) {
+    else if (isImportDeclaration(node)) {
         return visitImportDeclaration(node);
     }
-    else if (ts.isExportDeclaration(node) || ts.isExportAssignment(node)) {
+    else if (isExportDeclaration(node) || isExportAssignment(node)) {
         return '';
     }
-    const syntaxKind = ts.SyntaxKind[node.kind];
+    const syntaxKind = node.kind;
     if (!['FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
-        console.log(ts.SyntaxKind[node.kind], node.getText());
+        const snippet = String(node.text ?? node.kind).substring(0, 60).replace(/\n/g, ' ');
+        console.warn(`[TypeNative] Unsupported syntax: ${syntaxKind} — "${snippet}"`);
+    }
+    for (const child of childNodes(node)) {
+        code += visit(child);
     }
-    ts.forEachChild(node, (subNode) => {
-        code += visit(subNode);
-    });
     return code;
 }
 function getTypeText(typeNode) {
     if (!typeNode)
         return ':';
-    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+    if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
         return typeNode.typeName.text;
     }
     return getType(typeNode);
@@ -603,6 +1117,34 @@ function getTypeText(typeNode) {
 function toGoStringLiteral(value) {
     return JSON.stringify(value);
 }
+function visitSpreadArrayLiteral(node, elemType) {
+    const chunks = [];
+    for (const el of (node.elements ?? [])) {
+        if (isSpreadElement(el)) {
+            chunks.push({ isSpread: true, items: [el.expression] });
+        }
+        else {
+            const last = chunks[chunks.length - 1];
+            if (last && !last.isSpread) {
+                last.items.push(el);
+            }
+            else {
+                chunks.push({ isSpread: false, items: [el] });
+            }
+        }
+    }
+    const baseType = elemType || 'interface{}';
+    let result = `[]${baseType}{}`;
+    for (const chunk of chunks) {
+        if (chunk.isSpread) {
+            result = `append(${result}, ${visit(chunk.items[0])}...)`;
+        }
+        else {
+            result = `append(${result}, ${chunk.items.map((e) => visit(e)).join(', ')})`;
+        }
+    }
+    return result;
+}
 function visitTemplateExpression(node) {
     const parts = [];
     if (node.head.text.length > 0) {
@@ -629,16 +1171,16 @@ function getTempName(prefix) {
 }
 function inferExpectedTypeFromContext(node) {
     const parent = node.parent;
-    if (ts.isVariableDeclaration(parent) && parent.initializer === node && parent.type) {
+    if (isVariableDeclaration(parent) && parent.initializer === node && parent.type) {
         return getType(parent.type);
     }
-    if (ts.isReturnStatement(parent)) {
+    if (isReturnStatement(parent)) {
         let scope = parent.parent;
         while (scope) {
-            if (ts.isFunctionDeclaration(scope) ||
-                ts.isMethodDeclaration(scope) ||
-                ts.isFunctionExpression(scope) ||
-                ts.isArrowFunction(scope)) {
+            if (isFunctionDeclaration(scope) ||
+                isMethodDeclaration(scope) ||
+                isFunctionExpression(scope) ||
+                isArrowFunction(scope)) {
                 if (scope.type)
                     return getType(scope.type);
                 break;
@@ -650,9 +1192,9 @@ function inferExpectedTypeFromContext(node) {
 }
 function prescanVariableDeclarations(block) {
     for (const stmt of block.statements) {
-        if (ts.isVariableStatement(stmt)) {
+        if (isVariableStatement(stmt)) {
             for (const decl of stmt.declarationList.declarations) {
-                if (ts.isIdentifier(decl.name) && !variableGoTypes.has(decl.name.text)) {
+                if (isIdentifier(decl.name) && !variableGoTypes.has(decl.name.text)) {
                     if (decl.type) {
                         variableGoTypes.set(decl.name.text, getType(decl.type));
                     }
@@ -669,12 +1211,12 @@ function prescanVariableDeclarations(block) {
 function inferFunctionBodyReturnType(node) {
     if (node.type)
         return getType(node.type);
-    if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+    if (isArrowFunction(node) && !isBlock(node.body)) {
         return inferExpressionType(node.body);
     }
-    if (node.body && ts.isBlock(node.body)) {
+    if (node.body && isBlock(node.body)) {
         for (const stmt of node.body.statements) {
-            if (ts.isReturnStatement(stmt) && stmt.expression) {
+            if (isReturnStatement(stmt) && stmt.expression) {
                 const exprType = inferExpressionType(stmt.expression);
                 if (exprType)
                     return exprType;
@@ -684,42 +1226,43 @@ function inferFunctionBodyReturnType(node) {
     return undefined;
 }
 function inferArrowFunctionGoType(node) {
-    const params = node.parameters.map((p) => (p.type ? getType(p.type) : 'interface{}')).join(', ');
+    const params = (node.parameters ?? []).map((p) => (p.type ? getType(p.type) : 'interface{}')).join(', ');
     const retType = inferFunctionBodyReturnType(node);
     return `func(${params})${retType ? ` ${retType}` : ''}`;
 }
 function inferExpressionType(expr) {
-    if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
+    if (isArrowFunction(expr) || isFunctionExpression(expr)) {
         return inferArrowFunctionGoType(expr);
     }
-    if (ts.isParenthesizedExpression(expr))
+    if (isParenthesizedExpression(expr))
         return inferExpressionType(expr.expression);
-    if (ts.isNonNullExpression(expr))
+    if (isNonNullExpression(expr))
         return inferExpressionType(expr.expression);
-    if (ts.isAsExpression(expr))
+    if (isAsExpression(expr))
         return getType(expr.type);
-    if (ts.isTypeAssertionExpression(expr))
+    if (isTypeAssertionExpression(expr))
         return getType(expr.type);
-    if (ts.isStringLiteral(expr) ||
-        ts.isNoSubstitutionTemplateLiteral(expr) ||
-        ts.isTemplateExpression(expr)) {
+    if (isStringLiteral(expr) ||
+        isNoSubstitutionTemplateLiteral(expr) ||
+        isTemplateExpression(expr)) {
         return 'string';
     }
-    if (ts.isNumericLiteral(expr))
+    if (isNumericLiteral(expr))
         return 'float64';
-    if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword)
+    if (expr.kind === 'TrueKeyword' || expr.kind === 'FalseKeyword')
         return 'bool';
-    if (expr.kind === ts.SyntaxKind.NullKeyword)
+    if (expr.kind === 'NullKeyword')
         return 'nil';
-    if (ts.isIdentifier(expr))
+    if (isIdentifier(expr))
         return variableGoTypes.get(expr.text);
-    if (ts.isArrayLiteralExpression(expr)) {
-        if (expr.elements.length === 0)
+    if (isArrayLiteralExpression(expr)) {
+        const elements = expr.elements ?? [];
+        if (elements.length === 0)
             return '[]interface{}';
-        const firstElementType = inferExpressionType(expr.elements[0]) ?? 'interface{}';
+        const firstElementType = inferExpressionType(elements[0]) ?? 'interface{}';
         return `[]${firstElementType}`;
     }
-    if (ts.isNewExpression(expr) && ts.isIdentifier(expr.expression)) {
+    if (isNewExpression(expr) && isIdentifier(expr.expression)) {
         const ctorName = expr.expression.text;
         if (ctorName === 'Map' && expr.typeArguments && expr.typeArguments.length === 2) {
             return `map[${getType(expr.typeArguments[0])}]${getType(expr.typeArguments[1])}`;
@@ -728,8 +1271,8 @@ function inferExpressionType(expr) {
             return `map[${getType(expr.typeArguments[0])}]struct{}`;
         }
     }
-    if (ts.isPropertyAccessExpression(expr)) {
-        if (ts.isIdentifier(expr.expression) && enumNames.has(expr.expression.text)) {
+    if (isPropertyAccessExpression(expr)) {
+        if (isIdentifier(expr.expression) && enumNames.has(expr.expression.text)) {
             const enumType = getSafeName(expr.expression.text);
             return enumType;
         }
@@ -751,7 +1294,7 @@ function inferExpressionType(expr) {
         if (resolvedPropertyType) {
             return resolvedPropertyType;
         }
-        if (ts.isIdentifier(expr.expression)) {
+        if (isIdentifier(expr.expression)) {
             const className = variableClassNames.get(expr.expression.text);
             const memberType = className
                 ? classPropertyTypes.get(className)?.get(expr.name.text)
@@ -760,7 +1303,7 @@ function inferExpressionType(expr) {
                 return memberType;
         }
     }
-    if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) {
+    if (isCallExpression(expr) && isPropertyAccessExpression(expr.expression)) {
         const methodName = expr.expression.name.text;
         const ownerType = inferExpressionType(expr.expression.expression);
         if (ownerType && ownerType.startsWith('map[')) {
@@ -797,7 +1340,7 @@ function inferExpressionType(expr) {
                 return returnType;
             }
         }
-        if (ts.isIdentifier(expr.expression.expression)) {
+        if (isIdentifier(expr.expression.expression)) {
             const className = variableClassNames.get(expr.expression.expression.text);
             const returnType = className
                 ? classMethodReturnTypes.get(className)?.get(methodName)
@@ -810,15 +1353,15 @@ function inferExpressionType(expr) {
             }
         }
     }
-    if (ts.isConditionalExpression(expr)) {
+    if (isConditionalExpression(expr)) {
         const whenTrueType = inferExpressionType(expr.whenTrue);
         const whenFalseType = inferExpressionType(expr.whenFalse);
         if (whenTrueType && whenTrueType === whenFalseType)
             return whenTrueType;
         return whenTrueType ?? whenFalseType;
     }
-    if (ts.isBinaryExpression(expr) &&
-        expr.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+    if (isBinaryExpression(expr) &&
+        expr.operatorToken.kind === 'QuestionQuestionToken') {
         const leftType = inferExpressionType(expr.left);
         const rightType = inferExpressionType(expr.right);
         if (leftType && leftType.startsWith('*') && rightType === leftType.slice(1)) {
@@ -898,14 +1441,14 @@ function visitOptionalElementAccess(node) {
     return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; return ${elementExpr} }()`;
 }
 function visitOptionalCall(node) {
-    if (!ts.isPropertyAccessExpression(node.expression)) {
-        return `${visit(node.expression)}(${node.arguments.map((a) => visit(a)).join(', ')})`;
+    if (!isPropertyAccessExpression(node.expression)) {
+        return `${visit(node.expression)}(${(node.arguments ?? []).map((a) => visit(a)).join(', ')})`;
     }
     const baseNode = node.expression.expression;
     const methodName = node.expression.name.text;
     const baseExpr = visit(baseNode);
     const baseType = inferExpressionType(baseNode);
-    const args = node.arguments.map((a) => visit(a)).join(', ');
+    const args = (node.arguments ?? []).map((a) => visit(a)).join(', ');
     if (!baseType || !baseType.startsWith('*')) {
         return `${baseExpr}.${methodName}(${args})`;
     }
@@ -930,18 +1473,18 @@ function getArrayElementTypeFromGoType(goType) {
     return elementType || 'interface{}';
 }
 function inferArrayCallbackReturnType(callback, elementType, fallbackType) {
-    if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+    if (isArrowFunction(callback) || isFunctionExpression(callback)) {
         if (callback.type) {
             const explicitType = getType(callback.type);
             return explicitType || fallbackType;
         }
-        if (ts.isBlock(callback.body)) {
+        if (isBlock(callback.body)) {
             return fallbackType;
         }
         const inferred = inferExpressionType(callback.body);
         return inferred ?? fallbackType;
     }
-    if (ts.isIdentifier(callback)) {
+    if (isIdentifier(callback)) {
         const knownType = variableGoTypes.get(callback.text);
         if (knownType)
             return knownType;
@@ -949,7 +1492,7 @@ function inferArrayCallbackReturnType(callback, elementType, fallbackType) {
     return fallbackType;
 }
 function buildArrayCallbackInfo(callback, elementType, forcedReturnType) {
-    if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+    if (isArrowFunction(callback) || isFunctionExpression(callback)) {
         const paramCount = callback.parameters.length;
         const callbackReturnType = forcedReturnType ?? inferArrayCallbackReturnType(callback, elementType, 'interface{}');
         const params = [];
@@ -962,9 +1505,9 @@ function buildArrayCallbackInfo(callback, elementType, forcedReturnType) {
         if (paramCount > 2) {
             params.push(`${visit(callback.parameters[2].name)} []${elementType}`);
         }
-        const body = ts.isBlock(callback.body)
-            ? visit(callback.body)
-            : `{\n\t\treturn ${visit(callback.body)};\n\t}`;
+        const body = isBlock(callback.body)
+            ? visit(callback.body, { inline: true })
+            : `{ return ${visit(callback.body)}; }`;
         return {
             fnExpr: `func(${params.join(', ')}) ${callbackReturnType} ${body}`,
             paramCount,
@@ -987,11 +1530,24 @@ function buildArrayCallbackInvocation(callbackInfo, itemVar, indexVar, arrayVar)
         args.push(arrayVar);
     return `(${callbackInfo.fnExpr})(${args.join(', ')})`;
 }
+// Like buildArrayCallbackInvocation but for reduce: (acc, item, idx, arr)
+function buildArrayCallbackInvocationReduce(callbackInfo, accVar, itemVar, indexVar, arrayVar) {
+    const args = [];
+    if (callbackInfo.paramCount > 0)
+        args.push(accVar);
+    if (callbackInfo.paramCount > 1)
+        args.push(itemVar);
+    if (callbackInfo.paramCount > 2)
+        args.push(`float64(${indexVar})`);
+    if (callbackInfo.paramCount > 3)
+        args.push(arrayVar);
+    return `(${callbackInfo.fnExpr})(${args.join(', ')})`;
+}
 function visitArrayHigherOrderCall(node) {
-    if (!ts.isPropertyAccessExpression(node.expression))
+    if (!isPropertyAccessExpression(node.expression))
         return undefined;
     const methodName = node.expression.name.text;
-    if (!['map', 'filter', 'some', 'find', 'join'].includes(methodName)) {
+    if (!['map', 'filter', 'some', 'find', 'findIndex', 'every', 'forEach', 'reduce', 'join'].includes(methodName)) {
         return undefined;
     }
     const arrayExprNode = node.expression.expression;
@@ -1006,12 +1562,12 @@ function visitArrayHigherOrderCall(node) {
             return undefined;
         importedPackages.add('strings');
         importedPackages.add('fmt');
-        const separator = node.arguments[0] ? visit(node.arguments[0]) : '""';
+        const separator = (node.arguments ?? [])[0] ? visit((node.arguments ?? [])[0]) : '""';
         const arrVar = getTempName('arrjoin');
         const partsVar = getTempName('parts');
         return `func() string { ${arrVar} := ${arrayExpr}; ${partsVar} := make([]string, len(${arrVar})); for i, v := range ${arrVar} { ${partsVar}[i] = fmt.Sprintf("%v", v) }; return strings.Join(${partsVar}, ${separator}) }()`;
     }
-    const callback = node.arguments[0];
+    const callback = (node.arguments ?? [])[0];
     if (!callback) {
         return undefined;
     }
@@ -1039,6 +1595,43 @@ function visitArrayHigherOrderCall(node) {
         const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
         return `func() bool { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { return true } }; return false }()`;
     }
+    if (methodName === 'findIndex') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() float64 { ${arrVar} := ${arrayExpr}; for ${idxVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { return float64(${idxVar}) } }; return float64(-1) }()`;
+    }
+    if (methodName === 'every') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() bool { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if !(${callbackCall}) { return false } }; return true }()`;
+    }
+    if (methodName === 'forEach') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, '');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { ${callbackCall} } }()`;
+    }
+    if (methodName === 'reduce') {
+        const reduceCallback = (node.arguments ?? [])[0];
+        if (!reduceCallback)
+            return undefined;
+        const initialValue = (node.arguments ?? [])[1] ? visit((node.arguments ?? [])[1]) : undefined;
+        const accType = initialValue
+            ? (inferExpressionType((node.arguments ?? [])[1]) ?? elementType)
+            : elementType;
+        const accVar = getTempName('acc');
+        // Build a callback that takes (acc, item, idx, arr) — param count determines what gets passed
+        const cbInfo = buildArrayCallbackInfo(reduceCallback, elementType, accType ?? 'interface{}');
+        const cbCall = buildArrayCallbackInvocationReduce(cbInfo, accVar, itemVar, idxVar, arrVar);
+        // Only include the index loop var if the callback uses it (paramCount > 2)
+        const reduceIdxVar = cbInfo.paramCount > 2 ? idxVar : '_';
+        if (initialValue !== undefined) {
+            return `func() ${accType} { ${arrVar} := ${arrayExpr}; ${accVar} := ${initialValue}; for ${reduceIdxVar}, ${itemVar} := range ${arrVar} { ${accVar} = ${cbCall} }; return ${accVar} }()`;
+        }
+        return `func() ${elementType} { ${arrVar} := ${arrayExpr}; ${accVar} := ${arrVar}[0]; for ${reduceIdxVar}, ${itemVar} := range ${arrVar}[1:] { ${accVar} = ${cbCall} }; return ${accVar} }()`;
+    }
+    // find
     const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
     const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
     const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
@@ -1050,7 +1643,7 @@ function getAliasType(name, seen = new Set()) {
         return undefined;
     if (seen.has(name))
         return undefined;
-    if (ts.isTypeReferenceNode(aliasType) && ts.isIdentifier(aliasType.typeName)) {
+    if (isTypeReferenceNode(aliasType) && isIdentifier(aliasType.typeName)) {
         const nestedName = aliasType.typeName.text;
         if (typeAliases.has(nestedName)) {
             seen.add(name);
@@ -1070,33 +1663,33 @@ function getOptionalNodeType(typeNode, isOptional) {
     return baseType;
 }
 function getEnumMemberName(name) {
-    if (ts.isIdentifier(name)) {
+    if (isIdentifier(name)) {
         return getSafeName(name.text);
     }
-    if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+    if (isStringLiteral(name) || isNumericLiteral(name)) {
         const sanitized = name.text.replace(/[^a-zA-Z0-9_]/g, '_');
         return sanitized.length > 0 ? sanitized : 'Member';
     }
     return 'Member';
 }
 function getEnumBaseType(node) {
-    for (const member of node.members) {
+    for (const member of (node.members ?? [])) {
         const initializer = member.initializer;
         if (!initializer)
             continue;
-        if (ts.isStringLiteral(initializer) || ts.isNoSubstitutionTemplateLiteral(initializer)) {
+        if (isStringLiteral(initializer) || isNoSubstitutionTemplateLiteral(initializer)) {
             return 'string';
         }
     }
     return 'float64';
 }
 function readNumericEnumInitializer(initializer) {
-    if (ts.isNumericLiteral(initializer)) {
+    if (isNumericLiteral(initializer)) {
         return Number(initializer.text);
     }
-    if (ts.isPrefixUnaryExpression(initializer) &&
-        initializer.operator === ts.SyntaxKind.MinusToken &&
-        ts.isNumericLiteral(initializer.operand)) {
+    if (isPrefixUnaryExpression(initializer) &&
+        initializer.operator === 'MinusToken' &&
+        isNumericLiteral(initializer.operand)) {
         return -Number(initializer.operand.text);
     }
     return undefined;
@@ -1107,7 +1700,7 @@ function visitEnumDeclaration(node) {
     let nextNumericValue = 0;
     let canAutoIncrement = true;
     const members = [];
-    for (const member of node.members) {
+    for (const member of (node.members ?? [])) {
         const memberName = getEnumMemberName(member.name);
         const symbolName = `${enumName}_${memberName}`;
         let valueExpr;
@@ -1143,15 +1736,15 @@ function visitEnumDeclaration(node) {
 function getType(typeNode, getArrayType = false) {
     if (!typeNode)
         return ':';
-    if (ts.isArrayTypeNode(typeNode)) {
+    if (isArrayTypeNode(typeNode)) {
         const elementType = getType(typeNode.elementType);
         return getArrayType ? elementType : `[]${elementType}`;
     }
     // Handle union types (e.g. string | null, number | undefined)
-    if (ts.isUnionTypeNode(typeNode)) {
-        const nonNullTypes = typeNode.types.filter((t) => t.kind !== ts.SyntaxKind.NullKeyword &&
-            t.kind !== ts.SyntaxKind.UndefinedKeyword &&
-            !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));
+    if (isUnionTypeNode(typeNode)) {
+        const nonNullTypes = typeNode.types.filter((t) => t.kind !== 'NullKeyword' &&
+            t.kind !== 'UndefinedKeyword' &&
+            !(isLiteralTypeNode(t) && t.literal.kind === 'NullKeyword'));
         if (nonNullTypes.length === 1 && nonNullTypes.length < typeNode.types.length) {
             // This is a nullable type T | null or T | undefined
             const innerType = getType(nonNullTypes[0]);
@@ -1164,14 +1757,14 @@ function getType(typeNode, getArrayType = false) {
         // Non-nullable union or multi-type union → interface{}
         return 'interface{}';
     }
-    if (ts.isFunctionTypeNode(typeNode)) {
+    if (isFunctionTypeNode(typeNode)) {
         const params = typeNode.parameters
             .map((p) => (p.type ? getType(p.type) : 'interface{}'))
             .join(', ');
         const ret = typeNode.type ? ` ${getType(typeNode.type)}` : '';
         return `func(${params})${ret}`;
     }
-    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+    if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
         if (enumNames.has(name)) {
             return getSafeName(name);
@@ -1201,8 +1794,8 @@ function getType(typeNode, getArrayType = false) {
         }
         return `${name}${typeArgs}`;
     }
-    const type = TypeCheker.getTypeFromTypeNode(typeNode);
-    let typeName = TypeCheker.typeToString(type);
+    // Syntactic replacement for the ts typechecker: render the type node's text
+    let typeName = typeNodeToText(typeNode);
     const isArray = typeName.includes('[]');
     if (isArray) {
         if (getArrayType) {
@@ -1228,22 +1821,22 @@ function getType(typeNode, getArrayType = false) {
 function getTypeCategory(typeNode) {
     if (!typeNode)
         return undefined;
-    if (ts.isArrayTypeNode(typeNode))
+    if (isArrayTypeNode(typeNode))
         return 'array';
-    if (typeNode.kind === ts.SyntaxKind.StringKeyword)
+    if (typeNode.kind === 'StringKeyword')
         return 'string';
-    if (typeNode.kind === ts.SyntaxKind.NumberKeyword)
+    if (typeNode.kind === 'NumberKeyword')
         return 'number';
-    if (typeNode.kind === ts.SyntaxKind.BooleanKeyword)
+    if (typeNode.kind === 'BooleanKeyword')
         return 'boolean';
-    if (ts.isUnionTypeNode(typeNode)) {
-        const nonNullTypes = typeNode.types.filter((t) => t.kind !== ts.SyntaxKind.NullKeyword &&
-            t.kind !== ts.SyntaxKind.UndefinedKeyword &&
-            !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));
+    if (isUnionTypeNode(typeNode)) {
+        const nonNullTypes = typeNode.types.filter((t) => t.kind !== 'NullKeyword' &&
+            t.kind !== 'UndefinedKeyword' &&
+            !(isLiteralTypeNode(t) && t.literal.kind === 'NullKeyword'));
         if (nonNullTypes.length === 1)
             return getTypeCategory(nonNullTypes[0]);
     }
-    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+    if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
         if (name === 'Map')
             return 'Map';
@@ -1256,13 +1849,13 @@ function getTypeCategory(typeNode) {
     return undefined;
 }
 function getClassNameFromTypeNode(typeNode) {
-    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+    if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
         return classNames.has(typeNode.typeName.text) ? typeNode.typeName.text : undefined;
     }
-    if (ts.isUnionTypeNode(typeNode)) {
-        const nonNullTypes = typeNode.types.filter((t) => t.kind !== ts.SyntaxKind.NullKeyword &&
-            t.kind !== ts.SyntaxKind.UndefinedKeyword &&
-            !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));
+    if (isUnionTypeNode(typeNode)) {
+        const nonNullTypes = typeNode.types.filter((t) => t.kind !== 'NullKeyword' &&
+            t.kind !== 'UndefinedKeyword' &&
+            !(isLiteralTypeNode(t) && t.literal.kind === 'NullKeyword'));
         if (nonNullTypes.length === 1) {
             return getClassNameFromTypeNode(nonNullTypes[0]);
         }
@@ -1270,18 +1863,18 @@ function getClassNameFromTypeNode(typeNode) {
     return undefined;
 }
 function resolveExpressionType(expr) {
-    if (ts.isIdentifier(expr)) {
+    if (isIdentifier(expr)) {
         return variableTypes.get(expr.text);
     }
-    if (expr.kind === ts.SyntaxKind.ThisKeyword) {
+    if (expr.kind === 'ThisKeyword') {
         return 'class';
     }
     return undefined;
 }
 function isNilLiteral(node) {
-    if (node.kind === ts.SyntaxKind.NullKeyword)
+    if (node.kind === 'NullKeyword')
         return true;
-    if (ts.isIdentifier(node) && node.text === 'undefined')
+    if (isIdentifier(node) && node.text === 'undefined')
         return true;
     return false;
 }
@@ -1292,6 +1885,26 @@ function getAcessString(leftSide, rightSide, objectType) {
     if (rightSide === 'size' && (objectType === 'Map' || objectType === 'Set')) {
         return `float64(len(${leftSide}))`;
     }
+    // process global properties
+    if (leftSide === 'process') {
+        if (rightSide === 'argv') {
+            importedPackages.add('os');
+            return 'os.Args';
+        }
+        if (rightSide === 'platform') {
+            importedPackages.add('runtime');
+            return 'runtime.GOOS';
+        }
+        if (rightSide === 'env') {
+            // process.env.X is detected via the nested access below
+            return 'process.env';
+        }
+    }
+    // process.env.X → TnGetenv("X") (os.Environ() is a []string in Go, not a map)
+    if (leftSide === 'process.env') {
+        useHelper('getenv');
+        return `TnGetenv("${rightSide}")`;
+    }
     return `${leftSide}.${rightSide}`;
 }
 const callHandlers = {
@@ -1355,7 +1968,84 @@ const callHandlers = {
     parseFloat: (_caller, args) => {
         importedPackages.add('strconv');
         return `func() float64 { v, _ := strconv.ParseFloat(${args[0]}, 64); return v }()`;
-    }
+    },
+    'process.exit': (_caller, args) => {
+        importedPackages.add('os');
+        return `os.Exit(int(${args[0] ?? '0'}))`;
+    },
+    'process.cwd': () => {
+        importedPackages.add('os');
+        return `func() string { __d, _ := os.Getwd(); return __d }()`;
+    },
+    'JSON.stringify': (_caller, args) => {
+        importedPackages.add('encoding/json');
+        if (args.length >= 3) {
+            return `func() string { __b, _ := json.MarshalIndent(${args[0]}, "", "  "); return string(__b) }()`;
+        }
+        return `func() string { __b, _ := json.Marshal(${args[0]}); return string(__b) }()`;
+    },
+    'JSON.parse': (_caller, args) => {
+        importedPackages.add('encoding/json');
+        return `func() interface{} { var __v interface{}; json.Unmarshal([]byte(${args[0]}), &__v); return __v }()`;
+    },
+    'Object.keys': (_caller, args) => {
+        importedPackages.add('maps');
+        return `func() []string { __k := make([]string, 0); for k := range ${args[0]} { __k = append(__k, k) }; return __k }()`;
+    },
+    'Object.values': (_caller, args) => {
+        return `func() []interface{} { __v := make([]interface{}, 0); for _, v := range ${args[0]} { __v = append(__v, v) }; return __v }()`;
+    },
+    'Object.entries': (_caller, args) => {
+        // When used outside for...of, produce a slice of [key, value] pairs — rarely needed
+        return args[0];
+    },
+    'Math.log': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Log(${args[0]})`;
+    },
+    'Math.log2': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Log2(${args[0]})`;
+    },
+    'Math.log10': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Log10(${args[0]})`;
+    },
+    'Math.sin': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Sin(${args[0]})`;
+    },
+    'Math.cos': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Cos(${args[0]})`;
+    },
+    'Math.tan': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Tan(${args[0]})`;
+    },
+    'Math.trunc': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.Trunc(${args[0]})`;
+    },
+    'Math.sign': (_caller, args) => {
+        return `func() float64 { if ${args[0]} > 0 { return 1 }; if ${args[0]} < 0 { return -1 }; return 0 }()`;
+    },
+    'console.error': (_caller, args) => {
+        importedPackages.add('fmt');
+        importedPackages.add('os');
+        return `fmt.Fprintln(os.Stderr, ${args.join(', ')})`;
+    },
+    'String': (_caller, args) => {
+        importedPackages.add('fmt');
+        return `fmt.Sprintf("%v", ${args[0]})`;
+    },
+    'Number': (_caller, args) => {
+        importedPackages.add('strconv');
+        return `func() float64 { v, _ := strconv.ParseFloat(fmt.Sprintf("%v", ${args[0]}), 64); return v }()`;
+    },
+    'Boolean': (_caller, args) => {
+        return `(${args[0]} != nil && ${args[0]} != false && ${args[0]} != 0 && ${args[0]} != "")`;
+    },
 };
 const stringMethodHandlers = {
     split: (obj, args) => {
@@ -1422,6 +2112,32 @@ const stringMethodHandlers = {
         return `${obj}[int(${args[0]}):]`;
     },
     concat: (obj, args) => `${obj} + ${args.join(' + ')}`,
+    padStart: (obj, args) => {
+        importedPackages.add('fmt');
+        importedPackages.add('strings');
+        const pad = args[1] ?? '" "';
+        return `func() string { __s := ${obj}; __n := int(${args[0]}) - len(__s); if __n > 0 { __s = strings.Repeat(${pad}, __n)[:__n] + __s }; return __s }()`;
+    },
+    padEnd: (obj, args) => {
+        importedPackages.add('strings');
+        const pad = args[1] ?? '" "';
+        return `func() string { __s := ${obj}; __n := int(${args[0]}) - len(__s); if __n > 0 { __s = __s + strings.Repeat(${pad}, __n)[:__n] }; return __s }()`;
+    },
+    match: (obj, args) => {
+        importedPackages.add('regexp');
+        return `regexp.MustCompile(${args[0]}).FindStringSubmatch(${obj})`;
+    },
+    matchAll: (obj, args) => {
+        importedPackages.add('regexp');
+        return `regexp.MustCompile(${args[0]}).FindAllStringSubmatch(${obj}, -1)`;
+    },
+    search: (obj, args) => {
+        importedPackages.add('regexp');
+        return `float64(regexp.MustCompile(${args[0]}).FindStringIndex(${obj})[0])`;
+    },
+    at: (obj, args) => {
+        return `func() string { __i := int(${args[0]}); if __i < 0 { __i = len(${obj}) + __i }; return string(${obj}[__i]) }()`;
+    },
     toString: (obj) => {
         importedPackages.add('fmt');
         return `fmt.Sprintf("%v", ${obj})`;
@@ -1433,6 +2149,13 @@ const regexpMethodHandlers = {
 };
 const arrayMethodHandlers = {
     push: (obj, args) => `${obj} = append(${obj}, ${args.join(', ')})`,
+    pop: (obj) => {
+        return `func() interface{} { if len(${obj}) == 0 { return nil }; __last := ${obj}[len(${obj})-1]; ${obj} = ${obj}[:len(${obj})-1]; return __last }()`;
+    },
+    shift: (obj) => {
+        return `func() interface{} { if len(${obj}) == 0 { return nil }; __first := ${obj}[0]; ${obj} = ${obj}[1:]; return __first }()`;
+    },
+    unshift: (obj, args) => `${obj} = append([]interface{}{${args.join(', ')}}, ${obj}...)`,
     join: (obj, args) => {
         importedPackages.add('strings');
         return `strings.Join(${obj}, ${args[0] ?? '""'})`;
@@ -1442,10 +2165,30 @@ const arrayMethodHandlers = {
             return `${obj}[int(${args[0]}):int(${args[1]})]`;
         return `${obj}[int(${args[0]}):]`;
     },
+    reverse: (obj) => {
+        importedPackages.add('slices');
+        return `func() interface{} { slices.Reverse(${obj}); return nil }()`;
+    },
+    sort: (obj) => {
+        importedPackages.add('sort');
+        return `func() interface{} { sort.Slice(${obj}, func(i, j int) bool { return fmt.Sprintf("%v", ${obj}[i]) < fmt.Sprintf("%v", ${obj}[j]) }); return nil }()`;
+    },
+    indexOf: (obj, args) => {
+        return `func() float64 { for __i, __v := range ${obj} { if fmt.Sprintf("%v", __v) == fmt.Sprintf("%v", ${args[0]}) { return float64(__i) } }; return float64(-1) }()`;
+    },
+    includes: (obj, args) => {
+        return `func() bool { for _, __v := range ${obj} { if fmt.Sprintf("%v", __v) == fmt.Sprintf("%v", ${args[0]}) { return true } }; return false }()`;
+    },
+    concat: (obj, args) => `append(${obj}, ${args.join(', ')}...)`,
+    flat: (obj) => obj,
     toString: (obj) => {
         importedPackages.add('fmt');
         return `fmt.Sprintf("%v", ${obj})`;
-    }
+    },
+    // padStart / padEnd for string arrays (rarely used, but added for completeness)
+    at: (obj, args) => {
+        return `func() interface{} { __i := int(${args[0]}); if __i < 0 { __i = len(${obj}) + __i }; if __i < 0 || __i >= len(${obj}) { return nil }; return ${obj}[__i] }()`;
+    },
 };
 const mapMethodHandlers = {
     set: (obj, args) => `${obj}[${args[0]}] = ${args[1]}`,
@@ -1517,7 +2260,9 @@ function getDynamicCallHandler(caller, objectType) {
     return null;
 }
 function getCallString(caller, args, typeArgs = '', objectType) {
-    const handler = callHandlers[caller] ?? getDynamicCallHandler(caller, objectType);
+    // Parentheses from casts like `(mod as any).fn(...)` are stripped for lookup
+    const handler = callHandlers[caller] ?? callHandlers[caller.replace(/[()]/g, '')] ??
+        getDynamicCallHandler(caller, objectType);
     if (handler) {
         return handler(caller, args, typeArgs);
     }
@@ -1525,17 +2270,17 @@ function getCallString(caller, args, typeArgs = '', objectType) {
 }
 function getOperatorText(operator) {
     switch (operator) {
-        case ts.SyntaxKind.PlusToken:
+        case 'PlusToken':
             return '+';
-        case ts.SyntaxKind.MinusToken:
+        case 'MinusToken':
             return '-';
-        case ts.SyntaxKind.TildeToken:
+        case 'TildeToken':
             return '~';
-        case ts.SyntaxKind.ExclamationToken:
+        case 'ExclamationToken':
             return '!';
-        case ts.SyntaxKind.PlusPlusToken:
+        case 'PlusPlusToken':
             return '++';
-        case ts.SyntaxKind.MinusMinusToken:
+        case 'MinusMinusToken':
             return '--';
         default:
             console.error('Did not find operator', operator);
@@ -1578,6 +2323,17 @@ function getTypeArguments(typeArguments) {
     return `[${args.join(', ')}]`;
 }
 function getParameterGoType(param) {
+    // Rest parameter: ...args — use variadic syntax
+    if (param.dotDotDotToken) {
+        if (param.type) {
+            let baseType = getType(param.type);
+            // If annotated as T[], the variadic type is T
+            if (baseType.startsWith('[]'))
+                baseType = baseType.slice(2);
+            return `...${baseType}`;
+        }
+        return '...interface{}';
+    }
     if (param.type) {
         const explicitType = getType(param.type);
         return explicitType === ':' ? 'interface{}' : explicitType;
@@ -1640,12 +2396,12 @@ function getSafeName(name) {
 function getPromiseChannelType(node) {
     let parent = node.parent;
     while (parent) {
-        if (ts.isFunctionDeclaration(parent) ||
-            ts.isMethodDeclaration(parent) ||
-            ts.isFunctionExpression(parent)) {
+        if (isFunctionDeclaration(parent) ||
+            isMethodDeclaration(parent) ||
+            isFunctionExpression(parent)) {
             if (parent.type &&
-                ts.isTypeReferenceNode(parent.type) &&
-                ts.isIdentifier(parent.type.typeName)) {
+                isTypeReferenceNode(parent.type) &&
+                isIdentifier(parent.type.typeName)) {
                 if (parent.type.typeName.text === 'Promise' &&
                     parent.type.typeArguments &&
                     parent.type.typeArguments.length > 0) {
@@ -1660,7 +2416,7 @@ function getPromiseChannelType(node) {
 }
 function visitPromiseReturn(node, options) {
     const callback = node.arguments?.[0];
-    if (!callback || (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback))) {
+    if (!callback || (!isArrowFunction(callback) && !isFunctionExpression(callback))) {
         return `return ${visit(node)}` + (options.inline ? '' : ';\n\t');
     }
     const channelType = getPromiseChannelType(node);
@@ -1668,14 +2424,14 @@ function visitPromiseReturn(node, options) {
     const resolveName = resolveParam ? visit(resolveParam.name) : '';
     const prevResolveName = promiseResolveName;
     promiseResolveName = resolveName;
-    const body = ts.isBlock(callback.body) ? visit(callback.body) : `{ ${visit(callback.body)} }`;
+    const body = isBlock(callback.body) ? visit(callback.body) : `{ ${visit(callback.body)} }`;
     promiseResolveName = prevResolveName;
     return (`ch := make(chan ${channelType})\n\t\tgo func() ${body.trimEnd()}()\n\t\treturn ch` +
         (options.inline ? '' : ';\n\t'));
 }
 function visitNewPromise(node) {
     const callback = node.arguments?.[0];
-    if (!callback || (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback))) {
+    if (!callback || (!isArrowFunction(callback) && !isFunctionExpression(callback))) {
         return 'NewPromise()';
     }
     const channelType = getPromiseChannelType(node);
@@ -1683,7 +2439,7 @@ function visitNewPromise(node) {
     const resolveName = resolveParam ? visit(resolveParam.name) : '';
     const prevResolveName = promiseResolveName;
     promiseResolveName = resolveName;
-    const body = ts.isBlock(callback.body) ? visit(callback.body) : `{ ${visit(callback.body)} }`;
+    const body = isBlock(callback.body) ? visit(callback.body) : `{ ${visit(callback.body)} }`;
     promiseResolveName = prevResolveName;
     return `func() chan ${channelType} {\n\t\tch := make(chan ${channelType})\n\t\tgo func() ${body.trimEnd()}()\n\t\treturn ch;\n\t}()`;
 }
@@ -1706,19 +2462,19 @@ function extractMapValueType(mapType) {
 function visitNewMap(node) {
     let keyType = 'interface{}';
     let valueType = 'interface{}';
-    if (node.typeArguments && node.typeArguments.length === 2) {
-        keyType = getType(node.typeArguments[0]);
-        valueType = getType(node.typeArguments[1]);
+    if ((node.typeArguments ?? []) && (node.typeArguments ?? []).length === 2) {
+        keyType = getType((node.typeArguments ?? [])[0]);
+        valueType = getType((node.typeArguments ?? [])[1]);
     }
     const mapType = `map[${keyType}]${valueType}`;
-    const args = node.arguments;
-    if (!args || args.length === 0 || !ts.isArrayLiteralExpression(args[0])) {
+    const args = (node.arguments ?? []);
+    if (!args || args.length === 0 || !isArrayLiteralExpression(args[0])) {
         return `make(${mapType})`;
     }
     const initArg = args[0];
     const tmp = getTempName('map');
     const entries = initArg.elements
-        .filter((el) => ts.isArrayLiteralExpression(el) && el.elements.length >= 2)
+        .filter((el) => isArrayLiteralExpression(el) && el.elements.length >= 2)
         .map((el) => {
         const pair = el;
         return `${tmp}[${visit(pair.elements[0])}] = ${visit(pair.elements[1])}`;
@@ -1728,12 +2484,12 @@ function visitNewMap(node) {
 }
 function visitNewSet(node) {
     let elementType = 'interface{}';
-    if (node.typeArguments && node.typeArguments.length === 1) {
-        elementType = getType(node.typeArguments[0]);
+    if ((node.typeArguments ?? []) && (node.typeArguments ?? []).length === 1) {
+        elementType = getType((node.typeArguments ?? [])[0]);
     }
     const setType = `map[${elementType}]struct{}`;
-    const args = node.arguments;
-    if (!args || args.length === 0 || !ts.isArrayLiteralExpression(args[0])) {
+    const args = (node.arguments ?? []);
+    if (!args || args.length === 0 || !isArrayLiteralExpression(args[0])) {
         return `make(${setType})`;
     }
     const initArg = args[0];
@@ -1774,28 +2530,45 @@ function includeLocalImport(code, dir, goFileName) {
     }
     if (!goFileName) {
         // Inline mode (npm packages): pull declarations into the current transpilation context
-        const sf = ts.createSourceFile('imported.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+        const sf = parseFunction(code);
         for (const stmt of sf.statements) {
             visit(stmt, { addFunctionOutside: true });
         }
         currentFileDir = prevDir;
         return;
     }
-    // Separate-file mode (local TS imports): transpile to its own Go file
+    // Separate-file mode (local TS imports): transpile to its own Go file.
+    // Helper functions are NOT emitted per-file: every generated file shares
+    // `package main`, so helpers are emitted once in the main output file.
     const savedOutsideNodes = outsideNodes;
     const savedPackages = [...importedPackages];
     outsideNodes = [];
     importedPackages.clear();
-    const sf = ts.createSourceFile('imported.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    helperProvidedPackages.clear();
+    const sf = parseFunction(code);
     const inlineLines = [];
     for (const stmt of sf.statements) {
         const result = visit(stmt, { addFunctionOutside: true });
         if (result.trim())
             inlineLines.push(result);
     }
-    const fileImports = [...importedPackages].map((pkg) => `import "${pkg}"`).join('\n');
     const fileOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
     const fileInline = inlineLines.join('\n');
+    // Computed after all visits: function bodies (outside nodes) register
+    // packages too, and imports must be captured after those visits.
+    // Helper-provided packages are only imported here if the file's own code
+    // references them; the main file (which carries the helper sources)
+    // always imports them.
+    const fileCode = `${fileInline}\n${fileOutside}`;
+    const fileImports = [...importedPackages]
+        .filter((pkg) => {
+        if (!helperProvidedPackages.has(pkg))
+            return true;
+        const name = pkg.split('/').pop();
+        return fileCode.includes(`${name}.`);
+    })
+        .map((pkg) => `import "${pkg}"`)
+        .join('\n');
     const parts = ['package main'];
     if (fileImports)
         parts.push(fileImports);
@@ -1804,11 +2577,14 @@ function includeLocalImport(code, dir, goFileName) {
     if (fileOutside.trim())
         parts.push(fileOutside.trim());
     localImportFiles.set(goFileName, parts.join('\n\n'));
-    // Restore main-file state
+    // Restore main-file state; helper-provided packages carry over so the main
+    // file (which carries the helper sources) imports them.
     outsideNodes = savedOutsideNodes;
     importedPackages.clear();
     for (const p of savedPackages)
         importedPackages.add(p);
+    for (const p of helperProvidedPackages)
+        importedPackages.add(p);
     currentFileDir = prevDir;
 }
 function registerGoPackageAliases(node, goPkg) {
@@ -1821,14 +2597,14 @@ function registerGoPackageAliases(node, goPkg) {
         importAliases.set(clause.name.text, pkgName);
     }
     if (clause.namedBindings) {
-        if (ts.isNamespaceImport(clause.namedBindings)) {
+        if (isNamespaceImport(clause.namedBindings)) {
             // `import * as myFmt from 'go:fmt'`
             const localName = clause.namedBindings.name.text;
             if (localName !== pkgName) {
                 importAliases.set(localName, pkgName);
             }
         }
-        else if (ts.isNamedImports(clause.namedBindings)) {
+        else if (isNamedImports(clause.namedBindings)) {
             // `import { Println, Sprintf as Spf } from 'go:fmt'`
             for (const el of clause.namedBindings.elements) {
                 if (el.isTypeOnly)
@@ -1847,7 +2623,7 @@ function getImportLocalName(node) {
     if (clause.name)
         return clause.name.text;
     if (clause.namedBindings) {
-        if (ts.isNamespaceImport(clause.namedBindings))
+        if (isNamespaceImport(clause.namedBindings))
             return clause.namedBindings.name.text;
     }
     return null;
@@ -1856,34 +2632,375 @@ function getImportLocalName(node) {
 // For default/namespace imports (e.g. `import path from 'node:path'`), entries are registered
 // as `callHandlers[localName.funcName]`. For named imports (e.g. `import { join } from 'node:path'`),
 // the Go identifier is stored in importAliases so bare calls like `join(...)` resolve correctly.
+// Each emitter registers the Go packages it needs via `needPkg` only when actually used,
+// because Go rejects unused imports.
+function needPkg(pkg) {
+    importedPackages.add(pkg);
+}
+// Marks a Go helper as used; also registers the packages the helper needs,
+// since the import list is serialized before helpers are emitted.
+function useHelper(id) {
+    if (usedHelpers.has(id))
+        return;
+    usedHelpers.add(id);
+    for (const pkg of helperPackages[id] ?? []) {
+        importedPackages.add(pkg);
+        helperProvidedPackages.add(pkg);
+    }
+}
 const nodeModuleMappings = {
     path: {
-        goPackage: 'path/filepath',
         functions: {
-            join: (args) => `filepath.Join(${args.join(', ')})`,
-            dirname: (args) => `filepath.Dir(${args[0]})`,
-            basename: (args) => args[1]
-                ? `strings.TrimSuffix(filepath.Base(${args[0]}), ${args[1]})`
-                : `filepath.Base(${args[0]})`,
-            extname: (args) => `filepath.Ext(${args[0]})`,
-            resolve: (args) => `func() string { p, _ := filepath.Abs(filepath.Join(${args.join(', ')})); return p }()`
-        }
-    }
-    // Future node stdlib modules can be added here as additional keys:
-    // fs: { goPackage: 'os', functions: { ... } },
-    // os: { goPackage: 'os', functions: { ... } },
+            join: (args) => {
+                needPkg('path/filepath');
+                return `filepath.Join(${args.join(', ')})`;
+            },
+            dirname: (args) => {
+                needPkg('path/filepath');
+                return `filepath.Dir(${args[0]})`;
+            },
+            basename: (args) => {
+                needPkg('path/filepath');
+                if (args[1]) {
+                    needPkg('strings');
+                    return `strings.TrimSuffix(filepath.Base(${args[0]}), ${args[1]})`;
+                }
+                return `filepath.Base(${args[0]})`;
+            },
+            extname: (args) => {
+                needPkg('path/filepath');
+                return `filepath.Ext(${args[0]})`;
+            },
+            resolve: (args) => {
+                needPkg('path/filepath');
+                return `func() string { p, _ := filepath.Abs(filepath.Join(${args.join(', ')})); return p }()`;
+            }
+        }
+    },
+    fs: {
+        functions: {
+            readFileSync: (args) => {
+                useHelper('readFile');
+                return `TnReadFile(${args[0]})`;
+            },
+            writeFileSync: (args) => {
+                useHelper('writeFile');
+                return `TnWriteFile(${args[0]}, ${args[1]})`;
+            },
+            appendFileSync: (args) => {
+                useHelper('appendFile');
+                return `TnAppendFile(${args[0]}, ${args[1]})`;
+            },
+            existsSync: (args) => {
+                needPkg('os');
+                return `func() bool { _, err := os.Stat(${args[0]}); return !os.IsNotExist(err) }()`;
+            },
+            mkdirSync: (args) => {
+                useHelper('mkdirAll');
+                return `TnMkdirAll(${args[0]})`;
+            },
+            readdirSync: (args) => {
+                useHelper('readDir');
+                return `TnReadDir(${args[0]})`;
+            },
+            copyFileSync: (args) => {
+                useHelper('copyFile');
+                return `TnCopyFile(${args[0]}, ${args[1]})`;
+            },
+            rmSync: (args) => {
+                useHelper('removeAll');
+                return `TnRemoveAll(${args[0]})`;
+            }
+        }
+    },
+    url: {
+        functions: {
+            fileURLToPath: (args) => {
+                useHelper('fileURLToPath');
+                return `TnFileURLToPath(${args[0]})`;
+            },
+            pathToFileURL: (args) => {
+                useHelper('pathToFileURL');
+                return `TnPathToFileURL(${args[0]})`;
+            }
+        }
+    },
+    os: {
+        functions: {
+            platform: () => {
+                useHelper('osPlatform');
+                return 'TnOsPlatform()';
+            },
+            homedir: () => {
+                needPkg('os');
+                return `func() string { h, _ := os.UserHomeDir(); return h }()`;
+            },
+            tmpdir: () => {
+                needPkg('os');
+                return 'os.TempDir()';
+            }
+        }
+    },
+    child_process: {
+        functions: {
+            // exec(command) — run through the shell, returns { stdout, stderr, status }
+            exec: (args) => {
+                useHelper('exec');
+                return `TnExecShell(${args[0]})`;
+            },
+            // execSync(command) — run through the shell, returns stdout (panics on failure)
+            execSync: (args) => {
+                useHelper('exec');
+                useHelper('execSync');
+                return `TnExecShellSync(${args[0]})`;
+            },
+            // spawnSync(file, args, options) — matches Node's sync API.
+            // options with `inherit` → run with the parent's stdio (returns exit code);
+            // otherwise output is captured. Fields match Node: stdout/stderr/status.
+            spawnSync: (args) => {
+                useHelper('exec');
+                useHelper('runInherit');
+                if (args[2]?.includes('inherit')) {
+                    return `TnRunInherit(${args[0]})`;
+                }
+                // Untyped array literals visit as `[] {…}` — give them the []string
+                // type the variadic helper needs (`[]string{…}...` is valid Go spread)
+                const arrArg = args[1] ?? '[]string{}';
+                const typedArg = arrArg.startsWith('[]') && !arrArg.startsWith('[]string')
+                    ? `[]string ${arrArg.slice(2)}`
+                    : arrArg;
+                if (args[2]?.includes('input')) {
+                    // {input: expr, ...} → run with expr as stdin
+                    useHelper('execInput');
+                    const m = /input:\s*([^,}]+)/.exec(args[2]);
+                    const inputExpr = m ? m[1] : '""';
+                    return `TnExecInput(${args[0]}, ${inputExpr}, ${typedArg}...)`;
+                }
+                return `TnExec(${args[0]}, ${typedArg}...)`;
+            }
+        }
+    },
+    readline: {
+        functions: {
+            // question(prompt) — print prompt and read one line from stdin (synchronous)
+            question: (args) => {
+                useHelper('question');
+                return `TnQuestion(${args[0] ?? '""'})`;
+            }
+        }
+    }
 };
+// Go packages required by each helper, registered when the helper is used.
+const helperPackages = {
+    readFile: ['os'],
+    writeFile: ['os'],
+    appendFile: ['os'],
+    mkdirAll: ['os'],
+    readDir: ['os'],
+    copyFile: ['os', 'io', 'path/filepath'],
+    removeAll: ['os'],
+    fileURLToPath: ['net/url', 'path/filepath', 'strings'],
+    pathToFileURL: ['net/url', 'path/filepath'],
+    osPlatform: ['runtime'],
+    exec: ['os/exec', 'bytes', 'runtime'],
+    execSync: ['os/exec', 'bytes', 'runtime'],
+    runInherit: ['os/exec', 'os'],
+    question: ['bufio', 'fmt', 'os', 'strings'],
+    getenv: ['os'],
+    execInput: ['os/exec', 'bytes', 'strings']
+};
+// Go helper sources emitted (once) into the main output file when used.
+// Field names are intentionally lowercase: every generated file is `package main`,
+// so `result.stdout` in emitted code resolves to the struct field directly.
+const goHelpers = {
+    readFile: `func TnReadFile(path string) string {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return string(data)
+}`,
+    writeFile: `func TnWriteFile(path string, content string) {
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		panic(err)
+	}
+}`,
+    appendFile: `func TnAppendFile(path string, content string) {
+	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	if _, err := f.WriteString(content); err != nil {
+		panic(err)
+	}
+}`,
+    mkdirAll: `func TnMkdirAll(path string) {
+	if err := os.MkdirAll(path, 0o755); err != nil {
+		panic(err)
+	}
+}`,
+    readDir: `func TnReadDir(path string) []string {
+	entries, err := os.ReadDir(path)
+	if err != nil {
+		panic(err)
+	}
+	names := make([]string, 0, len(entries))
+	for _, e := range entries {
+		names = append(names, e.Name())
+	}
+	return names
+}`,
+    copyFile: `func TnCopyFile(src string, dst string) {
+	in, err := os.Open(src)
+	if err != nil {
+		panic(err)
+	}
+	defer in.Close()
+	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
+		panic(err)
+	}
+	out, err := os.Create(dst)
+	if err != nil {
+		panic(err)
+	}
+	defer out.Close()
+	if _, err := io.Copy(out, in); err != nil {
+		panic(err)
+	}
+}`,
+    removeAll: `func TnRemoveAll(path string) {
+	if err := os.RemoveAll(path); err != nil {
+		panic(err)
+	}
+}`,
+    fileURLToPath: `func TnFileURLToPath(u string) string {
+	trimmed := strings.TrimPrefix(u, "file://")
+	if unescaped, err := url.PathUnescape(trimmed); err == nil {
+		trimmed = unescaped
+	}
+	return filepath.FromSlash(trimmed)
+}`,
+    pathToFileURL: `func TnPathToFileURL(path string) string {
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		panic(err)
+	}
+	return "file://" + url.PathEscape(filepath.ToSlash(abs))
+}`,
+    osPlatform: `func TnOsPlatform() string {
+	if runtime.GOOS == "windows" {
+		return "win32"
+	}
+	if runtime.GOOS == "darwin" {
+		return "darwin"
+	}
+	return runtime.GOOS
+}`,
+    exec: `type tnExecResult struct {
+	stdout   string
+	stderr   string
+	status   float64
+}
+
+func TnExec(name string, args ...string) tnExecResult {
+	cmd := exec.Command(name, args...)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	status := 0.0
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			status = float64(exitErr.ExitCode())
+		} else {
+			panic(err)
+		}
+	}
+	return tnExecResult{stdout: stdout.String(), stderr: stderr.String(), status: status}
+}
+
+func TnExecShell(command string) tnExecResult {
+	if runtime.GOOS == "windows" {
+		return TnExec("cmd", "/C", command)
+	}
+	return TnExec("sh", "-c", command)
+}`,
+    execSync: `func TnExecShellSync(command string) string {
+	result := TnExecShell(command)
+	if result.status != 0 {
+		panic(result.stderr)
+	}
+	return result.stdout
+}`,
+    getenv: `func TnGetenv(name string) string {
+	return os.Getenv(name)
+}`,
+    execInput: `func TnExecInput(name string, input string, args ...string) tnExecResult {
+	cmd := exec.Command(name, args...)
+	cmd.Stdin = strings.NewReader(input)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	status := 0.0
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			status = float64(exitErr.ExitCode())
+		} else {
+			panic(err)
+		}
+	}
+	return tnExecResult{stdout: stdout.String(), stderr: stderr.String(), status: status}
+}`,
+    runInherit: `func TnRunInherit(name string, args ...string) float64 {
+	cmd := exec.Command(name, args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err := cmd.Run()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			return float64(exitErr.ExitCode())
+		}
+		panic(err)
+	}
+	return 0
+}`,
+    question: `var tnStdinReader = bufio.NewReader(os.Stdin)
+
+func TnQuestion(prompt string) string {
+	if prompt != "" {
+		fmt.Print(prompt)
+	}
+	// Reuse one buffered reader: a fresh reader per call would discard
+	// buffered stdin and hit EOF on the second question.
+	line, err := tnStdinReader.ReadString('\\n')
+	if err != nil && line == "" {
+		panic(err)
+	}
+	return strings.TrimRight(line, "\\r\\n")
+}`
+};
+// Returns the Go source for all helpers used in this transpilation, or '' if none.
+// Emitted only into the main output file: every generated file shares `package main`,
+// so helpers are visible across files and must not be duplicated.
+function emitGoHelpers() {
+    return [...usedHelpers]
+        .map((id) => goHelpers[id])
+        .filter(Boolean)
+        .join('\n\n');
+}
 // Mapping from Node.js stdlib module names to Go setup functions.
 // Each entry adds the required Go imports and registers call handlers for the local identifier.
 function setupNodeModuleImport(node, nodeModule) {
     const mapping = nodeModuleMappings[nodeModule];
     if (!mapping)
         return;
-    importedPackages.add(mapping.goPackage);
     const clause = node.importClause;
     if (!clause)
         return;
-    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && isNamedImports(clause.namedBindings)) {
         // Named imports: `import { join, dirname } from 'node:path'`
         // Map each local name directly to its Go qualified function via importAliases,
         // so bare calls like `join(...)` resolve to `filepath.Join(...)`.
@@ -1909,7 +3026,7 @@ function setupNodeModuleImport(node, nodeModule) {
     }
 }
 function visitImportDeclaration(node) {
-    if (!ts.isStringLiteral(node.moduleSpecifier))
+    if (!isStringLiteral(node.moduleSpecifier))
         return '';
     const moduleSpec = node.moduleSpecifier.text;
     // Relative imports → transpile to a separate Go file
@@ -1952,16 +3069,27 @@ function visitImportDeclaration(node) {
             includeLocalImport(resolved.content, resolved.dir, goFileName);
         }
     }
+    // Register default/namespace import name as a "stripped" namespace
+    // e.g. `import ts from 'typescript'` → ts.createSourceFile → createSourceFile
+    if (node.importClause) {
+        const clause = node.importClause;
+        if (clause.name) {
+            defaultImportNamespaces.add(clause.name.text);
+        }
+        else if (clause.namedBindings && isNamespaceImport(clause.namedBindings)) {
+            defaultImportNamespaces.add(clause.namedBindings.name.text);
+        }
+    }
     return '';
 }
 function getForOfVarNames(initializer) {
-    if (!ts.isVariableDeclarationList(initializer) || initializer.declarations.length === 0) {
+    if (!isVariableDeclarationList(initializer) || initializer.declarations.length === 0) {
         return ['_'];
     }
     const decl = initializer.declarations[0];
-    if (ts.isArrayBindingPattern(decl.name)) {
+    if (isArrayBindingPattern(decl.name)) {
         return decl.name.elements.map((el) => {
-            if (ts.isOmittedExpression(el))
+            if (isOmittedExpression(el))
                 return '_';
             return visit(el.name);
         });
@@ -1972,17 +3100,17 @@ function visitTryStatement(node, options) {
     const deferreds = [];
     // Register finally first (LIFO: runs last after catch)
     if (node.finallyBlock) {
-        const finallyBody = node.finallyBlock.statements.map((s) => visit(s)).join('\t');
+        const finallyBody = (node.finallyBlock.statements ?? []).map((s) => visit(s)).join('\t');
         deferreds.push(`defer func() {\n\t\t\t${finallyBody}\t\t\t}()`);
     }
     // Register catch second (LIFO: runs first, handles panic via recover)
     if (node.catchClause) {
         const varDecl = node.catchClause.variableDeclaration;
         const catchVar = varDecl ? visit(varDecl.name) : '_r';
-        const catchBody = node.catchClause.block.statements.map((s) => visit(s)).join('\t');
+        const catchBody = (node.catchClause.block.statements ?? []).map((s) => visit(s)).join('\t');
         deferreds.push(`defer func() {\n\t\t\tif r := recover(); r != nil {\n\t\t\t\t${catchVar} := r\n\t\t\t\t_ = ${catchVar}\n\t\t\t\t${catchBody}\t\t\t}\n\t\t\t}()`);
     }
-    const tryBody = node.tryBlock.statements.map((s) => visit(s)).join('\t');
+    const tryBody = (node.tryBlock.statements ?? []).map((s) => visit(s)).join('\t');
     const body = [...deferreds, tryBody].join('\n\t\t\t');
     return `func() {\n\t\t\t${body}\n\t\t\t}()` + (options.inline ? '' : ';\n\t');
 }