typenative 0.0.21 → 0.1.0

package/bin/transpiler.js

@@ -9,7 +9,7 @@ function isArrayLiteralExpression(n) {
     return n?.kind === 'ArrayLiteralExpression';
 }
 function isArrayTypeNode(n) {
-    return n?.kind === 'ArrayTypeNode';
+    return n?.kind === 'ArrayType';
 }
 function isArrowFunction(n) {
     return n?.kind === 'ArrowFunction';
@@ -45,7 +45,7 @@ function isConditionalExpression(n) {
     return n?.kind === 'ConditionalExpression';
 }
 function isConstructorDeclaration(n) {
-    return n?.kind === 'ConstructorDeclaration';
+    return n?.kind === 'Constructor';
 }
 function isDefaultClause(n) {
     return n?.kind === 'DefaultClause';
@@ -84,7 +84,7 @@ function isFunctionExpression(n) {
     return n?.kind === 'FunctionExpression';
 }
 function isFunctionTypeNode(n) {
-    return n?.kind === 'FunctionTypeNode';
+    return n?.kind === 'FunctionType';
 }
 function isGetAccessor(n) {
     return n?.kind === 'GetAccessor';
@@ -102,7 +102,7 @@ function isInterfaceDeclaration(n) {
     return n?.kind === 'InterfaceDeclaration';
 }
 function isLiteralTypeNode(n) {
-    return n?.kind === 'LiteralTypeNode';
+    return n?.kind === 'LiteralType';
 }
 function isMethodDeclaration(n) {
     return n?.kind === 'MethodDeclaration';
@@ -198,10 +198,10 @@ function isTypeAssertionExpression(n) {
     return n?.kind === 'TypeAssertionExpression';
 }
 function isTypeReferenceNode(n) {
-    return n?.kind === 'TypeReferenceNode';
+    return n?.kind === 'TypeReference';
 }
 function isUnionTypeNode(n) {
-    return n?.kind === 'UnionTypeNode';
+    return n?.kind === 'UnionType';
 }
 function isVariableDeclaration(n) {
     return n?.kind === 'VariableDeclaration';
@@ -250,6 +250,15 @@ function goSafeId() {
     return id;
 }
 let parseFunction;
+// Declarations of every parsed file, collected before visiting (functions are
+// hoisted, so call sites may precede them) for contextual typing
+const declaredFunctions = new Map();
+const declaredInterfaces = new Map();
+const declaredTypeAliases = new Map();
+// Package-level declarations of the main file's top-level variables
+const mainPackageVariables = [];
+// True while emitting a separate Go file, whose top-level statements sit at package scope
+let emittingModuleFile = false;
 const importedPackages = new Set();
 let outsideNodes = [];
 const classNames = new Set();
@@ -265,6 +274,21 @@ const dangerousNames = new Set([
     'select', 'struct', 'switch', 'type', 'var',
 ]);
 const renamedFunctions = new Map();
+// Go type of the receiver of the method call being emitted (for method handlers)
+let currentReceiverGoType;
+// Struct field / member names: Go keywords get a trailing underscore
+function goFieldName(name) {
+    return name !== 'main' && dangerousNames.has(name) ? `${name}_` : name;
+}
+function isFieldNameIdentifier(node) {
+    const parent = node.parent;
+    if (!parent || parent.name !== node)
+        return false;
+    return (isPropertyAccessExpression(parent) ||
+        isPropertyAssignment(parent) ||
+        isPropertySignature(parent) ||
+        isPropertyDeclaration(parent));
+}
 const variableTypes = new Map();
 const variableGoTypes = new Map();
 const variableClassNames = new Map();
@@ -329,7 +353,44 @@ function operatorTokenText(token) {
 function defaultParseFunction(_code) {
     throw new Error('transpileToNative: no parse function injected (options.parse)');
 }
+// Parses via the injected parser and links each node to its parent: the JSON
+// AST carries no parent pointers, but the transpiler walks up via node.parent.
+function parseSource(code) {
+    const sourceFile = parseFunction(code);
+    linkParents(sourceFile, undefined);
+    for (const stmt of sourceFile.statements ?? []) {
+        if (!stmt.name || !isIdentifier(stmt.name))
+            continue;
+        if (isFunctionDeclaration(stmt))
+            declaredFunctions.set(stmt.name.text, stmt);
+        else if (isInterfaceDeclaration(stmt))
+            declaredInterfaces.set(stmt.name.text, stmt);
+        else if (isTypeAliasDeclaration(stmt))
+            declaredTypeAliases.set(stmt.name.text, stmt.type);
+    }
+    return sourceFile;
+}
+function linkParents(node, parent) {
+    node.parent = parent;
+    for (const key of Object.keys(node)) {
+        if (key === 'parent')
+            continue;
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const child of value) {
+                if (child && typeof child === 'object' && child.kind)
+                    linkParents(child, node);
+            }
+        }
+        else if (value && typeof value === 'object' && value.kind) {
+            linkParents(value, node);
+        }
+    }
+}
 // Renders a type node's source text syntactically (no typechecker needed).
+function isAnyTypeNode(n) {
+    return n?.kind === 'AnyKeyword' || n?.kind === 'UnknownKeyword';
+}
 function typeNodeToText(node) {
     if (!node)
         return 'any';
@@ -349,13 +410,13 @@ function typeNodeToText(node) {
     };
     if (keywordMap[node.kind])
         return keywordMap[node.kind];
-    if (node.kind === 'TypeReferenceNode' && node.typeName) {
+    if (node.kind === 'TypeReference' && node.typeName) {
         return typeNodeToText(node.typeName);
     }
     if (node.kind === 'Identifier')
         return node.text;
-    if (node.kind === 'ArrayTypeNode' && node.elementType) {
-        return `${'{'}${''}}typeNodeToText(node.elementType)[]`;
+    if (node.kind === 'ArrayType' && node.elementType) {
+        return `${typeNodeToText(node.elementType)}[]`;
     }
     return 'any';
 }
@@ -363,7 +424,7 @@ function typeNodeToText(node) {
 function childNodes(node) {
     const out = [];
     for (const key of Object.keys(node ?? {})) {
-        if (key === 'kind' || key === 'text')
+        if (key === 'kind' || key === 'text' || key === 'parent')
             continue;
         const v = node[key];
         if (v && typeof v === 'object' && typeof v.kind === 'string') {
@@ -391,8 +452,14 @@ const helperProvidedPackages = new Set();
 export function transpileToNative(code, options) {
     fileResolver = options?.readFile ?? null;
     parseFunction = options?.parse ?? defaultParseFunction;
+    declaredFunctions.clear();
+    declaredInterfaces.clear();
+    declaredTypeAliases.clear();
+    variableTypeNodes.clear();
+    narrowedVariables.clear();
+    nodeCallResultTypes.clear();
     currentFileDir = null;
-    const sourceFile = parseFunction(code);
+    const sourceFile = parseSource(code);
     importedPackages.clear();
     outsideNodes = [];
     classNames.clear();
@@ -415,11 +482,14 @@ export function transpileToNative(code, options) {
     classStaticProps.clear();
     usedHelpers.clear();
     helperProvidedPackages.clear();
+    mainPackageVariables.length = 0;
     const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
     const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
     const main = `package main
 
-${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
+${[...importedPackages].sort().map((pkg) => `import "${pkg}"`).join('\n')}
+
+${mainPackageVariables.join('\n')}
 
 func main() {
     ${transpiledCode.trim()}
@@ -431,6 +501,13 @@ ${emitGoHelpers()}`.trimEnd();
 }
 export function visit(node, options = {}) {
     let code = '';
+    // Reads of a narrowed nullable property path dereference it
+    if (narrowedVariables.size > 0 && isPropertyAccessExpression(node) && !options.skipNarrowing) {
+        const key = getNarrowingKey(node);
+        if (key && narrowedVariables.has(key) && isNarrowableReference(node)) {
+            return `(*${visit(node, { ...options, skipNarrowing: true })})`;
+        }
+    }
     if (isSourceFile(node)) {
         return (node.statements ?? [])
             .map((n) => visit(n, { addFunctionOutside: true }))
@@ -438,18 +515,34 @@ export function visit(node, options = {}) {
             .join(options.inline ? '' : '\n\t');
     }
     else if (isIdentifier(node)) {
+        if (isFieldNameIdentifier(node))
+            return goFieldName(node.text);
+        if (node.text === 'Boolean' && isCallExpression(node.parent) && node.parent.arguments?.[0] === node) {
+            const receiver = isPropertyAccessExpression(node.parent.expression)
+                ? inferExpressionType(node.parent.expression.expression)
+                : undefined;
+            const elementType = receiver?.startsWith('[]') ? receiver.slice(2) : 'interface{}';
+            return `func(__v ${elementType}) bool { return ${truthinessCheck('__v', elementType)} }`;
+        }
         if (node.text === 'undefined')
             return 'nil';
+        if (node.text === 'NaN' || node.text === 'Infinity') {
+            importedPackages.add('math');
+            return node.text === 'NaN' ? 'math.NaN()' : 'math.Inf(1)';
+        }
         const goAlias = importAliases.get(node.text);
         if (goAlias)
             return goAlias;
+        if (narrowedVariables.has(node.text) && isNarrowableReference(node)) {
+            return `(*${getSafeName(node.text)})`;
+        }
         return getSafeName(node.text);
     }
     else if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
         return toGoStringLiteral(node.text);
     }
     else if (isAsExpression(node)) {
-        return visit(node.expression);
+        return toGoValueOfType(node.expression, getAsExpressionType(node));
     }
     else if (isTypeAssertionExpression(node)) {
         return visit(node.expression);
@@ -480,7 +573,7 @@ export function visit(node, options = {}) {
         return `regexp.MustCompile("${goFlags}${escaped}")`;
     }
     else if (isArrayLiteralExpression(node)) {
-        const type = isVariableDeclaration(node.parent) ? getType(node.parent.type, true) : '';
+        const type = getArrayLiteralElementType(node);
         const hasSpread = (node.elements ?? []).some((e) => isSpreadElement(e));
         if (hasSpread) {
             return visitSpreadArrayLiteral(node, type);
@@ -488,17 +581,50 @@ export function visit(node, options = {}) {
         return `[]${type} {${(node.elements ?? []).map((e) => visit(e)).join(', ')}}`;
     }
     else if (isBlock(node)) {
-        return `{\n\t\t${options.prefixBlockContent ?? ''}${(node.statements ?? [])
-            .map((n) => visit(n))
-            .join('\t')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
+        return `{\n\t\t${options.prefixBlockContent ?? ''}${visitBlockStatements(node.statements ?? [])}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
     }
     else if (isElementAccessExpression(node)) {
         if (hasQuestionDot(node)) {
             return visitOptionalElementAccess(node);
         }
+        if (isDynamicValue(node.expression)) {
+            useHelper('dynamic');
+            return `TnIndex(${visit(node.expression)}, ${visit(node.argumentExpression)})`;
+        }
+        // process.env['X'] → TnGetenv("X")
+        if (isProcessEnv(node.expression)) {
+            useHelper('getenv');
+            return `TnGetenv(${visit(node.argumentExpression)})`;
+        }
+        // Maps (Record/Map) and string keys index directly; arrays/strings need an int index
+        const targetType = inferExpressionType(node.expression);
+        if (targetType === 'string') {
+            // s[i] in JS is a one-character string ("" when out of range)
+            useHelper('dynamic');
+            return `TnCharAt(${visit(node.expression)}, ${visit(node.argumentExpression)})`;
+        }
+        if (targetType?.startsWith('*TnMap[')) {
+            return `${visit(node.expression)}.Get(${toGoValueOfType(node.argumentExpression, extractMapKeyType(targetType))})`;
+        }
+        if (isStringLiteral(node.argumentExpression)) {
+            return `${visit(node.expression)}[${visit(node.argumentExpression)}]`;
+        }
+        // Reading past the end of an array gives undefined in JS: the zero value here
+        if (targetType?.startsWith('[]') && !isAssignmentTarget(node)) {
+            useHelper('dynamic');
+            return `TnAt(${visit(node.expression)}, ${visit(node.argumentExpression)})`;
+        }
         return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
     }
     else if (isPropertyAccessExpression(node)) {
+        if (isDynamicValue(node.expression) && node.name.text === 'length' && !isCallee(node)) {
+            useHelper('dynamic');
+            return `TnLength(${visit(node.expression)})`;
+        }
+        if (isDynamicValue(node.expression) && !isCallee(node) && !isProcessEnv(node.expression)) {
+            useHelper('dynamic');
+            return `TnGet(${visit(node.expression)}, "${node.name.text}")`;
+        }
         if (hasQuestionDot(node)) {
             return visitOptionalPropertyAccess(node);
         }
@@ -538,7 +664,9 @@ export function visit(node, options = {}) {
         }
         // Array destructuring: const [a, b] = arr
         if (isArrayBindingPattern(node.name) && node.initializer) {
-            const initExpr = visit(node.initializer);
+            const initExpr = isDynamicValue(node.initializer)
+                ? toGoValueOfType(node.initializer, '[]interface{}')
+                : visit(node.initializer);
             const tmpVar = getTempName('arr');
             const parts = [`${tmpVar} := ${initExpr}`];
             node.name.elements.forEach((el, idx) => {
@@ -556,12 +684,31 @@ export function visit(node, options = {}) {
             });
             return parts.join(';\n\t');
         }
-        const type = getType(node.type);
+        // `const x: any = expr` keeps inference (x := expr); `any` elsewhere is interface{}
+        const isInferredAny = isAnyTypeNode(node.type) && !!node.initializer;
+        const type = isInferredAny ? ':' : getType(node.type);
         // Track variable type for type-aware method dispatch
         if (isIdentifier(node.name)) {
-            if (node.type) {
+            // A declaration replaces whatever an earlier variable of the same name recorded
+            const inferredType = node.initializer && (!node.type || isInferredAny)
+                ? inferExpressionType(node.initializer)
+                : undefined;
+            variableTypes.delete(node.name.text);
+            variableClassNames.delete(node.name.text);
+            narrowedVariables.delete(node.name.text);
+            if (node.type && !isInferredAny)
+                variableTypeNodes.set(node.name.text, node.type);
+            else
+                variableTypeNodes.delete(node.name.text);
+            if (node.type && !isInferredAny) {
                 variableGoTypes.set(node.name.text, getType(node.type));
             }
+            else if (inferredType) {
+                variableGoTypes.set(node.name.text, inferredType);
+            }
+            else {
+                variableGoTypes.delete(node.name.text);
+            }
             const cat = node.type ? getTypeCategory(node.type) : undefined;
             if (cat) {
                 variableTypes.set(node.name.text, cat);
@@ -586,22 +733,25 @@ export function visit(node, options = {}) {
             else if (node.initializer && isRegularExpressionLiteral(node.initializer)) {
                 variableTypes.set(node.name.text, 'RegExp');
             }
-            if (!variableGoTypes.has(node.name.text) && node.initializer) {
-                const inferredType = inferExpressionType(node.initializer);
-                if (inferredType) {
-                    variableGoTypes.set(node.name.text, inferredType);
-                }
-            }
         }
         let initializer = node.initializer ? `= ${visit(node.initializer)}` : '';
         // Wrap non-nil values assigned to nullable primitive pointer types
         // Only wrap for primitive pointers (*string, *float64, *bool), not class pointers
-        if (node.initializer &&
-            type.startsWith('*') &&
-            !isNilLiteral(node.initializer) &&
-            ['*string', '*float64', '*bool'].includes(type)) {
-            const value = visit(node.initializer);
-            initializer = `= func() ${type} { v := ${value}; return &v }()`;
+        if (node.initializer && (type.startsWith('*') || isDynamicValue(node.initializer))) {
+            initializer = `= ${toGoValueOfType(node.initializer, type)}`;
+        }
+        // Package scope has no `:=`: module-level declarations need `var x = expr`
+        const isTopLevelStatement = isVariableStatement(node.parent?.parent) && isSourceFile(node.parent?.parent?.parent);
+        const isPackageScope = emittingModuleFile && isTopLevelStatement;
+        if (type === ':' && isPackageScope) {
+            return `var ${visit(node.name)} ${initializer}`;
+        }
+        const isMainTopLevel = !emittingModuleFile && isTopLevelStatement;
+        const packageType = type === ':' ? variableGoTypes.get(node.name.text) : type;
+        if (isMainTopLevel && packageType && packageType !== 'nil' && isIdentifier(node.name)) {
+            const name = visit(node.name);
+            mainPackageVariables.push(`var ${name} ${packageType}`);
+            return initializer ? `${name} ${initializer}` : '';
         }
         return `${type === ':' ? '' : 'var '}${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
     }
@@ -610,6 +760,18 @@ export function visit(node, options = {}) {
             (isPropertyAccessExpression(node.expression) && hasQuestionDot(node.expression))) {
             return visitOptionalCall(node);
         }
+        if (isPropertyAccessExpression(node.expression) && isOptionalChain(node.expression.expression)) {
+            const receiverType = inferExpressionType(node.expression.expression);
+            if (receiverType && NULLABLE_PRIMITIVE_TYPES.includes(receiverType)) {
+                return visitNullablePrimitiveOptionalCall(node, visit(node.expression.expression), receiverType);
+            }
+        }
+        const dynamicCall = visitDynamicMethodCall(node);
+        if (dynamicCall)
+            return dynamicCall;
+        const regexReplace = visitRegexReplace(node);
+        if (regexReplace)
+            return regexReplace;
         // IIFE with named function expression: (function name() { ... })()
         if (isParenthesizedExpression(node.expression) &&
             isFunctionExpression(node.expression.expression)) {
@@ -621,7 +783,7 @@ export function visit(node, options = {}) {
             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})`;
+            return `func(${parameterInfo.signature})${returnType} ${visit(fn.body, { prefixBlockContent: parameterInfo.prefixBlockContent }).trimEnd()}(${args})`;
         }
         // Handle setTimeout specially to get raw delay value
         if (isIdentifier(node.expression) && node.expression.text === 'setTimeout') {
@@ -640,21 +802,37 @@ export function visit(node, options = {}) {
         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));
+        const args = hasSpreadArg ? visitSpreadCallArguments(node) : visitCallArguments(node);
         // Resolve object type for type-aware method dispatch
         let objectType;
         if (isPropertyAccessExpression(node.expression)) {
             objectType = resolveExpressionType(node.expression.expression);
         }
+        currentReceiverGoType = isPropertyAccessExpression(node.expression)
+            ? inferExpressionType(node.expression.expression)
+            : undefined;
         return getCallString(safeCaller, args, typeArgs, objectType);
     }
     else if (isPrefixUnaryExpression(node)) {
+        if (node.operator === 'ExclamationToken') {
+            return `!${wrapCondition(toGoCondition(node.operand))}`;
+        }
+        if (isIncrementOrDecrement(node))
+            return visitIncrementOrDecrement(node, true);
+        if (node.operator === 'TildeToken') {
+            useHelper('dynamic');
+            return `float64(^TnInt32(${visit(node.operand)}))`;
+        }
         return `${getOperatorText(node.operator)}${visit(node.operand)}`;
     }
     else if (isPostfixUnaryExpression(node)) {
-        return `${visit(node.operand, { inline: true })}${getOperatorText(node.operator)}`;
+        return visitIncrementOrDecrement(node, false);
+    }
+    else if (node.kind === 'DeleteExpression') {
+        return visitDelete(node);
+    }
+    else if (node.kind === 'TypeOfExpression') {
+        return visitTypeOf(node);
     }
     else if (isConditionalExpression(node)) {
         return visitConditionalExpression(node);
@@ -663,12 +841,57 @@ export function visit(node, options = {}) {
         if (node.operatorToken.kind === 'QuestionQuestionToken') {
             return visitNullishCoalescingExpression(node);
         }
+        if (node.operatorToken.kind === 'InstanceOfKeyword' && isIdentifier(node.right)) {
+            // x instanceof C: the runtime type is C's pointer type
+            return `func() bool { _, ok := interface{}(${visit(node.left)}).(*${getSafeName(node.right.text)}); return ok }()`;
+        }
+        if (node.operatorToken.kind === 'InKeyword') {
+            if (isDynamicValue(node.right)) {
+                useHelper('dynamic');
+                return `TnHas(${visit(node.right)}, ${visit(node.left)})`;
+            }
+            return `${visit(node.right)}.Has(${visit(node.left)})`;
+        }
+        if (isLogicalOperator(node.operatorToken)) {
+            const logical = visitLogicalExpression(node);
+            if (logical)
+                return logical;
+        }
+        // x ??= v → assign only when x is nil
+        if (node.operatorToken.kind === 'BarBarEqualsToken' || node.operatorToken.kind === 'AmpersandAmpersandEqualsToken') {
+            // a ||= b assigns when a is falsy; a &&= b when a is truthy
+            const target = visit(node.left);
+            const condition = toGoCondition(node.left);
+            const value = toGoValueOfType(node.right, inferExpressionType(node.left));
+            const test = node.operatorToken.kind === 'BarBarEqualsToken' ? `!${wrapCondition(condition)}` : condition;
+            return `if ${test} { ${target} = ${value} }`;
+        }
+        if (node.operatorToken.kind === 'QuestionQuestionEqualsToken') {
+            const target = visit(node.left);
+            const value = toGoValueOfType(node.right, inferExpressionType(node.left));
+            return `if ${target} == nil { ${target} = ${value} }`;
+        }
         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 === '/' && isNumericLiteral(node.right) && Number(node.right.text) === 0) {
+            return `func(a, b float64) float64 { return a / b }(${visit(node.left)}, ${visit(node.right)})`;
+        }
+        const bitwise = visitBitwise(node, op);
+        if (bitwise)
+            return bitwise;
+        if (op === '**') {
+            importedPackages.add('math');
+            return `math.Pow(${visit(node.left)}, ${visit(node.right)})`;
+        }
+        if (op === '**=') {
+            importedPackages.add('math');
+            const target = visit(node.left);
+            return `${target} = math.Pow(${target}, ${visit(node.right)})`;
+        }
         if (op === '%') {
             importedPackages.add('math');
             return `math.Mod(${visit(node.left)}, ${visit(node.right)})`;
@@ -678,6 +901,75 @@ export function visit(node, options = {}) {
             const left = visit(node.left);
             return `${left} = math.Mod(${left}, ${visit(node.right)})`;
         }
+        if (['<', '>', '<=', '>=', '-', '*', '/', '+'].includes(op)) {
+            const dynamicArithmetic = visitDynamicArithmetic(node, op);
+            if (dynamicArithmetic)
+                return dynamicArithmetic;
+        }
+        if (op === '==' || op === '!=') {
+            // any values: JS equality (objects by identity) without Go's uncomparable-type panic
+            if ((isDynamicValue(node.left) || isDynamicValue(node.right)) &&
+                !isNilLiteral(node.left) &&
+                !isNilLiteral(node.right)) {
+                useHelper('dynamic');
+                const same = `TnSame(${visit(node.left)}, ${visit(node.right)})`;
+                return op === '==' ? same : `!${same}`;
+            }
+            const nullableComparison = visitNullableComparison(node, op);
+            if (nullableComparison)
+                return nullableComparison;
+            // A value type (string, number, struct…) is never null/undefined
+            const otherSide = isNilLiteral(node.right) ? node.left : isNilLiteral(node.left) ? node.right : undefined;
+            const otherType = otherSide ? inferExpressionType(otherSide) : undefined;
+            if (otherType && otherType !== 'nil' && !isNilableGoType(otherType)) {
+                return op === '!=' ? 'true' : 'false';
+            }
+        }
+        if (op === '=' && isPropertyAccessExpression(node.left) && isDynamicValue(node.left.expression)) {
+            useHelper('dynamic');
+            return `TnSet(${visit(node.left.expression)}, "${node.left.name.text}", ${visit(node.right)})`;
+        }
+        // m[k] = v on an ordered map
+        if (isElementAccessExpression(node.left) && isAssignmentTarget(node.left)) {
+            const mapType = inferExpressionType(node.left.expression);
+            if (mapType?.startsWith('*TnMap[')) {
+                const map = visit(node.left.expression);
+                const key = toGoValueOfType(node.left.argumentExpression, extractMapKeyType(mapType));
+                const value = op === '='
+                    ? toGoValueOfType(node.right, extractMapValueType(mapType))
+                    : `${map}.Get(${key}) ${op.slice(0, -1)} ${visit(node.right)}`;
+                return `${map}.Set(${key}, ${value})`;
+            }
+        }
+        // arr.length = n truncates the slice
+        if (op === '=' &&
+            isPropertyAccessExpression(node.left) &&
+            node.left.name.text === 'length' &&
+            inferExpressionType(node.left.expression)?.startsWith('[]')) {
+            const array = visit(node.left.expression);
+            return `${array} = ${array}[:int(${visit(node.right)})]`;
+        }
+        // Assigning to a nullable primitive (*T) boxes the value
+        if (op === '=' && isIdentifier(node.left)) {
+            const leftType = variableGoTypes.get(node.left.text);
+            if (leftType && (leftType.startsWith('*') || isDynamicValue(node.right))) {
+                return `${getSafeName(node.left.text)} = ${toGoValueOfType(node.right, leftType)}`;
+            }
+        }
+        if (op === '&&' || op === '||') {
+            const right = withNarrowing(getNarrowedNames(node.left, op === '&&'), () => visit(node.right));
+            return `${visit(node.left)} ${op} ${right}`;
+        }
+        if (op === '+') {
+            const leftType = inferExpressionType(node.left);
+            const rightType = inferExpressionType(node.right);
+            if (leftType === 'string' && rightType !== 'string') {
+                return `${visit(node.left)} + ${jsStringOf(visit(node.right), rightType)}`;
+            }
+            if (rightType === 'string' && leftType !== 'string') {
+                return `${jsStringOf(visit(node.left), leftType)} + ${visit(node.right)}`;
+            }
+        }
         return `${visit(node.left)} ${op} ${visit(node.right)}`;
     }
     else if (isParenthesizedExpression(node)) {
@@ -694,15 +986,15 @@ export function visit(node, options = {}) {
         return visit(node.expression) + (options.inline ? '' : ';\n\t');
     }
     else if (isForStatement(node)) {
-        return `for ${visit(node.initializer, { inline: true })}; ${visit(node.condition, {
-            inline: true
-        })}; ${visit(node.incrementor, { inline: true })}${visit(node.statement)}`;
+        return `for ${visit(node.initializer, { inline: true })}; ${node.condition ? toGoCondition(node.condition) : ''}; ${visit(node.incrementor, { inline: true })}${visitLoopBody(node.statement)}`;
     }
     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)}`;
+        const iterated = visit(node.expression, { inline: true });
+        const isOrderedMap = inferExpressionType(node.expression)?.startsWith('*TnMap[');
+        return `for ${varName} := range ${iterated}${isOrderedMap ? '.All()' : ''}${visitLoopBody(node.statement)}`;
     }
     else if (isForOfStatement(node)) {
         // Unwrap Object.entries(x) → treat x as the iterable
@@ -715,31 +1007,38 @@ export function visit(node, options = {}) {
             iterNode.arguments.length > 0) {
             iterNode = iterNode.arguments[0];
         }
-        const iterExpr = visit(iterNode, { inline: true });
+        const iterExpr = isDynamicValue(iterNode)
+            ? toGoValueOfType(iterNode, '[]interface{}')
+            : visit(iterNode, { inline: true });
         const iterType = inferExpressionType(iterNode);
-        if (iterType && iterType.startsWith('map[')) {
+        if (iterType && iterType.startsWith('*TnMap[')) {
             const valueType = extractMapValueType(iterType);
             const isSet = valueType === 'struct{}';
             const varInfo = getForOfVarNames(node.initializer);
-            if (isSet) {
-                return `for ${varInfo[0]} := range ${iterExpr}${visit(node.statement)}`;
-            }
-            else if (varInfo.length >= 2) {
-                return `for ${varInfo[0]}, ${varInfo[1]} := range ${iterExpr}${visit(node.statement)}`;
-            }
-            else {
-                return `for ${varInfo[0]} := range ${iterExpr}${visit(node.statement)}`;
+            registerLocalVariable(varInfo[0], extractMapKeyType(iterType));
+            if (varInfo.length >= 2 && !isSet)
+                registerLocalVariable(varInfo[1], valueType);
+            if (varInfo.length >= 2 && !isSet) {
+                return `for ${varInfo[0]}, ${varInfo[1]} := range ${iterExpr}.All()${visitLoopBody(node.statement)}`;
             }
+            return `for ${varInfo[0]} := range ${iterExpr}.All()${visitLoopBody(node.statement)}`;
         }
-        return `for _,${visit(node.initializer, { inline: true })}= range ${iterExpr}${visit(node.statement)}`;
+        return visitForOfSequence(node, iterExpr, iterType);
     }
     else if (isWhileStatement(node)) {
-        return `for ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
+        // while ((x = next()) !== null) → for { x = next(); if !(x != nil) { break }; … }
+        const hoisted = getHoistedConditionAssignment(node.expression);
+        if (hoisted) {
+            const condition = { ...node.expression, left: hoisted.left };
+            const prefix = `${visit(hoisted, { inline: true })};\n\t\tif !(${visit(condition, {
+                inline: true
+            })}) {\n\t\t\tbreak\n\t\t}\n\t\t`;
+            return `for ${visitLoopBody(node.statement, prefix)}`;
+        }
+        return `for ${toGoCondition(node.expression)}${visitLoopBody(node.statement)}`;
     }
     else if (isDoStatement(node)) {
-        const condition = `\tif !(${visit(node.expression, {
-            inline: true
-        })}) {\n\t\t\tbreak \n\t\t}\n\t`;
+        const condition = `\tif !(${toGoCondition(node.expression)}) {\n\t\t\tbreak \n\t\t}\n\t`;
         return `for ${visit(node.statement, { inline: true, extraBlockContent: condition })}`;
     }
     else if (isIfStatement(node)) {
@@ -747,18 +1046,15 @@ export function visit(node, options = {}) {
         // 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)
+        const thenCode = withNarrowing(getNarrowedNames(node.expression, true), () => isBlock(node.thenStatement)
             ? visit(node.thenStatement, { inline: !!node.elseStatement })
-            : `{\n${visit(node.thenStatement)}\n}${thenTerm}`;
-        const condition = `if ${visit(node.expression, { inline: true })} ${thenCode}`;
+            : `{\n${visit(node.thenStatement)}\n}${thenTerm}`);
+        const condition = `if ${toGoCondition(node.expression)} ${thenCode}`;
         if (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)
+            const elseCode = withNarrowing(getNarrowedNames(node.expression, false), () => isBlock(node.elseStatement) || isIfStatement(node.elseStatement)
                 ? visit(node.elseStatement)
-                : `{\n${visit(node.elseStatement)}\n}`;
+                : `{\n${visit(node.elseStatement)}\n};\n\t`);
             return `${condition} else ${elseCode}`;
         }
         return condition;
@@ -785,6 +1081,9 @@ export function visit(node, options = {}) {
     else if (isBreakStatement(node)) {
         return 'break';
     }
+    else if (node.kind === 'ContinueStatement') {
+        return 'continue;\n\t';
+    }
     else if (isThrowStatement(node)) {
         const expr = node.expression;
         if (isNewExpression(expr) &&
@@ -807,7 +1106,14 @@ export function visit(node, options = {}) {
             node.expression.expression.text === 'Promise') {
             return visitPromiseReturn(node.expression, options);
         }
-        return (`return ${node.expression ? visit(node.expression) : ''}` + (options.inline ? '' : ';\n\t'));
+        const enclosingFn = getEnclosingFunction(node);
+        const isAsync = enclosingFn?.modifiers?.some((m) => m.kind === 'AsyncKeyword');
+        const returnGoType = enclosingFn && !isAsync ? inferFunctionBodyReturnType(enclosingFn) : undefined;
+        const value = node.expression ? toGoValueOfType(node.expression, returnGoType) : '';
+        const terminator = options.inline ? '' : ';\n\t';
+        if (tryReturn && enclosingFn === tryReturn.fn)
+            return tryAwareReturn(value) + terminator;
+        return `return ${value}` + terminator;
     }
     else if (isFunctionDeclaration(node) || isFunctionExpression(node)) {
         if (options.addFunctionOutside) {
@@ -815,7 +1121,7 @@ export function visit(node, options = {}) {
             return '';
         }
         const typeParams = getTypeParameters(node.typeParameters);
-        const parameterInfo = getFunctionParametersInfo((node.parameters ?? []));
+        const parameterInfo = withContextualParameters(node, getFunctionParametersInfo(node.parameters ?? []));
         if (node.body && isBlock(node.body)) {
             prescanVariableDeclarations(node.body);
         }
@@ -831,7 +1137,7 @@ export function visit(node, options = {}) {
         if (!node.name) {
             return `func${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
                 prefixBlockContent: parameterInfo.prefixBlockContent
-            })}`;
+            }).trimEnd()}`;
         }
         const name = visit(node.name, { inline: true });
         const safeName = getSafeName(name);
@@ -840,7 +1146,7 @@ export function visit(node, options = {}) {
         })}`;
     }
     else if (isArrowFunction(node)) {
-        const parameterInfo = getFunctionParametersInfo((node.parameters ?? []));
+        const parameterInfo = withContextualParameters(node, getFunctionParametersInfo(node.parameters ?? []));
         const inferredRetType = inferFunctionBodyReturnType(node);
         const returnType = inferredRetType ? ` ${inferredRetType}` : '';
         if (parameterInfo.prefixBlockContent && !isBlock(node.body)) {
@@ -851,7 +1157,7 @@ export function visit(node, options = {}) {
         }
         return `func(${parameterInfo.signature})${returnType} ${visit(node.body, {
             prefixBlockContent: parameterInfo.prefixBlockContent
-        })}`;
+        }).trimEnd()}`;
     }
     else if (node.kind === 'ThisKeyword') {
         return 'self';
@@ -868,7 +1174,34 @@ export function visit(node, options = {}) {
     }
     else if (isTypeAliasDeclaration(node)) {
         typeAliases.set(node.name.text, node.type);
-        return '';
+        if (node.type?.kind !== 'TypeLiteral')
+            return '';
+        // type X = { a: T } → type X struct { a T }
+        if (options.addFunctionOutside) {
+            outsideNodes.push(node);
+            const properties = new Map();
+            for (const member of node.type.members ?? []) {
+                if (isPropertySignature(member) && isIdentifier(member.name)) {
+                    properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+                }
+            }
+            if (properties.size > 0)
+                interfacePropertyTypes.set(visit(node.name), properties);
+            return '';
+        }
+        const localProperties = new Map();
+        for (const member of node.type.members ?? []) {
+            if (isPropertySignature(member) && isIdentifier(member.name)) {
+                localProperties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+            }
+        }
+        if (localProperties.size > 0)
+            interfacePropertyTypes.set(visit(node.name), localProperties);
+        const fields = (node.type.members ?? [])
+            .filter((m) => isPropertySignature(m) && isIdentifier(m.name))
+            .map((m) => `\t${goFieldName(m.name.text)} ${getOptionalNodeType(m.type, !!m.questionToken)}`);
+        const terminator = options.isOutside ? '' : ';\n\t';
+        return `type ${visit(node.name)}${getTypeParameters(node.typeParameters)} struct {\n${fields.join('\n')}\n}${terminator}`;
     }
     else if (isInterfaceDeclaration(node)) {
         if (options.addFunctionOutside) {
@@ -889,7 +1222,7 @@ export function visit(node, options = {}) {
         const extendedInterfaces = [];
         if ((node.heritageClauses ?? [])) {
             for (const clause of (node.heritageClauses ?? [])) {
-                if (clause.token?.kind === 'ExtendsKeyword') {
+                if (clause.token === 'ExtendsKeyword') {
                     for (const type of (clause.types ?? [])) {
                         extendedInterfaces.push(visit(type.expression));
                     }
@@ -908,7 +1241,7 @@ export function visit(node, options = {}) {
                 methods.push(`\t${methodName}(${params})${returnType}`);
             }
             else if (isPropertySignature(member) && isIdentifier(member.name)) {
-                properties.push(`\t${member.name.text} ${getOptionalNodeType(member.type, !!member.questionToken)}`);
+                properties.push(`\t${goFieldName(member.name.text)} ${getOptionalNodeType(member.type, !!member.questionToken)}`);
             }
         }
         if (properties.length > 0 && methods.length === 0) {
@@ -933,7 +1266,7 @@ export function visit(node, options = {}) {
                         classStaticProps.add(`${className}.${member.name.text}`);
                     }
                     else {
-                        properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+                        properties.set(member.name.text, getPropertyDeclarationType(member));
                     }
                 }
                 if (isMethodDeclaration(member) && isIdentifier(member.name)) {
@@ -945,6 +1278,9 @@ export function visit(node, options = {}) {
                     }
                 }
             }
+            for (const param of getParameterProperties(node)) {
+                properties.set(param.name.text, getParameterGoType(param));
+            }
             classPropertyTypes.set(className, properties);
             classMethodReturnTypes.set(className, methods);
             return '';
@@ -955,7 +1291,7 @@ export function visit(node, options = {}) {
         let parentClass = null;
         if ((node.heritageClauses ?? [])) {
             for (const clause of (node.heritageClauses ?? [])) {
-                if (clause.token?.kind === 'ExtendsKeyword') {
+                if (clause.token === 'ExtendsKeyword') {
                     parentClass = visit(clause.types[0].expression);
                 }
             }
@@ -972,16 +1308,19 @@ export function visit(node, options = {}) {
                     fieldType = `[]${getType(member.type, true)}`;
                 }
                 else {
-                    fieldType = getOptionalNodeType(member.type, !!member.questionToken);
+                    fieldType = getPropertyDeclarationType(member);
                 }
                 fields.push(`\t${fieldName} ${fieldType}`);
             }
         }
+        for (const param of getParameterProperties(node)) {
+            fields.push(`\t${goFieldName(param.name.text)} ${getParameterGoType(param)}`);
+        }
         let result = `type ${name}${typeParams} struct {\n${fields.join('\n')}\n}\n\n`;
         const ctor = (node.members ?? []).find((m) => isConstructorDeclaration(m));
         if (ctor) {
             const ctorParameterInfo = getFunctionParametersInfo(ctor.parameters ?? []);
-            const bodyStatements = ctor.body?.statements
+            const bodyStatements = (ctor.body?.statements ?? [])
                 .filter((s) => {
                 if (isExpressionStatement(s) && isCallExpression(s.expression)) {
                     return s.expression.expression.kind !== 'SuperKeyword';
@@ -990,10 +1329,13 @@ export function visit(node, options = {}) {
             })
                 .map((s) => visit(s))
                 .join('\t') ?? '';
-            result += `func New${name}${typeParams}(${ctorParameterInfo.signature}) *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${ctorParameterInfo.prefixBlockContent}${bodyStatements}return self;\n\t}\n\n`;
+            const parameterAssignments = getParameterProperties(node)
+                .map((p) => `self.${goFieldName(p.name.text)} = ${visit(p.name)}\n\t\t`)
+                .join('');
+            result += `func New${name}${typeParams}(${ctorParameterInfo.signature}) *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${ctorParameterInfo.prefixBlockContent}${fieldInitializers(node)}${parameterAssignments}${bodyStatements}return self;\n\t}\n\n`;
         }
         else {
-            result += `func New${name}${typeParams}() *${name}${typeParamNames} {\n\t\treturn &${name}${typeParamNames}{}\n\t}\n\n`;
+            result += `func New${name}${typeParams}() *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${fieldInitializers(node)}return self\n\t}\n\n`;
         }
         for (const member of (node.members ?? [])) {
             if (isMethodDeclaration(member)) {
@@ -1063,31 +1405,81 @@ export function visit(node, options = {}) {
         return `New${className}${typeArgs}(${args.join(', ')})`;
     }
     else if (isObjectLiteralExpression(node)) {
-        let typeName = '';
-        if (isVariableDeclaration(node.parent) && node.parent.type) {
-            typeName = getTypeText(node.parent.type);
+        if (isDynamicObjectLiteral(node)) {
+            // { ...a, k: v } → copy a's properties, then set k (in source order)
+            if ((node.properties ?? []).some((p) => p.kind === 'SpreadAssignment')) {
+                useHelper('dynamic');
+                const steps = (node.properties ?? []).map((p) => {
+                    if (p.kind === 'SpreadAssignment')
+                        return `TnAssign(__obj, ${visit(p.expression)})`;
+                    if (isShorthandPropertyAssignment(p))
+                        return `__obj[${mapKeyText(p.name)}] = ${visit(p.name)}`;
+                    return `__obj[${mapKeyText(p.name)}] = ${visit(p.initializer)}`;
+                });
+                return `func() map[string]interface{} { __obj := map[string]interface{}{}; ${steps.join('; ')}; return __obj }()`;
+            }
+            const entries = (node.properties ?? [])
+                .map((p) => {
+                if (isPropertyAssignment(p))
+                    return `${mapKeyText(p.name)}: ${visit(p.initializer)}`;
+                if (isShorthandPropertyAssignment(p))
+                    return `${mapKeyText(p.name)}: ${visit(p.name)}`;
+                return '';
+            })
+                .filter((e) => e);
+            return `map[string]interface{}${compositeBody(entries)}`;
+        }
+        const contextualType = resolveTypeNode(getContextualTypeNode(node));
+        if (isRecordTypeNode(contextualType)) {
+            return visitMapLiteral(node, contextualType);
+        }
+        const typeName = contextualType ? getTypeText(contextualType) : '';
+        if (!typeName || typeName === 'interface{}') {
+            return visitAnonymousStructLiteral(node);
+        }
+        // Objects are pointers: the struct type is typeName without its *
+        const structName = typeName.replace(/^\*/, '');
+        // { ...base, x: 1 } → a copy of *base with fields set
+        if ((node.properties ?? []).some((p) => p.kind === 'SpreadAssignment')) {
+            const steps = (node.properties ?? []).map((p) => {
+                if (p.kind === 'SpreadAssignment')
+                    return `__obj = *(${visit(p.expression)})`;
+                if (isShorthandPropertyAssignment(p))
+                    return `__obj.${goFieldName(p.name.text)} = ${visit(p.name)}`;
+                const spreadFieldType = isIdentifier(p.name)
+                    ? (interfacePropertyTypes.get(structName)?.get(p.name.text) ??
+                        getStructFieldGoType(structName, p.name.text))
+                    : undefined;
+                return `__obj.${visit(p.name)} = ${toGoValueOfType(p.initializer, spreadFieldType)}`;
+            });
+            return `func() *${structName} { var __obj ${structName}; ${steps.join('; ')}; return &__obj }()`;
         }
+        const fieldTypes = interfacePropertyTypes.get(structName) ?? classPropertyTypes.get(structName);
         const properties = (node.properties ?? [])
             .map((p) => {
             if (isPropertyAssignment(p)) {
-                return `${visit(p.name)}: ${visit(p.initializer)}`;
+                const fieldType = isIdentifier(p.name)
+                    ? (fieldTypes?.get(p.name.text) ?? getStructFieldGoType(typeName, p.name.text))
+                    : undefined;
+                return `${visit(p.name)}: ${toGoValueOfType(p.initializer, fieldType)}`;
             }
             // Shorthand: { name } → name: name
             if (isShorthandPropertyAssignment(p)) {
-                const name = visit(p.name);
-                return `${name}: ${name}`;
+                return `${goFieldName(p.name.text)}: ${toGoValueOfType(p.name, fieldTypes?.get(p.name.text) ?? getStructFieldGoType(typeName, p.name.text))}`;
             }
             // Spread: { ...obj } — not easily supported in Go structs, omit
             return '';
         })
-            .filter((p) => p)
-            .join(', ');
-        return `${typeName}{${properties}}`;
+            .filter((p) => p);
+        return `&${structName}${compositeBody(properties)}`;
     }
     else if (isPropertyAssignment(node)) {
         return `${visit(node.name)}: ${visit(node.initializer)}`;
     }
     else if (isNonNullExpression(node)) {
+        const innerType = inferExpressionType(node.expression);
+        if (innerType && NULLABLE_PRIMITIVE_TYPES.includes(innerType))
+            return `(*${visit(node.expression)})`;
         return visit(node.expression);
     }
     else if (isImportDeclaration(node)) {
@@ -1097,7 +1489,7 @@ export function visit(node, options = {}) {
         return '';
     }
     const syntaxKind = node.kind;
-    if (!['FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
+    if (!['VariableStatement', 'EndOfFileToken'].includes(syntaxKind)) {
         const snippet = String(node.text ?? node.kind).substring(0, 60).replace(/\n/g, ' ');
         console.warn(`[TypeNative] Unsupported syntax: ${syntaxKind} — "${snippet}"`);
     }
@@ -1106,6 +1498,850 @@ export function visit(node, options = {}) {
     }
     return code;
 }
+// Renders composite literal entries; multi-line entries need trailing commas
+// (Go inserts a semicolon after a newline that ends in `}`)
+// Visits a value going into a slot of Go type `goType`; non-nil values for
+// nullable primitives (*string/*float64/*bool) are boxed into pointers
+function toGoValueOfType(expr, goType) {
+    if (goType &&
+        ((isObjectLiteralExpression(expr) && (expr.properties ?? []).length === 0 && goType.startsWith('*TnMap[')) ||
+            (isArrayLiteralExpression(expr) && (expr.elements ?? []).length === 0 && goType.startsWith('[]')))) {
+        const mapArgs = splitMapTypeArgs(goType);
+        if (mapArgs)
+            return orderedMapLiteral(mapArgs[0], mapArgs[1], []);
+        return `${goType}{}`;
+    }
+    const code = visit(expr);
+    if (goType && goType !== 'interface{}' && goType !== ':' && isDynamicValue(expr)) {
+        useHelper('dynamic');
+        // T | undefined: box the dynamic value (nil when missing or of another type)
+        if (goType.startsWith('*'))
+            return `TnAsPtr[${goType.slice(1)}](${code})`;
+        return `TnAs[${goType}](${code})`;
+    }
+    // *Struct slot: take the address (shares the value, like a JS object reference)
+    if (goType?.startsWith('*') && isStructGoType(goType.slice(1)) && !isNilLiteral(expr)) {
+        // an untyped literal (&struct{...}) converts to the named pointer type
+        if (isObjectLiteralExpression(expr))
+            return code.startsWith('&struct{') ? `(${goType})(${code})` : code;
+        if (inferExpressionType(expr) !== goType.slice(1))
+            return code;
+        // the element itself (not a bounds-checked copy), so mutations are shared
+        if (isElementAccessExpression(expr) && inferExpressionType(expr.expression)?.startsWith('[]')) {
+            return `&${visit(expr.expression)}[int(${visit(expr.argumentExpression)})]`;
+        }
+        if (isIdentifier(expr) || isPropertyAccessExpression(expr)) {
+            return `&${code}`;
+        }
+        return `func() ${goType} { v := ${code}; return &v }()`;
+    }
+    if (!goType || !NULLABLE_PRIMITIVE_TYPES.includes(goType) || isNilLiteral(expr)) {
+        return code;
+    }
+    if (isConditionalExpression(expr))
+        return code;
+    if (isBinaryExpression(expr) &&
+        expr.operatorToken.kind === 'QuestionQuestionToken' &&
+        inferExpressionType(expr.left)?.startsWith('*')) {
+        return code;
+    }
+    if (inferExpressionType(expr) !== goType.slice(1))
+        return code;
+    return `func() ${goType} { v := ${code}; return &v }()`;
+}
+const NULLABLE_PRIMITIVE_TYPES = ['*string', '*float64', '*bool'];
+// Nullable primitives (T | null → *T) that a guard has narrowed to T in the
+// code being emitted; reads of them dereference the pointer
+const narrowedVariables = new Set();
+function isNullablePrimitiveVariable(name) {
+    return NULLABLE_PRIMITIVE_TYPES.includes(variableGoTypes.get(name) ?? '');
+}
+// Narrowing key of a variable or property path (`opts.source`), if it has one
+function getNarrowingKey(expr) {
+    if (isIdentifier(expr))
+        return expr.text;
+    if (expr.kind === 'ThisKeyword')
+        return 'this';
+    if (isPropertyAccessExpression(expr) && !hasQuestionDot(expr)) {
+        const objectKey = getNarrowingKey(expr.expression);
+        return objectKey ? `${objectKey}.${expr.name.text}` : undefined;
+    }
+    return undefined;
+}
+// Emits `emit()` with `names` narrowed
+function withNarrowing(names, emit) {
+    const added = names.filter((n) => !narrowedVariables.has(n));
+    for (const name of added)
+        narrowedVariables.add(name);
+    const code = emit();
+    for (const name of added)
+        narrowedVariables.delete(name);
+    return code;
+}
+function isProcessEnv(expr) {
+    while (isParenthesizedExpression(expr) || isAsExpression(expr) || isNonNullExpression(expr)) {
+        expr = expr.expression;
+    }
+    return (isPropertyAccessExpression(expr) &&
+        isIdentifier(expr.expression) &&
+        expr.expression.text === 'process' &&
+        expr.name.text === 'env');
+}
+// Whether an expression is (part of) an optional chain: a?.b, a?.b(), a?.b().c
+function isOptionalChain(expr) {
+    if (isCallExpression(expr)) {
+        return hasQuestionDot(expr) || isOptionalChain(expr.expression);
+    }
+    if (isPropertyAccessExpression(expr) || isElementAccessExpression(expr)) {
+        return hasQuestionDot(expr) || isOptionalChain(expr.expression);
+    }
+    return false;
+}
+// x in `x?.m(...)` / `x?.p`
+function getOptionalChainBase(expr) {
+    const access = isCallExpression(expr) ? expr.expression : expr;
+    if (isPropertyAccessExpression(access) && hasQuestionDot(access))
+        return access.expression;
+    return undefined;
+}
+// Variables known non-null when `condition` evaluates to `whenTrue`
+function getNarrowedNames(condition, whenTrue) {
+    if (isParenthesizedExpression(condition))
+        return getNarrowedNames(condition.expression, whenTrue);
+    if (whenTrue) {
+        const chainBase = getOptionalChainBase(condition);
+        if (chainBase)
+            return nullableKeys([chainBase]);
+    }
+    if (isIdentifier(condition) || isPropertyAccessExpression(condition)) {
+        return whenTrue ? nullableKeys([condition]) : [];
+    }
+    if (isPrefixUnaryExpression(condition) && condition.operator === 'ExclamationToken') {
+        return getNarrowedNames(condition.operand, !whenTrue);
+    }
+    if (!isBinaryExpression(condition))
+        return [];
+    const kind = condition.operatorToken.kind;
+    if (kind === 'AmpersandAmpersandToken') {
+        return whenTrue
+            ? [...getNarrowedNames(condition.left, true), ...getNarrowedNames(condition.right, true)]
+            : [];
+    }
+    if (kind === 'BarBarToken') {
+        return whenTrue
+            ? []
+            : [...getNarrowedNames(condition.left, false), ...getNarrowedNames(condition.right, false)];
+    }
+    const isNotEqual = kind === 'ExclamationEqualsEqualsToken' || kind === 'ExclamationEqualsToken';
+    const isEqual = kind === 'EqualsEqualsEqualsToken' || kind === 'EqualsEqualsToken';
+    if (!isNotEqual && !isEqual)
+        return [];
+    const checked = isNilLiteral(condition.right)
+        ? condition.left
+        : isNilLiteral(condition.left)
+            ? condition.right
+            : undefined;
+    if (!checked) {
+        // x === <non-null value>
+        if (!isEqual || !whenTrue)
+            return [];
+        const leftType = inferExpressionType(condition.left);
+        const rightType = inferExpressionType(condition.right);
+        if (rightType && !NULLABLE_PRIMITIVE_TYPES.includes(rightType))
+            return nullableKeys([condition.left]);
+        if (leftType && !NULLABLE_PRIMITIVE_TYPES.includes(leftType))
+            return nullableKeys([condition.right]);
+        return [];
+    }
+    return isNotEqual === whenTrue ? nullableKeys([checked]) : [];
+}
+// Narrowing keys of the given expressions that are nullable primitives (*T)
+function nullableKeys(exprs) {
+    const keys = [];
+    for (const expr of exprs) {
+        const key = getNarrowingKey(expr);
+        if (!key || narrowedVariables.has(key))
+            continue;
+        if (NULLABLE_PRIMITIVE_TYPES.includes(inferExpressionType(expr) ?? ''))
+            keys.push(key);
+    }
+    return keys;
+}
+// Identifier occurrences that read the variable (not declarations, member
+// names, or assignment targets)
+function isNarrowableReference(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    if (isPropertyAccessExpression(parent) && parent.name === node)
+        return false;
+    if (parent.name === node)
+        return false;
+    if (isBinaryExpression(parent) && parent.left === node) {
+        const op = parent.operatorToken.kind;
+        if (op === 'EqualsToken' || op === 'QuestionQuestionEqualsToken')
+            return false;
+    }
+    return true;
+}
+function alwaysExits(statement) {
+    if (isReturnStatement(statement) ||
+        isThrowStatement(statement) ||
+        isBreakStatement(statement) ||
+        statement.kind === 'ContinueStatement') {
+        return true;
+    }
+    if (isBlock(statement)) {
+        const statements = statement.statements ?? [];
+        return statements.length > 0 && alwaysExits(statements[statements.length - 1]);
+    }
+    return false;
+}
+// Statements of a block; after `if (!x) return;`, x stays narrowed for the rest
+function visitBlockStatements(statements) {
+    const added = [];
+    const parts = [];
+    for (const statement of statements) {
+        parts.push(visit(statement));
+        if (isIfStatement(statement) && !statement.elseStatement && alwaysExits(statement.thenStatement)) {
+            for (const name of getNarrowedNames(statement.expression, false)) {
+                if (!narrowedVariables.has(name)) {
+                    narrowedVariables.add(name);
+                    added.push(name);
+                }
+            }
+        }
+    }
+    for (const name of added)
+        narrowedVariables.delete(name);
+    return parts.join('\t');
+}
+function visitDynamicArithmetic(node, op) {
+    const leftDynamic = isDynamicValue(node.left);
+    const rightDynamic = isDynamicValue(node.right);
+    if (!leftDynamic && !rightDynamic)
+        return undefined;
+    const isConcat = op === '+' && [node.left, node.right].some((side) => inferExpressionType(side) === 'string');
+    const operand = (side, dynamic) => {
+        if (!dynamic)
+            return visit(side);
+        if (isConcat) {
+            importedPackages.add('fmt');
+            return `fmt.Sprint(${visit(side)})`;
+        }
+        useHelper('dynamic');
+        return `TnAs[float64](${visit(side)})`;
+    };
+    return `${operand(node.left, leftDynamic)} ${op} ${operand(node.right, rightDynamic)}`;
+}
+// `x === v` where x is *T and v is T: equal only when x is non-nil and *x == v
+function visitNullableComparison(node, op) {
+    const leftType = inferExpressionType(node.left);
+    const rightType = inferExpressionType(node.right);
+    let pointerSide;
+    let valueSide;
+    if (leftType && NULLABLE_PRIMITIVE_TYPES.includes(leftType) && rightType === leftType.slice(1)) {
+        pointerSide = node.left;
+        valueSide = node.right;
+    }
+    else if (rightType &&
+        NULLABLE_PRIMITIVE_TYPES.includes(rightType) &&
+        leftType === rightType.slice(1)) {
+        pointerSide = node.right;
+        valueSide = node.left;
+    }
+    else {
+        return undefined;
+    }
+    const tmp = getTempName('cmp');
+    const equal = `${tmp} != nil && *${tmp} == ${visit(valueSide)}`;
+    return `func() bool { ${tmp} := ${visit(pointerSide)}; return ${op === '==' ? equal : `!(${equal})`} }()`;
+}
+// Go type of a Map/Set/Record: an insertion-ordered map
+function mapGoType(keyType, valueType) {
+    useHelper('orderedMap');
+    return `*TnMap[${keyType}, ${valueType}]`;
+}
+// [K, V] of a *TnMap[K, V] type string
+function splitMapTypeArgs(mapType) {
+    if (!mapType.startsWith('*TnMap['))
+        return undefined;
+    const body = mapType.slice(7, -1);
+    let depth = 0;
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (ch === '[' || ch === '(' || ch === '{')
+            depth++;
+        else if (ch === ']' || ch === ')' || ch === '}')
+            depth--;
+        else if (ch === ',' && depth === 0)
+            return [body.slice(0, i).trim(), body.slice(i + 1).trim()];
+    }
+    return undefined;
+}
+// Key type of a map type string: *TnMap[K, V] → K
+function extractMapKeyType(mapType) {
+    const args = splitMapTypeArgs(mapType);
+    if (args)
+        return args[0];
+    let depth = 0;
+    for (let i = 4; i < mapType.length; i++) {
+        if (mapType[i] === '[')
+            depth++;
+        else if (mapType[i] === ']') {
+            if (depth === 0)
+                return mapType.slice(4, i);
+            depth--;
+        }
+    }
+    return 'interface{}';
+}
+// Field type of an anonymous struct type string: struct{ a T; b U } → field b → U
+function getStructFieldGoType(structType, field) {
+    structType = structType.replace(/^\*/, '');
+    if (!structType.startsWith('struct{'))
+        return undefined;
+    const body = structType.slice(7, structType.lastIndexOf('}'));
+    let depth = 0;
+    let start = 0;
+    const fields = [];
+    for (let i = 0; i <= body.length; i++) {
+        const ch = i < body.length ? body[i] : ';';
+        if (ch === '{' || ch === '(' || ch === '[')
+            depth++;
+        else if (ch === '}' || ch === ')' || ch === ']')
+            depth--;
+        else if (ch === ';' && depth === 0) {
+            fields.push(body.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    for (const entry of fields) {
+        const space = entry.indexOf(' ');
+        if (space > 0 && entry.slice(0, space) === goFieldName(field))
+            return entry.slice(space + 1).trim();
+    }
+    return undefined;
+}
+// A Go expression as the string JS would produce for it (numbers like JS:
+// 1000000, 0.5, NaN; not Go's 1e+06)
+function jsStringOf(code, goType) {
+    if (goType === 'string')
+        return code;
+    if (goType === 'float64') {
+        useHelper('dynamic');
+        return `TnNumStr(${code})`;
+    }
+    if (goType === 'bool') {
+        importedPackages.add('strconv');
+        return `strconv.FormatBool(${code})`;
+    }
+    importedPackages.add('fmt');
+    return `fmt.Sprintf("%v", ${code})`;
+}
+// JS bitwise operators work on 32-bit integers (ToInt32 / ToUint32)
+function visitBitwise(node, op) {
+    const kind = node.operatorToken.kind;
+    const base = {
+        AmpersandToken: '&',
+        BarToken: '|',
+        CaretToken: '^',
+        LessThanLessThanToken: '<<',
+        GreaterThanGreaterThanToken: '>>',
+        GreaterThanGreaterThanGreaterThanToken: '>>>',
+        AmpersandEqualsToken: '&',
+        BarEqualsToken: '|',
+        CaretEqualsToken: '^',
+        LessThanLessThanEqualsToken: '<<',
+        GreaterThanGreaterThanEqualsToken: '>>',
+        GreaterThanGreaterThanGreaterThanEqualsToken: '>>>'
+    };
+    const bitOp = base[kind];
+    if (!bitOp)
+        return undefined;
+    useHelper('dynamic');
+    const left = visit(node.left);
+    const right = visit(node.right);
+    let value;
+    if (bitOp === '>>>')
+        value = `float64(TnUint32(${left}) >> (TnUint32(${right}) & 31))`;
+    else if (bitOp === '<<' || bitOp === '>>') {
+        value = `float64(TnInt32(${left}) ${bitOp} (TnUint32(${right}) & 31))`;
+    }
+    else
+        value = `float64(TnInt32(${left}) ${bitOp} TnInt32(${right}))`;
+    const isAssignment = kind.endsWith('EqualsToken');
+    return isAssignment ? `${left} = ${value}` : value;
+}
+// delete obj.key / delete obj[key] on maps (Records and dynamic objects)
+function visitDelete(node) {
+    const target = unwrapParentheses(node.expression);
+    const object = target.expression;
+    const key = isPropertyAccessExpression(target)
+        ? toGoStringLiteral(target.name.text)
+        : visit(target.argumentExpression);
+    const objectType = inferExpressionType(object);
+    if (objectType?.startsWith('*TnMap['))
+        return `${visit(object)}.Delete(${key})`;
+    useHelper('dynamic');
+    return `TnDelete(${visit(object)}, ${key})`;
+}
+// f(...xs): variadic callees take xs...; fixed-parameter functions get
+// xs[0], xs[1], … for their remaining parameters
+function visitSpreadCallArguments(node) {
+    const fn = isIdentifier(node.expression) ? declaredFunctions.get(node.expression.text) : undefined;
+    const params = fn?.parameters ?? [];
+    const isVariadic = !fn || params.some((p) => p.dotDotDotToken);
+    const result = [];
+    for (const arg of node.arguments ?? []) {
+        if (!isSpreadElement(arg)) {
+            result.push(visit(arg));
+        }
+        else if (isVariadic) {
+            result.push(`${visit(arg.expression)}...`);
+        }
+        else {
+            useHelper('dynamic');
+            const source = visit(arg.expression);
+            const start = result.length;
+            for (let i = start; i < params.length; i++)
+                result.push(`TnAt(${source}, ${i - start})`);
+        }
+    }
+    return result;
+}
+// self.field = initializer for each instance field that has one
+function fieldInitializers(classNode) {
+    return (classNode.members ?? [])
+        .filter((m) => isPropertyDeclaration(m) &&
+        m.initializer &&
+        isIdentifier(m.name) &&
+        !(m.modifiers ?? []).some((mod) => mod.kind === 'StaticKeyword'))
+        .map((m) => `self.${goFieldName(m.name.text)} = ${toGoValueOfType(m.initializer, getPropertyDeclarationType(m))}\n\t\t`)
+        .join('');
+}
+// A class field's type: declared, else inferred from its initializer (n = 1 → float64)
+function getPropertyDeclarationType(member) {
+    if (member.type || !member.initializer)
+        return getOptionalNodeType(member.type, !!member.questionToken);
+    return toFieldGoType(inferExpressionType(member.initializer));
+}
+function isIncrementOrDecrement(node) {
+    return node.operator === 'PlusPlusToken' || node.operator === 'MinusMinusToken';
+}
+// x++ / ++x: Go only has the statement form, so used as a value they become
+// a closure returning the old (postfix) or new (prefix) value
+function visitIncrementOrDecrement(node, isPrefix) {
+    const target = visit(node.operand, { inline: true });
+    const op = node.operator === 'PlusPlusToken' ? '++' : '--';
+    const parent = node.parent;
+    const isStatement = isExpressionStatement(parent) || (isForStatement(parent) && parent.incrementor === node);
+    if (isStatement)
+        return `${target}${op}`;
+    if (isPrefix)
+        return `func() float64 { ${target}${op}; return ${target} }()`;
+    return `func() float64 { __old := ${target}; ${target}${op}; return __old }()`;
+}
+function compositeBody(rawEntries) {
+    const entries = rawEntries.map((e) => e.trimEnd());
+    if (!entries.some((e) => e.includes('\n')))
+        return `{${entries.join(', ')}}`;
+    return `{\n\t${entries.join(',\n\t')},\n}`;
+}
+// Struct field type for an inferred value type (null/unknown → interface{})
+function toFieldGoType(goType) {
+    return !goType || goType === 'nil' ? 'interface{}' : goType;
+}
+function isDictionaryLiteral(node) {
+    const declaration = node.parent;
+    if (!isVariableDeclaration(declaration) || !isIdentifier(declaration.name))
+        return false;
+    let scope = declaration.parent;
+    while (scope && !isBlock(scope) && !isSourceFile(scope))
+        scope = scope.parent;
+    if (!scope)
+        return false;
+    const name = declaration.name.text;
+    return containsNode(scope, (n) => isElementAccessExpression(n) &&
+        isIdentifier(n.expression) &&
+        n.expression.text === name &&
+        !isStringLiteral(n.argumentExpression));
+}
+function containsNode(root, predicate) {
+    for (const child of childNodes(root)) {
+        if (predicate(child) || containsNode(child, predicate))
+            return true;
+    }
+    return false;
+}
+function getDictionaryValueType(node) {
+    let valueType;
+    for (const p of node.properties ?? []) {
+        if (!isPropertyAssignment(p))
+            continue;
+        const t = inferExpressionType(p.initializer);
+        if (!t || (valueType && t !== valueType))
+            return 'interface{}';
+        valueType = t;
+    }
+    return valueType ?? 'interface{}';
+}
+// Go type of an object literal, matching what the visitor emits
+// Object literals that are dynamic objects: in an any context, or spreading an any value
+function isDynamicObjectLiteral(node) {
+    if (isAnyContext(getContextualTypeNode(node)))
+        return true;
+    return (node.properties ?? []).some((p) => p.kind === 'SpreadAssignment' && isDynamicValue(p.expression));
+}
+function getObjectLiteralGoType(node) {
+    if (isDynamicObjectLiteral(node))
+        return 'interface{}';
+    const contextualType = resolveTypeNode(getContextualTypeNode(node));
+    if (isRecordTypeNode(contextualType))
+        return getType(contextualType);
+    const typeName = contextualType ? getType(contextualType) : '';
+    if (typeName && typeName !== 'interface{}' && typeName !== ':')
+        return typeName;
+    if (isDictionaryLiteral(node))
+        return mapGoType('string', getDictionaryValueType(node));
+    const fields = (node.properties ?? [])
+        .filter((p) => (isPropertyAssignment(p) || isShorthandPropertyAssignment(p)) && isIdentifier(p.name))
+        .map((p) => {
+        const value = isPropertyAssignment(p) ? p.initializer : p.name;
+        return `${goFieldName(p.name.text)} ${toFieldGoType(inferExpressionType(value))}`;
+    });
+    return `*struct{ ${fields.join('; ')} }`;
+}
+// Values typed `any`/`unknown` are handled at runtime (TnGet/TnSet/...),
+// never by guessing their type
+function isDynamicValue(expr) {
+    return inferExpressionType(expr) === 'interface{}';
+}
+// Whether an expression is written to (x = …, x += …, x++)
+function isAssignmentTarget(node) {
+    const parent = node.parent;
+    if (isBinaryExpression(parent) && parent.left === node) {
+        return /^(EqualsToken|.*EqualsToken)$/.test(parent.operatorToken.kind) &&
+            !['EqualsEqualsToken', 'EqualsEqualsEqualsToken', 'ExclamationEqualsToken', 'ExclamationEqualsEqualsToken', 'LessThanEqualsToken', 'GreaterThanEqualsToken'].includes(parent.operatorToken.kind);
+    }
+    return ((isPrefixUnaryExpression(parent) || isPostfixUnaryExpression(parent)) &&
+        ['PlusPlusToken', 'MinusMinusToken'].includes(parent.operator));
+}
+// `x as T`: an any value cast to an object type stays dynamic (a JS object
+// cannot become a Go struct); other casts convert to T
+function getAsExpressionType(node) {
+    const target = getType(node.type);
+    if (isDynamicValue(node.expression) && (isStructGoType(target) || target.startsWith('*'))) {
+        return 'interface{}';
+    }
+    return target;
+}
+function isCallee(node) {
+    return isCallExpression(node.parent) && node.parent.expression === node;
+}
+// Whether a type node is `any`/`unknown`, directly or through aliases
+function isAnyContext(typeNode) {
+    for (let depth = 0; typeNode && depth < 10; depth++) {
+        if (isAnyTypeNode(typeNode))
+            return true;
+        // any | undefined is still any
+        if (isUnionTypeNode(typeNode)) {
+            return (typeNode.types ?? []).some((t) => isAnyContext(t));
+        }
+        if (!isTypeReferenceNode(typeNode) || !isIdentifier(typeNode.typeName))
+            return false;
+        typeNode = declaredTypeAliases.get(typeNode.typeName.text);
+    }
+    return false;
+}
+function isRecordTypeNode(typeNode) {
+    return (isTypeReferenceNode(typeNode) &&
+        isIdentifier(typeNode.typeName) &&
+        typeNode.typeName.text === 'Record' &&
+        (typeNode.typeArguments ?? []).length === 2);
+}
+// Object literal keys as Go map keys: identifiers become string literals
+function mapKeyText(name) {
+    if (isIdentifier(name))
+        return toGoStringLiteral(name.text);
+    if (name.kind === 'ComputedPropertyName')
+        return visit(name.expression);
+    return visit(name);
+}
+// { a: 1 } typed as Record<K, V> → map[K]V{"a": 1}
+// An ordered map built from "key, value" entries (in source order)
+function orderedMapLiteral(keyType, valueType, entries) {
+    useHelper('orderedMap');
+    const constructor = `TnNewMap[${keyType}, ${valueType}]()`;
+    if (entries.length === 0)
+        return constructor;
+    const sets = entries.map((e) => `.Set(${e})`).join('');
+    return `${constructor}${sets}`;
+}
+function visitMapLiteral(node, recordType) {
+    const keyType = getType(recordType.typeArguments[0]);
+    const valueType = getType(recordType.typeArguments[1]);
+    const entries = [];
+    for (const p of node.properties ?? []) {
+        if (isPropertyAssignment(p))
+            entries.push(`${mapKeyText(p.name)}, ${toGoValueOfType(p.initializer, valueType)}`);
+        else if (isShorthandPropertyAssignment(p))
+            entries.push(`${mapKeyText(p.name)}, ${visit(p.name)}`);
+    }
+    return orderedMapLiteral(keyType, valueType, entries);
+}
+// Object literal with no contextual type → anonymous struct with inferred fields,
+// or a map when the variable holding it is indexed dynamically (obj[key])
+function visitAnonymousStructLiteral(node) {
+    if (isDictionaryLiteral(node)) {
+        const valueType = getDictionaryValueType(node);
+        const entries = (node.properties ?? [])
+            .filter((p) => isPropertyAssignment(p))
+            .map((p) => `${mapKeyText(p.name)}, ${visit(p.initializer)}`);
+        return orderedMapLiteral('string', valueType, entries);
+    }
+    const fields = [];
+    const values = [];
+    for (const p of node.properties ?? []) {
+        if (isPropertyAssignment(p) && isIdentifier(p.name)) {
+            const field = goFieldName(p.name.text);
+            fields.push(`${field} ${toFieldGoType(inferExpressionType(p.initializer))}`);
+            values.push(`${field}: ${visit(p.initializer)}`);
+        }
+        else if (isShorthandPropertyAssignment(p)) {
+            const field = goFieldName(p.name.text);
+            fields.push(`${field} ${toFieldGoType(inferExpressionType(p.name))}`);
+            values.push(`${field}: ${visit(p.name)}`);
+        }
+    }
+    return `&struct{ ${fields.join('; ')} }${compositeBody(values)}`;
+}
+// Follows type aliases and strips null/undefined from unions
+function resolveTypeNode(typeNode, depth = 0) {
+    if (!typeNode || depth > 10)
+        return typeNode;
+    if (isAnyTypeNode(typeNode))
+        return undefined;
+    if (typeNode.kind === 'ParenthesizedType')
+        return resolveTypeNode(typeNode.type, depth + 1);
+    if (isUnionTypeNode(typeNode)) {
+        const nonNull = (typeNode.types ?? []).filter((t) => t.kind !== 'NullKeyword' &&
+            t.kind !== 'UndefinedKeyword' &&
+            !(isLiteralTypeNode(t) && t.literal?.kind === 'NullKeyword'));
+        return nonNull.length === 1 ? resolveTypeNode(nonNull[0], depth + 1) : typeNode;
+    }
+    if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
+        const alias = declaredTypeAliases.get(typeNode.typeName.text);
+        if (alias && alias.kind !== 'TypeLiteral')
+            return resolveTypeNode(alias, depth + 1);
+    }
+    return typeNode;
+}
+function getEnclosingFunction(node) {
+    let current = node.parent;
+    while (current) {
+        if (isFunctionDeclaration(current) ||
+            isFunctionExpression(current) ||
+            isArrowFunction(current) ||
+            isMethodDeclaration(current) ||
+            isGetAccessor(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+// Declared return type of a function, unwrapping Promise<T> for async functions
+function getReturnTypeNode(fn) {
+    const typeNode = fn?.type ?? (fn ? getContextualFunctionType(fn)?.type : undefined);
+    if (isTypeReferenceNode(typeNode) &&
+        isIdentifier(typeNode.typeName) &&
+        typeNode.typeName.text === 'Promise') {
+        return typeNode.typeArguments?.[0];
+    }
+    return typeNode;
+}
+// Type of member `name` within an object type (interface, type literal, Record)
+function getMemberTypeNode(typeNode, name) {
+    const resolved = resolveTypeNode(typeNode);
+    if (!resolved)
+        return undefined;
+    if (isRecordTypeNode(resolved))
+        return resolved.typeArguments[1];
+    let members = [];
+    if (resolved.kind === 'TypeLiteral') {
+        members = resolved.members ?? [];
+    }
+    else if (isTypeReferenceNode(resolved) && isIdentifier(resolved.typeName)) {
+        const aliasLiteral = declaredTypeAliases.get(resolved.typeName.text);
+        if (aliasLiteral?.kind === 'TypeLiteral')
+            members = aliasLiteral.members ?? [];
+        const iface = declaredInterfaces.get(resolved.typeName.text);
+        if (iface) {
+            members = iface.members ?? [];
+            for (const clause of iface.heritageClauses ?? []) {
+                for (const base of clause.types ?? []) {
+                    const baseType = { kind: 'TypeReference', typeName: base.expression };
+                    const inherited = getMemberTypeNode(baseType, name);
+                    if (inherited)
+                        return inherited;
+                }
+            }
+        }
+    }
+    for (const member of members) {
+        if (isPropertySignature(member) && isIdentifier(member.name) && member.name.text === name) {
+            return member.type;
+        }
+    }
+    return undefined;
+}
+// The type an expression is expected to have from where it appears
+// (TypeScript's "contextual type"), derived syntactically from declarations
+// Declared type nodes of variables/parameters in scope (latest declaration wins)
+const variableTypeNodes = new Map();
+// Declared type (as a type node) of an assignable expression, when known
+function getExpressionTypeNode(expr) {
+    if (isIdentifier(expr))
+        return variableTypeNodes.get(expr.text);
+    if (isParenthesizedExpression(expr))
+        return getExpressionTypeNode(expr.expression);
+    if (isPropertyAccessExpression(expr)) {
+        if (expr.expression.kind === 'ThisKeyword') {
+            let current = expr.parent;
+            while (current && !isClassDeclaration(current))
+                current = current.parent;
+            const member = (current?.members ?? []).find((m) => isPropertyDeclaration(m) && isIdentifier(m.name) && m.name.text === expr.name.text);
+            return member?.type;
+        }
+        const objectType = getExpressionTypeNode(expr.expression);
+        return objectType ? getMemberTypeNode(objectType, expr.name.text) : undefined;
+    }
+    if (isElementAccessExpression(expr)) {
+        const objectType = resolveTypeNode(getExpressionTypeNode(expr.expression));
+        if (isArrayTypeNode(objectType))
+            return objectType.elementType;
+        if (isTypeReferenceNode(objectType) &&
+            isIdentifier(objectType.typeName) &&
+            ['Record', 'Map'].includes(objectType.typeName.text)) {
+            return objectType.typeArguments?.[1];
+        }
+    }
+    return undefined;
+}
+function getContextualTypeNode(node) {
+    const parent = node.parent;
+    if (!parent)
+        return undefined;
+    if (isParenthesizedExpression(parent))
+        return getContextualTypeNode(parent);
+    if (isConditionalExpression(parent) && parent.condition !== node) {
+        return getContextualTypeNode(parent);
+    }
+    if (isBinaryExpression(parent)) {
+        const op = parent.operatorToken.kind;
+        if ((op === 'QuestionQuestionToken' || op === 'BarBarToken') && parent.right === node) {
+            return getContextualTypeNode(parent);
+        }
+        if (op === 'EqualsToken' && parent.right === node) {
+            return getExpressionTypeNode(parent.left);
+        }
+    }
+    if (isAsExpression(parent) || isTypeAssertionExpression(parent))
+        return parent.type;
+    if ((isVariableDeclaration(parent) || isPropertyDeclaration(parent) || parent.kind === 'Parameter') &&
+        parent.initializer === node) {
+        return parent.type;
+    }
+    if (isReturnStatement(parent)) {
+        return getReturnTypeNode(getEnclosingFunction(parent));
+    }
+    if (isArrowFunction(parent) && parent.body === node) {
+        return getReturnTypeNode(parent);
+    }
+    if (isCallExpression(parent) && isIdentifier(parent.expression)) {
+        const index = (parent.arguments ?? []).indexOf(node);
+        const fn = declaredFunctions.get(parent.expression.text);
+        if (index > -1 && fn)
+            return fn.parameters?.[index]?.type;
+    }
+    if (isPropertyAssignment(parent) &&
+        parent.initializer === node &&
+        (isIdentifier(parent.name) || isStringLiteral(parent.name))) {
+        const objectType = getContextualTypeNode(parent.parent);
+        return objectType ? getMemberTypeNode(objectType, parent.name.text) : undefined;
+    }
+    if (isArrayLiteralExpression(parent)) {
+        const arrayType = resolveTypeNode(getContextualTypeNode(parent));
+        if (isArrayTypeNode(arrayType))
+            return arrayType.elementType;
+    }
+    return undefined;
+}
+// Element type of an array literal: from its contextual type (declared
+// variable/parameter/return type), else inferred from its first typed element
+function getArrayLiteralElementType(node) {
+    const contextual = resolveTypeNode(getContextualTypeNode(node));
+    if (isArrayTypeNode(contextual))
+        return getType(contextual.elementType);
+    if (contextual?.kind === 'TupleType')
+        return getTupleElementType(contextual);
+    if (isTypeReferenceNode(contextual) &&
+        isIdentifier(contextual.typeName) &&
+        contextual.typeName.text === 'Array' &&
+        contextual.typeArguments?.length === 1) {
+        return getType(contextual.typeArguments[0]);
+    }
+    for (const element of node.elements ?? []) {
+        if (isSpreadElement(element)) {
+            const spreadType = inferExpressionType(element.expression);
+            if (spreadType?.startsWith('[]'))
+                return spreadType.slice(2);
+            if (spreadType?.startsWith('*TnMap[') && extractMapValueType(spreadType) === 'struct{}') {
+                return extractMapKeyType(spreadType);
+            }
+            continue;
+        }
+        const elementType = inferExpressionType(element);
+        if (elementType && elementType !== 'nil')
+            return elementType;
+    }
+    return 'interface{}';
+}
+// Loop bodies must be blocks in Go; `prefix` is emitted before the body's statements
+function visitLoopBody(statement, prefix = '') {
+    if (isBlock(statement))
+        return visit(statement, { prefixBlockContent: prefix });
+    return `{\n\t\t${prefix}${visit(statement)}}\n\t`;
+}
+// `(x = expr) op rhs` as a loop condition: returns the assignment to hoist
+function getHoistedConditionAssignment(condition) {
+    if (!isBinaryExpression(condition))
+        return undefined;
+    let left = condition.left;
+    while (isParenthesizedExpression(left))
+        left = left.expression;
+    if (isBinaryExpression(left) && left.operatorToken.kind === 'EqualsToken')
+        return left;
+    return undefined;
+}
+// Function type a function literal is expected to have (e.g. from a declared
+// variable, parameter, or Record value type)
+function getContextualFunctionType(fn) {
+    if (!isArrowFunction(fn) && !isFunctionExpression(fn))
+        return undefined;
+    const contextual = resolveTypeNode(getContextualTypeNode(fn));
+    return isFunctionTypeNode(contextual) ? contextual : undefined;
+}
+function unwrapParentheses(expr) {
+    while (isParenthesizedExpression(expr))
+        expr = expr.expression;
+    return expr;
+}
+function getTupleElementType(tuple) {
+    const types = (tuple.elements ?? []).map((t) => getType(t.kind === 'NamedTupleMember' ? t.type : t));
+    return types.length > 0 && types.every((t) => t === types[0]) ? types[0] : 'interface{}';
+}
 function getTypeText(typeNode) {
     if (!typeNode)
         return ':';
@@ -1117,6 +2353,14 @@ function getTypeText(typeNode) {
 function toGoStringLiteral(value) {
     return JSON.stringify(value);
 }
+// A spread source as a Go slice; Sets spread their elements (map keys)
+function visitSpreadSource(expr) {
+    const sourceType = inferExpressionType(expr);
+    if (sourceType?.startsWith('*TnMap[') && extractMapValueType(sourceType) === 'struct{}') {
+        return `${visit(expr)}.Keys()`;
+    }
+    return visit(expr);
+}
 function visitSpreadArrayLiteral(node, elemType) {
     const chunks = [];
     for (const el of (node.elements ?? [])) {
@@ -1124,7 +2368,7 @@ function visitSpreadArrayLiteral(node, elemType) {
             chunks.push({ isSpread: true, items: [el.expression] });
         }
         else {
-            const last = chunks[chunks.length - 1];
+            const last = chunks.length > 0 ? chunks[chunks.length - 1] : undefined;
             if (last && !last.isSpread) {
                 last.items.push(el);
             }
@@ -1137,7 +2381,7 @@ function visitSpreadArrayLiteral(node, elemType) {
     let result = `[]${baseType}{}`;
     for (const chunk of chunks) {
         if (chunk.isSpread) {
-            result = `append(${result}, ${visit(chunk.items[0])}...)`;
+            result = `append(${result}, ${visitSpreadSource(chunk.items[0])}...)`;
         }
         else {
             result = `append(${result}, ${chunk.items.map((e) => visit(e)).join(', ')})`;
@@ -1151,8 +2395,14 @@ function visitTemplateExpression(node) {
         parts.push(toGoStringLiteral(node.head.text));
     }
     for (const span of node.templateSpans) {
-        importedPackages.add('fmt');
-        parts.push(`fmt.Sprintf("%v", ${visit(span.expression)})`);
+        const spanType = inferExpressionType(span.expression);
+        if (spanType && NULLABLE_PRIMITIVE_TYPES.includes(spanType)) {
+            useHelper('dynamic');
+            parts.push(`TnFormat(${visit(span.expression)})`);
+        }
+        else {
+            parts.push(jsStringOf(visit(span.expression), spanType));
+        }
         if (span.literal.text.length > 0) {
             parts.push(toGoStringLiteral(span.literal.text));
         }
@@ -1211,6 +2461,9 @@ function prescanVariableDeclarations(block) {
 function inferFunctionBodyReturnType(node) {
     if (node.type)
         return getType(node.type);
+    const contextualFn = getContextualFunctionType(node);
+    if (contextualFn?.type)
+        return getType(contextualFn.type);
     if (isArrowFunction(node) && !isBlock(node.body)) {
         return inferExpressionType(node.body);
     }
@@ -1226,7 +2479,15 @@ function inferFunctionBodyReturnType(node) {
     return undefined;
 }
 function inferArrowFunctionGoType(node) {
-    const params = (node.parameters ?? []).map((p) => (p.type ? getType(p.type) : 'interface{}')).join(', ');
+    // Mirrors getFunctionParametersInfo: trailing defaulted parameters become
+    // a variadic `...interface{}`
+    const parameters = node.parameters ?? [];
+    const firstDefaultIndex = parameters.findIndex((p) => !!p.initializer);
+    const hasTrailingDefaults = firstDefaultIndex > -1 && !parameters.slice(firstDefaultIndex).some((p) => !p.initializer);
+    const paramTypes = (hasTrailingDefaults ? parameters.slice(0, firstDefaultIndex) : parameters).map((p) => getParameterGoType(p));
+    if (hasTrailingDefaults)
+        paramTypes.push('...interface{}');
+    const params = paramTypes.join(', ');
     const retType = inferFunctionBodyReturnType(node);
     return `func(${params})${retType ? ` ${retType}` : ''}`;
 }
@@ -1236,10 +2497,12 @@ function inferExpressionType(expr) {
     }
     if (isParenthesizedExpression(expr))
         return inferExpressionType(expr.expression);
-    if (isNonNullExpression(expr))
-        return inferExpressionType(expr.expression);
+    if (isNonNullExpression(expr)) {
+        const innerType = inferExpressionType(expr.expression);
+        return innerType && NULLABLE_PRIMITIVE_TYPES.includes(innerType) ? innerType.slice(1) : innerType;
+    }
     if (isAsExpression(expr))
-        return getType(expr.type);
+        return getAsExpressionType(expr);
     if (isTypeAssertionExpression(expr))
         return getType(expr.type);
     if (isStringLiteral(expr) ||
@@ -1249,29 +2512,144 @@ function inferExpressionType(expr) {
     }
     if (isNumericLiteral(expr))
         return 'float64';
+    if (expr.kind === 'TypeOfExpression')
+        return 'string';
+    if (isRegularExpressionLiteral(expr))
+        return '*regexp.Regexp';
+    if (isNewExpression(expr) && isIdentifier(expr.expression) && expr.expression.text === 'RegExp') {
+        return '*regexp.Regexp';
+    }
     if (expr.kind === 'TrueKeyword' || expr.kind === 'FalseKeyword')
         return 'bool';
     if (expr.kind === 'NullKeyword')
         return 'nil';
-    if (isIdentifier(expr))
-        return variableGoTypes.get(expr.text);
+    if (isIdentifier(expr) && expr.text === 'undefined')
+        return 'nil';
+    if (isIdentifier(expr)) {
+        const varType = variableGoTypes.get(expr.text);
+        return narrowedVariables.has(expr.text) && varType?.startsWith('*') ? varType.slice(1) : varType;
+    }
     if (isArrayLiteralExpression(expr)) {
-        const elements = expr.elements ?? [];
-        if (elements.length === 0)
-            return '[]interface{}';
-        const firstElementType = inferExpressionType(elements[0]) ?? 'interface{}';
-        return `[]${firstElementType}`;
+        return `[]${getArrayLiteralElementType(expr)}`;
     }
+    if (isObjectLiteralExpression(expr))
+        return getObjectLiteralGoType(expr);
     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])}`;
+        const typeArguments = getCollectionTypeArguments(expr);
+        if (ctorName === 'Map' && typeArguments.length === 2) {
+            return mapGoType(getType(typeArguments[0]), getType(typeArguments[1]));
         }
-        if (ctorName === 'Set' && expr.typeArguments && expr.typeArguments.length === 1) {
-            return `map[${getType(expr.typeArguments[0])}]struct{}`;
+        if (ctorName === 'Set' && typeArguments.length === 1) {
+            return mapGoType(getType(typeArguments[0]), 'struct{}');
         }
+        if (ctorName === 'Set' && expr.arguments?.length && isArrayLiteralExpression(expr.arguments[0])) {
+            return mapGoType(getArrayLiteralElementType(expr.arguments[0]), 'struct{}');
+        }
+    }
+    if (isElementAccessExpression(expr)) {
+        const objectType = inferExpressionType(expr.expression);
+        if (objectType === 'string')
+            return 'string';
+        if (objectType?.startsWith('[]'))
+            return objectType.slice(2);
+        if (objectType?.startsWith('*TnMap['))
+            return extractMapValueType(objectType);
+        const declared = getExpressionTypeNode(expr);
+        if (declared)
+            return getType(declared);
+    }
+    if (isPropertyAccessExpression(expr) &&
+        isIdentifier(expr.expression) &&
+        expr.expression.text === 'process' &&
+        expr.name.text === 'argv') {
+        return '[]string';
+    }
+    if (isIdentifier(expr) && (expr.text === 'NaN' || expr.text === 'Infinity'))
+        return 'float64';
+    if (isPropertyAccessExpression(expr) && isIdentifier(expr.expression) && expr.expression.text === 'Number') {
+        return 'float64';
+    }
+    // process.env.X (also through casts: (process.env as any).X)
+    if (isPropertyAccessExpression(expr) && isProcessEnv(expr.expression))
+        return 'string';
+    if ((isPrefixUnaryExpression(expr) || isPostfixUnaryExpression(expr)) &&
+        ['MinusToken', 'PlusToken', 'TildeToken', 'PlusPlusToken', 'MinusMinusToken'].includes(expr.operator)) {
+        return 'float64';
+    }
+    if (isCallExpression(expr)) {
+        const callee = isIdentifier(expr.expression)
+            ? expr.expression.text
+            : isPropertyAccessExpression(expr.expression) && isIdentifier(expr.expression.expression)
+                ? `${expr.expression.expression.text}.${expr.expression.name.text}`
+                : undefined;
+        const nodeResultType = callee ? nodeCallResultTypes.get(callee) : undefined;
+        if (callee && BUILTIN_CALL_TYPES[callee])
+            return BUILTIN_CALL_TYPES[callee];
+        if (callee?.startsWith('Math.'))
+            return 'float64';
+        if (nodeResultType)
+            return nodeResultType;
+    }
+    // Object.keys(map) / Object.values(map)
+    if (isCallExpression(expr) &&
+        isPropertyAccessExpression(expr.expression) &&
+        isIdentifier(expr.expression.expression) &&
+        expr.expression.expression.text === 'Object') {
+        const mapType = inferExpressionType(expr.arguments?.[0]);
+        if (mapType?.startsWith('*TnMap[')) {
+            if (expr.expression.name.text === 'keys')
+                return `[]${extractMapKeyType(mapType)}`;
+            if (expr.expression.name.text === 'values')
+                return `[]${extractMapValueType(mapType)}`;
+            if (expr.expression.name.text === 'entries')
+                return '[][]interface{}';
+        }
+    }
+    if (isCallExpression(expr) && isIdentifier(expr.expression)) {
+        const builtinType = BUILTIN_FUNCTION_TYPES[expr.expression.text];
+        if (builtinType && !declaredFunctions.has(expr.expression.text))
+            return builtinType;
+    }
+    if (isPropertyAccessExpression(expr) && expr.name.text === 'length' && isDynamicValue(expr.expression)) {
+        return 'float64';
+    }
+    if ((isPropertyAccessExpression(expr) || isElementAccessExpression(expr)) && isDynamicValue(expr.expression)) {
+        return 'interface{}';
+    }
+    if (isCallExpression(expr) && isObjectKeysOfDynamic(expr))
+        return '[]string';
+    if (isCallExpression(expr) &&
+        isPropertyAccessExpression(expr.expression) &&
+        isIdentifier(expr.expression.expression) &&
+        expr.expression.expression.text === 'JSON' &&
+        expr.expression.name.text === 'parse') {
+        return 'interface{}';
+    }
+    if (isCallExpression(expr) &&
+        isPropertyAccessExpression(expr.expression) &&
+        isDynamicValue(expr.expression.expression)) {
+        const method = expr.expression.name.text;
+        const castCall = castDynamicReceiverCall(expr);
+        if (castCall)
+            return inferExpressionType(castCall);
+        if (method === 'includes')
+            return 'bool';
+        if (method === 'indexOf')
+            return 'float64';
+        if (method === 'slice' || method === 'concat')
+            return 'interface{}';
     }
     if (isPropertyAccessExpression(expr)) {
+        const narrowingKey = getNarrowingKey(expr);
+        if (narrowingKey && narrowedVariables.has(narrowingKey)) {
+            // Narrowed: the declared (pointer) type without its pointer
+            narrowedVariables.delete(narrowingKey);
+            const nullableType = inferExpressionType(expr);
+            narrowedVariables.add(narrowingKey);
+            if (nullableType?.startsWith('*'))
+                return nullableType.slice(1);
+        }
         if (isIdentifier(expr.expression) && enumNames.has(expr.expression.text)) {
             const enumType = getSafeName(expr.expression.text);
             return enumType;
@@ -1286,7 +2664,9 @@ function inferExpressionType(expr) {
             : undefined;
         if (hasQuestionDot(expr)) {
             if (leftType && leftType.startsWith('*')) {
-                const memberType = resolvedPropertyType ?? 'interface{}';
+                const memberType = resolvedPropertyType ??
+                    getStructFieldGoType(leftType.slice(1), expr.name.text) ??
+                    'interface{}';
                 return makeNullableType(memberType);
             }
             return 'interface{}';
@@ -1294,6 +2674,9 @@ function inferExpressionType(expr) {
         if (resolvedPropertyType) {
             return resolvedPropertyType;
         }
+        const structFieldType = leftType ? getStructFieldGoType(leftType.replace(/^\*/, ''), expr.name.text) : undefined;
+        if (structFieldType)
+            return structFieldType;
         if (isIdentifier(expr.expression)) {
             const className = variableClassNames.get(expr.expression.text);
             const memberType = className
@@ -1303,14 +2686,46 @@ function inferExpressionType(expr) {
                 return memberType;
         }
     }
+    if (isCallExpression(expr) && isIdentifier(expr.expression)) {
+        const fn = declaredFunctions.get(expr.expression.text);
+        if (fn?.type)
+            return getType(fn.type);
+        const fnValueType = variableGoTypes.get(expr.expression.text);
+        if (fnValueType?.startsWith('func('))
+            return goFuncReturnType(fnValueType);
+    }
     if (isCallExpression(expr) && isPropertyAccessExpression(expr.expression)) {
         const methodName = expr.expression.name.text;
         const ownerType = inferExpressionType(expr.expression.expression);
-        if (ownerType && ownerType.startsWith('map[')) {
+        if (ownerType &&
+            NULLABLE_PRIMITIVE_TYPES.includes(ownerType) &&
+            (hasQuestionDot(expr) ||
+                hasQuestionDot(expr.expression) ||
+                isOptionalChain(expr.expression.expression))) {
+            const tmp = getTempName('optt');
+            const call = makeNarrowedReceiverCall(expr, tmp, ownerType);
+            const resultType = withNarrowingType([tmp], () => inferExpressionType(call));
+            variableGoTypes.delete(tmp);
+            return resultType ? makeNullableType(resultType) : undefined;
+        }
+        if (ownerType === 'string') {
+            const stringMethodType = STRING_METHOD_RETURN_TYPES[methodName];
+            if (stringMethodType)
+                return stringMethodType;
+        }
+        if (ownerType === '*regexp.Regexp') {
+            if (methodName === 'exec')
+                return '[]string';
+            if (methodName === 'test')
+                return 'bool';
+        }
+        if (ownerType && ownerType.startsWith('*TnMap[')) {
             if (methodName === 'has')
                 return 'bool';
-            if (methodName === 'get')
-                return extractMapValueType(ownerType);
+            if (methodName === 'get') {
+                const valueType = extractMapValueType(ownerType);
+                return isStructGoType(valueType) ? `*${valueType}` : valueType;
+            }
         }
         if (isArrayLikeGoType(ownerType)) {
             const elementType = getArrayElementTypeFromGoType(ownerType);
@@ -1321,10 +2736,17 @@ function inferExpressionType(expr) {
                     : elementType;
                 return `[]${mappedType}`;
             }
-            if (methodName === 'filter')
+            if (['filter', 'slice', 'concat', 'reverse', 'sort'].includes(methodName)) {
                 return `[]${elementType}`;
-            if (methodName === 'some')
+            }
+            if (['some', 'every', 'includes'].includes(methodName))
                 return 'bool';
+            if (['indexOf', 'lastIndexOf', 'findIndex'].includes(methodName))
+                return 'float64';
+            if (['pop', 'shift', 'at'].includes(methodName))
+                return elementType;
+            if (methodName === 'flat' && elementType.startsWith('[]'))
+                return elementType;
             if (methodName === 'find')
                 return elementType;
             if (methodName === 'join')
@@ -1356,55 +2778,352 @@ function inferExpressionType(expr) {
     if (isConditionalExpression(expr)) {
         const whenTrueType = inferExpressionType(expr.whenTrue);
         const whenFalseType = inferExpressionType(expr.whenFalse);
+        // `c ? value : undefined` is nullable
+        if (whenTrueType === 'nil' && whenFalseType)
+            return makeNullableType(whenFalseType);
+        if (whenFalseType === 'nil' && whenTrueType)
+            return makeNullableType(whenTrueType);
         if (whenTrueType && whenTrueType === whenFalseType)
             return whenTrueType;
-        return whenTrueType ?? whenFalseType;
+        if (whenTrueType && whenFalseType === `*${whenTrueType}`)
+            return whenFalseType;
+        if (whenFalseType && whenTrueType === `*${whenFalseType}`)
+            return whenTrueType;
+        const branchType = whenTrueType ?? whenFalseType;
+        return branchType === 'nil' ? 'interface{}' : branchType;
     }
     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)) {
-            return rightType;
+        return getNullishResultType(expr);
+    }
+    if (isPrefixUnaryExpression(expr) && expr.operator === 'ExclamationToken')
+        return 'bool';
+    if (isBinaryExpression(expr)) {
+        const kind = expr.operatorToken.kind;
+        if (COMPARISON_OPERATORS.has(kind) || kind === 'InKeyword' || kind === 'InstanceOfKeyword') {
+            return 'bool';
+        }
+        if (isLogicalOperator(expr.operatorToken)) {
+            return isLogicalValueExpression(expr) ? getLogicalValueType(expr) : 'bool';
+        }
+        if ([
+            'MinusToken',
+            'AsteriskToken',
+            'SlashToken',
+            'PercentToken',
+            'AsteriskAsteriskToken',
+            'AmpersandToken',
+            'BarToken',
+            'CaretToken',
+            'LessThanLessThanToken',
+            'GreaterThanGreaterThanToken',
+            'GreaterThanGreaterThanGreaterThanToken'
+        ].includes(kind)) {
+            return 'float64';
+        }
+        if (kind === 'PlusToken') {
+            const isString = [expr.left, expr.right].some((side) => inferExpressionType(side) === 'string');
+            return isString ? 'string' : 'float64';
+        }
+        if (['LessThanToken', 'GreaterThanToken', 'LessThanEqualsToken', 'GreaterThanEqualsToken'].includes(kind)) {
+            return 'bool';
+        }
+    }
+    return undefined;
+}
+const BUILTIN_CALL_TYPES = {
+    'Number.isNaN': 'bool',
+    'Number.isFinite': 'bool',
+    'Number.isInteger': 'bool',
+    isNaN: 'bool'
+};
+const BUILTIN_FUNCTION_TYPES = {
+    parseFloat: 'float64',
+    parseInt: 'float64',
+    Number: 'float64',
+    String: 'string'
+};
+const STRING_METHOD_RETURN_TYPES = {
+    trim: 'string',
+    trimStart: 'string',
+    trimEnd: 'string',
+    toUpperCase: 'string',
+    toLowerCase: 'string',
+    slice: 'string',
+    substring: 'string',
+    replace: 'string',
+    replaceAll: 'string',
+    padStart: 'string',
+    padEnd: 'string',
+    repeat: 'string',
+    charAt: 'string',
+    concat: 'string',
+    at: 'string',
+    split: '[]string',
+    match: '[]string',
+    matchAll: '[][]string',
+    includes: 'bool',
+    startsWith: 'bool',
+    endsWith: 'bool',
+    indexOf: 'float64',
+    lastIndexOf: 'float64',
+    search: 'float64',
+    charCodeAt: 'float64'
+};
+// Return type of a Go func type string: `func(a T) R` → `R`
+function goFuncReturnType(funcType) {
+    let depth = 0;
+    for (let i = 4; i < funcType.length; i++) {
+        const ch = funcType[i];
+        if (ch === '(')
+            depth++;
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0)
+                return funcType.slice(i + 1).trim() || undefined;
         }
-        return rightType ?? leftType;
     }
     return undefined;
 }
+const COMPARISON_OPERATORS = new Set([
+    'EqualsEqualsEqualsToken',
+    'ExclamationEqualsEqualsToken',
+    'EqualsEqualsToken',
+    'ExclamationEqualsToken',
+    'LessThanToken',
+    'LessThanEqualsToken',
+    'GreaterThanToken',
+    'GreaterThanEqualsToken'
+]);
+function isLogicalOperator(token) {
+    return token?.kind === 'AmpersandAmpersandToken' || token?.kind === 'BarBarToken';
+}
+// JS truthiness of an expression as a Go bool, by its Go type
+function toGoCondition(expr) {
+    if (isParenthesizedExpression(expr))
+        return `(${toGoCondition(expr.expression)})`;
+    if (isPrefixUnaryExpression(expr) && expr.operator === 'ExclamationToken') {
+        return `!${wrapCondition(toGoCondition(expr.operand))}`;
+    }
+    if (isBinaryExpression(expr) && isLogicalOperator(expr.operatorToken)) {
+        const isAnd = expr.operatorToken.kind === 'AmpersandAmpersandToken';
+        const right = withNarrowing(getNarrowedNames(expr.left, isAnd), () => toGoCondition(expr.right));
+        return `${toGoCondition(expr.left)} ${isAnd ? '&&' : '||'} ${right}`;
+    }
+    return truthinessCheck(visit(expr, { inline: true }), inferExpressionType(expr));
+}
+function truthinessCheck(code, goType) {
+    if (!goType || goType === 'bool' || goType === ':')
+        return code;
+    if (goType === 'interface{}') {
+        useHelper('dynamic');
+        return `TnTruthy(${code})`;
+    }
+    if (NULLABLE_PRIMITIVE_TYPES.includes(goType) && !/^[\w.()*]+$/.test(code)) {
+        return `func() bool { __t := ${code}; return ${truthinessCheck('__t', goType)} }()`;
+    }
+    // structs (value types) are always truthy
+    if (isStructGoType(goType))
+        return 'true';
+    if (goType === 'string')
+        return `${code} != ""`;
+    if (goType === 'float64')
+        return `${code} != 0`;
+    if (goType === '*bool')
+        return `(${code} != nil && *${code})`;
+    if (goType === '*string')
+        return `(${code} != nil && *${code} != "")`;
+    if (goType === '*float64')
+        return `(${code} != nil && *${code} != 0)`;
+    if (goType.startsWith('*') ||
+        goType.startsWith('[]') ||
+        goType.startsWith('map[') ||
+        goType.startsWith('func') ||
+        goType.startsWith('chan ') ||
+        goType === 'interface{}') {
+        return `${code} != nil`;
+    }
+    return code;
+}
+// Parenthesizes a condition unless it is already atomic
+function wrapCondition(condition) {
+    return /^[\w.]+$/.test(condition) || /^\(.*\)$/.test(condition) ? condition : `(${condition})`;
+}
+// `a || b` with non-bool operands is a value (JS returns an operand), not a bool
+function isLogicalValueExpression(expr) {
+    if (expr.operatorToken.kind !== 'BarBarToken')
+        return false;
+    const leftType = inferExpressionType(expr.left);
+    const rightType = inferExpressionType(expr.right);
+    return !!leftType && leftType !== 'bool' && !!rightType && rightType !== 'bool';
+}
+function getLogicalValueType(expr) {
+    const leftType = inferExpressionType(expr.left);
+    const rightType = inferExpressionType(expr.right);
+    if (rightType === 'nil')
+        return makeNullableType(leftType);
+    if (leftType.startsWith('*') && rightType === leftType.slice(1))
+        return rightType;
+    return leftType;
+}
+// && / || : boolean form when any operand is non-bool (truthiness), value form for
+// `a || fallback`; undefined keeps the plain Go operator (both operands bool/unknown)
+function visitLogicalExpression(expr) {
+    const leftType = inferExpressionType(expr.left);
+    const rightType = inferExpressionType(expr.right);
+    const isBoolOrUnknown = (t) => !t || t === 'bool' || t === ':';
+    if (isBoolOrUnknown(leftType) && isBoolOrUnknown(rightType))
+        return undefined;
+    if (!isLogicalValueExpression(expr))
+        return toGoCondition(expr);
+    // a || b → func() T { if truthy(a) { return a }; return b }()
+    const resultType = getLogicalValueType(expr);
+    const tmp = getTempName('or');
+    let leftValue = tmp;
+    if (leftType.startsWith('*') && resultType === leftType.slice(1))
+        leftValue = `*${tmp}`;
+    else if (resultType === `*${leftType}`)
+        leftValue = `&${tmp}`;
+    return `func() ${resultType} { ${tmp} := ${visit(expr.left)}; if ${truthinessCheck(tmp, leftType)} { return ${leftValue} }; return ${toGoValueOfType(expr.right, resultType)} }()`;
+}
 function makeNullableType(typeName) {
     if (!typeName || typeName === 'interface{}' || typeName.startsWith('*'))
         return typeName || 'interface{}';
     if (['string', 'float64', 'bool'].includes(typeName))
         return `*${typeName}`;
+    if (isStructGoType(typeName))
+        return `*${typeName}`;
     return typeName;
 }
+// Go struct types (value types that cannot be nil): anonymous structs and
+// property-only interfaces / object type aliases
+// Object types that compile to Go structs: property-only interfaces and
+// object type aliases (values of these types are *Name, like JS references)
+function isObjectTypeName(name) {
+    const alias = declaredTypeAliases.get(name) ?? typeAliases.get(name);
+    if (alias)
+        return alias.kind === 'TypeLiteral';
+    const iface = declaredInterfaces.get(name);
+    if (iface) {
+        const members = iface.members ?? [];
+        return members.some((m) => isPropertySignature(m)) && !members.some((m) => isMethodSignature(m));
+    }
+    return interfacePropertyTypes.has(name);
+}
+function isStructGoType(goType) {
+    return goType.startsWith('struct{') || interfacePropertyTypes.has(goType);
+}
 function visitConditionalExpression(node) {
-    const whenTrue = visit(node.whenTrue);
-    const whenFalse = visit(node.whenFalse);
-    const resultType = inferExpectedTypeFromContext(node) ||
-        (() => {
-            const whenTrueType = inferExpressionType(node.whenTrue);
-            const whenFalseType = inferExpressionType(node.whenFalse);
-            if (whenTrueType && whenTrueType === whenFalseType)
-                return whenTrueType;
-            return whenTrueType ?? whenFalseType ?? 'interface{}';
-        })();
-    return `func() ${resultType} { if ${visit(node.condition)} { return ${whenTrue} }; return ${whenFalse} }()`;
+    const resultType = inferExpectedTypeFromContext(node) || inferExpressionType(node) || 'interface{}';
+    const whenTrue = withNarrowing(getNarrowedNames(node.condition, true), () => toGoValueOfType(node.whenTrue, resultType));
+    const whenFalse = withNarrowing(getNarrowedNames(node.condition, false), () => toGoValueOfType(node.whenFalse, resultType));
+    return `func() ${resultType} { if ${toGoCondition(node.condition)} { return ${whenTrue} }; return ${whenFalse} }()`;
+}
+// Type of `a ?? b`: NonNullable<A> | B — nullable only when b can be null too
+function getNullishResultType(expr) {
+    const leftType = inferExpressionType(expr.left);
+    const rightType = inferExpressionType(expr.right);
+    const leftValueType = leftType && NULLABLE_PRIMITIVE_TYPES.includes(leftType) ? leftType.slice(1) : leftType;
+    if (!rightType || rightType === 'nil')
+        return leftType;
+    if (rightType === leftValueType)
+        return rightType;
+    if (leftValueType && rightType === `*${leftValueType}`)
+        return rightType;
+    if (leftValueType === 'interface{}')
+        return 'interface{}';
+    if (!leftValueType)
+        return rightType;
+    return leftValueType;
+}
+// Inside a ?? chain an operand keeps its own type; otherwise the context decides
+function getNullishEmitType(node) {
+    const parent = node.parent;
+    const inChain = isBinaryExpression(parent) && parent.operatorToken.kind === 'QuestionQuestionToken';
+    return (inChain ? undefined : inferExpectedTypeFromContext(node)) || getNullishResultType(node);
 }
+// a ?? b ?? c: operands are tried in order; map lookups (comma-ok) and nil-able
+// values may be missing, anything else is always defined and ends the chain
 function visitNullishCoalescingExpression(node) {
-    const leftType = inferExpressionType(node.left);
-    const rightType = inferExpressionType(node.right);
-    if (leftType && leftType.startsWith('*')) {
-        const leftValueType = leftType.slice(1);
-        const expectedType = inferExpectedTypeFromContext(node);
-        const resultType = expectedType || (rightType === leftValueType ? leftValueType : (rightType ?? leftType));
+    const operands = flattenNullishChain(node);
+    const resultType = getNullishEmitType(node) || 'interface{}';
+    const steps = [];
+    for (let i = 0; i < operands.length; i++) {
+        const operand = operands[i];
+        const isLast = i === operands.length - 1;
         const tmp = getTempName('nullish');
-        const leftExpr = visit(node.left);
-        const rightExpr = visit(node.right);
-        const returnLeft = resultType === leftValueType ? `*${tmp}` : tmp;
-        return `func() ${resultType} { ${tmp} := ${leftExpr}; if ${tmp} == nil { return ${rightExpr} }; return ${returnLeft} }()`;
+        const lookup = isLast ? undefined : getMapLookup(operand);
+        const operandType = inferExpressionType(operand);
+        const arrayType = !isLast && isElementAccessExpression(operand) ? inferExpressionType(operand.expression) : undefined;
+        if (arrayType?.startsWith('[]')) {
+            // arr[i] ?? x: out of range is undefined in JS
+            const array = getTempName('arr');
+            const index = getTempName('idx');
+            steps.push(`if ${array}, ${index} := ${visit(operand.expression)}, int(${visit(operand.argumentExpression)}); ${index} >= 0 && ${index} < len(${array}) { return ${convertGoValue(`${array}[${index}]`, arrayType.slice(2), resultType)} }`);
+        }
+        else if (lookup) {
+            const valueType = extractMapValueType(inferExpressionType(lookup.mapNode) ?? '');
+            steps.push(`if ${tmp}, ok := ${lookup.map}.Lookup(${lookup.key}); ok { return ${convertGoValue(tmp, valueType, resultType)} }`);
+        }
+        else if (!isLast && operandType && isNilableGoType(operandType)) {
+            steps.push(`if ${tmp} := ${visit(operand)}; ${tmp} != nil { return ${convertGoValue(tmp, operandType, resultType)} }`);
+        }
+        else {
+            steps.push(`return ${toGoValueOfType(operand, resultType)}`);
+            break;
+        }
+    }
+    return `func() ${resultType} { ${steps.join('; ')} }()`;
+}
+function flattenNullishChain(node) {
+    if (isBinaryExpression(node) && node.operatorToken.kind === 'QuestionQuestionToken') {
+        return [...flattenNullishChain(node.left), node.right];
+    }
+    if (isParenthesizedExpression(node))
+        return flattenNullishChain(node.expression);
+    return [node];
+}
+// Converts a Go variable between T and *T as the target type requires
+function convertGoValue(variable, fromType, toType) {
+    if (toType === `*${fromType}`)
+        return `&${variable}`;
+    if (fromType === `*${toType}`)
+        return `*${variable}`;
+    // dynamic (any) values hold the concrete type at runtime
+    if (fromType === 'interface{}' && toType !== 'interface{}')
+        return `${variable}.(${toType})`;
+    return variable;
+}
+// Map lookups (m.get(k) on a Map, m[k] on a Record): Go code of the map and key
+function getMapLookup(expr) {
+    if (isCallExpression(expr) &&
+        isPropertyAccessExpression(expr.expression) &&
+        expr.expression.name.text === 'get' &&
+        inferExpressionType(expr.expression.expression)?.startsWith('*TnMap[')) {
+        const mapType = inferExpressionType(expr.expression.expression);
+        return {
+            map: visit(expr.expression.expression),
+            key: toGoValueOfType(expr.arguments[0], extractMapKeyType(mapType)),
+            mapNode: expr.expression.expression
+        };
+    }
+    if (isElementAccessExpression(expr) && inferExpressionType(expr.expression)?.startsWith('*TnMap[')) {
+        const mapType = inferExpressionType(expr.expression);
+        return {
+            map: visit(expr.expression),
+            key: toGoValueOfType(expr.argumentExpression, extractMapKeyType(mapType)),
+            mapNode: expr.expression
+        };
     }
-    return visit(node.left);
+    return undefined;
+}
+function isNilableGoType(goType) {
+    return (goType.startsWith('*') ||
+        goType.startsWith('[]') ||
+        goType.startsWith('map[') ||
+        goType.startsWith('func') ||
+        goType.startsWith('chan ') ||
+        goType === 'interface{}');
 }
 function visitOptionalPropertyAccess(node) {
     const baseExpr = visit(node.expression);
@@ -1414,7 +3133,10 @@ function visitOptionalPropertyAccess(node) {
         return getAcessString(baseExpr, visit(node.name), objectType);
     }
     const className = baseType.replace(/^\*/, '').replace(/\[.*\]$/, '');
-    const propertyType = classPropertyTypes.get(className)?.get(node.name.text) ?? 'interface{}';
+    const propertyType = classPropertyTypes.get(className)?.get(node.name.text) ??
+        interfacePropertyTypes.get(className)?.get(node.name.text) ??
+        getStructFieldGoType(className, node.name.text) ??
+        'interface{}';
     const nullableType = makeNullableType(propertyType);
     const tmp = getTempName('opt');
     const propertyAccess = `${tmp}.${visit(node.name)}`;
@@ -1427,8 +3149,9 @@ function visitOptionalPropertyAccess(node) {
 function visitOptionalElementAccess(node) {
     const baseExpr = visit(node.expression);
     const baseType = inferExpressionType(node.expression);
-    if (!baseType || !baseType.startsWith('*')) {
-        return `${baseExpr}[int(${visit(node.argumentExpression)})]`;
+    if (!baseType || !baseType.startsWith('*') || baseType.startsWith('*TnMap[')) {
+        const plainAccess = { ...node, questionDotToken: undefined };
+        return visit(plainAccess);
     }
     const valueType = inferExpectedTypeFromContext(node) ?? 'interface{}';
     const nullableType = makeNullableType(valueType);
@@ -1440,6 +3163,33 @@ function visitOptionalElementAccess(node) {
     }
     return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; return ${elementExpr} }()`;
 }
+// The call with its receiver replaced by a narrowed temporary of the receiver's type
+function makeNarrowedReceiverCall(node, tmp, baseType) {
+    variableGoTypes.set(tmp, baseType);
+    const receiver = { kind: 'Identifier', text: tmp };
+    const access = { ...node.expression, questionDotToken: undefined, expression: receiver };
+    const call = { ...node, questionDotToken: undefined, expression: access, parent: node.parent };
+    receiver.parent = access;
+    access.parent = call;
+    return call;
+}
+function visitNullablePrimitiveOptionalCall(node, baseExpr, baseType) {
+    const tmp = getTempName('optc');
+    const call = makeNarrowedReceiverCall(node, tmp, baseType);
+    const resultType = makeNullableType(withNarrowingType([tmp], () => inferExpressionType(call)) ?? 'interface{}');
+    const callCode = withNarrowing([tmp], () => visit(call));
+    const value = resultType.startsWith('*') ? `func() ${resultType} { v := ${callCode}; return &v }()` : callCode;
+    return `func() ${resultType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { return nil }; return ${value} }()`;
+}
+function withNarrowingType(names, infer) {
+    const added = names.filter((n) => !narrowedVariables.has(n));
+    for (const name of added)
+        narrowedVariables.add(name);
+    const type = infer();
+    for (const name of added)
+        narrowedVariables.delete(name);
+    return type;
+}
 function visitOptionalCall(node) {
     if (!isPropertyAccessExpression(node.expression)) {
         return `${visit(node.expression)}(${(node.arguments ?? []).map((a) => visit(a)).join(', ')})`;
@@ -1449,8 +3199,14 @@ function visitOptionalCall(node) {
     const baseExpr = visit(baseNode);
     const baseType = inferExpressionType(baseNode);
     const args = (node.arguments ?? []).map((a) => visit(a)).join(', ');
-    if (!baseType || !baseType.startsWith('*')) {
-        return `${baseExpr}.${methodName}(${args})`;
+    if (baseType && NULLABLE_PRIMITIVE_TYPES.includes(baseType)) {
+        return visitNullablePrimitiveOptionalCall(node, baseExpr, baseType);
+    }
+    if (!baseType || !baseType.startsWith('*') || baseType.startsWith('*TnMap[')) {
+        const plainAccess = { ...node.expression, questionDotToken: undefined };
+        const plainCall = { ...node, questionDotToken: undefined, expression: plainAccess };
+        plainAccess.parent = plainCall;
+        return visit(plainCall);
     }
     const className = baseType.replace(/^\*/, '').replace(/\[.*\]$/, '');
     const returnType = classMethodReturnTypes.get(className)?.get(methodName) ?? 'interface{}';
@@ -1479,7 +3235,7 @@ function inferArrayCallbackReturnType(callback, elementType, fallbackType) {
             return explicitType || fallbackType;
         }
         if (isBlock(callback.body)) {
-            return fallbackType;
+            return inferFunctionBodyReturnType(callback) ?? fallbackType;
         }
         const inferred = inferExpressionType(callback.body);
         return inferred ?? fallbackType;
@@ -1491,23 +3247,24 @@ function inferArrayCallbackReturnType(callback, elementType, fallbackType) {
     }
     return fallbackType;
 }
-function buildArrayCallbackInfo(callback, elementType, forcedReturnType) {
+function buildArrayCallbackInfo(callback, elementType, forcedReturnType, paramTypes = [elementType, 'float64', `[]${elementType}`]) {
     if (isArrowFunction(callback) || isFunctionExpression(callback)) {
-        const paramCount = callback.parameters.length;
-        const callbackReturnType = forcedReturnType ?? inferArrayCallbackReturnType(callback, elementType, 'interface{}');
-        const params = [];
-        if (paramCount > 0) {
-            params.push(`${visit(callback.parameters[0].name)} ${elementType}`);
-        }
-        if (paramCount > 1) {
-            params.push(`${visit(callback.parameters[1].name)} float64`);
-        }
-        if (paramCount > 2) {
-            params.push(`${visit(callback.parameters[2].name)} []${elementType}`);
-        }
+        const paramCount = (callback.parameters ?? []).length;
+        (callback.parameters ?? []).slice(0, paramTypes.length).forEach((p, index) => {
+            if (isIdentifier(p.name))
+                registerLocalVariable(p.name.text, paramTypes[index]);
+        });
+        const callbackReturnType = forcedReturnType ?? inferArrayCallbackReturnType(callback, elementType, elementType);
+        const params = (callback.parameters ?? [])
+            .slice(0, paramTypes.length)
+            .map((p, index) => `${visit(p.name)} ${paramTypes[index]}`);
         const body = isBlock(callback.body)
             ? visit(callback.body, { inline: true })
-            : `{ return ${visit(callback.body)}; }`;
+            : forcedReturnType === 'bool'
+                ? `{ return ${toGoCondition(callback.body)}; }`
+                : forcedReturnType === ''
+                    ? `{ ${visit(unwrapParentheses(callback.body))}; }`
+                    : `{ return ${visit(callback.body)}; }`;
         return {
             fnExpr: `func(${params.join(', ')}) ${callbackReturnType} ${body}`,
             paramCount,
@@ -1528,7 +3285,12 @@ function buildArrayCallbackInvocation(callbackInfo, itemVar, indexVar, arrayVar)
         args.push(`float64(${indexVar})`);
     if (callbackInfo.paramCount > 2)
         args.push(arrayVar);
-    return `(${callbackInfo.fnExpr})(${args.join(', ')})`;
+    const call = `(${callbackInfo.fnExpr})(${args.join(', ')})`;
+    if (callbackInfo.paramCount > 0)
+        return call;
+    const returnType = callbackInfo.returnType ? ` ${callbackInfo.returnType}` : '';
+    const ret = callbackInfo.returnType ? 'return ' : '';
+    return `func()${returnType} { _ = ${itemVar}; ${ret}${call} }()`;
 }
 // Like buildArrayCallbackInvocation but for reduce: (acc, item, idx, arr)
 function buildArrayCallbackInvocationReduce(callbackInfo, accVar, itemVar, indexVar, arrayVar) {
@@ -1556,6 +3318,21 @@ function visitArrayHigherOrderCall(node) {
     const elementType = isArrayLikeGoType(ownerType)
         ? getArrayElementTypeFromGoType(ownerType)
         : 'interface{}';
+    if (methodName === 'forEach' && ownerType?.startsWith('*TnMap[')) {
+        const callback = (node.arguments ?? [])[0];
+        if (!callback)
+            return undefined;
+        const keyType = extractMapKeyType(ownerType);
+        const valueType = extractMapValueType(ownerType);
+        const info = buildArrayCallbackInfo(callback, valueType, '', [
+            valueType === 'struct{}' ? keyType : valueType,
+            keyType
+        ]);
+        const key = getTempName('key');
+        const value = getTempName('value');
+        const args = [valueType === 'struct{}' ? key : value, key].slice(0, info.paramCount).join(', ');
+        return `func() { for ${key}, ${value} := range ${arrayExpr}.All() { _, _ = ${key}, ${value}; (${info.fnExpr})(${args}) } }()`;
+    }
     if (methodName === 'join') {
         // Only intercept array.join — if owner type is unknown/not array, fall through to callHandlers
         if (!isArrayLikeGoType(ownerType))
@@ -1575,7 +3352,7 @@ function visitArrayHigherOrderCall(node) {
     const idxVar = getTempName('i');
     const itemVar = getTempName('item');
     if (methodName === 'map') {
-        const callbackInfo = buildArrayCallbackInfo(callback, elementType, elementType);
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType);
         const mappedType = callbackInfo.returnType || 'interface{}';
         const resultVar = getTempName('mapres');
         const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
@@ -1622,7 +3399,12 @@ function visitArrayHigherOrderCall(node) {
             : 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 cbInfo = buildArrayCallbackInfo(reduceCallback, elementType, accType, [
+            accType,
+            elementType,
+            'float64',
+            `[]${elementType}`
+        ]);
         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 : '_';
@@ -1736,10 +3518,17 @@ function visitEnumDeclaration(node) {
 function getType(typeNode, getArrayType = false) {
     if (!typeNode)
         return ':';
+    if (typeNode.kind === 'ParenthesizedType')
+        return getType(typeNode.type, getArrayType);
     if (isArrayTypeNode(typeNode)) {
         const elementType = getType(typeNode.elementType);
         return getArrayType ? elementType : `[]${elementType}`;
     }
+    // [A, B] tuples are slices: []A when all elements share a type, else []interface{}
+    if (typeNode.kind === 'TupleType') {
+        const elementType = getTupleElementType(typeNode);
+        return getArrayType ? elementType : `[]${elementType}`;
+    }
     // Handle union types (e.g. string | null, number | undefined)
     if (isUnionTypeNode(typeNode)) {
         const nonNullTypes = typeNode.types.filter((t) => t.kind !== 'NullKeyword' &&
@@ -1748,7 +3537,7 @@ function getType(typeNode, getArrayType = false) {
         if (nonNullTypes.length === 1 && nonNullTypes.length < typeNode.types.length) {
             // This is a nullable type T | null or T | undefined
             const innerType = getType(nonNullTypes[0]);
-            if (['float64', 'string', 'bool'].includes(innerType)) {
+            if (['float64', 'string', 'bool'].includes(innerType) || isStructGoType(innerType)) {
                 return `*${innerType}`;
             }
             // Pointer/interface types already support nil
@@ -1758,7 +3547,7 @@ function getType(typeNode, getArrayType = false) {
         return 'interface{}';
     }
     if (isFunctionTypeNode(typeNode)) {
-        const params = typeNode.parameters
+        const params = (typeNode.parameters ?? [])
             .map((p) => (p.type ? getType(p.type) : 'interface{}'))
             .join(', ');
         const ret = typeNode.type ? ` ${getType(typeNode.type)}` : '';
@@ -1770,7 +3559,7 @@ function getType(typeNode, getArrayType = false) {
             return getSafeName(name);
         }
         const aliasType = getAliasType(name);
-        if (aliasType) {
+        if (aliasType && aliasType.kind !== 'TypeLiteral') {
             return getType(aliasType, getArrayType);
         }
         if (name === 'Promise' && typeNode.typeArguments && typeNode.typeArguments.length > 0) {
@@ -1779,21 +3568,30 @@ function getType(typeNode, getArrayType = false) {
         if (name === 'RegExp') {
             return '*regexp.Regexp';
         }
-        if (name === 'Map' && typeNode.typeArguments && typeNode.typeArguments.length === 2) {
-            const keyType = getType(typeNode.typeArguments[0]);
-            const valueType = getType(typeNode.typeArguments[1]);
-            return `map[${keyType}]${valueType}`;
+        if (name === 'RegExpExecArray' || name === 'RegExpMatchArray') {
+            return '[]string';
+        }
+        if ((name === 'Map' || name === 'Record') &&
+            typeNode.typeArguments &&
+            typeNode.typeArguments.length === 2) {
+            return mapGoType(getType(typeNode.typeArguments[0]), getType(typeNode.typeArguments[1]));
         }
         if (name === 'Set' && typeNode.typeArguments && typeNode.typeArguments.length === 1) {
-            const elementType = getType(typeNode.typeArguments[0]);
-            return `map[${elementType}]struct{}`;
+            return mapGoType(getType(typeNode.typeArguments[0]), 'struct{}');
         }
         const typeArgs = getTypeArguments(typeNode.typeArguments);
-        if (classNames.has(name)) {
+        if (classNames.has(name) || isObjectTypeName(name)) {
             return `*${name}${typeArgs}`;
         }
         return `${name}${typeArgs}`;
     }
+    // { a: T; b?: U } → struct{ a T; b *U }
+    if (typeNode.kind === 'TypeLiteral') {
+        const fields = (typeNode.members ?? [])
+            .filter((m) => isPropertySignature(m) && isIdentifier(m.name))
+            .map((m) => `${goFieldName(m.name.text)} ${getOptionalNodeType(m.type, !!m.questionToken)}`);
+        return fields.length > 0 ? `*struct{ ${fields.join('; ')} }` : 'interface{}';
+    }
     // Syntactic replacement for the ts typechecker: render the type node's text
     let typeName = typeNodeToText(typeNode);
     const isArray = typeName.includes('[]');
@@ -1811,7 +3609,7 @@ function getType(typeNode, getArrayType = false) {
         case 'boolean':
             return 'bool';
         case 'any':
-            return ':';
+            return 'interface{}';
         case 'void':
             return '';
         default:
@@ -1864,11 +3662,25 @@ function getClassNameFromTypeNode(typeNode) {
 }
 function resolveExpressionType(expr) {
     if (isIdentifier(expr)) {
-        return variableTypes.get(expr.text);
+        return variableTypes.get(expr.text) ?? goTypeCategory(variableGoTypes.get(expr.text));
     }
     if (expr.kind === 'ThisKeyword') {
         return 'class';
     }
+    return goTypeCategory(inferExpressionType(expr));
+}
+// Method-dispatch category of an inferred Go type (e.g. `const s = new Set<T>()`)
+function goTypeCategory(goType) {
+    if (!goType)
+        return undefined;
+    if (goType.startsWith('*TnMap['))
+        return extractMapValueType(goType) === 'struct{}' ? 'Set' : 'Map';
+    if (goType.startsWith('[]'))
+        return 'array';
+    if (goType === 'string')
+        return 'string';
+    if (goType === '*regexp.Regexp')
+        return 'RegExp';
     return undefined;
 }
 function isNilLiteral(node) {
@@ -1883,7 +3695,7 @@ function getAcessString(leftSide, rightSide, objectType) {
         return `float64(len(${leftSide}))`;
     }
     if (rightSide === 'size' && (objectType === 'Map' || objectType === 'Set')) {
-        return `float64(len(${leftSide}))`;
+        return `float64(${leftSide}.Len())`;
     }
     // process global properties
     if (leftSide === 'process') {
@@ -1892,16 +3704,32 @@ function getAcessString(leftSide, rightSide, objectType) {
             return 'os.Args';
         }
         if (rightSide === 'platform') {
-            importedPackages.add('runtime');
-            return 'runtime.GOOS';
+            // Node's names: win32 / darwin / linux
+            useHelper('osPlatform');
+            return 'TnOsPlatform()';
         }
         if (rightSide === 'env') {
             // process.env.X is detected via the nested access below
             return 'process.env';
         }
     }
+    if (leftSide === 'Number') {
+        const constants = {
+            MAX_SAFE_INTEGER: 'float64(9007199254740991)',
+            MIN_SAFE_INTEGER: 'float64(-9007199254740991)',
+            EPSILON: 'float64(2.220446049250313e-16)'
+        };
+        if (constants[rightSide])
+            return constants[rightSide];
+        if (rightSide === 'MAX_VALUE' || rightSide === 'POSITIVE_INFINITY' || rightSide === 'NaN') {
+            importedPackages.add('math');
+            if (rightSide === 'MAX_VALUE')
+                return 'math.MaxFloat64';
+            return rightSide === 'NaN' ? 'math.NaN()' : 'math.Inf(1)';
+        }
+    }
     // process.env.X → TnGetenv("X") (os.Environ() is a []string in Go, not a map)
-    if (leftSide === 'process.env') {
+    if (leftSide === 'process.env' || leftSide === '(process.env)') {
         useHelper('getenv');
         return `TnGetenv("${rightSide}")`;
     }
@@ -1945,13 +3773,20 @@ const callHandlers = {
         importedPackages.add('math');
         return `math.Abs(${args[0]})`;
     },
+    // Math.max(...arr) → slices.Max(arr); otherwise Go's variadic builtin
     'Math.max': (_caller, args) => {
-        importedPackages.add('math');
-        return `math.Max(${args[0]}, ${args[1]})`;
+        if (args.length === 1 && args[0].endsWith('...')) {
+            importedPackages.add('slices');
+            return `slices.Max(${args[0].slice(0, -3)})`;
+        }
+        return `max(${args.join(', ')})`;
     },
     'Math.min': (_caller, args) => {
-        importedPackages.add('math');
-        return `math.Min(${args[0]}, ${args[1]})`;
+        if (args.length === 1 && args[0].endsWith('...')) {
+            importedPackages.add('slices');
+            return `slices.Min(${args[0].slice(0, -3)})`;
+        }
+        return `min(${args.join(', ')})`;
     },
     'Math.sqrt': (_caller, args) => {
         importedPackages.add('math');
@@ -1962,12 +3797,12 @@ const callHandlers = {
         return `math.Pow(${args[0]}, ${args[1]})`;
     },
     parseInt: (_caller, args) => {
-        importedPackages.add('strconv');
-        return `func() float64 { v, _ := strconv.Atoi(${args[0]}); return float64(v) }()`;
+        useHelper('dynamic');
+        return `TnParseInt(${args[0]}, ${args[1] ?? '10'})`;
     },
     parseFloat: (_caller, args) => {
-        importedPackages.add('strconv');
-        return `func() float64 { v, _ := strconv.ParseFloat(${args[0]}, 64); return v }()`;
+        useHelper('dynamic');
+        return `TnParseFloat(${args[0]})`;
     },
     'process.exit': (_caller, args) => {
         importedPackages.add('os');
@@ -1978,27 +3813,17 @@ const callHandlers = {
         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) }()`;
+        useHelper('jsonStringify');
+        return `TnJSONStringify(${args[0]}, ${args.length >= 3 ? '"  "' : '""'})`;
     },
     '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];
-    },
+    'Object.keys': (_caller, args) => `${args[0]}.Keys()`,
+    'Object.values': (_caller, args) => `${args[0]}.Values()`,
+    // Outside for...of (which iterates the map directly): [key, value] pairs
+    'Object.entries': (_caller, args) => `${args[0]}.Entries()`,
     'Math.log': (_caller, args) => {
         importedPackages.add('math');
         return `math.Log(${args[0]})`;
@@ -2035,13 +3860,38 @@ const callHandlers = {
         importedPackages.add('os');
         return `fmt.Fprintln(os.Stderr, ${args.join(', ')})`;
     },
+    'console.warn': (_caller, args) => {
+        importedPackages.add('fmt');
+        importedPackages.add('os');
+        return `fmt.Fprintln(os.Stderr, ${args.join(', ')})`;
+    },
+    'Array.isArray': (_caller, args) => {
+        importedPackages.add('reflect');
+        return `(reflect.ValueOf(${args[0]}).Kind() == reflect.Slice)`;
+    },
     '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 }()`;
+        useHelper('dynamic');
+        return `TnNumber(${args[0]})`;
+    },
+    'Number.isNaN': (_caller, args) => {
+        importedPackages.add('math');
+        return `math.IsNaN(${args[0]})`;
+    },
+    isNaN: (_caller, args) => {
+        importedPackages.add('math');
+        return `math.IsNaN(${args[0]})`;
+    },
+    'Number.isFinite': (_caller, args) => {
+        importedPackages.add('math');
+        return `!math.IsInf(${args[0]}, 0) && !math.IsNaN(${args[0]})`;
+    },
+    'Number.isInteger': (_caller, args) => {
+        importedPackages.add('math');
+        return `(${args[0]} == math.Trunc(${args[0]}) && !math.IsInf(${args[0]}, 0))`;
     },
     'Boolean': (_caller, args) => {
         return `(${args[0]} != nil && ${args[0]} != false && ${args[0]} != 0 && ${args[0]} != "")`;
@@ -2049,6 +3899,8 @@ const callHandlers = {
 };
 const stringMethodHandlers = {
     split: (obj, args) => {
+        if (args[0]?.startsWith('regexp.MustCompile('))
+            return `${args[0]}.Split(${obj}, -1)`;
         importedPackages.add('strings');
         return `strings.Split(${obj}, ${args[0]})`;
     },
@@ -2103,17 +3955,16 @@ const stringMethodHandlers = {
     charAt: (obj, args) => `string(${obj}[int(${args[0]})])`,
     substring: (obj, args) => {
         if (args.length >= 2)
-            return `${obj}[int(${args[0]}):int(${args[1]})]`;
-        return `${obj}[int(${args[0]}):]`;
+            return `${obj}[${sliceIndex(obj, args[0])}:${sliceIndex(obj, args[1])}]`;
+        return `${obj}[${sliceIndex(obj, args[0])}:]`;
     },
     slice: (obj, args) => {
         if (args.length >= 2)
-            return `${obj}[int(${args[0]}):int(${args[1]})]`;
-        return `${obj}[int(${args[0]}):]`;
+            return `${obj}[${sliceIndex(obj, args[0])}:${sliceIndex(obj, args[1])}]`;
+        return `${obj}[${sliceIndex(obj, 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 }()`;
@@ -2123,17 +3974,12 @@ const stringMethodHandlers = {
         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])`;
+    match: (obj, args) => `${toGoRegexp(args[0])}.FindStringSubmatch(${obj})`,
+    matchAll: (obj, args) => `${toGoRegexp(args[0])}.FindAllStringSubmatch(${obj}, -1)`,
+    search: (obj, args) => `func() float64 { __loc := ${toGoRegexp(args[0])}.FindStringIndex(${obj}); if __loc == nil { return -1 }; return float64(__loc[0]) }()`,
+    lastIndexOf: (obj, args) => {
+        importedPackages.add('strings');
+        return `float64(strings.LastIndex(${obj}, ${args[0]}))`;
     },
     at: (obj, args) => {
         return `func() string { __i := int(${args[0]}); if __i < 0 { __i = len(${obj}) + __i }; return string(${obj}[__i]) }()`;
@@ -2150,37 +3996,54 @@ 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 }()`;
+        const elementType = receiverElementType();
+        if (!isAddressable(obj)) {
+            return `func() ${elementType} { __s := ${obj}; if len(__s) == 0 { var __zero ${elementType}; return __zero }; return __s[len(__s)-1] }()`;
+        }
+        return `func() ${elementType} { if len(${obj}) == 0 { var __zero ${elementType}; return __zero }; __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 }()`;
+        const elementType = receiverElementType();
+        if (!isAddressable(obj)) {
+            return `func() ${elementType} { __s := ${obj}; if len(__s) == 0 { var __zero ${elementType}; return __zero }; return __s[0] }()`;
+        }
+        return `func() ${elementType} { if len(${obj}) == 0 { var __zero ${elementType}; return __zero }; __first := ${obj}[0]; ${obj} = ${obj}[1:]; return __first }()`;
     },
-    unshift: (obj, args) => `${obj} = append([]interface{}{${args.join(', ')}}, ${obj}...)`,
+    unshift: (obj, args) => `${obj} = append([]${receiverElementType()}{${args.join(', ')}}, ${obj}...)`,
     join: (obj, args) => {
         importedPackages.add('strings');
         return `strings.Join(${obj}, ${args[0] ?? '""'})`;
     },
     slice: (obj, args) => {
         if (args.length >= 2)
-            return `${obj}[int(${args[0]}):int(${args[1]})]`;
-        return `${obj}[int(${args[0]}):]`;
+            return `${obj}[${sliceIndex(obj, args[0])}:${sliceIndex(obj, args[1])}]`;
+        return `${obj}[${sliceIndex(obj, args[0])}:]`;
     },
     reverse: (obj) => {
         importedPackages.add('slices');
         return `func() interface{} { slices.Reverse(${obj}); return nil }()`;
     },
-    sort: (obj) => {
+    // Sorts in place and returns the array; without a comparator, compares as strings (like JS)
+    sort: (obj, args) => {
         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 }()`;
+        const arrayType = currentReceiverGoType?.startsWith('[]') ? currentReceiverGoType : '[]interface{}';
+        let less = `(${args[0]})(__s[i], __s[j]) < 0`;
+        if (!args[0]) {
+            importedPackages.add('fmt');
+            less = `fmt.Sprintf("%v", __s[i]) < fmt.Sprintf("%v", __s[j])`;
+        }
+        return `func() ${arrayType} { __s := ${obj}; sort.SliceStable(__s, func(i, j int) bool { return ${less} }); return __s }()`;
     },
+    indexOf: (obj, args) => `func() float64 { __x := ${args[0]}; for __i, __v := range ${obj} { if ${elementEquals('__v', '__x')} { return float64(__i) } }; return float64(-1) }()`,
+    includes: (obj, args) => `func() bool { __x := ${args[0]}; for _, __v := range ${obj} { if ${elementEquals('__v', '__x')} { return true } }; return false }()`,
     concat: (obj, args) => `append(${obj}, ${args.join(', ')}...)`,
-    flat: (obj) => obj,
+    // [][]T → []T (one level, like JS's default depth)
+    flat: (obj) => {
+        const elementType = receiverElementType();
+        if (!elementType.startsWith('[]'))
+            return obj;
+        return `func() ${elementType} { var __flat ${elementType}; for _, __inner := range ${obj} { __flat = append(__flat, __inner...) }; return __flat }()`;
+    },
     toString: (obj) => {
         importedPackages.add('fmt');
         return `fmt.Sprintf("%v", ${obj})`;
@@ -2190,24 +4053,52 @@ const arrayMethodHandlers = {
         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] }()`;
     },
 };
+function receiverElementType() {
+    return currentReceiverGoType?.startsWith('[]') ? currentReceiverGoType.slice(2) : 'interface{}';
+}
+// Go expressions that can be assigned to (variables, fields, index expressions)
+function isAddressable(code) {
+    return /^[\w.]+(\[[^\]]*\])*$/.test(code);
+}
+// A regex argument as a *regexp.Regexp: compiled literals pass through, pattern
+// strings are compiled
+function toGoRegexp(arg) {
+    importedPackages.add('regexp');
+    if (arg.startsWith('regexp.MustCompile(') || variableGoTypes.get(arg) === '*regexp.Regexp')
+        return arg;
+    return `regexp.MustCompile(${arg})`;
+}
+// A JS slice index: negative values count from the end
+// A JS slice index: negative values count from the end; out-of-range values clamp
+function sliceIndex(obj, index) {
+    if (index.startsWith('-'))
+        return `max(0, int(float64(len(${obj})) + ${index}))`;
+    return `min(int(${index}), len(${obj}))`;
+}
+// Equality of two array elements of the current receiver's element type
+function elementEquals(a, b) {
+    const elementType = receiverElementType();
+    if (elementType === 'interface{}' || elementType.startsWith('*TnMap[') || elementType.startsWith('[]')) {
+        useHelper('dynamic');
+        return `TnSame(${a}, ${b})`;
+    }
+    return `${a} == ${b}`;
+}
 const mapMethodHandlers = {
-    set: (obj, args) => `${obj}[${args[0]}] = ${args[1]}`,
-    get: (obj, args) => `${obj}[${args[0]}]`,
-    has: (obj, args) => {
-        const tmp = getTempName('ok');
-        return `func() bool { _, ${tmp} := ${obj}[${args[0]}]; return ${tmp} }()`;
-    },
-    delete: (obj, args) => `delete(${obj}, ${args[0]})`,
-    clear: (obj) => `clear(${obj})`
+    set: (obj, args) => `${obj}.Set(${args[0]}, ${args[1]})`,
+    get: (obj, args) => `${obj}.Get(${args[0]})`,
+    has: (obj, args) => `${obj}.Has(${args[0]})`,
+    delete: (obj, args) => `${obj}.Delete(${args[0]})`,
+    clear: (obj) => `${obj}.Clear()`,
+    keys: (obj) => `${obj}.Keys()`,
+    values: (obj) => `${obj}.Values()`
 };
 const setMethodHandlers = {
-    add: (obj, args) => `${obj}[${args[0]}] = struct{}{}`,
-    has: (obj, args) => {
-        const tmp = getTempName('ok');
-        return `func() bool { _, ${tmp} := ${obj}[${args[0]}]; return ${tmp} }()`;
-    },
-    delete: (obj, args) => `delete(${obj}, ${args[0]})`,
-    clear: (obj) => `clear(${obj})`
+    add: (obj, args) => `${obj}.Set(${args[0]}, struct{}{})`,
+    has: (obj, args) => `${obj}.Has(${args[0]})`,
+    delete: (obj, args) => `${obj}.Delete(${args[0]})`,
+    clear: (obj) => `${obj}.Clear()`,
+    values: (obj) => `${obj}.Keys()`
 };
 function getDynamicCallHandler(caller, objectType) {
     if (promiseResolveName && caller === promiseResolveName) {
@@ -2218,10 +4109,20 @@ function getDynamicCallHandler(caller, objectType) {
         const methodName = caller.substring(dotIndex + 1);
         // toString() is universal — works for any type including numbers and objects
         if (methodName === 'toString') {
-            return (c) => {
+            return (c, args) => {
                 const obj = c.substring(0, dotIndex);
-                importedPackages.add('fmt');
-                return `fmt.Sprintf("%v", ${obj})`;
+                if (args.length > 0) {
+                    importedPackages.add('strconv');
+                    return `strconv.FormatInt(int64(${obj}), int(${args[0]}))`;
+                }
+                return jsStringOf(obj, objectType === 'number' || objectType === 'float64' ? 'float64' : undefined);
+            };
+        }
+        // number.toFixed(digits)
+        if (methodName === 'toFixed') {
+            return (c, args) => {
+                importedPackages.add('strconv');
+                return `strconv.FormatFloat(${c.substring(0, dotIndex)}, 'f', int(${args[0] ?? '0'}), 64)`;
             };
         }
         // Class instances use their own methods — never intercept
@@ -2290,6 +4191,177 @@ function getOperatorText(operator) {
 function getTimerName(name) {
     return `__timer_${name.replaceAll(' ', '_').replaceAll('"', '')}__`;
 }
+// typeof x: a constant when the Go type is known, a runtime check for any values
+function visitTypeOf(node) {
+    const goType = inferExpressionType(node.expression);
+    const known = { string: 'string', float64: 'number', bool: 'boolean', nil: 'undefined' };
+    if (goType && known[goType])
+        return toGoStringLiteral(known[goType]);
+    if (goType?.startsWith('func'))
+        return '"function"';
+    if (goType && goType !== 'interface{}' && !NULLABLE_PRIMITIVE_TYPES.includes(goType))
+        return '"object"';
+    useHelper('typeOf');
+    return `TnTypeOf(${visit(node.expression)})`;
+}
+// x.method(...) with an any receiver, as a call on the receiver cast to the type
+// that defines the method (array or string); undefined for other methods
+function castDynamicReceiverCall(node) {
+    if (!isPropertyAccessExpression(node.expression) || isAsExpression(node.expression.expression)) {
+        return undefined;
+    }
+    if (!isDynamicValue(node.expression.expression))
+        return undefined;
+    const method = node.expression.name.text;
+    let castType;
+    if (ARRAY_ONLY_METHODS.has(method))
+        castType = { kind: 'ArrayType', elementType: { kind: 'AnyKeyword' } };
+    else if (STRING_ONLY_METHODS.has(method))
+        castType = { kind: 'StringKeyword' };
+    if (!castType)
+        return undefined;
+    const cast = { kind: 'AsExpression', expression: node.expression.expression, type: castType };
+    const access = { ...node.expression, expression: cast };
+    const call = { ...node, expression: access };
+    cast.parent = access;
+    access.parent = call;
+    return call;
+}
+function isObjectKeysOfDynamic(node) {
+    return (isPropertyAccessExpression(node.expression) &&
+        isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === 'Object' &&
+        node.expression.name.text === 'keys' &&
+        !!node.arguments?.[0] &&
+        isDynamicValue(node.arguments[0]));
+}
+const ARRAY_ONLY_METHODS = new Set([
+    'map', 'filter', 'some', 'every', 'find', 'findIndex', 'forEach', 'reduce', 'join', 'flat', 'sort', 'reverse'
+]);
+const STRING_ONLY_METHODS = new Set([
+    'startsWith', 'endsWith', 'trim', 'trimStart', 'trimEnd', 'toUpperCase', 'toLowerCase', 'split',
+    'replace', 'replaceAll', 'charAt', 'charCodeAt', 'padStart', 'padEnd', 'repeat', 'match', 'matchAll', 'search',
+    'substring', 'lastIndexOf'
+]);
+// x.method(...) where x is any: re-visit with the receiver cast to the type the
+// method belongs to; methods of both strings and arrays dispatch at runtime
+function visitDynamicMethodCall(node) {
+    if (isObjectKeysOfDynamic(node)) {
+        useHelper('dynamic');
+        return `TnKeys(${visit(node.arguments[0])})`;
+    }
+    if (!isPropertyAccessExpression(node.expression) || !isDynamicValue(node.expression.expression)) {
+        return undefined;
+    }
+    const method = node.expression.name.text;
+    const castCall = castDynamicReceiverCall(node);
+    if (castCall)
+        return visit(castCall);
+    const dynamicHelpers = {
+        includes: 'TnIncludes',
+        indexOf: 'TnIndexOf',
+        slice: 'TnSlice',
+        concat: 'TnConcat'
+    };
+    const helper = dynamicHelpers[method];
+    if (!helper)
+        return undefined;
+    useHelper('dynamic');
+    const args = (node.arguments ?? []).map((a) => visit(a));
+    return `${helper}(${[visit(node.expression.expression), ...args].join(', ')})`;
+}
+function isRegexReplaceCall(node) {
+    if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression))
+        return false;
+    const method = node.expression.name.text;
+    if (method !== 'replace' && method !== 'replaceAll')
+        return false;
+    const pattern = (node.arguments ?? [])[0];
+    if (!pattern || (node.arguments ?? []).length < 2)
+        return false;
+    return (isRegularExpressionLiteral(pattern) ||
+        inferExpressionType(pattern) === '*regexp.Regexp' ||
+        resolveExpressionType(pattern) === 'RegExp');
+}
+// Element type of the array whose .sort(fn) receives this comparator
+function getSortComparatorElementType(fn) {
+    const call = fn.parent;
+    if (!isCallExpression(call) || call.arguments?.[0] !== fn)
+        return undefined;
+    if (!isPropertyAccessExpression(call.expression) || call.expression.name.text !== 'sort') {
+        return undefined;
+    }
+    const arrayType = inferExpressionType(call.expression.expression);
+    return arrayType?.startsWith('[]') ? arrayType.slice(2) : undefined;
+}
+function isRegexReplacerCallback(fn) {
+    if (!isArrowFunction(fn) && !isFunctionExpression(fn))
+        return false;
+    const call = fn.parent;
+    return !!call && isRegexReplaceCall(call) && call.arguments[1] === fn;
+}
+// JS replacement patterns → Go: $& (whole match) → ${0}, $1 → ${1}
+function jsReplacementToGo(replacement) {
+    if (!isStringLiteral(replacement) && !isNoSubstitutionTemplateLiteral(replacement)) {
+        return visit(replacement);
+    }
+    const text = replacement.text;
+    let goPattern = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        const next = i + 1 < text.length ? text[i + 1] : '';
+        if (ch !== '$') {
+            goPattern += ch;
+        }
+        else if (next === '$') {
+            goPattern += '$$';
+            i++;
+        }
+        else if (next === '&') {
+            goPattern += '${0}';
+            i++;
+        }
+        else if (next >= '0' && next <= '9') {
+            let digits = next;
+            i++;
+            while (i + 1 < text.length && text[i + 1] >= '0' && text[i + 1] <= '9') {
+                digits += text[i + 1];
+                i++;
+            }
+            goPattern += '${' + digits + '}';
+        }
+        else {
+            goPattern += '$$';
+        }
+    }
+    return toGoStringLiteral(goPattern);
+}
+// str.replace(/re/g, x) → re.ReplaceAllString; without g only the first match is
+// replaced; a function replacer receives (match, ...groups)
+function visitRegexReplace(node) {
+    if (!isRegexReplaceCall(node))
+        return undefined;
+    const [pattern, replacement] = node.arguments;
+    const isGlobal = node.expression.name.text === 'replaceAll' ||
+        (isRegularExpressionLiteral(pattern) &&
+            pattern.text.substring(pattern.text.lastIndexOf('/') + 1).includes('g'));
+    const target = toGoValueOfType(node.expression.expression, 'string');
+    const re = visit(pattern);
+    importedPackages.add('regexp');
+    if (isArrowFunction(replacement) || isFunctionExpression(replacement)) {
+        useHelper('regexReplaceFunc');
+        const callback = visit(replacement);
+        const groupArgs = (replacement.parameters ?? [])
+            .map((_p, index) => `TnGroup(__m, ${index})`)
+            .join(', ');
+        return `TnRegexReplaceFunc(${re}, ${target}, func(__m []string) string { return (${callback})(${groupArgs}) }, ${isGlobal})`;
+    }
+    const goReplacement = jsReplacementToGo(replacement);
+    if (isGlobal)
+        return `${re}.ReplaceAllString(${target}, ${goReplacement})`;
+    useHelper('regexReplaceFirst');
+    return `TnRegexReplaceFirst(${re}, ${target}, ${goReplacement})`;
+}
 function jsRegexFlagsToGo(flags) {
     let goFlags = '';
     if (flags.includes('i'))
@@ -2336,7 +4408,9 @@ function getParameterGoType(param) {
     }
     if (param.type) {
         const explicitType = getType(param.type);
-        return explicitType === ':' ? 'interface{}' : explicitType;
+        if (explicitType === ':')
+            return 'interface{}';
+        return param.questionToken ? makeNullableType(explicitType) : explicitType;
     }
     if (param.initializer) {
         const inferredType = inferExpressionType(param.initializer);
@@ -2344,29 +4418,174 @@ function getParameterGoType(param) {
             return inferredType;
         }
     }
+    if (param.parent && isRegexReplacerCallback(param.parent))
+        return 'string';
+    const sortElementType = param.parent ? getSortComparatorElementType(param.parent) : undefined;
+    if (sortElementType)
+        return sortElementType;
+    const contextualFn = param.parent ? getContextualFunctionType(param.parent) : undefined;
+    if (contextualFn) {
+        const index = (param.parent.parameters ?? []).indexOf(param);
+        const contextualParamType = contextualFn.parameters?.[index]?.type;
+        if (contextualParamType)
+            return getType(contextualParamType);
+    }
     return 'interface{}';
 }
+// Parameters are variables of the function body: record their types (replacing
+// whatever an earlier variable of the same name had)
+function registerParameterType(param) {
+    if (!isIdentifier(param.name))
+        return;
+    const name = param.name.text;
+    const goType = getParameterGoType(param);
+    variableGoTypes.set(name, goType.startsWith('...') ? `[]${goType.slice(3)}` : goType);
+    const category = param.type ? getTypeCategory(param.type) : undefined;
+    if (category)
+        variableTypes.set(name, category);
+    else
+        variableTypes.delete(name);
+    const className = param.type ? getClassNameFromTypeNode(param.type) : undefined;
+    if (className)
+        variableClassNames.set(name, className);
+    else
+        variableClassNames.delete(name);
+    narrowedVariables.delete(name);
+    if (param.type)
+        variableTypeNodes.set(name, param.type);
+    else
+        variableTypeNodes.delete(name);
+}
+// Constructor parameter properties: constructor(private x: T) declares field x
+function getParameterProperties(classNode) {
+    const ctor = (classNode.members ?? []).find((m) => isConstructorDeclaration(m));
+    return (ctor?.parameters ?? []).filter((p) => isIdentifier(p.name) && (p.modifiers ?? []).length > 0);
+}
+// Argument types of map.get/has/set/delete, set.add/has/delete, array.push
+function getCollectionArgumentTypes(node) {
+    if (!isPropertyAccessExpression(node.expression))
+        return undefined;
+    const method = node.expression.name.text;
+    const receiverType = inferExpressionType(node.expression.expression);
+    if (receiverType?.startsWith('*TnMap[')) {
+        const keyType = extractMapKeyType(receiverType);
+        const valueType = extractMapValueType(receiverType);
+        if (valueType === 'struct{}' && ['add', 'has', 'delete'].includes(method))
+            return [keyType];
+        if (['get', 'has', 'delete'].includes(method))
+            return [keyType];
+        if (method === 'set')
+            return [keyType, valueType];
+    }
+    if (receiverType === '*regexp.Regexp' && (method === 'test' || method === 'exec'))
+        return ['string'];
+    if (receiverType?.startsWith('[]') && method === 'push') {
+        return (node.arguments ?? []).map(() => receiverType.slice(2));
+    }
+    return undefined;
+}
+// TS lets a function literal omit trailing parameters of its contextual type;
+// Go func types must match exactly, so the omitted ones are added as unused `_`
+// Arguments of a call; for calls to declared functions, values are converted to
+// the parameter types (nullable primitives boxed) and omitted optional
+// parameters are passed as zero values (nil for pointers)
+function visitCallArguments(node) {
+    const args = node.arguments ?? [];
+    const collectionTypes = getCollectionArgumentTypes(node);
+    if (collectionTypes)
+        return args.map((arg, index) => toGoValueOfType(arg, collectionTypes[index]));
+    let fn = isIdentifier(node.expression) ? declaredFunctions.get(node.expression.text) : undefined;
+    if (!fn && isIdentifier(node.expression)) {
+        const fnType = resolveTypeNode(variableTypeNodes.get(node.expression.text));
+        if (isFunctionTypeNode(fnType))
+            fn = fnType;
+    }
+    if (!fn)
+        return args.map((a) => visit(a));
+    const params = fn.parameters ?? [];
+    const result = args.map((arg, index) => {
+        const param = params[index];
+        return param && !param.dotDotDotToken ? toGoValueOfType(arg, getParameterGoType(param)) : visit(arg);
+    });
+    for (let i = args.length; i < params.length; i++) {
+        const param = params[i];
+        if (!param.questionToken || param.initializer || param.dotDotDotToken)
+            break;
+        result.push(`*new(${getParameterGoType(param)})`);
+    }
+    return result;
+}
+function withContextualParameters(fn, info) {
+    const contextualFn = getContextualFunctionType(fn);
+    const declaredCount = (fn.parameters ?? []).length;
+    const contextualParams = contextualFn?.parameters ?? [];
+    if (contextualParams.length <= declaredCount || info.signature.includes('...'))
+        return info;
+    const extra = contextualParams
+        .slice(declaredCount)
+        .map((p) => `_ ${p.dotDotDotToken ? '...' : ''}${p.type ? getType(p.type) : 'interface{}'}`);
+    const signature = [info.signature, ...extra].filter((part) => part).join(', ');
+    return { ...info, signature };
+}
+// Destructured parameters ({ a, b }: T / [x, y]: T[]) get a temporary name
+function getParameterName(param, parameters) {
+    if (isIdentifier(param.name))
+        return visit(param.name);
+    return `__param${parameters.indexOf(param)}`;
+}
+// Unpacks destructured parameters at the start of the function body
+function getParameterDestructuring(parameters) {
+    let code = '';
+    for (const param of parameters) {
+        if (isIdentifier(param.name))
+            continue;
+        const source = getParameterName(param, parameters);
+        const paramType = getParameterGoType(param);
+        (param.name.elements ?? []).forEach((el, index) => {
+            if (isOmittedExpression(el) || !isIdentifier(el.name))
+                return;
+            let value;
+            let valueType;
+            if (isObjectBindingPattern(param.name)) {
+                const field = (el.propertyName ?? el.name).text;
+                value = `${source}.${goFieldName(field)}`;
+                valueType =
+                    interfacePropertyTypes.get(paramType)?.get(field) ?? getStructFieldGoType(paramType, field);
+            }
+            else {
+                value = `${source}[${index}]`;
+                valueType = paramType.startsWith('[]') ? paramType.slice(2) : undefined;
+            }
+            registerLocalVariable(el.name.text, valueType);
+            code += `${visit(el.name)} := ${value}\n\t\t_ = ${visit(el.name)}\n\t\t`;
+        });
+    }
+    return code;
+}
 function getFunctionParametersInfo(parameters) {
+    for (const param of parameters)
+        registerParameterType(param);
     if (parameters.length === 0) {
         return { signature: '', prefixBlockContent: '' };
     }
+    const destructuring = getParameterDestructuring(parameters);
     const firstDefaultIndex = parameters.findIndex((p) => !!p.initializer);
     if (firstDefaultIndex === -1) {
         return {
-            signature: parameters.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`).join(', '),
-            prefixBlockContent: ''
+            signature: parameters.map((p) => `${getParameterName(p, parameters)} ${getParameterGoType(p)}`).join(', '),
+            prefixBlockContent: destructuring
         };
     }
     const hasRequiredAfterDefault = parameters.slice(firstDefaultIndex).some((p) => !p.initializer);
     if (hasRequiredAfterDefault) {
         return {
-            signature: parameters.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`).join(', '),
-            prefixBlockContent: ''
+            signature: parameters.map((p) => `${getParameterName(p, parameters)} ${getParameterGoType(p)}`).join(', '),
+            prefixBlockContent: destructuring
         };
     }
     const requiredParams = parameters.slice(0, firstDefaultIndex);
     const defaultedParams = parameters.slice(firstDefaultIndex);
-    const signatureParts = requiredParams.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`);
+    const signatureParts = requiredParams.map((p) => `${getParameterName(p, parameters)} ${getParameterGoType(p)}`);
     signatureParts.push('__defaultArgs ...interface{}');
     const prefixBlockContent = defaultedParams
         .map((param, index) => {
@@ -2381,7 +4600,7 @@ function getFunctionParametersInfo(parameters) {
         .join('');
     return {
         signature: signatureParts.join(', '),
-        prefixBlockContent
+        prefixBlockContent: prefixBlockContent + destructuring
     };
 }
 function getSafeName(name) {
@@ -2444,7 +4663,9 @@ function visitNewPromise(node) {
     return `func() chan ${channelType} {\n\t\tch := make(chan ${channelType})\n\t\tgo func() ${body.trimEnd()}()\n\t\treturn ch;\n\t}()`;
 }
 function extractMapValueType(mapType) {
-    // mapType is "map[K]V" — find the closing bracket of K accounting for nesting
+    const args = splitMapTypeArgs(mapType);
+    if (args)
+        return args[1];
     if (!mapType.startsWith('map['))
         return 'interface{}';
     let depth = 0;
@@ -2459,43 +4680,43 @@ function extractMapValueType(mapType) {
     }
     return 'interface{}';
 }
+// Type arguments of new Map/Set: explicit, else from the declared/contextual type
+function getCollectionTypeArguments(node) {
+    if ((node.typeArguments ?? []).length > 0)
+        return node.typeArguments;
+    const contextual = resolveTypeNode(getContextualTypeNode(node));
+    return isTypeReferenceNode(contextual) ? (contextual.typeArguments ?? []) : [];
+}
 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]);
-    }
-    const mapType = `map[${keyType}]${valueType}`;
-    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) => isArrayLiteralExpression(el) && el.elements.length >= 2)
-        .map((el) => {
-        const pair = el;
-        return `${tmp}[${visit(pair.elements[0])}] = ${visit(pair.elements[1])}`;
-    })
-        .join('; ');
-    return `func() ${mapType} { ${tmp} := make(${mapType}); ${entries}; return ${tmp} }()`;
+    const typeArguments = getCollectionTypeArguments(node);
+    if (typeArguments.length === 2) {
+        keyType = getType(typeArguments[0]);
+        valueType = getType(typeArguments[1]);
+    }
+    const args = node.arguments ?? [];
+    const entries = args.length > 0 && isArrayLiteralExpression(args[0])
+        ? args[0].elements
+            .filter((el) => isArrayLiteralExpression(el) && el.elements.length >= 2)
+            .map((pair) => `${visit(pair.elements[0])}, ${visit(pair.elements[1])}`)
+        : [];
+    return orderedMapLiteral(keyType, valueType, entries);
 }
 function visitNewSet(node) {
     let elementType = 'interface{}';
-    if ((node.typeArguments ?? []) && (node.typeArguments ?? []).length === 1) {
-        elementType = getType((node.typeArguments ?? [])[0]);
+    const typeArguments = getCollectionTypeArguments(node);
+    if (typeArguments.length === 1) {
+        elementType = getType(typeArguments[0]);
     }
-    const setType = `map[${elementType}]struct{}`;
-    const args = (node.arguments ?? []);
-    if (!args || args.length === 0 || !isArrayLiteralExpression(args[0])) {
-        return `make(${setType})`;
+    else if (node.arguments?.length && isArrayLiteralExpression(node.arguments[0])) {
+        elementType = getArrayLiteralElementType(node.arguments[0]);
     }
-    const initArg = args[0];
-    const tmp = getTempName('set');
-    const values = initArg.elements.map((el) => `${tmp}[${visit(el)}] = struct{}{}`).join('; ');
-    return `func() ${setType} { ${tmp} := make(${setType}); ${values}; return ${tmp} }()`;
+    const args = node.arguments ?? [];
+    const values = args.length > 0 && isArrayLiteralExpression(args[0])
+        ? args[0].elements.map((el) => `${visit(el)}, struct{}{}`)
+        : [];
+    return orderedMapLiteral(elementType, 'struct{}', values);
 }
 function specifierToGoFileName(specifier) {
     const segments = specifier.split(/[/\\]/);
@@ -2530,7 +4751,7 @@ function includeLocalImport(code, dir, goFileName) {
     }
     if (!goFileName) {
         // Inline mode (npm packages): pull declarations into the current transpilation context
-        const sf = parseFunction(code);
+        const sf = parseSource(code);
         for (const stmt of sf.statements) {
             visit(stmt, { addFunctionOutside: true });
         }
@@ -2545,13 +4766,16 @@ function includeLocalImport(code, dir, goFileName) {
     outsideNodes = [];
     importedPackages.clear();
     helperProvidedPackages.clear();
-    const sf = parseFunction(code);
+    const sf = parseSource(code);
     const inlineLines = [];
+    const prevEmittingModuleFile = emittingModuleFile;
+    emittingModuleFile = true;
     for (const stmt of sf.statements) {
         const result = visit(stmt, { addFunctionOutside: true });
         if (result.trim())
             inlineLines.push(result);
     }
+    emittingModuleFile = prevEmittingModuleFile;
     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
@@ -2565,8 +4789,9 @@ function includeLocalImport(code, dir, goFileName) {
         if (!helperProvidedPackages.has(pkg))
             return true;
         const name = pkg.split('/').pop();
-        return fileCode.includes(`${name}.`);
+        return stripGoStrings(fileCode).includes(`${name}.`);
     })
+        .sort()
         .map((pkg) => `import "${pkg}"`)
         .join('\n');
     const parts = ['package main'];
@@ -2587,6 +4812,10 @@ function includeLocalImport(code, dir, goFileName) {
         importedPackages.add(p);
     currentFileDir = prevDir;
 }
+// Go source without its string literals (for detecting real package use)
+function stripGoStrings(code) {
+    return code.replace(/"(?:[^"\\\n]|\\.)*"|`[^`]*`/g, '""');
+}
 function registerGoPackageAliases(node, goPkg) {
     const pkgName = goPkg.split('/').pop();
     if (!node.importClause)
@@ -2710,6 +4939,10 @@ const nodeModuleMappings = {
             rmSync: (args) => {
                 useHelper('removeAll');
                 return `TnRemoveAll(${args[0]})`;
+            },
+            unlinkSync: (args) => {
+                useHelper('removeAll');
+                return `TnRemoveAll(${args[0]})`;
             }
         }
     },
@@ -2760,15 +4993,15 @@ const nodeModuleMappings = {
             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.replace(/^\[\]\S* \{/, '[]string{')
                     : arrArg;
+                if (args[2]?.includes('inherit')) {
+                    return `TnRunInherit(${args[0]}, ${typedArg}...)`;
+                }
                 if (args[2]?.includes('input')) {
                     // {input: expr, ...} → run with expr as stdin
                     useHelper('execInput');
@@ -2792,6 +5025,12 @@ const nodeModuleMappings = {
 };
 // Go packages required by each helper, registered when the helper is used.
 const helperPackages = {
+    regexReplaceFirst: ['regexp'],
+    orderedMap: ['iter', 'encoding/json', 'bytes', 'fmt'],
+    jsonStringify: ['encoding/json', 'bytes', 'strings'],
+    typeOf: ['reflect'],
+    dynamic: ['math', 'strings', 'fmt', 'sort', 'reflect', 'strconv', 'regexp'],
+    regexReplaceFunc: ['regexp'],
     readFile: ['os'],
     writeFile: ['os'],
     appendFile: ['os'],
@@ -2813,6 +5052,535 @@ const helperPackages = {
 // 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 = {
+    dynamic: `// Dynamic (any) values: JSON-like objects are map[string]interface{},
+// arrays []interface{}, numbers float64
+func TnGet(obj interface{}, key string) interface{} {
+	switch o := obj.(type) {
+	case map[string]interface{}:
+		return o[key]
+	case []interface{}:
+		if key == "length" {
+			return float64(len(o))
+		}
+	case string:
+		if key == "length" {
+			return float64(len(o))
+		}
+	}
+	return nil
+}
+
+func TnSet(obj interface{}, key string, value interface{}) {
+	if o, ok := obj.(map[string]interface{}); ok {
+		o[key] = value
+		return
+	}
+	panic("TnSet: cannot set property " + key)
+}
+
+func TnIndex(obj interface{}, key interface{}) interface{} {
+	switch o := obj.(type) {
+	case map[string]interface{}:
+		if k, ok := key.(string); ok {
+			return o[k]
+		}
+	case []interface{}:
+		if i, ok := key.(float64); ok && i >= 0 && int(i) < len(o) {
+			return o[int(i)]
+		}
+	case string:
+		if i, ok := key.(float64); ok && i >= 0 && int(i) < len(o) {
+			return string(o[int(i)])
+		}
+	}
+	return nil
+}
+
+// JS ===: objects and arrays compare by identity, other values by value
+func TnSame(a interface{}, b interface{}) bool {
+	if a == nil || b == nil {
+		return a == nil && b == nil
+	}
+	va, vb := reflect.ValueOf(a), reflect.ValueOf(b)
+	switch va.Kind() {
+	case reflect.Map, reflect.Slice, reflect.Func, reflect.Pointer:
+		return va.Kind() == vb.Kind() && va.Type() == vb.Type() && va.Pointer() == vb.Pointer() &&
+			(va.Kind() != reflect.Slice || va.Len() == vb.Len())
+	}
+	if !va.Type().Comparable() || !vb.Type().Comparable() {
+		return false
+	}
+	return a == b
+}
+
+func TnAt[T any](s []T, i float64) T {
+	if i < 0 || int(i) >= len(s) {
+		var zero T
+		return zero
+	}
+	return s[int(i)]
+}
+
+func TnCharAt(s string, i float64) string {
+	if i < 0 || int(i) >= len(s) {
+		return ""
+	}
+	return string(s[int(i)])
+}
+
+func TnLength(v interface{}) float64 {
+	switch t := v.(type) {
+	case string:
+		return float64(len(t))
+	case []interface{}:
+		return float64(len(t))
+	}
+	return 0
+}
+
+// A value as JS prints it in a template literal (nil pointers are "undefined")
+func TnFormat(v interface{}) string {
+	rv := reflect.ValueOf(v)
+	if !rv.IsValid() || (rv.Kind() == reflect.Pointer && rv.IsNil()) {
+		return "undefined"
+	}
+	if rv.Kind() == reflect.Pointer {
+		return fmt.Sprintf("%v", rv.Elem().Interface())
+	}
+	return fmt.Sprintf("%v", v)
+}
+
+// Object spread: copies the properties of src into dst
+func TnAssign(dst map[string]interface{}, src interface{}) {
+	if o, ok := src.(map[string]interface{}); ok {
+		for k, v := range o {
+			dst[k] = v
+		}
+	}
+}
+
+// A number as JS prints it
+func TnNumStr(f float64) string {
+	switch {
+	case math.IsNaN(f):
+		return "NaN"
+	case math.IsInf(f, 1):
+		return "Infinity"
+	case math.IsInf(f, -1):
+		return "-Infinity"
+	case f == math.Trunc(f) && math.Abs(f) < 1e21:
+		return strconv.FormatFloat(f, 'f', -1, 64)
+	}
+	return strconv.FormatFloat(f, 'g', -1, 64)
+}
+
+// Number(x) like JS: "" → 0, invalid → NaN, booleans → 0/1
+func TnNumber(v interface{}) float64 {
+	switch t := v.(type) {
+	case float64:
+		return t
+	case bool:
+		if t {
+			return 1
+		}
+		return 0
+	case string:
+		s := strings.TrimSpace(t)
+		if s == "" {
+			return 0
+		}
+		if f, err := strconv.ParseFloat(s, 64); err == nil {
+			return f
+		}
+	case nil:
+		return 0
+	}
+	return math.NaN()
+}
+
+var tnLeadingFloat = regexp.MustCompile("^[+-]?(Infinity|[0-9]+[.]?[0-9]*([eE][+-]?[0-9]+)?|[.][0-9]+([eE][+-]?[0-9]+)?)")
+
+// parseFloat: the leading number of the string, NaN if none
+func TnParseFloat(s string) float64 {
+	m := tnLeadingFloat.FindString(strings.TrimSpace(s))
+	if m == "" {
+		return math.NaN()
+	}
+	if strings.HasSuffix(m, "Infinity") {
+		if strings.HasPrefix(m, "-") {
+			return math.Inf(-1)
+		}
+		return math.Inf(1)
+	}
+	f, _ := strconv.ParseFloat(m, 64)
+	return f
+}
+
+// parseInt: the leading integer in the given radix, NaN if none
+func TnParseInt(s string, radix float64) float64 {
+	s = strings.TrimSpace(s)
+	base := int(radix)
+	sign := 1.0
+	if strings.HasPrefix(s, "-") || strings.HasPrefix(s, "+") {
+		if s[0] == '-' {
+			sign = -1
+		}
+		s = s[1:]
+	}
+	if (base == 16 || base == 0) && (strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X")) {
+		s, base = s[2:], 16
+	}
+	if base == 0 {
+		base = 10
+	}
+	end := 0
+	for end < len(s) {
+		c := s[end]
+		d := 99
+		switch {
+		case c >= '0' && c <= '9':
+			d = int(c - '0')
+		case c >= 'a' && c <= 'z':
+			d = int(c-'a') + 10
+		case c >= 'A' && c <= 'Z':
+			d = int(c-'A') + 10
+		}
+		if d >= base {
+			break
+		}
+		end++
+	}
+	if end == 0 {
+		return math.NaN()
+	}
+	v, _ := strconv.ParseInt(s[:end], base, 64)
+	return sign * float64(v)
+}
+
+// JS ToInt32 / ToUint32 (wrapping modulo 2^32; NaN and Infinity → 0)
+func TnInt32(f float64) int32 {
+	if math.IsNaN(f) || math.IsInf(f, 0) {
+		return 0
+	}
+	return int32(int64(math.Trunc(math.Mod(f, 4294967296))))
+}
+
+func TnUint32(f float64) uint32 { return uint32(TnInt32(f)) }
+
+func TnDelete(obj interface{}, key interface{}) bool {
+	o, ok := obj.(map[string]interface{})
+	k, isString := key.(string)
+	if !ok || !isString {
+		return false
+	}
+	delete(o, k)
+	return true
+}
+
+func TnHas(obj interface{}, key interface{}) bool {
+	if o, ok := obj.(map[string]interface{}); ok {
+		if k, ok := key.(string); ok {
+			_, found := o[k]
+			return found
+		}
+	}
+	return false
+}
+
+func TnKeys(obj interface{}) []string {
+	o, _ := obj.(map[string]interface{})
+	keys := make([]string, 0, len(o))
+	for k := range o {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+func TnIncludes(v interface{}, x interface{}) bool {
+	return TnIndexOf(v, x) >= 0
+}
+
+func TnIndexOf(v interface{}, x interface{}) float64 {
+	switch t := v.(type) {
+	case string:
+		if s, ok := x.(string); ok {
+			return float64(strings.Index(t, s))
+		}
+	case []interface{}:
+		for i, item := range t {
+			if TnSame(item, x) {
+				return float64(i)
+			}
+		}
+	}
+	return -1
+}
+
+func TnSlice(v interface{}, bounds ...float64) interface{} {
+	length := 0
+	switch t := v.(type) {
+	case string:
+		length = len(t)
+	case []interface{}:
+		length = len(t)
+	default:
+		return nil
+	}
+	clamp := func(i float64) int {
+		n := int(i)
+		if n < 0 {
+			n += length
+		}
+		return max(0, min(n, length))
+	}
+	start, end := 0, length
+	if len(bounds) > 0 {
+		start = clamp(bounds[0])
+	}
+	if len(bounds) > 1 {
+		end = clamp(bounds[1])
+	}
+	if start > end {
+		start = end
+	}
+	if s, ok := v.(string); ok {
+		return s[start:end]
+	}
+	return v.([]interface{})[start:end]
+}
+
+func TnConcat(v interface{}, others ...interface{}) interface{} {
+	if s, ok := v.(string); ok {
+		for _, o := range others {
+			s += fmt.Sprint(o)
+		}
+		return s
+	}
+	result := append([]interface{}{}, TnAs[[]interface{}](v)...)
+	for _, o := range others {
+		if items, ok := o.([]interface{}); ok {
+			result = append(result, items...)
+		} else {
+			result = append(result, o)
+		}
+	}
+	return result
+}
+
+func TnAsPtr[T any](v interface{}) *T {
+	if p, ok := v.(*T); ok {
+		return p
+	}
+	if t, ok := v.(T); ok {
+		return &t
+	}
+	return nil
+}
+
+func TnAs[T any](v interface{}) T {
+	if p, ok := v.(*T); ok && p != nil {
+		return *p
+	}
+	t, _ := v.(T)
+	return t
+}
+
+func TnTruthy(v interface{}) bool {
+	switch t := v.(type) {
+	case nil:
+		return false
+	case bool:
+		return t
+	case float64:
+		return t != 0 && !math.IsNaN(t)
+	case string:
+		return t != ""
+	}
+	return true
+}`,
+    typeOf: `func TnTypeOf(v interface{}) string {
+	switch v.(type) {
+	case nil:
+		return "undefined"
+	case string, *string:
+		return "string"
+	case float64, *float64:
+		return "number"
+	case bool, *bool:
+		return "boolean"
+	}
+	if reflect.ValueOf(v).Kind() == reflect.Func {
+		return "function"
+	}
+	return "object"
+}`,
+    jsonStringify: `func TnJSONStringify(v interface{}, indent string) string {
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	enc.SetIndent("", indent)
+	enc.Encode(v)
+	return strings.TrimSuffix(buf.String(), "\\n")
+}`,
+    orderedMap: `// TnMap: JS Map/Set/object semantics — keys iterate in insertion order
+type TnMap[K comparable, V any] struct {
+	keys   []K
+	values map[K]V
+}
+
+func TnNewMap[K comparable, V any]() *TnMap[K, V] {
+	return &TnMap[K, V]{values: map[K]V{}}
+}
+
+func (m *TnMap[K, V]) Set(k K, v V) *TnMap[K, V] {
+	if _, ok := m.values[k]; !ok {
+		m.keys = append(m.keys, k)
+	}
+	m.values[k] = v
+	return m
+}
+
+func (m *TnMap[K, V]) Get(k K) V {
+	if m == nil {
+		var zero V
+		return zero
+	}
+	return m.values[k]
+}
+
+func (m *TnMap[K, V]) Lookup(k K) (V, bool) {
+	if m == nil {
+		var zero V
+		return zero, false
+	}
+	v, ok := m.values[k]
+	return v, ok
+}
+
+func (m *TnMap[K, V]) Has(k K) bool {
+	if m == nil {
+		return false
+	}
+	_, ok := m.values[k]
+	return ok
+}
+
+func (m *TnMap[K, V]) Delete(k K) bool {
+	if _, ok := m.values[k]; !ok {
+		return false
+	}
+	delete(m.values, k)
+	for i, key := range m.keys {
+		if key == k {
+			m.keys = append(m.keys[:i], m.keys[i+1:]...)
+			break
+		}
+	}
+	return true
+}
+
+func (m *TnMap[K, V]) Clear() {
+	m.keys = nil
+	m.values = map[K]V{}
+}
+
+func (m *TnMap[K, V]) Len() int {
+	if m == nil {
+		return 0
+	}
+	return len(m.keys)
+}
+
+func (m *TnMap[K, V]) Keys() []K {
+	if m == nil {
+		return nil
+	}
+	return append([]K{}, m.keys...)
+}
+
+func (m *TnMap[K, V]) Values() []V {
+	if m == nil {
+		return nil
+	}
+	values := make([]V, 0, len(m.keys))
+	for _, k := range m.keys {
+		values = append(values, m.values[k])
+	}
+	return values
+}
+
+func (m *TnMap[K, V]) Entries() [][]interface{} {
+	entries := make([][]interface{}, 0, m.Len())
+	for _, k := range m.Keys() {
+		entries = append(entries, []interface{}{k, m.values[k]})
+	}
+	return entries
+}
+
+func (m *TnMap[K, V]) All() iter.Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		for _, k := range m.Keys() {
+			if v, ok := m.values[k]; ok && !yield(k, v) {
+				return
+			}
+		}
+	}
+}
+
+// JSON objects keep insertion order
+func (m *TnMap[K, V]) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+	buf.WriteByte('{')
+	for i, k := range m.keys {
+		if i > 0 {
+			buf.WriteByte(',')
+		}
+		key, _ := json.Marshal(fmt.Sprint(k))
+		value, err := json.Marshal(m.values[k])
+		if err != nil {
+			return nil, err
+		}
+		buf.Write(key)
+		buf.WriteByte(':')
+		buf.Write(value)
+	}
+	buf.WriteByte('}')
+	return buf.Bytes(), nil
+}`,
+    regexReplaceFirst: `func TnRegexReplaceFirst(re *regexp.Regexp, s string, repl string) string {
+	loc := re.FindStringSubmatchIndex(s)
+	if loc == nil {
+		return s
+	}
+	return s[:loc[0]] + string(re.ExpandString(nil, repl, s, loc)) + s[loc[1]:]
+}`,
+    regexReplaceFunc: `func TnRegexReplaceFunc(re *regexp.Regexp, s string, fn func([]string) string, all bool) string {
+	limit := 1
+	if all {
+		limit = -1
+	}
+	result := ""
+	last := 0
+	for _, loc := range re.FindAllStringSubmatchIndex(s, limit) {
+		groups := make([]string, len(loc)/2)
+		for i := range groups {
+			if loc[2*i] >= 0 {
+				groups[i] = s[loc[2*i]:loc[2*i+1]]
+			}
+		}
+		result += s[last:loc[0]] + fn(groups)
+		last = loc[1]
+	}
+	return result + s[last:]
+}
+
+func TnGroup(groups []string, i int) string {
+	if i < len(groups) {
+		return groups[i]
+	}
+	return ""
+}`,
     readFile: `func TnReadFile(path string) string {
 	data, err := os.ReadFile(path)
 	if err != nil {
@@ -2953,7 +5721,7 @@ func TnExecShell(command string) tnExecResult {
 	}
 	return tnExecResult{stdout: stdout.String(), stderr: stderr.String(), status: status}
 }`,
-    runInherit: `func TnRunInherit(name string, args ...string) float64 {
+    runInherit: `func TnRunInherit(name string, args ...string) tnExecResult {
 	cmd := exec.Command(name, args...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
@@ -2961,11 +5729,11 @@ func TnExecShell(command string) tnExecResult {
 	err := cmd.Run()
 	if err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
-			return float64(exitErr.ExitCode())
+			return tnExecResult{status: float64(exitErr.ExitCode())}
 		}
 		panic(err)
 	}
-	return 0
+	return tnExecResult{}
 }`,
     question: `var tnStdinReader = bufio.NewReader(os.Stdin)
 
@@ -2987,10 +5755,41 @@ func TnQuestion(prompt string) string {
 // so helpers are visible across files and must not be duplicated.
 function emitGoHelpers() {
     return [...usedHelpers]
+        .sort()
         .map((id) => goHelpers[id])
         .filter(Boolean)
         .join('\n\n');
 }
+// Result types of the mapped Node.js stdlib functions ('' = no result)
+const NODE_FUNCTION_TYPES = {
+    path: {
+        join: 'string',
+        resolve: 'string',
+        dirname: 'string',
+        basename: 'string',
+        extname: 'string',
+        relative: 'string',
+        normalize: 'string'
+    },
+    fs: {
+        readFileSync: 'string',
+        existsSync: 'bool',
+        readdirSync: '[]string',
+        writeFileSync: '',
+        appendFileSync: '',
+        mkdirSync: '',
+        copyFileSync: '',
+        rmSync: '',
+        unlinkSync: ''
+    },
+    os: { platform: 'string', homedir: 'string', tmpdir: 'string' },
+    url: { fileURLToPath: 'string', pathToFileURL: 'string' },
+    child_process: { execSync: 'string' },
+    readline: { question: 'string' }
+};
+// Result types of imported Node.js functions by their local callee text
+// (`join`, `path.join`)
+const nodeCallResultTypes = new Map();
 // 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) {
@@ -3009,6 +5808,9 @@ function setupNodeModuleImport(node, nodeModule) {
                 continue;
             const localName = el.name.text;
             const importedName = el.propertyName?.text ?? localName;
+            const resultType = NODE_FUNCTION_TYPES[nodeModule]?.[importedName];
+            if (resultType !== undefined)
+                nodeCallResultTypes.set(localName, resultType);
             const fn = mapping.functions[importedName];
             if (fn) {
                 // Register a call handler keyed on the local name
@@ -3020,6 +5822,9 @@ function setupNodeModuleImport(node, nodeModule) {
         // Default import (`import path from 'node:path'`) or
         // namespace import (`import * as path from 'node:path'`)
         const localName = getImportLocalName(node) ?? nodeModule;
+        for (const [funcName, resultType] of Object.entries(NODE_FUNCTION_TYPES[nodeModule] ?? {})) {
+            nodeCallResultTypes.set(`${localName}.${funcName}`, resultType);
+        }
         for (const [funcName, fn] of Object.entries(mapping.functions)) {
             callHandlers[`${localName}.${funcName}`] = (_caller, args) => fn(args);
         }
@@ -3082,6 +5887,93 @@ function visitImportDeclaration(node) {
     }
     return '';
 }
+// Records the type of a variable introduced by a loop or binding
+function registerLocalVariable(name, goType) {
+    if (!name || name === '_')
+        return;
+    variableTypes.delete(name);
+    variableClassNames.delete(name);
+    variableTypeNodes.delete(name);
+    narrowedVariables.delete(name);
+    if (goType)
+        variableGoTypes.set(name, goType);
+    else
+        variableGoTypes.delete(name);
+}
+// for...of over arrays and strings (a string yields one-character strings)
+function visitForOfSequence(node, iterExpr, iterType) {
+    if (iterType === 'interface{}')
+        iterType = '[]interface{}';
+    const elementType = iterType === 'string' ? 'string' : iterType?.startsWith('[]') ? iterType.slice(2) : undefined;
+    const declaration = isVariableDeclarationList(node.initializer)
+        ? node.initializer.declarations[0]
+        : undefined;
+    const binding = declaration?.name;
+    const item = getTempName('item');
+    let prefix = '';
+    let loopVar = item;
+    if (binding && isArrayBindingPattern(binding)) {
+        // for (const [a, b] of pairs) → a := item[0]; b := item[1]
+        const memberType = elementType?.startsWith('[]') ? elementType.slice(2) : undefined;
+        (binding.elements ?? []).forEach((el, index) => {
+            if (isOmittedExpression(el))
+                return;
+            const name = visit(el.name);
+            registerLocalVariable(name, memberType);
+            prefix += `${name} := ${item}[${index}]\n\t\t_ = ${name}\n\t\t`;
+        });
+    }
+    else if (binding && isIdentifier(binding)) {
+        const name = visit(binding);
+        registerLocalVariable(binding.text, elementType);
+        if (iterType === 'string') {
+            prefix = `${name} := string(${item})\n\t\t`;
+        }
+        else {
+            loopVar = name;
+        }
+    }
+    else {
+        loopVar = visit(node.initializer, { inline: true });
+    }
+    return `for _, ${loopVar} := range ${iterExpr}${visitLoopBody(node.statement, prefix)}`;
+}
+// try/catch with returns: the closure reports (value, done) and the caller
+// returns when done
+function visitReturningTryStatement(node, fn, options) {
+    const returnGoType = inferFunctionBodyReturnType(fn);
+    const hasValue = !!returnGoType;
+    const saved = tryReturn;
+    const retVar = getTempName('tryret');
+    const doneVar = getTempName('trydone');
+    const blockCode = (block, inCatch) => {
+        tryReturn = { fn, hasValue, inCatch, retVar, doneVar };
+        const code = (block.statements ?? []).map((s) => visit(s)).join('\t');
+        tryReturn = saved;
+        return code;
+    };
+    const deferreds = [];
+    if (node.finallyBlock) {
+        const finallyBody = (node.finallyBlock.statements ?? []).map((s) => visit(s)).join('\t');
+        deferreds.push(`defer func() {\n\t\t\t${finallyBody}\t\t\t}()`);
+    }
+    if (node.catchClause) {
+        const varDecl = node.catchClause.variableDeclaration;
+        const catchVar = varDecl ? visit(varDecl.name) : '_r';
+        const catchBody = blockCode(node.catchClause.block, true);
+        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 = blockCode(node.tryBlock, false);
+    const results = hasValue
+        ? `(${retVar} ${returnGoType}, ${doneVar} bool)`
+        : `(${doneVar} bool)`;
+    const body = [...deferreds, tryBody, 'return'].join('\n\t\t\t');
+    const outer = hasValue ? `${retVar}, ${doneVar}` : doneVar;
+    // Leaving through an enclosing try/catch closure of the same function passes the value on
+    const exit = tryAwareReturn(hasValue ? retVar : '');
+    return (`if ${outer} := func() ${results} {\n\t\t\t${body}\n\t\t\t}(); ${doneVar} { ${exit} }` +
+        (options.inline ? '' : ';\n\t'));
+}
 function getForOfVarNames(initializer) {
     if (!isVariableDeclarationList(initializer) || initializer.declarations.length === 0) {
         return ['_'];
@@ -3096,7 +5988,27 @@ function getForOfVarNames(initializer) {
     }
     return [visit(decl.name)];
 }
+// Set while emitting a try/catch whose blocks return from the enclosing function
+let tryReturn;
+// `return value` from inside a try/catch closure: report (value, done)
+function tryAwareReturn(value) {
+    if (!tryReturn)
+        return `return ${value}`;
+    const results = tryReturn.hasValue ? `${value}, true` : 'true';
+    if (tryReturn.inCatch) {
+        const targets = tryReturn.hasValue
+            ? `${tryReturn.retVar}, ${tryReturn.doneVar}`
+            : tryReturn.doneVar;
+        return `${targets} = ${results}; return`;
+    }
+    return `return ${results}`;
+}
 function visitTryStatement(node, options) {
+    const fn = getEnclosingFunction(node);
+    const returnsFromFunction = (block) => !!block && containsNode(block, (n) => isReturnStatement(n) && getEnclosingFunction(n) === fn);
+    if (fn && (returnsFromFunction(node.tryBlock) || returnsFromFunction(node.catchClause?.block))) {
+        return visitReturningTryStatement(node, fn, options);
+    }
     const deferreds = [];
     // Register finally first (LIFO: runs last after catch)
     if (node.finallyBlock) {