typenative 0.1.1 → 0.1.2

package/bin/transpiler.js

@@ -263,6 +263,7 @@ const importedPackages = new Set();
 let outsideNodes = [];
 const classNames = new Set();
 let promiseResolveName = '';
+let promiseRejectName = '';
 // Go keywords that cannot be used as identifiers
 const dangerousNames = new Set([
     'main',
@@ -396,6 +397,11 @@ function defaultParseFunction(_code) {
 // AST carries no parent pointers, but the transpiler walks up via node.parent.
 function parseSource(code) {
     const sourceFile = parseFunction(code);
+    stripThisParameters(sourceFile);
+    lowerIndexSignatures(sourceFile);
+    lowerClassExpressions(sourceFile);
+    lowerWeakCollections(sourceFile);
+    lowerGlobalThis(sourceFile);
     linkParents(sourceFile, undefined);
     for (const stmt of sourceFile.statements ?? []) {
         if (!stmt.name || !isIdentifier(stmt.name))
@@ -415,6 +421,83 @@ function parseSource(code) {
     }
     return sourceFile;
 }
+// `this: T` parameters only type `this`; they are not real parameters
+function stripThisParameters(node) {
+    if (Array.isArray(node.parameters)) {
+        node.parameters = node.parameters.filter((p) => !(isIdentifier(p.name) && p.name.text === 'this'));
+    }
+    for (const child of childNodes(node))
+        stripThisParameters(child);
+}
+// { [k: K]: V } and { [K in string]: V } → Record<K, V>; an interface that is
+// only an index signature becomes an alias of that Record
+function lowerIndexSignatures(node) {
+    for (const child of childNodes(node))
+        lowerIndexSignatures(child);
+    const keyKind = node.typeParameter?.constraint?.kind;
+    if (node.kind === 'MappedType' && (keyKind === 'StringKeyword' || keyKind === 'NumberKeyword')) {
+        const keyType = { kind: keyKind };
+        makeRecordReference(node, keyType, node.type);
+        return;
+    }
+    const members = node.members ?? [];
+    if (members.length !== 1 || members[0].kind !== 'IndexSignature')
+        return;
+    const signature = members[0];
+    if (node.kind === 'TypeLiteral')
+        makeRecordReference(node, signature.parameters[0].type, signature.type);
+    if (node.kind === 'InterfaceDeclaration') {
+        const record = { kind: 'TypeLiteral' };
+        makeRecordReference(record, signature.parameters[0].type, signature.type);
+        delete node.members;
+        delete node.heritageClauses;
+        node.kind = 'TypeAliasDeclaration';
+        node.type = record;
+    }
+}
+// Turns node into the type reference Record<keyType, valueType>
+function makeRecordReference(node, keyType, valueType) {
+    for (const key of Object.keys(node))
+        if (key !== 'parent')
+            delete node[key];
+    const typeName = { kind: 'Identifier', text: 'Record' };
+    node.kind = 'TypeReference';
+    node.typeName = typeName;
+    node.typeArguments = [keyType, valueType];
+}
+// const Point = class { … } → class Point { … } (the variable names the class)
+function lowerClassExpressions(node) {
+    for (const child of childNodes(node))
+        lowerClassExpressions(child);
+    if (!Array.isArray(node.statements))
+        return;
+    node.statements = node.statements.map((statement) => {
+        const declarations = statement.kind === 'VariableStatement' ? (statement.declarationList?.declarations ?? []) : [];
+        const initializer = declarations.length === 1 ? declarations[0].initializer : undefined;
+        if (initializer?.kind !== 'ClassExpression' || !isIdentifier(declarations[0].name))
+            return statement;
+        return { ...initializer, kind: 'ClassDeclaration', name: declarations[0].name, modifiers: statement.modifiers };
+    });
+}
+// WeakMap / WeakSet → Map / Set: same API; weakness is not observable
+function lowerWeakCollections(node) {
+    for (const child of childNodes(node))
+        lowerWeakCollections(child);
+    const name = node.kind === 'NewExpression' ? node.expression : node.kind === 'TypeReference' ? node.typeName : undefined;
+    if (isIdentifier(name) && (name.text === 'WeakMap' || name.text === 'WeakSet'))
+        name.text = name.text.slice(4);
+}
+// globalThis.x (typed) is the global x itself; (globalThis as any) stays a dynamic object
+function lowerGlobalThis(node) {
+    for (const key of Object.keys(node)) {
+        const child = node[key];
+        if (isPropertyAccessExpression(child) && isIdentifier(child.expression) && child.expression.text === 'globalThis') {
+            node[key] = child.name;
+        }
+    }
+    for (const child of childNodes(node))
+        lowerGlobalThis(child);
+}
 function linkParents(node, parent) {
     node.parent = parent;
     for (const key of Object.keys(node)) {
@@ -542,6 +625,8 @@ export function transpileToNative(code, options) {
     const drains = [];
     if (usedHelpers.has('asyncWait'))
         drains.push('__tnWaitGroup.Wait()');
+    if (usedHelpers.has('timerWait'))
+        drains.unshift('TnRunMicrotasks()');
     if (usedHelpers.has('timerWait'))
         drains.push('__tnTimers.Wait()');
     const drainCode = drains.length > 0 ? `\n\t${drains.join('\n\t')}` : '';
@@ -600,6 +685,10 @@ function visit(node, options = {}) {
             .filter((n) => !!n)
             .join(options.inline ? '' : '\n\t');
     }
+    else if (isIdentifier(node) && node.text === 'globalThis') {
+        useHelper('globalThis');
+        return 'TnGlobalThis';
+    }
     else if (isIdentifier(node)) {
         if (isFieldNameIdentifier(node))
             return goFieldName(node.text);
@@ -640,6 +729,18 @@ function visit(node, options = {}) {
     else if (isTemplateExpression(node)) {
         return visitTemplateExpression(node);
     }
+    else if (node.kind === 'TaggedTemplateExpression' && isStringRawTag(node.tag)) {
+        // String.raw`a\n${x}`: the raw source text with the values interpolated
+        const template = node.template;
+        const raw = (part) => toGoStringLiteral(part.rawText ?? part.text);
+        if (template.kind === 'NoSubstitutionTemplateLiteral')
+            return raw(template);
+        const pieces = [raw(template.head)];
+        for (const span of template.templateSpans ?? []) {
+            pieces.push(jsStringOf(visit(span.expression), inferExpressionType(span.expression)), raw(span.literal));
+        }
+        return `(${pieces.join(' + ')})`;
+    }
     else if (node.kind === 'TaggedTemplateExpression') {
         // tag`x${2}` → tag(["x", ""], 2)
         const tag = visit(node.tag);
@@ -684,7 +785,7 @@ function visit(node, options = {}) {
         // backtracking engine — both live in the TnRegex wrapper
         if (needsStatefulRegex(pattern, flags)) {
             useHelper('fancyRegex');
-            return `TnRegexCompile("${goPattern}", ${flags.includes('g') ? 'true' : 'false'})`;
+            return `TnRegexCompile("${goPattern}", "${flags}", ${toGoStringLiteral(pattern)})`;
         }
         importedPackages.add('regexp');
         const goFlags = jsRegexFlagsToGo(flags);
@@ -735,16 +836,19 @@ function visit(node, options = {}) {
         return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
     }
     else if (isPropertyAccessExpression(node)) {
+        const regexProperty = visitRegexProperty(node);
+        if (regexProperty)
+            return regexProperty;
         // import.meta.url — the file URL of the running program
         if (node.expression.kind === 'MetaProperty' && node.name.text === 'url') {
             useHelper('moduleUrl');
             return 'TnModuleURL()';
         }
-        if (isDynamicValue(node.expression) && node.name.text === 'length' && !isCallee(node)) {
+        if (hasDynamicProperties(node.expression) && node.name.text === 'length' && !isCallee(node)) {
             useHelper('dynamic');
             return `TnLength(${visit(node.expression)})`;
         }
-        if (isDynamicValue(node.expression) && !isCallee(node) && !isProcessEnv(node.expression)) {
+        if (hasDynamicProperties(node.expression) && !isCallee(node) && !isProcessEnv(node.expression)) {
             useHelper('dynamic');
             return `TnGet(${visit(node.expression)}, "${node.name.text}")`;
         }
@@ -953,6 +1057,11 @@ function visit(node, options = {}) {
             if (referenceArrays.has(node.name.text) && type.startsWith('[]')) {
                 type = variableGoTypes.get(node.name.text);
             }
+            // const v = undefined / void 0: Go cannot infer a type from nil
+            if (type === ':' && inferredType === 'nil') {
+                type = 'interface{}';
+                setVarGoType(node.name.text, 'interface{}');
+            }
         }
         let initializer = node.initializer ? `= ${visit(node.initializer)}` : '';
         // Wrap non-nil values assigned to nullable primitive pointer types
@@ -981,6 +1090,13 @@ function visit(node, options = {}) {
             return initializer ? `${name} ${initializer}` : '';
         }
         const declName = isIdentifier(node.name) ? getSafeName(node.name.text) : visit(node.name);
+        // const f = (…) => … f(…) … / const id = setInterval(() => clearInterval(id)):
+        // a Go closure can't see the variable in its own :=, so declare first, then assign
+        if (type === ':' &&
+            isIdentifier(node.name) &&
+            containsNode(node.initializer, (n) => isIdentifier(n) && n.text === node.name.text && !isFieldNameIdentifier(n))) {
+            return `var ${declName} ${inferExpressionType(node.initializer)}\n\t\t${declName} ${initializer}`;
+        }
         return `${type === ':' ? '' : 'var '}${declName} ${type}${type === ':' ? '' : ' '}${initializer}`;
     }
     else if (isCallExpression(node)) {
@@ -994,6 +1110,9 @@ function visit(node, options = {}) {
                 return visitNullablePrimitiveOptionalCall(node, visit(node.expression.expression), receiverType);
             }
         }
+        const recordCall = visitRecordFunctionCall(node);
+        if (recordCall)
+            return recordCall;
         const dynamicCall = visitDynamicMethodCall(node);
         if (dynamicCall)
             return dynamicCall;
@@ -1020,8 +1139,8 @@ function visit(node, options = {}) {
             const callback = visit((node.arguments ?? [])[0]);
             const delayNode = (node.arguments ?? [])[1];
             const delay = isNumericLiteral(delayNode) ? delayNode.text : visit(delayNode);
-            // Registered on the wait group so the process lives until it fires
-            return `__tnTimers.Add(1)\n\t\ttime.AfterFunc(${delay} * time.Millisecond, func() {\n\t\t\tdefer __tnTimers.Done()\n\t\t\t${callback.trim()}()\n\t\t})`;
+            // Registered on the wait group so the process lives until it fires (or is cleared)
+            return `TnSetTimeout(${delay ?? '0'}, func() { (${callback.trim()})() })`;
         }
         // p.then(cb) on a channel-based Promise: wait for the value, run the callback
         if (isPropertyAccessExpression(node.expression) &&
@@ -1075,6 +1194,12 @@ function visit(node, options = {}) {
         if (arrayHigherOrderCall) {
             return arrayHigherOrderCall;
         }
+        const promiseCall = visitPromiseCall(node);
+        if (promiseCall)
+            return promiseCall;
+        const objectCall = visitObjectCall(node);
+        if (objectCall)
+            return objectCall;
         const caller = visit(node.expression);
         const safeCaller = getSafeName(caller);
         const typeArgs = getTypeArguments((node.typeArguments ?? []));
@@ -1086,6 +1211,7 @@ function visit(node, options = {}) {
         if (isPropertyAccessExpression(node.expression)) {
             objectType = resolveExpressionType(node.expression.expression);
         }
+        currentCallArgTypes = (node.arguments ?? []).map((a) => inferExpressionType(a));
         currentReceiverGoType = isPropertyAccessExpression(node.expression)
             ? inferExpressionType(node.expression.expression)
             : undefined;
@@ -1106,6 +1232,15 @@ function visit(node, options = {}) {
     else if (isPostfixUnaryExpression(node)) {
         return visitIncrementOrDecrement(node, false);
     }
+    else if (node.kind === 'VoidExpression') {
+        // void expr evaluates expr and gives undefined
+        if (isNumericLiteral(node.expression))
+            return 'nil';
+        return `func() interface{} { _ = ${visit(node.expression)}; return nil }()`;
+    }
+    else if (node.kind === 'SatisfiesExpression') {
+        return visit(node.expression);
+    }
     else if (node.kind === 'DeleteExpression') {
         return visitDelete(node);
     }
@@ -1254,6 +1389,11 @@ function visit(node, options = {}) {
                 return op === '==' ? eq : `!(${eq})`;
             }
         }
+        // obj[key] = v on any
+        if (op === '=' && isElementAccessExpression(node.left) && isDynamicValue(node.left.expression)) {
+            useHelper('dynamic');
+            return `TnSetIndex(${visit(node.left.expression)}, ${visit(node.left.argumentExpression)}, ${visit(node.right)})`;
+        }
         if (op === '=' && isPropertyAccessExpression(node.left) && isDynamicValue(node.left.expression)) {
             useHelper('dynamic');
             return `TnSet(${visit(node.left.expression)}, "${node.left.name.text}", ${visit(node.right)})`;
@@ -1328,6 +1468,10 @@ function visit(node, options = {}) {
         return '';
     }
     else if (isAwaitExpression(node)) {
+        if (inferExpressionType(node.expression)?.startsWith('chan ')) {
+            useHelper('promise');
+            return `TnAwait(${visit(node.expression)})`;
+        }
         return `<-${visit(node.expression)}`;
     }
     else if (isVariableDeclarationList(node)) {
@@ -1342,11 +1486,15 @@ function visit(node, options = {}) {
             asyncFunctionNames.has(exprStmt.expression.text) &&
             !emittingModuleFile) {
             useHelper('asyncWait');
-            return `__tnWaitGroup.Add(1)\n\t\tgo func() {\n\t\t\tdefer __tnWaitGroup.Done()\n\t\t\t<-${getSafeName(exprStmt.expression.text)}()\n\t\t}();\n\t`;
+            useHelper('promise');
+            return `__tnWaitGroup.Add(1)\n\t\tgo func() {\n\t\t\tdefer __tnWaitGroup.Done()\n\t\t\tTnAwait(${getSafeName(exprStmt.expression.text)}())\n\t\t}();\n\t`;
         }
         return visit(node.expression) + (options.inline ? '' : ';\n\t');
     }
     else if (isForStatement(node)) {
+        const multi = visitMultiForHeader(node);
+        if (multi)
+            return multi;
         return `for ${visit(node.initializer, { inline: true })}; ${node.condition ? toGoCondition(node.condition) : ''}; ${visit(node.incrementor, { inline: true })}${visitLoopBody(node.statement)}`;
     }
     else if (isForInStatement(node)) {
@@ -1489,6 +1637,9 @@ function visit(node, options = {}) {
         return `return ${value}` + terminator;
     }
     else if (isFunctionDeclaration(node) || isFunctionExpression(node)) {
+        // overload signatures have no body: only the implementation is emitted
+        if (!node.body)
+            return '';
         if (options.addFunctionOutside) {
             outsideNodes.push(node);
             return '';
@@ -1535,7 +1686,7 @@ function visit(node, options = {}) {
         }
         if (!isBlock(node.body)) {
             // void-style calls (console.*, assert) emit statements, not values
-            if (isVoidStatementCall(node.body)) {
+            if (isVoidStatementCall(node.body) || !inferredRetType) {
                 return `func(${parameterInfo.signature})${returnType} { ${visit(node.body)}; }`;
             }
             return `func(${parameterInfo.signature})${returnType} { return ${visit(node.body)}; }`;
@@ -1936,6 +2087,12 @@ function visit(node, options = {}) {
                 result += `var ${name}_${fieldName} ${fieldType}${initializer}\n\n`;
             }
         }
+        // static { … } blocks run once at program start, after the static fields
+        for (const member of node.members ?? []) {
+            if (member.kind === 'ClassStaticBlockDeclaration' && member.body) {
+                result += `func init() ${visit(member.body).trimEnd()}\n\n`;
+            }
+        }
         return result.trim();
     }
     else if (isNewExpression(node)) {
@@ -2018,8 +2175,12 @@ function visit(node, options = {}) {
         if (!typeName || typeName === 'interface{}') {
             return visitAnonymousStructLiteral(node);
         }
-        // Objects are pointers: the struct type is typeName without its *
-        const structName = typeName.replace(/^\*/, '');
+        // Objects are pointers: the struct type is typeName without its *; generic
+        // types are instantiated with the contextual type arguments (Box<number> → Box[float64])
+        const typeArgs = isTypeReferenceNode(contextualType) && contextualType.typeName.text === typeName.replace(/^\*/, '')
+            ? getTypeArguments(contextualType.typeArguments)
+            : '';
+        const structName = typeName.replace(/^\*/, '') + (typeName.endsWith(']') ? '' : typeArgs);
         // { ...base, x: 1 } → a copy of *base with fields set
         if ((node.properties ?? []).some((p) => p.kind === 'SpreadAssignment')) {
             const steps = (node.properties ?? []).map((p) => {
@@ -2035,7 +2196,7 @@ function visit(node, options = {}) {
             });
             return `func() *${structName} { var __obj ${structName}; ${steps.join('; ')}; return &__obj }()`;
         }
-        const fieldTypes = interfacePropertyTypes.get(structName) ?? classPropertyTypes.get(structName);
+        const fieldTypes = typeArgs ? undefined : (interfacePropertyTypes.get(structName) ?? classPropertyTypes.get(structName));
         const properties = (node.properties ?? [])
             .map((p) => {
             if (isPropertyAssignment(p)) {
@@ -2137,7 +2298,7 @@ function toGoValueOfType(expr, goType) {
         return code;
     if (isBinaryExpression(expr) &&
         expr.operatorToken.kind === 'QuestionQuestionToken' &&
-        inferExpressionType(expr.left)?.startsWith('*')) {
+        getNullishEmitType(expr) === goType) {
         return code;
     }
     if (inferExpressionType(expr) !== goType.slice(1))
@@ -2270,7 +2431,8 @@ function isNarrowableReference(node) {
         return false;
     if (isPropertyAccessExpression(parent) && parent.name === node)
         return false;
-    if (parent.name === node)
+    // { x } reads the variable x
+    if (parent.name === node && !isShorthandPropertyAssignment(parent))
         return false;
     if (isBinaryExpression(parent) && parent.left === node) {
         const op = parent.operatorToken.kind;
@@ -2533,6 +2695,71 @@ function getPropertyDeclarationType(member) {
         return getOptionalNodeType(member.type, !!member.questionToken);
     return toFieldGoType(inferExpressionType(member.initializer));
 }
+// Sorts in place and returns the array; without a comparator, compares as strings (like JS)
+function sortArray(obj, args) {
+    importedPackages.add('sort');
+    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 }()`;
+}
+function mathCall(fn, args) {
+    importedPackages.add('math');
+    return `math.${fn}(${args.join(', ')})`;
+}
+// Go types of the arguments of the call being emitted (for call handlers)
+let currentCallArgTypes = [];
+// for headers with several declarations / updates: Go's parallel forms
+// (i, j := 0, 10 and i, j = i+1, j-1)
+function visitMultiForHeader(node) {
+    const declarations = isVariableDeclarationList(node.initializer) ? (node.initializer.declarations ?? []) : [];
+    const updates = [];
+    const collect = (expr) => {
+        if (!expr)
+            return;
+        if (isBinaryExpression(expr) && expr.operatorToken.kind === 'CommaToken') {
+            collect(expr.left);
+            collect(expr.right);
+        }
+        else
+            updates.push(expr);
+    };
+    collect(node.incrementor);
+    if (declarations.length < 2 && updates.length < 2)
+        return undefined;
+    let init = visit(node.initializer, { inline: true });
+    if (declarations.length >= 2) {
+        for (const d of declarations) {
+            if (isIdentifier(d.name) && d.initializer)
+                registerLocalVariable(d.name.text, inferExpressionType(d.initializer));
+        }
+        init = `${declarations.map((d) => visit(d.name)).join(', ')} := ${declarations.map((d) => (d.initializer ? visit(d.initializer) : 'nil')).join(', ')}`;
+    }
+    let post = visit(node.incrementor, { inline: true });
+    if (updates.length >= 2) {
+        const targets = [];
+        const values = [];
+        for (const u of updates) {
+            if ((isPrefixUnaryExpression(u) || isPostfixUnaryExpression(u)) && isIncrementOrDecrement(u)) {
+                const target = visit(u.operand);
+                targets.push(target);
+                values.push(`${target} ${u.operator === 'PlusPlusToken' ? '+' : '-'} 1`);
+            }
+            else if (isBinaryExpression(u) && u.operatorToken.kind === 'EqualsToken') {
+                targets.push(visit(u.left));
+                values.push(visit(u.right));
+            }
+            else
+                return undefined;
+        }
+        post = `${targets.join(', ')} = ${values.join(', ')}`;
+    }
+    const condition = node.condition ? toGoCondition(node.condition) : '';
+    return `for ${init}; ${condition}; ${post}${visitLoopBody(node.statement)}`;
+}
 function isIncrementOrDecrement(node) {
     return node.operator === 'PlusPlusToken' || node.operator === 'MinusMinusToken';
 }
@@ -2598,6 +2825,15 @@ function getDictionaryValueType(node) {
 function isDynamicObjectLiteral(node) {
     if (isAnyContext(getContextualTypeNode(node)))
         return true;
+    // { name: { … } } nested in a dynamic object (with no declared member type) is dynamic too
+    const parent = node.parent;
+    if (isPropertyAssignment(parent) &&
+        parent.initializer === node &&
+        isObjectLiteralExpression(parent.parent) &&
+        !getContextualTypeNode(node) &&
+        isDynamicObjectLiteral(parent.parent)) {
+        return true;
+    }
     return (node.properties ?? []).some((p) => p.kind === 'SpreadAssignment' && isDynamicValue(p.expression));
 }
 function getObjectLiteralGoType(node) {
@@ -2638,6 +2874,14 @@ function getObjectLiteralGoType(node) {
 function isDynamicValue(expr) {
     return inferExpressionType(expr) === 'interface{}';
 }
+// A value whose type is a type parameter (a: T in f<T>): its properties are read dynamically
+function isTypeParameterValue(expr) {
+    const type = inferExpressionType(expr);
+    return !!type && isUnboundGoType(type) && isTypeParameterInScope(type, expr);
+}
+function hasDynamicProperties(expr) {
+    return isDynamicValue(expr) || isTypeParameterValue(expr);
+}
 // Whether an expression is written to (x = …, x += …, x++)
 function isAssignmentTarget(node) {
     const parent = node.parent;
@@ -2680,6 +2924,30 @@ function isAnyContext(typeNode) {
     }
     return false;
 }
+const JS_MAP_METHODS = new Set(['get', 'set', 'has', 'delete', 'clear', 'keys', 'values', 'entries', 'forEach']);
+// rec.fn(args) where rec is a Record/dictionary (an ordered map) holding functions.
+// Names of JS Map methods (get, set, …) are Map methods unless rec is typed as a Record.
+function getRecordFunctionCall(node) {
+    if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression))
+        return undefined;
+    const receiver = node.expression.expression;
+    const mapType = inferExpressionType(receiver);
+    if (!mapType?.startsWith('*TnMap['))
+        return undefined;
+    if (!extractMapValueType(mapType).startsWith('func('))
+        return undefined;
+    if (JS_MAP_METHODS.has(node.expression.name.text) && !isRecordTypeNode(resolveTypeNode(getExpressionTypeNode(receiver)))) {
+        return undefined;
+    }
+    return { receiver, mapType };
+}
+function visitRecordFunctionCall(node) {
+    const call = getRecordFunctionCall(node);
+    if (!call)
+        return undefined;
+    const args = (node.arguments ?? []).map((a) => visit(a)).join(', ');
+    return `${visit(call.receiver)}.Get(${toGoStringLiteral(node.expression.name.text)})(${args})`;
+}
 function isRecordTypeNode(typeNode) {
     return (isTypeReferenceNode(typeNode) &&
         isIdentifier(typeNode.typeName) &&
@@ -2981,8 +3249,9 @@ function getContextualTypeNode(node) {
             return getExpressionTypeNode(parent.left);
         }
     }
-    if (isAsExpression(parent) || isTypeAssertionExpression(parent))
+    if (isAsExpression(parent) || isTypeAssertionExpression(parent) || parent.kind === 'SatisfiesExpression') {
         return parent.type;
+    }
     if ((isVariableDeclaration(parent) || isPropertyDeclaration(parent) || parent.kind === 'Parameter') &&
         parent.initializer === node) {
         return parent.type;
@@ -3012,6 +3281,14 @@ function getContextualTypeNode(node) {
     }
     return undefined;
 }
+// A type parameter of an enclosing function or class (T inside function f<T>)
+function isTypeParameterInScope(name, node) {
+    for (let n = node; n; n = n.parent) {
+        if ((n.typeParameters ?? []).some((tp) => tp.name?.text === name))
+            return true;
+    }
+    return false;
+}
 // 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) {
@@ -3019,7 +3296,7 @@ function getArrayLiteralElementType(node) {
     if (isArrayTypeNode(contextual)) {
         const elem = getType(contextual.elementType);
         // An unbound type parameter (call-site []T) resolves from the elements
-        if (!isUnboundGoType(elem))
+        if (!isUnboundGoType(elem) || isTypeParameterInScope(elem, node))
             return elem;
     }
     if (contextual?.kind === 'TupleType')
@@ -3032,6 +3309,7 @@ function getArrayLiteralElementType(node) {
         if (!isUnboundGoType(elem))
             return elem;
     }
+    let firstElementType;
     for (const element of node.elements ?? []) {
         if (isSpreadElement(element)) {
             const spreadType = inferExpressionType(element.expression);
@@ -3044,11 +3322,16 @@ function getArrayLiteralElementType(node) {
             }
             continue;
         }
+        // mixed element types ([['a', 1]]) make an interface{} array
         const elementType = inferExpressionType(element);
-        if (elementType && elementType !== 'nil' && !isUnboundGoType(elementType))
-            return elementType;
+        if (elementType && elementType !== 'nil' && !isUnboundGoType(elementType)) {
+            if (firstElementType && firstElementType !== elementType)
+                return 'interface{}';
+            if (!firstElementType)
+                firstElementType = elementType;
+        }
     }
-    return 'interface{}';
+    return firstElementType ?? 'interface{}';
 }
 // A Go type that is a generic type parameter of the enclosing function (T)
 // rather than a concrete type: unresolvable at the call site
@@ -3111,6 +3394,13 @@ function getTupleElementType(tuple) {
 function getTypeText(typeNode) {
     if (!typeNode)
         return ':';
+    // Partial<T> etc. construct T
+    if (isTypeReferenceNode(typeNode) &&
+        isIdentifier(typeNode.typeName) &&
+        UTILITY_TYPES.has(typeNode.typeName.text) &&
+        typeNode.typeArguments?.length) {
+        return getTypeText(typeNode.typeArguments[0]);
+    }
     if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
         return typeNode.typeName.text;
     }
@@ -3187,8 +3477,10 @@ function visitTemplateExpression(node) {
 function isVoidStatementCall(expr) {
     if (!isCallExpression(expr))
         return false;
-    if (isIdentifier(expr.expression))
-        return expr.expression.text === 'assert';
+    if (isIdentifier(expr.expression)) {
+        const name = expr.expression.text;
+        return name === 'assert' || (!!promiseResolveName && name === promiseResolveName) || (!!promiseRejectName && name === promiseRejectName);
+    }
     return (isPropertyAccessExpression(expr.expression) &&
         isIdentifier(expr.expression.expression) &&
         expr.expression.expression.text === 'console');
@@ -3298,10 +3590,16 @@ function inferExpressionType(expr) {
     }
     if (isNumericLiteral(expr))
         return 'float64';
+    if (expr.kind === 'VoidExpression')
+        return 'nil';
+    if (expr.kind === 'SatisfiesExpression')
+        return inferExpressionType(expr.expression);
     if (expr.kind === 'BigIntLiteral')
         return '*tnbig.Int';
     if (expr.kind === 'TypeOfExpression')
         return 'string';
+    if (expr.kind === 'TaggedTemplateExpression' && isStringRawTag(expr.tag))
+        return 'string';
     if (isRegularExpressionLiteral(expr)) {
         const lastSlash = expr.text.lastIndexOf('/');
         if (needsStatefulRegex(expr.text.substring(1, lastSlash), expr.text.substring(lastSlash + 1))) {
@@ -3396,6 +3694,15 @@ function inferExpressionType(expr) {
             : isPropertyAccessExpression(expr.expression) && isIdentifier(expr.expression.expression)
                 ? `${expr.expression.expression.text}.${expr.expression.name.text}`
                 : undefined;
+        const promiseType = inferPromiseCallType(expr);
+        if (promiseType)
+            return promiseType;
+        const objectCallType = inferObjectCallType(expr);
+        if (objectCallType)
+            return objectCallType;
+        if (isIdentifier(expr.expression) && expr.expression.text === 'structuredClone') {
+            return inferExpressionType(expr.arguments?.[0]);
+        }
         // Promise.all([...]) resolves to a slice over a channel
         if (isPropertyAccessExpression(expr.expression) &&
             isIdentifier(expr.expression.expression) &&
@@ -3441,12 +3748,18 @@ function inferExpressionType(expr) {
         if (builtinType && !declaredFunctions.has(expr.expression.text))
             return builtinType;
     }
-    if (isPropertyAccessExpression(expr) && expr.name.text === 'length' && isDynamicValue(expr.expression)) {
+    const regexPropertyType = inferRegexPropertyType(expr);
+    if (regexPropertyType)
+        return regexPropertyType;
+    if (isPropertyAccessExpression(expr) && expr.name.text === 'length' && hasDynamicProperties(expr.expression)) {
         return 'float64';
     }
     if ((isPropertyAccessExpression(expr) || isElementAccessExpression(expr)) && isDynamicValue(expr.expression)) {
         return 'interface{}';
     }
+    if (isPropertyAccessExpression(expr) && !isCallee(expr) && isTypeParameterValue(expr.expression)) {
+        return 'interface{}';
+    }
     if (isCallExpression(expr) &&
         isPropertyAccessExpression(expr.expression) &&
         isIdentifier(expr.expression.expression) &&
@@ -3456,6 +3769,15 @@ function inferExpressionType(expr) {
     }
     if (isCallExpression(expr) && isObjectKeysOfDynamic(expr))
         return '[]string';
+    // f?.() is undefined when f is
+    if (isCallExpression(expr) && hasQuestionDot(expr)) {
+        const fnType = inferExpressionType(expr.expression) ?? '';
+        const returnType = fnType.startsWith('func(') ? goFuncReturnType(fnType) : undefined;
+        return returnType ? makeNullableType(returnType) : undefined;
+    }
+    const recordCall = isCallExpression(expr) ? getRecordFunctionCall(expr) : undefined;
+    if (recordCall)
+        return goFuncReturnType(extractMapValueType(recordCall.mapType));
     if (isCallExpression(expr) &&
         isPropertyAccessExpression(expr.expression) &&
         isIdentifier(expr.expression.expression) &&
@@ -3570,15 +3892,17 @@ function inferExpressionType(expr) {
             if (methodName === 'getTime' || methodName === 'valueOf' || methodName === 'getMilliseconds' ||
                 methodName === 'getSeconds' || methodName === 'getMinutes' || methodName === 'getHours' ||
                 methodName === 'getDate' || methodName === 'getDay' || methodName === 'getMonth' ||
-                methodName === 'getFullYear')
+                methodName === 'getFullYear' || methodName.startsWith('getUTC'))
                 return 'float64';
             if (methodName === 'toISOString' || methodName === 'toJSON' || methodName === 'toString' ||
                 methodName === 'toDateString' || methodName === 'toTimeString')
                 return 'string';
         }
         if (ownerType && ownerType.startsWith('*TnMap[')) {
-            if (methodName === 'has')
+            if (['has', 'isSubsetOf', 'isSupersetOf', 'isDisjointFrom'].includes(methodName))
                 return 'bool';
+            if (['union', 'intersection', 'difference', 'symmetricDifference'].includes(methodName))
+                return ownerType;
             if (methodName === 'get') {
                 const valueType = extractMapValueType(ownerType);
                 return isStructGoType(valueType) ? `*${valueType}` : valueType;
@@ -3602,6 +3926,10 @@ function inferExpressionType(expr) {
                 return 'float64';
             if (['pop', 'shift', 'at'].includes(methodName))
                 return elementType;
+            if (['concat', 'toSorted', 'toReversed', 'with', 'copyWithin', 'toSpliced'].includes(methodName))
+                return ownerType;
+            if (methodName === 'reduceRight' && expr.arguments?.[1])
+                return inferExpressionType(expr.arguments[1]);
             if (methodName === 'flat' && elementType.startsWith('[]'))
                 return elementType;
             if (methodName === 'flat' || methodName === 'flatMap')
@@ -3698,6 +4026,11 @@ function inferExpressionType(expr) {
     return undefined;
 }
 const BUILTIN_CALL_TYPES = {
+    isFinite: 'bool',
+    encodeURIComponent: 'string',
+    decodeURIComponent: 'string',
+    'Object.fromEntries': 'interface{}',
+    'Date.UTC': 'float64',
     'Number.isNaN': 'bool',
     'Number.isFinite': 'bool',
     'Number.isInteger': 'bool',
@@ -3705,6 +4038,156 @@ const BUILTIN_CALL_TYPES = {
     'Object.assign': '*TnMap[string, interface{}]',
     'Date.now': 'float64'
 };
+// Object.freeze & co. record the integrity level (1 preventExtensions, 2 seal,
+// 3 freeze) by identity; TypeScript's Readonly<T> result types reject writes
+const OBJECT_INTEGRITY_LEVELS = { preventExtensions: 1, seal: 2, freeze: 3 };
+const OBJECT_INTEGRITY_CHECKS = { isExtensible: 1, isSealed: 2, isFrozen: 3 };
+function getObjectCallName(node) {
+    if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression))
+        return undefined;
+    if (!isIdentifier(node.expression.expression) || node.expression.expression.text !== 'Object')
+        return undefined;
+    return node.expression.name.text;
+}
+// The Go type of a property of an object type (anonymous struct, interface or class)
+function getObjectFieldGoType(objectType, field) {
+    const base = objectType.replace(/^\*/, '').replace(/\[.*$/, '');
+    return (getStructFieldGoType(objectType, field) ??
+        interfacePropertyTypes.get(base)?.get(field) ??
+        classPropertyTypes.get(base)?.get(field));
+}
+function inferObjectCallType(expr) {
+    const name = getObjectCallName(expr);
+    if (!name)
+        return undefined;
+    if (OBJECT_INTEGRITY_LEVELS[name] || name === 'defineProperty')
+        return inferExpressionType(expr.arguments?.[0]);
+    if (OBJECT_INTEGRITY_CHECKS[name] || name === 'hasOwn')
+        return 'bool';
+    if (name === 'getOwnPropertyNames')
+        return inferExpressionType({ ...expr, expression: { ...expr.expression, name: { kind: 'Identifier', text: 'keys' } } });
+    return undefined;
+}
+function visitObjectCall(node) {
+    const name = getObjectCallName(node);
+    if (!name)
+        return undefined;
+    const args = node.arguments ?? [];
+    if (OBJECT_INTEGRITY_LEVELS[name]) {
+        useHelper('objectIntegrity');
+        return `TnSetIntegrity(${visit(args[0])}, ${OBJECT_INTEGRITY_LEVELS[name]})`;
+    }
+    if (OBJECT_INTEGRITY_CHECKS[name]) {
+        useHelper('objectIntegrity');
+        const check = `TnHasIntegrity(${visit(args[0])}, ${OBJECT_INTEGRITY_CHECKS[name]})`;
+        return name === 'isExtensible' ? `!${check}` : check;
+    }
+    if (name === 'getOwnPropertyNames') {
+        return visit({ ...node, expression: { ...node.expression, name: { kind: 'Identifier', text: 'keys' } } });
+    }
+    const objectType = inferExpressionType(args[0]) ?? '';
+    const key = args[1];
+    if (name === 'hasOwn') {
+        if (isDynamicValue(args[0])) {
+            useHelper('dynamic');
+            return `TnHas(${visit(args[0])}, ${visit(key)})`;
+        }
+        if (objectType.startsWith('*TnMap['))
+            return `${visit(args[0])}.Has(${visit(key)})`;
+        if (!isStringLiteral(key))
+            throw new Error('Object.hasOwn on a typed object needs a literal key');
+        const fieldType = getObjectFieldGoType(objectType, key.text);
+        if (!fieldType)
+            return 'false';
+        // an absent optional primitive is nil
+        return /^\*(float64|string|bool)$/.test(fieldType) ? `(${visit(args[0])}.${goFieldName(key.text)} != nil)` : 'true';
+    }
+    if (name === 'defineProperty') {
+        const descriptor = args[2];
+        const valueProp = isObjectLiteralExpression(descriptor)
+            ? (descriptor.properties ?? []).find((p) => isPropertyAssignment(p) && isIdentifier(p.name) && p.name.text === 'value')
+            : undefined;
+        if (!valueProp)
+            throw new Error('Object.defineProperty needs a { value } descriptor literal');
+        const target = visit(args[0]);
+        if (isDynamicValue(args[0])) {
+            useHelper('dynamic');
+            return `TnSet(${target}, ${visit(key)}, ${visit(valueProp.initializer)})`;
+        }
+        if (objectType.startsWith('*TnMap[')) {
+            return `${target}.Set(${visit(key)}, ${toGoValueOfType(valueProp.initializer, extractMapValueType(objectType))})`;
+        }
+        if (!isStringLiteral(key))
+            throw new Error('Object.defineProperty on a typed object needs a literal key');
+        return `${target}.${goFieldName(key.text)} = ${toGoValueOfType(valueProp.initializer, getObjectFieldGoType(objectType, key.text))}`;
+    }
+    return undefined;
+}
+const PROMISE_COMBINATORS = new Set(['race', 'allSettled', 'any']);
+function isPromiseStaticCall(node, names) {
+    return (isCallExpression(node) &&
+        isPropertyAccessExpression(node.expression) &&
+        isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === 'Promise' &&
+        names.has(node.expression.name.text));
+}
+// p.catch(cb) / p.finally(cb) on a promise channel
+function isPromiseMethodCall(node) {
+    return (isCallExpression(node) &&
+        isPropertyAccessExpression(node.expression) &&
+        ['catch', 'finally'].includes(node.expression.name.text) &&
+        !!inferExpressionType(node.expression.expression)?.startsWith('chan '));
+}
+// The value type of Promise.reject(…): from sibling promises in an array, else the
+// enclosing function's Promise<T>
+function getRejectedPromiseType(node) {
+    const parent = node.parent;
+    if (isArrayLiteralExpression(parent)) {
+        for (const sibling of parent.elements ?? []) {
+            if (sibling === node || isPromiseStaticCall(sibling, new Set(['reject'])))
+                continue;
+            const type = inferExpressionType(sibling);
+            if (type?.startsWith('chan '))
+                return type.slice(5);
+        }
+    }
+    return getPromiseChannelType(node);
+}
+function inferPromiseCallType(expr) {
+    if (isPromiseStaticCall(expr, new Set(['reject'])))
+        return `chan ${getRejectedPromiseType(expr)}`;
+    if (isPromiseStaticCall(expr, PROMISE_COMBINATORS)) {
+        const elem = promiseAllElementType(expr) ?? 'interface{}';
+        return expr.expression.name.text === 'allSettled' ? `chan []*TnSettled[${elem}]` : `chan ${elem}`;
+    }
+    if (isPromiseMethodCall(expr))
+        return inferExpressionType(expr.expression.expression);
+    return undefined;
+}
+function visitPromiseCall(node) {
+    const args = node.arguments ?? [];
+    if (isPromiseStaticCall(node, new Set(['reject']))) {
+        useHelper('promise');
+        return `TnPromiseReject[${getRejectedPromiseType(node)}](${args[0] ? visit(args[0]) : 'nil'})`;
+    }
+    if (isPromiseStaticCall(node, PROMISE_COMBINATORS)) {
+        useHelper('promise');
+        const name = node.expression.name.text;
+        return `TnPromise${name[0].toUpperCase()}${name.slice(1)}(${args[0] ? visit(args[0]) : '[]chan interface{}{}'})`;
+    }
+    if (!isPromiseMethodCall(node))
+        return undefined;
+    useHelper('promise');
+    const receiver = visit(node.expression.expression);
+    const callback = args[0];
+    const cb = callback ? visit(callback) : 'func() {}';
+    if (node.expression.name.text === 'finally')
+        return `TnPromiseFinally(${receiver}, ${cb})`;
+    // .catch(() => …) ignores the reason; .catch((e) => value) settles with the value
+    const handler = callback && (callback.parameters ?? []).length === 0 ? `func(_ interface{}) { (${cb})() }` : cb;
+    const returnsValue = callback && !/\)$/.test(inferExpressionType(callback) ?? ')');
+    return `TnPromiseCatch${returnsValue ? 'Value' : ''}(${receiver}, ${handler})`;
+}
 // Element type of `await Promise.all([...])` from the first promise channel
 function promiseAllElementType(expr) {
     const arrayNode = (expr.arguments ?? [])[0];
@@ -3716,7 +4199,9 @@ const BUILTIN_FUNCTION_TYPES = {
     parseFloat: 'float64',
     parseInt: 'float64',
     Number: 'float64',
-    String: 'string'
+    String: 'string',
+    setTimeout: '*time.Timer',
+    setInterval: '*TnInterval'
 };
 const STRING_METHOD_RETURN_TYPES = {
     trim: 'string',
@@ -3886,6 +4371,43 @@ function isObjectTypeName(name) {
     }
     return interfacePropertyTypes.has(name);
 }
+// The keys a mapped type iterates: string literals of a union, or keyof an object type
+function getMappedTypeKeys(constraint) {
+    const keys = resolveTypeNode(constraint);
+    if (!keys)
+        return undefined;
+    if (keys.kind === 'TypeOperator' && keys.operator === 'KeyOfKeyword') {
+        const fields = getObjectTypeFields(keys.type);
+        return fields.length > 0 ? fields.map((f) => f.split(' ')[0]) : undefined;
+    }
+    const types = isUnionTypeNode(keys) ? (keys.types ?? []) : [keys];
+    if (!types.every((t) => isLiteralTypeNode(t) && isStringLiteral(t.literal)))
+        return undefined;
+    return types.map((t) => goFieldName(t.literal.text));
+}
+function getMappedType(typeNode) {
+    const valueType = typeNode.type ? getOptionalNodeType(typeNode.type, !!typeNode.questionToken) : 'interface{}';
+    const keys = getMappedTypeKeys(typeNode.typeParameter?.constraint);
+    if (keys)
+        return `*struct{ ${keys.map((k) => `${k} ${valueType}`).join('; ')} }`;
+    return 'interface{}';
+}
+const UTILITY_TYPES = new Set(['Partial', 'Required', 'Readonly', 'Pick', 'Omit', 'NonNullable']);
+// "name T" field declarations of an object type (type literal, alias or interface)
+function getObjectTypeFields(typeNode) {
+    let members = [];
+    const resolved = typeNode.kind === 'TypeLiteral' ? typeNode : undefined;
+    if (resolved)
+        members = resolved.members ?? [];
+    else if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
+        const name = typeNode.typeName.text;
+        const alias = declaredTypeAliases.get(name) ?? typeAliases.get(name);
+        members = alias?.kind === 'TypeLiteral' ? (alias.members ?? []) : (declaredInterfaces.get(name)?.members ?? []);
+    }
+    return members
+        .filter((m) => isPropertySignature(m) && isIdentifier(m.name))
+        .map((m) => `${goFieldName(m.name.text)} ${getOptionalNodeType(m.type, !!m.questionToken)}`);
+}
 function isStructGoType(goType) {
     return goType.startsWith('struct{') || interfacePropertyTypes.has(goType);
 }
@@ -4071,6 +4593,18 @@ function withNarrowingType(names, infer) {
     return type;
 }
 function visitOptionalCall(node) {
+    // f?.(): call only when the function value is not nil
+    if (hasQuestionDot(node)) {
+        const fnType = inferExpressionType(node.expression) ?? '';
+        const returnType = fnType.startsWith('func(') ? goFuncReturnType(fnType) : undefined;
+        const fn = getTempName('fn');
+        const args = (node.arguments ?? []).map((a) => visit(a)).join(', ');
+        if (!returnType)
+            return `func() { if ${fn} := ${visit(node.expression)}; ${fn} != nil { ${fn}(${args}) } }()`;
+        const resultType = makeNullableType(returnType);
+        const value = resultType === returnType ? `${fn}(${args})` : `func() ${resultType} { v := ${fn}(${args}); return &v }()`;
+        return `func() ${resultType} { ${fn} := ${visit(node.expression)}; if ${fn} == nil { return nil }; return ${value} }()`;
+    }
     if (!isPropertyAccessExpression(node.expression)) {
         return `${visit(node.expression)}(${(node.arguments ?? []).map((a) => visit(a)).join(', ')})`;
     }
@@ -4189,7 +4723,7 @@ function visitArrayHigherOrderCall(node) {
     if (!isPropertyAccessExpression(node.expression))
         return undefined;
     const methodName = node.expression.name.text;
-    if (!['map', 'filter', 'some', 'find', 'findIndex', 'findLast', 'findLastIndex', 'every', 'forEach', 'reduce', 'join', 'entries', 'flatMap'].includes(methodName)) {
+    if (!['map', 'filter', 'some', 'find', 'findIndex', 'findLast', 'findLastIndex', 'every', 'forEach', 'reduce', 'reduceRight', 'join', 'entries', 'flatMap'].includes(methodName)) {
         return undefined;
     }
     const arrayExprNode = node.expression.expression;
@@ -4294,6 +4828,17 @@ function visitArrayHigherOrderCall(node) {
         const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
         return `func() { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { ${callbackCall} } }()`;
     }
+    if (methodName === 'reduceRight') {
+        importedPackages.add('slices');
+        const reversed = { kind: 'Identifier', text: `func() []${elementType} { __s := slices.Clone(${arrayExpr}); slices.Reverse(__s); return __s }()` };
+        variableGoTypes.set(reversed.text, ownerType ?? '[]interface{}');
+        const access = { ...node.expression, name: { kind: 'Identifier', text: 'reduce' }, expression: reversed };
+        const call = { ...node, expression: access };
+        reversed.parent = access;
+        access.parent = call;
+        access.name.parent = access;
+        return visitArrayHigherOrderCall(call);
+    }
     if (methodName === 'reduce') {
         const reduceCallback = (node.arguments ?? [])[0];
         if (!reduceCallback)
@@ -4444,6 +4989,24 @@ function getType(typeNode, getArrayType = false) {
         const elementType = getType(typeNode.elementType);
         return getArrayType ? elementType : `[]${elementType}`;
     }
+    if (typeNode.kind === 'MappedType')
+        return getMappedType(typeNode);
+    // readonly T[] → T[]; keyof T → string
+    if (typeNode.kind === 'TypeOperator') {
+        return typeNode.operator === 'KeyOfKeyword' ? 'string' : getType(typeNode.type, getArrayType);
+    }
+    // typeof x → x's type
+    if (typeNode.kind === 'TypeQuery' && isIdentifier(typeNode.exprName)) {
+        return variableGoTypes.get(typeNode.exprName.text) ?? 'interface{}';
+    }
+    // asserts x is T → no value; x is T → bool
+    if (typeNode.kind === 'TypePredicate')
+        return typeNode.assertsModifier ? '' : 'bool';
+    // A & B of object types → one struct with all their fields
+    if (typeNode.kind === 'IntersectionType') {
+        const fields = (typeNode.types ?? []).flatMap((t) => getObjectTypeFields(t));
+        return fields.length > 0 ? `*struct{ ${fields.join('; ')} }` : getType(typeNode.types[0]);
+    }
     // [A, B] tuples are slices: []A when all elements share a type, else []interface{}
     if (typeNode.kind === 'TupleType') {
         const elementType = getTupleElementType(typeNode);
@@ -4518,6 +5081,10 @@ function getType(typeNode, getArrayType = false) {
         if (name === 'Set' && typeNode.typeArguments && typeNode.typeArguments.length === 1) {
             return mapGoType(getType(typeNode.typeArguments[0]), 'struct{}');
         }
+        // Partial / Required / Readonly / Pick / Omit / NonNullable<T, ...> → T's Go type
+        if (UTILITY_TYPES.has(name) && typeNode.typeArguments?.length) {
+            return getType(typeNode.typeArguments[0], getArrayType);
+        }
         const typeArgs = getTypeArguments(typeNode.typeArguments);
         if (classNames.has(name) || isObjectTypeName(name)) {
             return `*${name}${typeArgs}`;
@@ -4550,7 +5117,10 @@ function getType(typeNode, getArrayType = false) {
         case 'any':
             return 'interface{}';
         case 'void':
+        case 'never':
             return '';
+        case 'object':
+            return 'interface{}';
         default:
             return typeName;
     }
@@ -4661,6 +5231,22 @@ function getAcessString(leftSide, rightSide, objectType) {
             return 'process.env';
         }
     }
+    if (leftSide === 'Math') {
+        const mathConstants = {
+            PI: 'math.Pi',
+            E: 'math.E',
+            LN2: 'math.Ln2',
+            LN10: 'math.Ln10',
+            LOG2E: 'math.Log2E',
+            LOG10E: 'math.Log10E',
+            SQRT2: 'math.Sqrt2',
+            SQRT1_2: '(1 / math.Sqrt2)'
+        };
+        if (mathConstants[rightSide]) {
+            importedPackages.add('math');
+            return `float64(${mathConstants[rightSide]})`;
+        }
+    }
     if (leftSide === 'Number') {
         const constants = {
             MAX_SAFE_INTEGER: 'float64(9007199254740991)',
@@ -4701,6 +5287,63 @@ const callHandlers = {
         importedPackages.add('fmt');
         return `fmt.Println("Elapsed time:", time.Since(${getTimerName(args[0])}))`;
     },
+    'Math.hypot': (_caller, args) => mathCall('Hypot', args),
+    'Math.cbrt': (_caller, args) => mathCall('Cbrt', args),
+    'Math.exp': (_caller, args) => mathCall('Exp', args),
+    'Math.expm1': (_caller, args) => mathCall('Expm1', args),
+    'Math.log1p': (_caller, args) => mathCall('Log1p', args),
+    'Math.asin': (_caller, args) => mathCall('Asin', args),
+    'Math.acos': (_caller, args) => mathCall('Acos', args),
+    'Math.atan': (_caller, args) => mathCall('Atan', args),
+    'Math.atan2': (_caller, args) => mathCall('Atan2', args),
+    'Math.sinh': (_caller, args) => mathCall('Sinh', args),
+    'Math.cosh': (_caller, args) => mathCall('Cosh', args),
+    'Math.tanh': (_caller, args) => mathCall('Tanh', args),
+    isFinite: (_caller, args) => {
+        importedPackages.add('math');
+        return `(!math.IsInf(${args[0]}, 0) && !math.IsNaN(${args[0]}))`;
+    },
+    encodeURIComponent: (_caller, args) => {
+        useHelper('uri');
+        return `TnEncodeURIComponent(${args[0]})`;
+    },
+    decodeURIComponent: (_caller, args) => {
+        useHelper('uri');
+        return `TnDecodeURIComponent(${args[0]})`;
+    },
+    'Object.fromEntries': (_caller, args) => {
+        useHelper('dynamic');
+        return `TnFromEntries(${args[0]})`;
+    },
+    'Date.UTC': (_caller, args) => {
+        importedPackages.add('time');
+        const part = (i, fallback) => (args[i] ? `int(${args[i]})` : fallback);
+        return `float64(time.Date(${part(0, '1970')}, time.Month(${part(1, '0')}+1), ${part(2, '1')}, ${part(3, '0')}, ${part(4, '0')}, ${part(5, '0')}, ${part(6, '0')}*1000000, time.UTC).UnixMilli())`;
+    },
+    'Promise.resolve': (_caller, args) => {
+        const valueType = currentCallArgTypes[0] ?? 'interface{}';
+        return `func() chan ${valueType} { __ch := make(chan ${valueType}, 1); __ch <- ${args[0] ?? 'nil'}; return __ch }()`;
+    },
+    structuredClone: (_caller, args) => {
+        useHelper('structuredClone');
+        return `TnStructuredClone(${args[0]})`;
+    },
+    setInterval: (_caller, args) => {
+        useHelper('timerWait');
+        return `TnSetInterval(${args[1] ?? '0'}, ${args[0]})`;
+    },
+    clearInterval: (_caller, args) => {
+        useHelper('timerWait');
+        return `TnClearInterval(${args[0]})`;
+    },
+    queueMicrotask: (_caller, args) => {
+        useHelper('timerWait');
+        return `TnQueueMicrotask(${args[0]})`;
+    },
+    clearTimeout: (_caller, args) => {
+        useHelper('timerWait');
+        return `TnClearTimeout(${args[0]})`;
+    },
     'Math.random': () => {
         importedPackages.add('math/rand');
         return 'rand.Float64()';
@@ -4833,10 +5476,7 @@ const callHandlers = {
         importedPackages.add('reflect');
         return `(reflect.ValueOf(${args[0]}).Kind() == reflect.Slice)`;
     },
-    'String': (_caller, args) => {
-        importedPackages.add('fmt');
-        return `fmt.Sprintf("%v", ${args[0]})`;
-    },
+    'String': (_caller, args) => jsStringOf(args[0] ?? '""', currentCallArgTypes[0]),
     'String.fromCharCode': (_caller, args) => `string(rune(int(${args[0] ?? '0'})))`,
     // Symbol(description) — unique values for record keys
     Symbol: (_caller, args) => {
@@ -4863,9 +5503,7 @@ const callHandlers = {
         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]} != "")`;
-    },
+    'Boolean': (_caller, args) => `(${truthinessCheck(args[0] ?? 'false', currentCallArgTypes[0] ?? 'interface{}')})`,
 };
 const stringMethodHandlers = {
     split: (obj, args) => {
@@ -5011,8 +5649,16 @@ const dateMethodHandlers = {
     getDay: (obj) => `float64(int((${obj}).Weekday()))`,
     getMonth: (obj) => `float64(int((${obj}).Month()) - 1)`,
     getFullYear: (obj) => `float64((${obj}).Year())`,
-    toISOString: (obj) => `(${obj}).UTC().Format("2006-01-01T15:04:05.000Z07:00")`,
-    toJSON: (obj) => `(${obj}).UTC().Format("2006-01-01T15:04:05.000Z07:00")`,
+    toISOString: (obj) => `(${obj}).UTC().Format("2006-01-02T15:04:05.000Z07:00")`,
+    toJSON: (obj) => `(${obj}).UTC().Format("2006-01-02T15:04:05.000Z07:00")`,
+    getUTCMilliseconds: (obj) => `float64((${obj}).UTC().Nanosecond() / 1000000)`,
+    getUTCSeconds: (obj) => `float64((${obj}).UTC().Second())`,
+    getUTCMinutes: (obj) => `float64((${obj}).UTC().Minute())`,
+    getUTCHours: (obj) => `float64((${obj}).UTC().Hour())`,
+    getUTCDate: (obj) => `float64((${obj}).UTC().Day())`,
+    getUTCDay: (obj) => `float64(int((${obj}).UTC().Weekday()))`,
+    getUTCMonth: (obj) => `float64(int((${obj}).UTC().Month()) - 1)`,
+    getUTCFullYear: (obj) => `float64((${obj}).UTC().Year())`,
     toString: (obj) => `(${obj}).UTC().Format("Mon Jan 02 2006 15:04:05 GMT+0000 (UTC)")`,
     toDateString: (obj) => `(${obj}).UTC().Format("Mon Jan 02 2006")`,
     toTimeString: (obj) => `(${obj}).UTC().Format("15:04:05 GMT+0000 (UTC)")`,
@@ -5071,19 +5717,38 @@ const arrayMethodHandlers = {
         return `func() float64 { __x := ${args[0]}; for __i := len(${obj}) - 1; __i >= 0; __i-- { if ${elementEqualsFor(elementType, `${obj}[__i]`, '__x')} { return float64(__i) } }; return float64(-1) }()`;
     },
     // Sorts in place and returns the array; without a comparator, compares as strings (like JS)
-    sort: (obj, args) => {
-        importedPackages.add('sort');
-        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 }()`;
-    },
+    sort: (obj, args) => sortArray(obj, args),
     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(', ')}...)`,
+    // concat(a, [b, c], d): arrays are flattened one level, other values appended
+    concat: (obj, args) => {
+        const parts = args.map((arg, i) => currentCallArgTypes[i]?.startsWith('[]') ? `__r = append(__r, ${arg}...)` : `__r = append(__r, ${arg})`);
+        return `func() []${receiverElementType()} { __r := append([]${receiverElementType()}{}, ${obj}...); ${parts.join('; ')}; return __r }()`;
+    },
+    toSorted: (obj, args) => {
+        importedPackages.add('slices');
+        return sortArray(`slices.Clone(${obj})`, args);
+    },
+    // copyWithin(target, start, end?): copies in place (overlap-safe) and returns the array
+    copyWithin: (obj, args) => {
+        const end = args[2] ? sliceIndex('__s', args[2]) : 'len(__s)';
+        return `func() []${receiverElementType()} { __s := ${obj}; __t := ${sliceIndex('__s', args[0] ?? '0')}; __start := ${sliceIndex('__s', args[1] ?? '0')}; __end := ${end}; if __start < __end { copy(__s[__t:], __s[__start:__end]) }; return __s }()`;
+    },
+    // toSpliced(start, deleteCount?, ...items): a spliced copy
+    toSpliced: (obj, args) => {
+        importedPackages.add('slices');
+        const elementType = receiverElementType();
+        const end = args.length >= 2 ? `min(__start+max(int(${args[1]}), 0), len(__s))` : 'len(__s)';
+        return `func() []${elementType} { __s := ${obj}; __start := ${sliceIndex('__s', args[0] ?? '0')}; return slices.Concat(__s[:__start:__start], []${elementType}{${args.slice(2).join(', ')}}, __s[${end}:]) }()`;
+    },
+    toReversed: (obj) => {
+        importedPackages.add('slices');
+        return `func() []${receiverElementType()} { __s := slices.Clone(${obj}); slices.Reverse(__s); return __s }()`;
+    },
+    with: (obj, args) => {
+        importedPackages.add('slices');
+        return `func() []${receiverElementType()} { __s := slices.Clone(${obj}); __s[${sliceIndex('__s', args[0])}] = ${args[1]}; return __s }()`;
+    },
     // [][]T → []T (one level, like JS's default depth)
     flat: (obj) => {
         const elementType = receiverElementType();
@@ -5148,12 +5813,25 @@ const setMethodHandlers = {
     has: (obj, args) => `${obj}.Has(${args[0]})`,
     delete: (obj, args) => `${obj}.Delete(${args[0]})`,
     clear: (obj) => `${obj}.Clear()`,
-    values: (obj) => `${obj}.Keys()`
+    values: (obj) => `${obj}.Keys()`,
+    union: (obj, args) => `${obj}.Union(${args[0]})`,
+    intersection: (obj, args) => `${obj}.Intersection(${args[0]})`,
+    difference: (obj, args) => `${obj}.Difference(${args[0]})`,
+    symmetricDifference: (obj, args) => `${obj}.SymmetricDifference(${args[0]})`,
+    isSubsetOf: (obj, args) => `${obj}.IsSubsetOf(${args[0]})`,
+    isSupersetOf: (obj, args) => `${args[0]}.IsSubsetOf(${obj})`,
+    isDisjointFrom: (obj, args) => `(${obj}.Intersection(${args[0]}).Len() == 0)`
 };
 function getDynamicCallHandler(caller, objectType) {
     if (promiseResolveName && caller === promiseResolveName) {
         return (_caller, args) => `ch <- ${args[0]}`;
     }
+    if (promiseRejectName && caller === promiseRejectName) {
+        return (_caller, args) => {
+            useHelper('promise');
+            return `TnReject(ch, ${args[0] ?? 'nil'})`;
+        };
+    }
     const dotIndex = caller.lastIndexOf('.');
     if (dotIndex !== -1) {
         const methodName = caller.substring(dotIndex + 1);
@@ -5168,6 +5846,12 @@ function getDynamicCallHandler(caller, objectType) {
                 return jsStringOf(obj, objectType === 'number' || objectType === 'float64' ? 'float64' : undefined);
             };
         }
+        if (methodName === 'toPrecision') {
+            return (c, args) => {
+                importedPackages.add('strconv');
+                return `strconv.FormatFloat(${c.substring(0, dotIndex)}, 'g', int(${args[0] ?? '-1'}), 64)`;
+            };
+        }
         // number.toFixed(digits)
         if (methodName === 'toFixed') {
             return (c, args) => {
@@ -5289,7 +5973,9 @@ function isObjectKeysOfDynamic(node) {
         isDynamicValue(node.arguments[0]));
 }
 const ARRAY_ONLY_METHODS = new Set([
-    'map', 'filter', 'some', 'every', 'find', 'findIndex', 'forEach', 'reduce', 'join', 'flat', 'sort', 'reverse'
+    'map', 'filter', 'some', 'every', 'find', 'findIndex', 'findLast', 'findLastIndex', 'forEach', 'reduce',
+    'reduceRight', 'join', 'flat', 'flatMap', 'sort', 'reverse', 'toSorted', 'toReversed', 'fill', 'splice',
+    'copyWithin', 'toSpliced'
 ]);
 const STRING_ONLY_METHODS = new Set([
     'startsWith', 'endsWith', 'trim', 'trimStart', 'trimEnd', 'toUpperCase', 'toLowerCase', 'split',
@@ -5341,7 +6027,7 @@ 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') {
+    if (!isPropertyAccessExpression(call.expression) || !['sort', 'toSorted'].includes(call.expression.name.text)) {
         return undefined;
     }
     const arrayType = inferExpressionType(call.expression.expression);
@@ -5441,6 +6127,9 @@ function jsRegexFlagsToGo(flags) {
 // groups to RE2 syntax: (?<name> → (?P<name>
 function translateJsRegexPattern(pattern) {
     return pattern
+        // \u{1F600} / \u00e9 → RE2's \x{…}
+        .replace(/\\u\{([0-9A-Fa-f]+)\}/g, '\\x{$1}')
+        .replace(/\\u([0-9A-Fa-f]{4})/g, '\\x{$1}')
         .replace(/\\/g, '\\\\')
         .replace(/"/g, '\\"')
         .replace(/\(\?<([A-Za-z_][A-Za-z0-9_]*)>/g, '(?P<$1>');
@@ -5449,12 +6138,57 @@ function translateJsRegexPattern(pattern) {
 // Named groups (?<name> are fine (translated to (?P<name>), so strip them
 // before testing for lookarounds (?= (?! (?<= (?<!
 function needsStatefulRegex(pattern, flags) {
-    if (flags.includes('g'))
+    // /g and /y keep lastIndex state; /u keeps its flag for .flags
+    if (flags.includes('g') || flags.includes('y') || flags.includes('u'))
         return true;
     const stripped = pattern.replace(/\(\?<[A-Za-z_][A-Za-z0-9_]*>/g, '');
     // (?= (?! and any remaining (?< (lookbehind) need the backtracker
     return /\\[1-9]|\(\?[=!<]/.test(stripped);
 }
+const REGEX_FLAG_PROPERTIES = {
+    global: 'g', ignoreCase: 'i', multiline: 'm', dotAll: 's', unicode: 'u', sticky: 'y'
+};
+function inferRegexPropertyType(expr) {
+    if (!isPropertyAccessExpression(expr))
+        return undefined;
+    const receiverType = inferExpressionType(expr.expression);
+    if (receiverType !== '*TnRegex' && receiverType !== '*regexp.Regexp')
+        return undefined;
+    const name = expr.name.text;
+    if (name === 'lastIndex')
+        return 'float64';
+    if (name === 'source' || name === 'flags')
+        return 'string';
+    if (REGEX_FLAG_PROPERTIES[name])
+        return 'bool';
+    return undefined;
+}
+function visitRegexProperty(node) {
+    const type = inferRegexPropertyType(node);
+    if (!type || isCallee(node))
+        return undefined;
+    const name = node.name.text;
+    const receiver = visit(node.expression);
+    useHelper('fancyRegex');
+    if (inferExpressionType(node.expression) === '*TnRegex') {
+        if (name === 'lastIndex' || name === 'source' || name === 'flags')
+            return `${receiver}.${name}`;
+        importedPackages.add('strings');
+        return `strings.Contains(${receiver}.flags, "${REGEX_FLAG_PROPERTIES[name]}")`;
+    }
+    // plain RE2 regexes have no state; their flags (i/m/s) lead the pattern
+    if (name === 'lastIndex')
+        return 'float64(0)';
+    if (name === 'source')
+        return `TnRegexpSource(${receiver})`;
+    if (name === 'flags')
+        return `TnRegexpFlags(${receiver})`;
+    importedPackages.add('strings');
+    return `strings.Contains(TnRegexpFlags(${receiver}), "${REGEX_FLAG_PROPERTIES[name]}")`;
+}
+function isStringRawTag(tag) {
+    return isPropertyAccessExpression(tag) && isIdentifier(tag.expression) && tag.expression.text === 'String' && tag.name.text === 'raw';
+}
 // Whether a visited regex argument is the stateful wrapper type
 function isTnRegexArg(arg) {
     return arg.startsWith('TnRegexCompile(') || variableGoTypes.get(arg) === '*TnRegex';
@@ -5465,7 +6199,8 @@ function getTypeParameters(typeParameters) {
     const params = typeParameters.map((tp) => {
         const name = visit(tp.name);
         const constraint = tp.constraint ? getType(tp.constraint) : 'any';
-        return `${name} ${constraint}`;
+        // Go constraints cannot require fields: object-type bounds become any
+        return `${name} ${constraint.startsWith('*') ? 'any' : constraint}`;
     });
     return `[${params.join(', ')}]`;
 }
@@ -5737,7 +6472,8 @@ function getPromiseChannelType(node) {
     while (parent) {
         if (isFunctionDeclaration(parent) ||
             isMethodDeclaration(parent) ||
-            isFunctionExpression(parent)) {
+            isFunctionExpression(parent) ||
+            isArrowFunction(parent)) {
             if (parent.type &&
                 isTypeReferenceNode(parent.type) &&
                 isIdentifier(parent.type.typeName)) {
@@ -5764,6 +6500,9 @@ function emitChannelFunction(node, isAsync) {
     }
     const chanType = isAsync ? getPromiseChannelType(node) : getGeneratorYieldType(node);
     const channelVar = '__ch';
+    if (isAsync)
+        useHelper('promise');
+    const rejectOnPanic = isAsync ? `\n\t\tdefer TnRejectOnPanic(${channelVar})` : '';
     const prevChannel = asyncChannelVar;
     const prevFn = asyncFunctionNode;
     asyncChannelVar = channelVar;
@@ -5771,7 +6510,7 @@ function emitChannelFunction(node, isAsync) {
     const body = visit(node.body, { prefixBlockContent: parameterInfo.prefixBlockContent });
     asyncChannelVar = prevChannel;
     asyncFunctionNode = prevFn;
-    return (`func ${name}${typeParams}(${parameterInfo.signature}) chan ${chanType} {\n\t${channelVar} := make(chan ${chanType})\n\tgo func() {\n\t\tdefer close(${channelVar})\n\t\t${body.trim()}\n\t}()\n\treturn ${channelVar}\n}`);
+    return (`func ${name}${typeParams}(${parameterInfo.signature}) chan ${chanType} {\n\t${channelVar} := make(chan ${chanType})\n\tgo func() {\n\t\tdefer close(${channelVar})${rejectOnPanic}\n\t\t${body.trim()}\n\t}()\n\treturn ${channelVar}\n}`);
 }
 // The type a generator yields: from its first yield expression's operand
 function getGeneratorYieldType(fn) {
@@ -5793,10 +6532,14 @@ function visitPromiseReturn(node, options) {
     const channelType = getPromiseChannelType(node);
     const resolveParam = callback.parameters[0];
     const resolveName = resolveParam ? visit(resolveParam.name) : '';
+    const rejectParam = callback.parameters[1];
     const prevResolveName = promiseResolveName;
+    const prevRejectName = promiseRejectName;
     promiseResolveName = resolveName;
+    promiseRejectName = rejectParam ? visit(rejectParam.name) : '';
     const body = isBlock(callback.body) ? visit(callback.body) : `{ ${visit(callback.body)} }`;
     promiseResolveName = prevResolveName;
+    promiseRejectName = prevRejectName;
     return (`ch := make(chan ${channelType})\n\t\tgo func() ${body.trimEnd()}()\n\t\treturn ch` +
         (options.inline ? '' : ';\n\t'));
 }
@@ -5808,10 +6551,14 @@ function visitNewPromise(node) {
     const channelType = getPromiseChannelType(node);
     const resolveParam = callback.parameters[0];
     const resolveName = resolveParam ? visit(resolveParam.name) : '';
+    const rejectParam = callback.parameters[1];
     const prevResolveName = promiseResolveName;
+    const prevRejectName = promiseRejectName;
     promiseResolveName = resolveName;
+    promiseRejectName = rejectParam ? visit(rejectParam.name) : '';
     const body = isBlock(callback.body) ? visit(callback.body) : `{ ${visit(callback.body)} }`;
     promiseResolveName = prevResolveName;
+    promiseRejectName = prevRejectName;
     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) {
@@ -6029,7 +6776,11 @@ function needPkg(pkg) {
 // since the import list is serialized before helpers are emitted.
 const helperRequires = {
     objectAssign: ['orderedMap'],
-    promiseAll: ['orderedMap', 'asyncWait'],
+    promiseAll: ['orderedMap', 'asyncWait', 'promise'],
+    promise: ['error'],
+    objectIntegrity: [],
+    structuredClone: [],
+    globalThis: ['dynamic'],
     namedGroups: ['orderedMap'],
     fancyRegex: ['orderedMap'],
     dynamic: ['error'],
@@ -6205,7 +6956,7 @@ const helperPackages = {
     jsonStringify: ['encoding/json', 'bytes', 'strings', 'unsafe'],
     objectAssign: ['reflect', 'unsafe'],
     typeOf: ['reflect'],
-    dynamic: ['math', 'strings', 'fmt', 'sort', 'reflect', 'strconv', 'regexp'],
+    dynamic: ['math', 'strings', 'fmt', 'sort', 'reflect', 'strconv', 'regexp', 'unsafe'],
     regexReplaceFunc: ['regexp'],
     readFile: ['os'],
     writeFile: ['os'],
@@ -6225,7 +6976,12 @@ const helperPackages = {
     moduleUrl: ['os'],
     asyncWait: ['sync'],
     timerWait: ['sync', 'time'],
+    uri: ['strings', 'fmt', 'net/url'],
     promiseAll: [],
+    promise: ['sync'],
+    objectIntegrity: ['sync', 'reflect'],
+    structuredClone: ['reflect', 'unsafe'],
+    globalThis: [],
     exec: ['os/exec', 'bytes', 'runtime'],
     execSync: ['os/exec', 'bytes', 'runtime'],
     runInherit: ['os/exec', 'os'],
@@ -6256,6 +7012,18 @@ func TnGet(obj interface{}, key string) interface{} {
 			return o.message
 		}
 	}
+	rv := reflect.ValueOf(obj)
+	if rv.Kind() == reflect.Pointer && !rv.IsNil() && rv.Elem().Kind() == reflect.Struct {
+		for _, name := range []string{key, key + "_"} {
+			if f := rv.Elem().FieldByName(name); f.IsValid() {
+				// Unexported field: read it through a pointer to bypass the flag
+				return reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem().Interface()
+			}
+		}
+	}
+	if key == "length" {
+		return TnLength(obj)
+	}
 	return nil
 }
 
@@ -6267,6 +7035,22 @@ func TnSet(obj interface{}, key string, value interface{}) {
 	panic("TnSet: cannot set property " + key)
 }
 
+func TnSetIndex(obj interface{}, key interface{}, value interface{}) {
+	switch o := obj.(type) {
+	case map[string]interface{}:
+		if k, ok := key.(string); ok {
+			o[k] = value
+			return
+		}
+	case []interface{}:
+		if i, ok := key.(float64); ok && i >= 0 && int(i) < len(o) {
+			o[int(i)] = value
+			return
+		}
+	}
+	panic(fmt.Sprintf("TnSetIndex: cannot set property %v", key))
+}
+
 func TnIndex(obj interface{}, key interface{}) interface{} {
 	switch o := obj.(type) {
 	case map[string]interface{}:
@@ -6324,6 +7108,9 @@ func TnLength(v interface{}) float64 {
 	case []interface{}:
 		return float64(len(t))
 	}
+	if rv := reflect.ValueOf(v); rv.Kind() == reflect.Slice || rv.Kind() == reflect.Map {
+		return float64(rv.Len())
+	}
 	return 0
 }
 
@@ -6466,6 +7253,19 @@ func TnDelete(obj interface{}, key interface{}) bool {
 	return true
 }
 
+// Object.fromEntries: [key, value] pairs → a dynamic object
+func TnFromEntries(entries interface{}) interface{} {
+	result := map[string]interface{}{}
+	list := reflect.ValueOf(entries)
+	for i := 0; i < list.Len(); i++ {
+		pair := reflect.ValueOf(list.Index(i).Interface())
+		if pair.Kind() == reflect.Slice && pair.Len() >= 2 {
+			result[fmt.Sprint(pair.Index(0).Interface())] = pair.Index(1).Interface()
+		}
+	}
+	return result
+}
+
 func TnHas(obj interface{}, key interface{}) bool {
 	if o, ok := obj.(map[string]interface{}); ok {
 		if k, ok := key.(string); ok {
@@ -6673,7 +7473,7 @@ func tnJSONWrite(buf *bytes.Buffer, rv reflect.Value, indent string, depth int)
 	case reflect.Float32, reflect.Float64:
 		buf.WriteString(TnNumStr(rv.Float()))
 	case reflect.String:
-		data, _ := json.Marshal(rv.String())
+		data, _ := tnJSONMarshal(rv.String())
 		buf.Write(data)
 	case reflect.Slice, reflect.Array:
 		if rv.Kind() == reflect.Slice && rv.IsNil() {
@@ -6704,7 +7504,7 @@ func tnJSONWrite(buf *bytes.Buffer, rv reflect.Value, indent string, depth int)
 				buf.WriteByte(',')
 				tnJSONNewline(buf, indent, depth+1)
 			}
-			kd, _ := json.Marshal(ks)
+			kd, _ := tnJSONMarshal(ks)
 			buf.Write(kd)
 			buf.WriteByte(':')
 			tnJSONWrite(buf, byKey[ks], indent, depth+1)
@@ -6739,20 +7539,31 @@ func tnJSONWrite(buf *bytes.Buffer, rv reflect.Value, indent string, depth int)
 				tnJSONNewline(buf, indent, depth+1)
 			}
 			first = false
-			kd, _ := json.Marshal(f.Name)
+			kd, _ := tnJSONMarshal(f.Name)
 			buf.Write(kd)
 			buf.WriteByte(':')
 			tnJSONWrite(buf, value, indent, depth+1)
 		}
 		buf.WriteByte('}')
 	default:
-		data, err := json.Marshal(rv.Interface())
+		data, err := tnJSONMarshal(rv.Interface())
 		if err != nil {
 			buf.WriteString("null")
 			return
 		}
 		buf.Write(data)
 	}
+}
+
+// json.Marshal without HTML escaping of <, > and & (JSON.stringify does not escape them)
+func tnJSONMarshal(v interface{}) ([]byte, error) {
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(v); err != nil {
+		return nil, err
+	}
+	return bytes.TrimSuffix(buf.Bytes(), []byte("\\n")), nil
 }`,
     orderedMap: `// TnMap: JS Map/Set/object semantics — keys iterate in insertion order
 type TnMap[K comparable, V any] struct {
@@ -6811,6 +7622,51 @@ func (m *TnMap[K, V]) Delete(k K) bool {
 	return true
 }
 
+// Set operations (ES2025), in the receiver's insertion order then the argument's
+func (m *TnMap[K, V]) Union(o *TnMap[K, V]) *TnMap[K, V] {
+	r := TnNewMap[K, V]()
+	for _, k := range m.keys {
+		r.Set(k, m.values[k])
+	}
+	for _, k := range o.keys {
+		r.Set(k, o.values[k])
+	}
+	return r
+}
+
+func (m *TnMap[K, V]) Intersection(o *TnMap[K, V]) *TnMap[K, V] {
+	r := TnNewMap[K, V]()
+	for _, k := range m.keys {
+		if o.Has(k) {
+			r.Set(k, m.values[k])
+		}
+	}
+	return r
+}
+
+func (m *TnMap[K, V]) Difference(o *TnMap[K, V]) *TnMap[K, V] {
+	r := TnNewMap[K, V]()
+	for _, k := range m.keys {
+		if !o.Has(k) {
+			r.Set(k, m.values[k])
+		}
+	}
+	return r
+}
+
+func (m *TnMap[K, V]) SymmetricDifference(o *TnMap[K, V]) *TnMap[K, V] {
+	return m.Difference(o).Union(o.Difference(m))
+}
+
+func (m *TnMap[K, V]) IsSubsetOf(o *TnMap[K, V]) bool {
+	for _, k := range m.keys {
+		if !o.Has(k) {
+			return false
+		}
+	}
+	return true
+}
+
 func (m *TnMap[K, V]) Clear() {
 	m.keys = nil
 	m.values = map[K]V{}
@@ -6910,15 +7766,44 @@ func TnRegexExecNamed(re *regexp.Regexp, s string) *TnMatch {
 type TnRegex struct {
 	re        *regexp.Regexp
 	bt        *tnBt
-	lastIndex int
+	lastIndex float64
 	global    bool
+	sticky    bool
+	source    string
+	flags     string
 }
 
-func TnRegexCompile(pattern string, global bool) *TnRegex {
-	if re, err := regexp.Compile(pattern); err == nil {
-		return &TnRegex{re: re, global: global}
+func TnRegexCompile(pattern string, flags string, source string) *TnRegex {
+	r := &TnRegex{global: strings.Contains(flags, "g"), sticky: strings.Contains(flags, "y"), source: source, flags: flags}
+	prefix := ""
+	for _, f := range "ims" {
+		if strings.ContainsRune(flags, f) {
+			prefix += string(f)
+		}
 	}
-	return &TnRegex{bt: tnBtCompile(pattern), global: global}
+	if prefix != "" {
+		prefix = "(?" + prefix + ")"
+	}
+	if re, err := regexp.Compile(prefix + pattern); err == nil {
+		r.re = re
+	} else {
+		r.bt = tnBtCompile(pattern)
+	}
+	return r
+}
+
+// .source / .flags of a plain RE2 regex: flags lead the pattern as (?ims)
+var tnRegexpFlagPrefix = regexp.MustCompile("^\\\\(\\\\?([ims]+)\\\\)")
+
+func TnRegexpSource(re *regexp.Regexp) string {
+	return strings.ReplaceAll(tnRegexpFlagPrefix.ReplaceAllString(re.String(), ""), "(?P<", "(?<")
+}
+
+func TnRegexpFlags(re *regexp.Regexp) string {
+	if m := tnRegexpFlagPrefix.FindStringSubmatch(re.String()); m != nil {
+		return m[1]
+	}
+	return ""
 }
 
 func (r *TnRegex) Test(s string) bool {
@@ -7065,15 +7950,15 @@ func (r *TnRegex) find(s string) ([]string, []int) {
 	runs := []rune(s)
 	if r.bt != nil {
 		start := 0
-		if r.global {
-			if r.lastIndex > len(runs) {
+		if r.global || r.sticky {
+			if int(r.lastIndex) > len(runs) {
 				r.lastIndex = 0
 				return nil, nil
 			}
-			start = r.lastIndex
+			start = int(r.lastIndex)
 		}
 		offs := tnByteOffsets(runs)
-		for pos := start; pos <= len(runs); pos++ {
+		for pos := start; pos <= len(runs) && (!r.sticky || pos == start); pos++ {
 			caps := make([]int, (r.bt.ngroups+1)*2)
 			for i := range caps {
 				caps[i] = -1
@@ -7093,22 +7978,22 @@ func (r *TnRegex) find(s string) ([]string, []int) {
 						loc[2*i], loc[2*i+1] = -1, -1
 					}
 				}
-				if r.global {
+				if r.global || r.sticky {
 					next := end
 					if next == pos {
 						next++
 					}
-					r.lastIndex = next
+					r.lastIndex = float64(next)
 				}
 				return groups, loc
 			}
 		}
-		if r.global {
+		if r.global || r.sticky {
 			r.lastIndex = 0
 		}
 		return nil, nil
 	}
-	if !r.global {
+	if !r.global && !r.sticky {
 		loc := r.re.FindStringSubmatchIndex(s)
 		if loc == nil {
 			return nil, nil
@@ -7121,16 +8006,16 @@ func (r *TnRegex) find(s string) ([]string, []int) {
 		}
 		return groups, loc
 	}
-	if r.lastIndex >= len(runs) {
+	if int(r.lastIndex) >= len(runs) {
 		r.lastIndex = 0
 		return nil, nil
 	}
 	byteStart := 0
-	for i := 0; i < r.lastIndex; i++ {
+	for i := 0; i < int(r.lastIndex); i++ {
 		byteStart += len(string(runs[i]))
 	}
 	loc := r.re.FindStringSubmatchIndex(s[byteStart:])
-	if loc == nil {
+	if loc == nil || (r.sticky && loc[0] != 0) {
 		r.lastIndex = 0
 		return nil, nil
 	}
@@ -7145,16 +8030,16 @@ func (r *TnRegex) find(s string) ([]string, []int) {
 			groups[i] = s[loc[2*i]:loc[2*i+1]]
 		}
 	}
-	endRune := r.lastIndex
+	endRune := int(r.lastIndex)
 	bo := byteStart
-	for ri := r.lastIndex; ri < len(runs) && bo < loc[1]; ri++ {
+	for ri := int(r.lastIndex); ri < len(runs) && bo < loc[1]; ri++ {
 		bo += len(string(runs[ri]))
 		endRune = ri + 1
 	}
-	if endRune == r.lastIndex {
+	if endRune == int(r.lastIndex) {
 		endRune++
 	}
-	r.lastIndex = endRune
+	r.lastIndex = float64(endRune)
 	return groups, loc
 }
 
@@ -7926,14 +8811,358 @@ func TnNewSymbol(description string) *TnSymbol {
 	return &TnSymbol{description: description}
 }`,
     timerWait: `// Pending setTimeout timers are waited on before the process exits
-var __tnTimers sync.WaitGroup`,
+var __tnTimers sync.WaitGroup
+
+func TnSetTimeout(ms float64, fn func()) *time.Timer {
+	__tnTimers.Add(1)
+	return time.AfterFunc(time.Duration(ms*float64(time.Millisecond)), func() {
+		defer __tnTimers.Done()
+		fn()
+		TnRunMicrotasks()
+	})
+}
+
+// setInterval: fn every ms until cleared (the process lives until then)
+type TnInterval struct {
+	stop chan struct{}
+	once sync.Once
+}
+
+func TnSetInterval(ms float64, fn func()) *TnInterval {
+	__tnTimers.Add(1)
+	t := &TnInterval{stop: make(chan struct{})}
+	go func() {
+		ticker := time.NewTicker(max(time.Duration(ms*float64(time.Millisecond)), time.Millisecond))
+		defer ticker.Stop()
+		for {
+			select {
+			case <-t.stop:
+				return
+			case <-ticker.C:
+				fn()
+				TnRunMicrotasks()
+			}
+		}
+	}()
+	return t
+}
+
+func TnClearInterval(t *TnInterval) {
+	if t != nil {
+		t.once.Do(func() {
+			close(t.stop)
+			__tnTimers.Done()
+		})
+	}
+}
+
+// queueMicrotask: run after the current synchronous code (end of main or of a timer callback)
+var tnMicrotasks []func()
+var tnMicrotasksMu sync.Mutex
+
+func TnQueueMicrotask(fn func()) {
+	tnMicrotasksMu.Lock()
+	tnMicrotasks = append(tnMicrotasks, fn)
+	tnMicrotasksMu.Unlock()
+}
+
+func TnRunMicrotasks() {
+	for {
+		tnMicrotasksMu.Lock()
+		if len(tnMicrotasks) == 0 {
+			tnMicrotasksMu.Unlock()
+			return
+		}
+		fn := tnMicrotasks[0]
+		tnMicrotasks = tnMicrotasks[1:]
+		tnMicrotasksMu.Unlock()
+		fn()
+	}
+}
+
+func TnClearTimeout(t *time.Timer) {
+	if t != nil && t.Stop() {
+		__tnTimers.Done()
+	}
+}`,
+    uri: `// encodeURIComponent: escapes everything except A-Z a-z 0-9 - _ . ! ~ * ' ( )
+func TnEncodeURIComponent(s string) string {
+	var b strings.Builder
+	for _, c := range []byte(s) {
+		if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || strings.IndexByte("-_.!~*'()", c) >= 0 {
+			b.WriteByte(c)
+		} else {
+			fmt.Fprintf(&b, "%%%02X", c)
+		}
+	}
+	return b.String()
+}
+
+func TnDecodeURIComponent(s string) string {
+	decoded, err := tnurl.PathUnescape(s)
+	if err != nil {
+		panic(err)
+	}
+	return decoded
+}`,
+    objectIntegrity: `// Object.freeze / seal / preventExtensions levels, by object identity
+var tnIntegrity sync.Map
+
+func tnIdentity(v interface{}) (uintptr, bool) {
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Pointer, reflect.Map, reflect.Slice, reflect.Func, reflect.Chan:
+		return rv.Pointer(), true
+	}
+	return 0, false
+}
+
+func TnSetIntegrity[T any](v T, level int) T {
+	if id, ok := tnIdentity(v); ok {
+		if prev, had := tnIntegrity.Load(id); !had || prev.(int) < level {
+			tnIntegrity.Store(id, level)
+		}
+	}
+	return v
+}
+
+// Primitives are always frozen
+func TnHasIntegrity(v interface{}, level int) bool {
+	id, ok := tnIdentity(v)
+	if !ok {
+		return true
+	}
+	l, had := tnIntegrity.Load(id)
+	return had && l.(int) >= level
+}`,
+    structuredClone: `// structuredClone: a deep copy (pointers, structs, slices, maps)
+func TnStructuredClone[T any](v T) T {
+	return tnCloneValue(reflect.ValueOf(&v).Elem()).Interface().(T)
+}
+
+func tnCloneValue(v reflect.Value) reflect.Value {
+	switch v.Kind() {
+	case reflect.Pointer:
+		if v.IsNil() {
+			return v
+		}
+		c := reflect.New(v.Elem().Type())
+		c.Elem().Set(tnCloneValue(v.Elem()))
+		return c
+	case reflect.Struct:
+		if !v.CanAddr() {
+			tmp := reflect.New(v.Type()).Elem()
+			tmp.Set(v)
+			v = tmp
+		}
+		c := reflect.New(v.Type()).Elem()
+		for i := 0; i < v.NumField(); i++ {
+			// unexported fields are read and written through their addresses
+			src := reflect.NewAt(v.Field(i).Type(), unsafe.Pointer(v.Field(i).UnsafeAddr())).Elem()
+			dst := reflect.NewAt(c.Field(i).Type(), unsafe.Pointer(c.Field(i).UnsafeAddr())).Elem()
+			dst.Set(tnCloneValue(src))
+		}
+		return c
+	case reflect.Slice:
+		if v.IsNil() {
+			return v
+		}
+		c := reflect.MakeSlice(v.Type(), v.Len(), v.Len())
+		for i := 0; i < v.Len(); i++ {
+			c.Index(i).Set(tnCloneValue(v.Index(i)))
+		}
+		return c
+	case reflect.Map:
+		if v.IsNil() {
+			return v
+		}
+		c := reflect.MakeMapWithSize(v.Type(), v.Len())
+		iter := v.MapRange()
+		for iter.Next() {
+			c.SetMapIndex(iter.Key(), tnCloneValue(iter.Value()))
+		}
+		return c
+	case reflect.Interface:
+		if v.IsNil() {
+			return v
+		}
+		c := reflect.New(v.Type()).Elem()
+		c.Set(tnCloneValue(v.Elem()))
+		return c
+	}
+	return v
+}`,
+    globalThis: `// (globalThis as any).x: properties set on the global object at runtime
+var TnGlobalThis = map[string]interface{}{}`,
+    promise: `// Promises are channels; a rejected promise is a closed channel with a reason
+var tnRejections sync.Map
+
+func TnReject[T any](ch chan T, reason interface{}) {
+	tnRejections.Store(ch, reason)
+	close(ch)
+}
+
+// Deferred in async functions: a throw rejects the function's promise
+func TnRejectOnPanic[T any](ch chan T) {
+	if r := recover(); r != nil {
+		tnRejections.Store(ch, r)
+	}
+}
+
+// Waits for a promise: its value, or its rejection reason
+func tnSettle[T any](ch chan T) (T, interface{}, bool) {
+	v, ok := <-ch
+	if !ok {
+		if reason, rejected := tnRejections.Load(ch); rejected {
+			return v, reason, true
+		}
+	}
+	return v, nil, false
+}
+
+// await: the value, or the rejection rethrown
+func TnAwait[T any](ch chan T) T {
+	v, reason, rejected := tnSettle(ch)
+	if rejected {
+		panic(reason)
+	}
+	return v
+}
+
+func TnPromiseReject[T any](reason interface{}) chan T {
+	ch := make(chan T)
+	TnReject(ch, reason)
+	return ch
+}
+
+func TnPromiseCatch[T any, E any](p chan T, onRejected func(E)) chan T {
+	out := make(chan T, 1)
+	go func() {
+		v, reason, rejected := tnSettle(p)
+		if rejected {
+			e, _ := reason.(E)
+			onRejected(e)
+		}
+		out <- v
+		close(out)
+	}()
+	return out
+}
+
+func TnPromiseCatchValue[T any, E any](p chan T, onRejected func(E) T) chan T {
+	out := make(chan T, 1)
+	go func() {
+		v, reason, rejected := tnSettle(p)
+		if rejected {
+			e, _ := reason.(E)
+			v = onRejected(e)
+		}
+		out <- v
+		close(out)
+	}()
+	return out
+}
+
+func TnPromiseFinally[T any](p chan T, onFinally func()) chan T {
+	out := make(chan T, 1)
+	go func() {
+		v, reason, rejected := tnSettle(p)
+		onFinally()
+		if rejected {
+			TnReject(out, reason)
+			return
+		}
+		out <- v
+		close(out)
+	}()
+	return out
+}
+
+// Promise.race: the first promise to settle, fulfilled or rejected
+func TnPromiseRace[T any](chs []chan T) chan T {
+	out := make(chan T, 1)
+	var once sync.Once
+	for _, ch := range chs {
+		go func(ch chan T) {
+			v, reason, rejected := tnSettle(ch)
+			once.Do(func() {
+				if rejected {
+					TnReject(out, reason)
+					return
+				}
+				out <- v
+				close(out)
+			})
+		}(ch)
+	}
+	return out
+}
+
+type TnSettled[T any] struct {
+	status string
+	value  T
+	reason interface{}
+}
+
+func TnPromiseAllSettled[T any](chs []chan T) chan []*TnSettled[T] {
+	out := make(chan []*TnSettled[T], 1)
+	go func() {
+		results := make([]*TnSettled[T], len(chs))
+		for i, ch := range chs {
+			v, reason, rejected := tnSettle(ch)
+			if rejected {
+				results[i] = &TnSettled[T]{status: "rejected", reason: reason}
+			} else {
+				results[i] = &TnSettled[T]{status: "fulfilled", value: v}
+			}
+		}
+		out <- results
+		close(out)
+	}()
+	return out
+}
+
+// Promise.any: the first promise to fulfil; rejected when all of them reject
+func TnPromiseAny[T any](chs []chan T) chan T {
+	out := make(chan T, 1)
+	go func() {
+		values := make(chan T, len(chs))
+		failures := make(chan interface{}, len(chs))
+		for _, ch := range chs {
+			go func(ch chan T) {
+				v, reason, rejected := tnSettle(ch)
+				if rejected {
+					failures <- reason
+				} else {
+					values <- v
+				}
+			}(ch)
+		}
+		for range chs {
+			select {
+			case v := <-values:
+				out <- v
+				close(out)
+				return
+			case <-failures:
+			}
+		}
+		TnReject(out, TnNewError("All promises were rejected"))
+	}()
+	return out
+}`,
     promiseAll: `// Promise.all: every channel drained in order, results collected
 func TnPromiseAll[T any](chs []chan T) chan []T {
 	out := make(chan []T)
 	go func() {
 		results := make([]T, len(chs))
 		for i, ch := range chs {
-			results[i] = <-ch
+			v, reason, rejected := tnSettle(ch)
+			if rejected {
+				TnReject(out, reason)
+				return
+			}
+			results[i] = v
 		}
 		out <- results
 		close(out)
@@ -8121,6 +9350,18 @@ function visitImportDeclaration(node) {
                 includeLocalImport(resolved.content, resolved.dir, goFileName);
             }
         }
+        // Renamed bindings refer to the original declaration (one Go package)
+        const bindings = node.importClause?.namedBindings;
+        if (bindings && isNamedImports(bindings)) {
+            for (const el of bindings.elements ?? []) {
+                if (!el.propertyName)
+                    continue;
+                importAliases.set(el.name.text, getSafeName(el.propertyName.text));
+                const fn = declaredFunctions.get(el.propertyName.text);
+                if (fn)
+                    declaredFunctions.set(el.name.text, fn);
+            }
+        }
         return '';
     }
     // Type-only imports contribute nothing to runtime