typenative 0.1.1 → 0.1.3

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',
@@ -337,6 +338,8 @@ const interfacePropertyTypes = new Map();
 const typeAliases = new Map();
 const enumNames = new Set();
 const enumBaseTypes = new Map();
+// Member types of heterogeneous enums ("E.A" → float64 / string)
+const enumMemberGoTypes = new Map();
 // Maps local TS name → Go qualified name (e.g. 'Println' → 'fmt.Println', 'myFmt' → 'fmt')
 const importAliases = new Map();
 // Tracks static methods per class: Set of "ClassName.methodName" strings
@@ -389,13 +392,22 @@ const OPERATOR_TEXT = {
 function operatorTokenText(token) {
     return OPERATOR_TEXT[token?.kind] ?? token?.kind ?? '';
 }
-function defaultParseFunction(_code) {
+function defaultParseFunction(_code, _tsx) {
     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);
+    const sourceFile = parseFunction(code, currentFileIsTsx);
+    stripThisParameters(sourceFile);
+    lowerIndexSignatures(sourceFile);
+    lowerAmbientDeclarations(sourceFile);
+    lowerModuleForms(sourceFile);
+    lowerDisposeSymbols(sourceFile);
+    lowerNamespaces(sourceFile);
+    lowerClassExpressions(sourceFile);
+    lowerWeakCollections(sourceFile);
+    lowerGlobalThis(sourceFile);
     linkParents(sourceFile, undefined);
     for (const stmt of sourceFile.statements ?? []) {
         if (!stmt.name || !isIdentifier(stmt.name))
@@ -415,6 +427,289 @@ 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 ?? [];
+    // { (a: A): R } / { new (a: A): C } → (a: A) => R / (a: A) => C
+    const isSignature = (m) => m.kind === 'CallSignature' || m.kind === 'ConstructSignature';
+    if (members.length === 1 && isSignature(members[0]) && (node.kind === 'TypeLiteral' || node.kind === 'InterfaceDeclaration')) {
+        const fnType = { kind: 'FunctionType', parameters: members[0].parameters ?? [], type: members[0].type };
+        if (node.kind === 'TypeLiteral') {
+            for (const key of Object.keys(node))
+                if (key !== 'parent')
+                    delete node[key];
+            node.kind = 'FunctionType';
+            node.parameters = fnType.parameters;
+            node.type = fnType.type;
+        }
+        else {
+            delete node.members;
+            delete node.heritageClauses;
+            node.kind = 'TypeAliasDeclaration';
+            node.type = fnType;
+        }
+        return;
+    }
+    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];
+}
+function lowerAmbientDeclarations(node) {
+    for (const child of childNodes(node))
+        lowerAmbientDeclarations(child);
+    if (!Array.isArray(node.statements))
+        return;
+    const isDeclare = (m) => m.kind === 'DeclareKeyword';
+    node.statements = node.statements.filter((statement) => {
+        if (statement.kind === 'VariableStatement' && statement.modifiers) {
+            // declare / export on variables don't change the emitted Go
+            statement.modifiers = statement.modifiers.filter((m) => !isDeclare(m) && m.kind !== 'ExportKeyword');
+            return true;
+        }
+        return !(statement.modifiers ?? []).some(isDeclare);
+    });
+}
+// Every module form becomes an import declaration (all files share one Go package):
+//   export { a, b as c } from './m'  → import { a, b as c } from './m'
+//   export * from './m'               → import './m'
+//   import x = require('./m')         → import * as x from './m'
+//   const x = await import('./m')     → import * as x from './m'
+function lowerModuleForms(node) {
+    for (const child of childNodes(node))
+        lowerModuleForms(child);
+    if (!Array.isArray(node.statements))
+        return;
+    node.statements = node.statements.map((statement) => {
+        const namespaceImport = (name, specifier) => ({
+            kind: 'ImportDeclaration',
+            moduleSpecifier: specifier,
+            importClause: { kind: 'ImportClause', namedBindings: { kind: 'NamespaceImport', name } }
+        });
+        if (statement.kind === 'ExportDeclaration' && statement.moduleSpecifier && !statement.isTypeOnly) {
+            const clause = statement.exportClause;
+            if (clause?.kind === 'NamespaceExport')
+                return namespaceImport(clause.name, statement.moduleSpecifier);
+            const importClause = clause
+                ? { kind: 'ImportClause', namedBindings: { kind: 'NamedImports', elements: clause.elements ?? [] } }
+                : undefined;
+            return { kind: 'ImportDeclaration', moduleSpecifier: statement.moduleSpecifier, importClause };
+        }
+        if (statement.kind === 'ImportEqualsDeclaration' && statement.moduleReference?.kind === 'ExternalModuleReference') {
+            return namespaceImport(statement.name, statement.moduleReference.expression);
+        }
+        const declarations = statement.kind === 'VariableStatement' ? (statement.declarationList?.declarations ?? []) : [];
+        const init = declarations.length === 1 ? declarations[0].initializer : undefined;
+        const call = init?.kind === 'AwaitExpression' ? init.expression : undefined;
+        if (call?.kind === 'CallExpression' && call.expression?.kind === 'ImportKeyword' && isStringLiteral(call.arguments?.[0]) && isIdentifier(declarations[0].name)) {
+            return namespaceImport(declarations[0].name, call.arguments[0]);
+        }
+        return statement;
+    });
+}
+// Names whose identifier is a property / member name, not a reference
+const MEMBER_NAME_PARENTS = new Set([
+    'PropertyAccessExpression', 'PropertyAssignment', 'PropertySignature', 'MethodSignature',
+    'PropertyDeclaration', 'MethodDeclaration', 'GetAccessor', 'SetAccessor', 'EnumMember'
+]);
+// Top-level names a statement list declares
+function getDeclaredNames(statements) {
+    const names = [];
+    for (const statement of statements) {
+        if (statement.kind === 'VariableStatement') {
+            for (const d of statement.declarationList?.declarations ?? [])
+                if (isIdentifier(d.name))
+                    names.push(d.name.text);
+        }
+        else if (isIdentifier(statement.name)) {
+            names.push(statement.name.text);
+        }
+    }
+    return names;
+}
+// Renames references to the given names (not property/member names) to prefix_name
+function renameIdentifiers(node, names, prefix) {
+    for (const key of Object.keys(node)) {
+        if (key === 'parent')
+            continue;
+        const value = node[key];
+        const children = Array.isArray(value) ? value : value && typeof value === 'object' ? [value] : [];
+        for (const child of children) {
+            if (!child || typeof child.kind !== 'string')
+                continue;
+            if (isIdentifier(child) && names.has(child.text)) {
+                if (key === 'name' && MEMBER_NAME_PARENTS.has(node.kind))
+                    continue;
+                if (key === 'right' && node.kind === 'QualifiedName')
+                    continue;
+                if (node.kind === 'ShorthandPropertyAssignment') {
+                    // { unit } keeps its key: { unit: N_unit }
+                    node.kind = 'PropertyAssignment';
+                    const initializer = { kind: 'Identifier', text: `${prefix}_${child.text}` };
+                    node.initializer = initializer;
+                    continue;
+                }
+                child.text = `${prefix}_${child.text}`;
+            }
+            else {
+                renameIdentifiers(child, names, prefix);
+            }
+        }
+    }
+}
+// Flattens the namespaces in a statement list; returns the namespace names found
+// (nested ones as Outer_Inner)
+function flattenNamespaces(statements) {
+    const out = [];
+    const namespaces = [];
+    for (const statement of statements) {
+        const isDeclare = (statement.modifiers ?? []).some((m) => m.kind === 'DeclareKeyword');
+        if (statement.kind !== 'ModuleDeclaration' || !isIdentifier(statement.name) || isDeclare) {
+            out.push(statement);
+            continue;
+        }
+        const prefix = statement.name.text;
+        // namespace A.B { } nests a ModuleDeclaration as the body
+        const body = statement.body?.kind === 'ModuleDeclaration' ? [statement.body] : (statement.body?.statements ?? []);
+        const inner = flattenNamespaces(body);
+        rewriteNamespaceAccess(inner.statements, new Set(inner.namespaces));
+        const names = new Set([...getDeclaredNames(inner.statements), ...inner.namespaces]);
+        for (const child of inner.statements) {
+            const wrapper = { kind: 'Block', statements: [child] };
+            renameIdentifiers(wrapper, names, prefix);
+        }
+        namespaces.push(prefix);
+        for (const n of inner.namespaces)
+            namespaces.push(`${prefix}_${n}`);
+        out.push(...inner.statements);
+    }
+    return { statements: out, namespaces };
+}
+// N.x / N.Inner.x (expressions) and N.T (types) → the flattened identifiers
+function rewriteNamespaceAccess(nodes, namespaces) {
+    const rewrite = (node) => {
+        for (const key of Object.keys(node)) {
+            if (key === 'parent')
+                continue;
+            const value = node[key];
+            if (Array.isArray(value))
+                node[key] = value.map((v) => (v && typeof v.kind === 'string' ? rewrite(v) : v));
+            else if (value && typeof value.kind === 'string')
+                node[key] = rewrite(value);
+        }
+        const left = node.kind === 'PropertyAccessExpression' ? node.expression : node.kind === 'QualifiedName' ? node.left : undefined;
+        const right = node.kind === 'PropertyAccessExpression' ? node.name : node.kind === 'QualifiedName' ? node.right : undefined;
+        if (isIdentifier(left) && namespaces.has(left.text) && isIdentifier(right)) {
+            const flattened = { kind: 'Identifier', text: `${left.text}_${right.text}` };
+            return flattened;
+        }
+        return node;
+    };
+    for (let i = 0; i < nodes.length; i++)
+        nodes[i] = rewrite(nodes[i]);
+}
+function lowerNamespaces(sourceFile) {
+    const flat = flattenNamespaces(sourceFile.statements ?? []);
+    sourceFile.statements = flat.statements;
+    if (flat.namespaces.length > 0)
+        rewriteNamespaceAccess(sourceFile.statements, new Set(flat.namespaces));
+}
+const DISPOSE_SYMBOLS = { dispose: '__dispose', asyncDispose: '__asyncDispose' };
+function getDisposeSymbolName(expr) {
+    if (!isPropertyAccessExpression(expr) || !isIdentifier(expr.expression) || expr.expression.text !== 'Symbol')
+        return undefined;
+    return DISPOSE_SYMBOLS[expr.name.text];
+}
+// [Symbol.dispose]() { … } → __dispose() { … }; x[Symbol.dispose]() → x.__dispose()
+function lowerDisposeSymbols(node) {
+    for (const child of childNodes(node))
+        lowerDisposeSymbols(child);
+    if (node.name?.kind === 'ComputedPropertyName') {
+        const name = getDisposeSymbolName(node.name.expression);
+        if (name) {
+            const identifier = { kind: 'Identifier', text: name };
+            node.name = identifier;
+        }
+    }
+    if (node.kind === 'ElementAccessExpression') {
+        const name = getDisposeSymbolName(node.argumentExpression);
+        if (name) {
+            const identifier = { kind: 'Identifier', text: name };
+            node.kind = 'PropertyAccessExpression';
+            node.name = identifier;
+            delete node.argumentExpression;
+        }
+    }
+}
+// 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)) {
@@ -494,9 +789,12 @@ const usedHelpers = new Set();
 // per-file import lists can exclude them (helpers are emitted once, in the
 // main file, which carries these imports instead).
 const helperProvidedPackages = new Set();
+// Whether the file being parsed is .tsx
+let currentFileIsTsx = false;
 export function transpileToNative(code, options) {
     fileResolver = options?.readFile ?? null;
     parseFunction = options?.parse ?? defaultParseFunction;
+    currentFileIsTsx = !!options?.tsx;
     declaredFunctions.clear();
     declaredInterfaces.clear();
     declaredTypeAliases.clear();
@@ -542,6 +840,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 +900,13 @@ function visit(node, options = {}) {
             .filter((n) => !!n)
             .join(options.inline ? '' : '\n\t');
     }
+    else if (isJsxNode(node)) {
+        return visitJsx(node);
+    }
+    else if (isIdentifier(node) && node.text === 'globalThis') {
+        useHelper('globalThis');
+        return 'TnGlobalThis';
+    }
     else if (isIdentifier(node)) {
         if (isFieldNameIdentifier(node))
             return goFieldName(node.text);
@@ -619,6 +926,9 @@ function visit(node, options = {}) {
         const goAlias = importAliases.get(node.text);
         if (goAlias)
             return goAlias;
+        // A class passed as a value (make(Box)) is its constructor function
+        if (classNames.has(node.text) && isValuePosition(node))
+            return `New${getSafeName(node.text)}`;
         // Array references: reads go through the shared slice-header pointer
         if (referenceArrays.has(node.text)) {
             return `(*${getSafeName(node.text)})`;
@@ -640,6 +950,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 +1006,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 +1057,21 @@ 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 (isNewTargetNode(node.expression) && node.name.text === 'name')
+            return '__newTarget';
         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 +1280,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 +1313,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 +1333,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 +1362,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 +1417,15 @@ function visit(node, options = {}) {
         if (arrayHigherOrderCall) {
             return arrayHigherOrderCall;
         }
+        const promiseCall = visitPromiseCall(node);
+        if (promiseCall)
+            return promiseCall;
+        const functionCall = visitFunctionCallApply(node);
+        if (functionCall)
+            return functionCall;
+        const objectCall = visitObjectCall(node);
+        if (objectCall)
+            return objectCall;
         const caller = visit(node.expression);
         const safeCaller = getSafeName(caller);
         const typeArgs = getTypeArguments((node.typeArguments ?? []));
@@ -1086,6 +1437,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 +1458,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 +1615,16 @@ function visit(node, options = {}) {
                 return op === '==' ? eq : `!(${eq})`;
             }
         }
+        // new.target === C → the target class name is C's
+        if ((op === '==' || op === '!=') && (isNewTargetNode(node.left) || isNewTargetNode(node.right))) {
+            const other = isNewTargetNode(node.left) ? node.right : node.left;
+            return `__newTarget ${op} ${isIdentifier(other) ? toGoStringLiteral(other.text) : '""'}`;
+        }
+        // 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 +1699,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 +1717,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 +1868,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 '';
@@ -1503,7 +1885,7 @@ function visit(node, options = {}) {
         if (options.isOutside) {
             // async functions run their body in a goroutine sending over a channel
             const isAsync = (node.modifiers ?? []).some((m) => m.kind === 'AsyncKeyword');
-            if (isAsync && node.name) {
+            if (isAsync && node.name && !node.asteriskToken) {
                 return emitChannelFunction(node, true);
             }
             if (node.asteriskToken && node.name) {
@@ -1535,7 +1917,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)}; }`;
@@ -1547,6 +1929,10 @@ function visit(node, options = {}) {
     else if (node.kind === 'ThisKeyword') {
         if (thisOverrideName && getEnclosingFunction(node) === thisOverrideFn)
             return thisOverrideName;
+        if (isThisOfPlainFunction(node)) {
+            useHelper('decorators');
+            return 'TnThis';
+        }
         return 'self';
     }
     else if (node.kind === 'PrivateIdentifier') {
@@ -1558,6 +1944,8 @@ function visit(node, options = {}) {
         enumNames.add(enumName);
         enumBaseTypes.set(enumName, getEnumBaseType(node));
         if (options.addFunctionOutside) {
+            if (enumHasComputedMember(node))
+                return visitEnumDeclaration(node, true);
             outsideNodes.push(node);
             return '';
         }
@@ -1645,7 +2033,7 @@ function visit(node, options = {}) {
             return `type ${name}${typeParams} struct {\n${fields.join('\n')}\n}`;
         }
         const members = [...extendedInterfaces.map((e) => `\t${e}`), ...methods];
-        return `type ${name}${typeParams} interface {\n${members.join('\n')}\n}`;
+        return `type ${name}${typeParams} interface {\n${members.join('\n')}\n}${extendedInterfaces.length === 0 ? emitInterfaceAdapter(node) : ''}`;
     }
     else if (isClassDeclaration(node)) {
         if (options.addFunctionOutside) {
@@ -1729,7 +2117,7 @@ function visit(node, options = {}) {
             }
             classPropertyTypes.set(className, properties);
             classMethodReturnTypes.set(className, methods);
-            return '';
+            return visitClassDecorators(node);
         }
         const name = visit(node.name);
         const typeParams = getTypeParameters(node.typeParameters);
@@ -1785,7 +2173,7 @@ function visit(node, options = {}) {
                     const args = (s.expression.arguments ?? []).map((a) => visit(a));
                     if (extendsError)
                         return `self.message = ${args[0] ?? '""'}\n\t\t`;
-                    return `self.${goFieldName(parentClass)} = *New${parentClass}(${args.join(', ')})\n\t\t`;
+                    return `self.${goFieldName(parentClass)} = *${parentConstructorCall(parentClass, args)}\n\t\t`;
                 }
                 return visit(s);
             })
@@ -1794,17 +2182,19 @@ function visit(node, options = {}) {
                 .map((p) => `self.${goFieldName(p.name.text)} = ${visit(p.name)}\n\t\t`)
                 .join('');
             const parentInit = parentClass && !extendsError && !superCalledInCtor
-                ? `self.${goFieldName(parentClass)} = *New${parentClass}()\n\t\t`
+                ? `self.${goFieldName(parentClass)} = *${parentConstructorCall(parentClass, [])}\n\t\t`
                 : '';
-            result += `func New${name}${typeParams}(${ctorParameterInfo.signature}) *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${ctorParameterInfo.prefixBlockContent}${parentInit}${fieldInitializers(node)}${parameterAssignments}${bodyStatements}return self;\n\t}\n\n`;
+            const ctorBody = `{\n\t\tself := &${name}${typeParamNames}{}\n\t\t${ctorParameterInfo.prefixBlockContent}${parentInit}${fieldInitializers(node)}${parameterAssignments}${bodyStatements}return self;\n\t}`;
+            result += emitConstructor(name, typeParams, typeParamNames, ctorParameterInfo.signature, ctorBody);
         }
         else if (extendsError) {
             // class X extends Error {} — the constructor takes the message
             result += `func New${name}${typeParams}(message string) *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\tself.message = message\n\t\t${fieldInitializers(node)}return self\n\t}\n\n`;
         }
         else {
-            const parentInit = parentClass && !extendsError ? `self.${goFieldName(parentClass)} = *New${parentClass}()\n\t\t` : '';
-            result += `func New${name}${typeParams}() *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${parentInit}${fieldInitializers(node)}return self\n\t}\n\n`;
+            const parentInit = parentClass && !extendsError ? `self.${goFieldName(parentClass)} = *${parentConstructorCall(parentClass, [])}\n\t\t` : '';
+            const ctorBody = `{\n\t\tself := &${name}${typeParamNames}{}\n\t\t${parentInit}${fieldInitializers(node)}return self\n\t}`;
+            result += emitConstructor(name, typeParams, typeParamNames, '', ctorBody);
         }
         // Inherited concrete methods are copied onto the subclass: Go embedding
         // promotes the parent's receiver, which would break `this` dispatch
@@ -1856,6 +2246,10 @@ function visit(node, options = {}) {
                     if (!methodName || ownMethodNames.has(methodName))
                         continue;
                     ownMethodNames.add(methodName);
+                    if (getDecorators(member).length > 0) {
+                        copiedMethods.push(emitDecoratedMethod(name, typeParamNames, member, visit(ancestor.name)));
+                        continue;
+                    }
                     const methodParameterInfo = getFunctionParametersInfo(member.parameters ?? []);
                     const returnType = member.type ? ` ${getType(member.type)}` : '';
                     copiedMethods.push(`func (self *${name}${typeParamNames}) ${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, { prefixBlockContent: methodParameterInfo.prefixBlockContent })}\n`);
@@ -1902,7 +2296,10 @@ function visit(node, options = {}) {
                     continue; // abstract method — implemented by subclasses
                 if (isAbstractClass && !isStatic)
                     continue; // only reachable via subclasses
-                if (isStatic) {
+                if (getDecorators(member).length > 0) {
+                    result += emitDecoratedMethod(name, typeParamNames, member, name);
+                }
+                else if (isStatic) {
                     // Static methods become package-level functions named ClassName_methodName
                     result += `func ${name}_${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, { prefixBlockContent: methodParameterInfo.prefixBlockContent })}\n\n`;
                 }
@@ -1936,6 +2333,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)) {
@@ -1983,6 +2386,10 @@ function visit(node, options = {}) {
         }
         const typeArgs = getTypeArguments((node.typeArguments ?? []));
         const args = node.arguments ? (node.arguments ?? []).map((a) => visit(a)) : [];
+        // new F(…) where F holds a constructor function (construct signature)
+        if (!classNames.has(className) && inferExpressionType(node.expression)?.startsWith('func(')) {
+            return `${className}(${args.join(', ')})`;
+        }
         return `New${className}${typeArgs}(${args.join(', ')})`;
     }
     else if (isObjectLiteralExpression(node)) {
@@ -2018,8 +2425,14 @@ 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);
+        if (isMethodInterfaceName(typeName.replace(/^\*/, '')))
+            return visitInterfaceLiteral(node, typeName.replace(/^\*/, ''), 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 +2448,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)) {
@@ -2084,6 +2497,8 @@ function visit(node, options = {}) {
 // 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 === 'string' && inferExpressionType(expr) === 'TnJsxNode')
+        return `string(${visit(expr)})`;
     if (goType &&
         ((isObjectLiteralExpression(expr) && (expr.properties ?? []).length === 0 && goType.startsWith('*TnMap[')) ||
             (isArrayLiteralExpression(expr) && (expr.elements ?? []).length === 0 && goType.startsWith('[]')))) {
@@ -2137,7 +2552,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 +2685,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;
@@ -2296,7 +2712,12 @@ function alwaysExits(statement) {
 function visitBlockStatements(statements) {
     const added = [];
     const parts = [];
-    for (const statement of statements) {
+    for (let index = 0; index < statements.length; index++) {
+        const statement = statements[index];
+        if (isUsingDeclaration(statement)) {
+            parts.push(visitUsingDeclaration(statement, statements.slice(index + 1)));
+            break;
+        }
         parts.push(visit(statement));
         if (isIfStatement(statement) && !statement.elseStatement && alwaysExits(statement.thenStatement)) {
             for (const name of getNarrowedNames(statement.expression, false)) {
@@ -2311,6 +2732,39 @@ function visitBlockStatements(statements) {
         narrowedVariables.delete(name);
     return parts.join('\t');
 }
+function isUsingDeclaration(statement) {
+    const kind = statement.kind === 'VariableStatement' ? statement.declarationList?.declarationKind : undefined;
+    return kind === 'using' || kind === 'await using';
+}
+// using x = r; …rest → x := r; defer dispose(x); …rest. In a function body Go's
+// defer is the block end; nested blocks run the rest in a closure so disposal
+// happens when the block ends (return/break/continue there keep the defer form)
+function visitUsingDeclaration(statement, rest) {
+    const isAwait = statement.declarationList.declarationKind === 'await using';
+    const disposals = (statement.declarationList.declarations ?? [])
+        .filter((d) => isIdentifier(d.name))
+        .map((d) => {
+        const name = visit(d.name);
+        const goType = inferExpressionType(d.initializer) ?? '';
+        const className = goType.replace(/^\*/, '').replace(/\[.*$/, '');
+        const classNode = declaredClasses.get(className);
+        const hasAsync = (classNode?.members ?? []).some((m) => m.name?.text === '__asyncDispose');
+        if (isAwait && hasAsync)
+            useHelper('promise');
+        const call = isAwait && hasAsync ? `TnAwait(${name}.__asyncDispose())` : `${name}.__dispose()`;
+        return `defer func() { if ${name} != nil { ${call} } }()`;
+    })
+        .reverse();
+    const declaration = { ...statement, declarationList: { ...statement.declarationList, declarationKind: 'const' } };
+    const head = `${visit(declaration)}${disposals.join('\n\t\t')}\n\t\t`;
+    const block = statement.parent;
+    const isFunctionBody = !!block?.parent && block.parent.body === block;
+    const restBlock = { kind: 'Block', statements: rest };
+    const exits = containsNode(restBlock, (n) => n.kind === 'ReturnStatement' || n.kind === 'BreakStatement' || n.kind === 'ContinueStatement');
+    if (isFunctionBody || exits)
+        return head + visitBlockStatements(rest);
+    return `func() {\n\t\t${head}${visitBlockStatements(rest)}}()\n\t`;
+}
 function visitDynamicArithmetic(node, op) {
     const leftDynamic = isDynamicValue(node.left);
     const rightDynamic = isDynamicValue(node.right);
@@ -2515,6 +2969,66 @@ function visitSpreadCallArguments(node) {
     return result;
 }
 // self.field = initializer for each instance field that has one
+// Whether a class's constructor chain (its own or an ancestor's) reads new.target
+function usesNewTarget(className) {
+    let current = className;
+    for (let depth = 0; depth < 50; depth++) {
+        const classNode = declaredClasses.get(current);
+        if (!classNode)
+            return false;
+        const ctor = (classNode.members ?? []).find((m) => isConstructorDeclaration(m));
+        if (ctor?.body && containsNode(ctor.body, (n) => isNewTargetNode(n)))
+            return true;
+        const extendsClause = (classNode.heritageClauses ?? []).find((c) => c.token === 'ExtendsKeyword');
+        if (!extendsClause)
+            return false;
+        current = visit(extendsClause.types[0].expression);
+    }
+    return false;
+}
+function isNewTargetNode(node) {
+    return node?.kind === 'MetaProperty' && node.name?.text === 'target';
+}
+// The parent part of a subclass constructor: new.target-aware chains pass the target on
+function parentConstructorCall(parentClass, args) {
+    if (!usesNewTarget(parentClass))
+        return `New${parentClass}(${args.join(', ')})`;
+    return `new${parentClass}As(${['__newTarget', ...args].join(', ')})`;
+}
+// Splits a Go parameter list at top-level commas
+function splitGoParameters(signature) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of signature) {
+        if (ch === '(' || ch === '[' || ch === '{')
+            depth++;
+        if (ch === ')' || ch === ']' || ch === '}')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            parts.push(current.trim());
+            current = '';
+        }
+        else
+            current += ch;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}
+// NewX(…) — or, for new.target-aware classes, newXAs(__newTarget string, …) plus a
+// NewX(…) that calls it with "X"
+function emitConstructor(name, typeParams, typeParamNames, signature, body) {
+    if (!usesNewTarget(name))
+        return `func New${name}${typeParams}(${signature}) *${name}${typeParamNames} ${body}\n\n`;
+    const forward = splitGoParameters(signature).map((p) => {
+        const [paramName, paramType] = [p.slice(0, p.indexOf(' ')), p.slice(p.indexOf(' ') + 1)];
+        return paramType.startsWith('...') ? `${paramName}...` : paramName;
+    });
+    const internal = ['__newTarget string', signature].filter((part) => part).join(', ');
+    return (`func new${name}As${typeParams}(${internal}) *${name}${typeParamNames} ${body}\n\n` +
+        `func New${name}${typeParams}(${signature}) *${name}${typeParamNames} {\n\t\treturn new${name}As${typeParamNames}(${[toGoStringLiteral(name), ...forward].join(', ')})\n\t}\n\n`);
+}
 function fieldInitializers(classNode) {
     return (classNode.members ?? [])
         .filter((m) => isPropertyDeclaration(m) &&
@@ -2533,6 +3047,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 +3177,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 +3226,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 +3276,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 +3601,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 +3633,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 +3648,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 +3661,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 +3674,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 +3746,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 +3829,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 +3942,18 @@ 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 (isJsxNode(expr))
+        return 'TnJsxNode';
+    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))) {
@@ -3375,6 +4027,8 @@ function inferExpressionType(expr) {
         return '[]string';
     }
     // import.meta.url is a string
+    if (isPropertyAccessExpression(expr) && isNewTargetNode(expr.expression) && expr.name.text === 'name')
+        return 'string';
     if (isPropertyAccessExpression(expr) && expr.expression.kind === 'MetaProperty' && expr.name.text === 'url') {
         return 'string';
     }
@@ -3396,6 +4050,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 +4104,21 @@ 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) && inferExpressionType(expr.expression) === '*TnDecoratorContext') {
+        return ['static', 'private'].includes(expr.name.text) ? 'bool' : 'string';
+    }
+    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 +4128,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) &&
@@ -3491,6 +4172,9 @@ function inferExpressionType(expr) {
             // Numeric enums are float64 constants; string enums keep their type
             if (enumBaseTypes.get(expr.expression.text) === 'float64')
                 return 'float64';
+            if (enumBaseTypes.get(expr.expression.text) === 'interface{}') {
+                return enumMemberGoTypes.get(`${expr.expression.text}.${getEnumMemberName(expr.name)}`) ?? 'interface{}';
+            }
             const enumType = getSafeName(expr.expression.text);
             return enumType;
         }
@@ -3570,15 +4254,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 +4288,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 +4388,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 +4400,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,11 +4561,14 @@ 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',
     trimStart: 'string',
+    normalize: 'string',
     trimEnd: 'string',
     toUpperCase: 'string',
     toLowerCase: 'string',
@@ -3875,6 +4723,46 @@ function makeNullableType(typeName) {
 // 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)
+// A declared interface with method signatures (a Go interface type)
+function isMethodInterfaceName(name) {
+    return (declaredInterfaces.get(name)?.members ?? []).some((m) => isMethodSignature(m));
+}
+// type P_obj struct { get_fn func() T; … } + func (o *P_obj) get() T { return o.get_fn() }
+function emitInterfaceAdapter(node) {
+    const name = visit(node.name);
+    const typeParams = getTypeParameters(node.typeParameters);
+    const typeParamNames = getTypeParameterNames(node.typeParameters);
+    const fields = [];
+    const methods = [];
+    for (const member of node.members ?? []) {
+        if (!isMethodSignature(member))
+            continue;
+        const methodName = visit(member.name);
+        const params = (member.parameters ?? []).map((p) => `${visit(p.name)} ${getType(p.type)}`);
+        const args = (member.parameters ?? []).map((p) => visit(p.name));
+        const returnType = member.type ? getType(member.type) : '';
+        const signature = `func(${params.join(', ')})${returnType ? ` ${returnType}` : ''}`;
+        fields.push(`\t${methodName}_fn ${signature}`);
+        methods.push(`func (o *${name}_obj${typeParamNames}) ${methodName}(${params.join(', ')})${returnType ? ` ${returnType}` : ''} { ${returnType ? 'return ' : ''}o.${methodName}_fn(${args.join(', ')}) }`);
+    }
+    return `\n\ntype ${name}_obj${typeParams} struct {\n${fields.join('\n')}\n}\n\n${methods.join('\n\n')}`;
+}
+// { get: () => 4, set(v) { … } } typed as a method interface → &P_obj{get_fn: …, set_fn: …}
+function visitInterfaceLiteral(node, interfaceName, typeArgs) {
+    const fields = (node.properties ?? []).map((p) => {
+        const fieldName = `${visit(p.name)}_fn`;
+        if (isPropertyAssignment(p))
+            return `${fieldName}: ${visit(p.initializer)}`;
+        if (isShorthandPropertyAssignment(p))
+            return `${fieldName}: ${visit(p.name)}`;
+        if (isMethodDeclaration(p)) {
+            const fn = { kind: 'FunctionExpression', parameters: p.parameters, type: p.type, body: p.body, parent: p.parent };
+            return `${fieldName}: ${visit(fn)}`;
+        }
+        return '';
+    });
+    return `&${interfaceName}_obj${typeArgs}${compositeBody(fields.filter((f) => f))}`;
+}
 function isObjectTypeName(name) {
     const alias = declaredTypeAliases.get(name) ?? typeAliases.get(name);
     if (alias)
@@ -3886,6 +4774,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 +4996,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 +5126,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 +5231,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)
@@ -4359,16 +5307,23 @@ function getEnumMemberName(name) {
     }
     return 'Member';
 }
+// string enums, numeric enums, or interface{} for heterogeneous ones (each member keeps its own type)
 function getEnumBaseType(node) {
+    let hasString = false;
+    let hasNumber = false;
     for (const member of (node.members ?? [])) {
         const initializer = member.initializer;
-        if (!initializer)
-            continue;
-        if (isStringLiteral(initializer) || isNoSubstitutionTemplateLiteral(initializer)) {
-            return 'string';
+        if (initializer && (isStringLiteral(initializer) || isNoSubstitutionTemplateLiteral(initializer))) {
+            hasString = true;
+        }
+        else {
+            hasNumber = true;
         }
+        enumMemberGoTypes.set(`${node.name.text}.${getEnumMemberName(member.name)}`, initializer && (isStringLiteral(initializer) || isNoSubstitutionTemplateLiteral(initializer)) ? 'string' : 'float64');
     }
-    return 'float64';
+    if (hasString && hasNumber)
+        return 'interface{}';
+    return hasString ? 'string' : 'float64';
 }
 function readNumericEnumInitializer(initializer) {
     if (isNumericLiteral(initializer)) {
@@ -4381,18 +5336,28 @@ function readNumericEnumInitializer(initializer) {
     }
     return undefined;
 }
-function visitEnumDeclaration(node) {
+function enumHasComputedMember(node) {
+    return (node.members ?? []).some((m) => m.initializer &&
+        !isStringLiteral(m.initializer) &&
+        !isNoSubstitutionTemplateLiteral(m.initializer) &&
+        readNumericEnumInitializer(m.initializer) === undefined);
+}
+function visitEnumDeclaration(node, inPlace = false) {
     const enumName = getSafeName(node.name.text);
     const baseType = enumBaseTypes.get(node.name.text) ?? getEnumBaseType(node);
     let nextNumericValue = 0;
     let canAutoIncrement = true;
+    let hasComputedMember = false;
     const members = [];
     for (const member of (node.members ?? [])) {
         const memberName = getEnumMemberName(member.name);
         const symbolName = `${enumName}_${memberName}`;
         let valueExpr;
         if (member.initializer) {
-            if (baseType === 'float64') {
+            if (baseType === 'interface{}' && (isStringLiteral(member.initializer) || isNoSubstitutionTemplateLiteral(member.initializer))) {
+                valueExpr = visit(member.initializer);
+            }
+            else if (baseType !== 'string') {
                 const numericValue = readNumericEnumInitializer(member.initializer);
                 if (numericValue !== undefined) {
                     valueExpr = `${numericValue}`;
@@ -4402,13 +5367,14 @@ function visitEnumDeclaration(node) {
                 else {
                     valueExpr = `float64(${visit(member.initializer)})`;
                     canAutoIncrement = false;
+                    hasComputedMember = true;
                 }
             }
             else {
                 valueExpr = visit(member.initializer);
             }
         }
-        else if (baseType === 'float64') {
+        else if (baseType !== 'string') {
             const currentValue = canAutoIncrement ? nextNumericValue : 0;
             valueExpr = `${currentValue}`;
             nextNumericValue = currentValue + 1;
@@ -4418,10 +5384,37 @@ function visitEnumDeclaration(node) {
         }
         members.push(`\t${symbolName} ${enumName} = ${enumName}(${valueExpr})`);
     }
-    // Numeric enums are plain float64 constants so they compare against numbers;
-    // string enums keep a named type
+    // Assigned in place: package variables declared, values set in source order
+    if (inPlace) {
+        return members
+            .map((m) => {
+            const name = m.slice(m.indexOf('\t') + 1, m.indexOf(' '));
+            const raw = m.slice(m.indexOf(`= ${enumName}(`) + enumName.length + 3, -1);
+            const value = /^-?[0-9.]+$/.test(raw) ? `float64(${raw})` : raw;
+            const memberType = baseType === 'interface{}'
+                ? (enumMemberGoTypes.get(`${node.name.text}.${name.slice(enumName.length + 1)}`) ?? 'interface{}')
+                : baseType === 'float64'
+                    ? 'float64'
+                    : enumName;
+            mainPackageVariables.push(`var ${name} ${memberType}`);
+            return `${name} = ${memberType === enumName ? `${enumName}(${raw})` : value};\n\t`;
+        })
+            .join('');
+    }
+    // Heterogeneous enums: plain variables of each member's own type
+    if (baseType === 'interface{}') {
+        return `var (\n${members
+            .map((m) => {
+            const name = m.slice(m.indexOf('\t') + 1, m.indexOf(' '));
+            const value = m.slice(m.indexOf(`= ${enumName}(`) + enumName.length + 3, -1);
+            return `\t${name} = ${/^-?[0-9.]+$/.test(value) ? `float64(${value})` : value}`;
+        })
+            .join('\n')}\n)`;
+    }
+    // Numeric enums are plain float64 constants so they compare against numbers
+    // (variables when a member is computed); string enums keep a named type
     if (baseType === 'float64') {
-        return `const (\n${members
+        return `${hasComputedMember ? 'var' : 'const'} (\n${members
             .map((m) => {
             const name = m.slice(m.indexOf('\t') + 1, m.indexOf(' '));
             const value = m.slice(m.lastIndexOf('=') + 1).trim();
@@ -4444,6 +5437,35 @@ function getType(typeNode, getArrayType = false) {
         const elementType = getType(typeNode.elementType);
         return getArrayType ? elementType : `[]${elementType}`;
     }
+    if (typeNode.kind === 'MappedType')
+        return getMappedType(typeNode);
+    if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName) && /DecoratorContext$/.test(typeNode.typeName.text)) {
+        useHelper('decorators');
+        return '*TnDecoratorContext';
+    }
+    if (isTypeReferenceNode(typeNode) &&
+        typeNode.typeName?.kind === 'QualifiedName' &&
+        typeNode.typeName.left?.text === 'JSX' &&
+        typeNode.typeName.right?.text === 'Element') {
+        useHelper('jsx');
+        return 'TnJsxNode';
+    }
+    // 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);
@@ -4467,8 +5489,12 @@ function getType(typeNode, getArrayType = false) {
         return 'interface{}';
     }
     if (isFunctionTypeNode(typeNode)) {
+        // (...args: T[]) => R is variadic: func(...T) R
         const params = (typeNode.parameters ?? [])
-            .map((p) => (p.type ? getType(p.type) : 'interface{}'))
+            .map((p) => {
+            const paramType = p.type ? getType(p.type) : 'interface{}';
+            return p.dotDotDotToken && paramType.startsWith('[]') ? `...${paramType.slice(2)}` : paramType;
+        })
             .join(', ');
         const ret = typeNode.type ? ` ${getType(typeNode.type)}` : '';
         return `func(${params})${ret}`;
@@ -4488,6 +5514,8 @@ function getType(typeNode, getArrayType = false) {
             // Numeric enums lowered to float64 constants have no named type
             if (enumBaseTypes.get(name) === 'float64')
                 return 'float64';
+            if (enumBaseTypes.get(name) === 'interface{}')
+                return 'interface{}';
             return getSafeName(name);
         }
         const aliasType = getAliasType(name);
@@ -4518,6 +5546,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 +5582,10 @@ function getType(typeNode, getArrayType = false) {
         case 'any':
             return 'interface{}';
         case 'void':
+        case 'never':
             return '';
+        case 'object':
+            return 'interface{}';
         default:
             return typeName;
     }
@@ -4661,6 +5696,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 +5752,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 +5941,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 +5968,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) => {
@@ -4943,6 +6046,15 @@ const stringMethodHandlers = {
         return `${obj}[${sliceIndex(obj, args[0])}:]`;
     },
     concat: (obj, args) => `${obj} + ${args.join(' + ')}`,
+    // normalize('NFC' | 'NFD' | 'NFKC' | 'NFKD')
+    normalize: (obj, args) => {
+        importedPackages.add('golang.org/x/text/unicode/norm');
+        const form = args[0] ?? '"NFC"';
+        const literal = /^"(NFC|NFD|NFKC|NFKD)"$/.exec(form);
+        if (literal)
+            return `tnnorm.${literal[1]}.String(${obj})`;
+        return `func() string { switch ${form} { case "NFD": return tnnorm.NFD.String(${obj}); case "NFKC": return tnnorm.NFKC.String(${obj}); case "NFKD": return tnnorm.NFKD.String(${obj}) }; return tnnorm.NFC.String(${obj}) }()`;
+    },
     padStart: (obj, args) => {
         importedPackages.add('strings');
         const pad = args[1] ?? '" "';
@@ -5011,8 +6123,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 +6191,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 +6287,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 +6320,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 +6447,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 +6501,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 +6601,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 +6612,267 @@ 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]}")`;
+}
+// Whether an expression is used as a value (argument, initializer, element, assigned or returned)
+function isValuePosition(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    if (isCallExpression(parent))
+        return (parent.arguments ?? []).includes(node);
+    if (isVariableDeclaration(parent) || isPropertyAssignment(parent))
+        return parent.initializer === node;
+    if (isArrayLiteralExpression(parent))
+        return true;
+    if (isReturnStatement(parent))
+        return true;
+    return isBinaryExpression(parent) && parent.operatorToken.kind === 'EqualsToken' && parent.right === node;
+}
+function isJsxNode(node) {
+    return node?.kind === 'JsxElement' || node?.kind === 'JsxSelfClosingElement' || node?.kind === 'JsxFragment';
+}
+// JSX text: lines trimmed at their inner edges, blank lines dropped, joined by a space
+function cleanJsxText(text) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    const kept = [];
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i].replace(/\t/g, ' ');
+        if (i > 0)
+            line = line.replace(/^ +/, '');
+        if (i < lines.length - 1)
+            line = line.replace(/ +$/, '');
+        if (line)
+            kept.push(line);
+    }
+    return kept.join(' ');
+}
+// The children of an element as []interface{} (text, {expressions}, nested elements)
+function visitJsxChildren(children) {
+    const parts = [];
+    for (const child of children) {
+        if (child.kind === 'JsxText') {
+            const text = cleanJsxText(child.text ?? '');
+            if (text)
+                parts.push(toGoStringLiteral(text));
+        }
+        else if (child.kind === 'JsxExpression') {
+            if (child.expression)
+                parts.push(visit(child.expression));
+        }
+        else {
+            parts.push(visit(child));
+        }
+    }
+    return `[]interface{}{${parts.join(', ')}}`;
+}
+// An attribute's value: name="x", name={expr}, or a bare name (true)
+function getJsxAttributeValue(attribute) {
+    if (!attribute.initializer) {
+        const trueNode = { kind: 'TrueKeyword', parent: attribute };
+        return trueNode;
+    }
+    return attribute.initializer.kind === 'JsxExpression' ? attribute.initializer.expression : attribute.initializer;
+}
+function visitJsx(node) {
+    useHelper('jsx');
+    if (node.kind === 'JsxFragment')
+        return `TnJsxChildren(${visitJsxChildren(node.children ?? [])})`;
+    const opening = node.kind === 'JsxElement' ? node.openingElement : node;
+    const children = node.kind === 'JsxElement' ? (node.children ?? []) : [];
+    const tag = opening.tagName;
+    const attributes = (opening.attributes?.properties ?? []).filter((a) => a.kind === 'JsxAttribute');
+    // <div …> / <my-element …>: an HTML element
+    if (isIdentifier(tag) && (/^[a-z]/.test(tag.text) || tag.text.includes('-'))) {
+        const attrs = attributes.map((a) => `{${toGoStringLiteral(a.name.text)}, ${visit(getJsxAttributeValue(a))}}`);
+        return `TnJsxElement(${toGoStringLiteral(tag.text)}, []TnJsxAttr{${attrs.join(', ')}}, ${visitJsxChildren(children)})`;
+    }
+    // <Card title="x">…</Card> → Card({ title: "x", children: … })
+    const call = { kind: 'CallExpression', expression: tag, arguments: [], parent: node.parent };
+    tag.parent = call;
+    const properties = [];
+    for (const a of attributes) {
+        const name = { kind: 'Identifier', text: a.name.text };
+        const property = { kind: 'PropertyAssignment', name, initializer: getJsxAttributeValue(a) };
+        property.initializer.parent = property;
+        name.parent = property;
+        properties.push(property);
+    }
+    const meaningful = children.filter((c) => c.kind !== 'JsxText' || cleanJsxText(c.text ?? ''));
+    if (meaningful.length > 0) {
+        const name = { kind: 'Identifier', text: 'children' };
+        const fragment = { kind: 'JsxFragment', children };
+        const property = { kind: 'PropertyAssignment', name, initializer: fragment };
+        fragment.parent = property;
+        name.parent = property;
+        properties.push(property);
+    }
+    const props = { kind: 'ObjectLiteralExpression', properties, parent: call };
+    for (const property of properties)
+        property.parent = props;
+    const declared = isIdentifier(tag) ? declaredFunctions.get(tag.text) : undefined;
+    if (properties.length > 0 || (declared?.parameters ?? []).length > 0) {
+        const args = [props];
+        call.arguments = args;
+    }
+    return visit(call);
+}
+function getDecorators(node) {
+    return (node.modifiers ?? []).filter((m) => m.kind === 'Decorator');
+}
+// `this` inside a function / function expression (not a class member, not an arrow's)
+function isThisOfPlainFunction(node) {
+    for (let n = node.parent; n; n = n.parent) {
+        if (isArrowFunction(n))
+            continue;
+        if (isFunctionExpression(n) || isFunctionDeclaration(n))
+            return !isPropertyAssignment(n.parent);
+        if (isMethodDeclaration(n) || isConstructorDeclaration(n) || isPropertyDeclaration(n) || isGetAccessor(n) || isSetAccessor(n) || isClassDeclaration(n))
+            return false;
+    }
+    return false;
+}
+// f.call(thisArg, a, b) → f(a, b); f.apply(thisArg, args) → f(args...) (this is TnThis)
+function visitFunctionCallApply(node) {
+    if (!isPropertyAccessExpression(node.expression))
+        return undefined;
+    const method = node.expression.name.text;
+    if (method !== 'call' && method !== 'apply')
+        return undefined;
+    if (!inferExpressionType(node.expression.expression)?.startsWith('func('))
+        return undefined;
+    const fn = visit(node.expression.expression);
+    const args = (node.arguments ?? []).slice(1);
+    if (method === 'apply')
+        return `${fn}(${args[0] ? `${visit(args[0])}...` : ''})`;
+    return `${fn}(${args.map((a) => (isSpreadElement(a) ? `${visit(a.expression)}...` : visit(a))).join(', ')})`;
+}
+// Whether a decorator call returns a value (a replacement), or only has effects
+function decoratorReturnsValue(decorator) {
+    let fnType = inferExpressionType(decorator.expression);
+    // @factory(args): the decorator is what the factory returns
+    const factoryCall = decorator.expression;
+    if (isCallExpression(factoryCall) && isIdentifier(factoryCall.expression)) {
+        const factory = declaredFunctions.get(factoryCall.expression.text);
+        if (factory)
+            fnType = factory.type ? getType(factory.type) : inferFunctionBodyReturnType(factory);
+    }
+    if (fnType?.startsWith('func('))
+        return !!goFuncReturnType(fnType);
+    const call = { kind: 'CallExpression', expression: decorator.expression, arguments: [], parent: decorator };
+    const returnType = inferExpressionType(call);
+    return !!returnType && returnType !== 'struct{}';
+}
+// The decorated method m: m__undecorated holds the body; m calls the decorated function
+// (Owner_m__decorated) with TnThis set to the receiver
+function emitDecoratedMethod(className, typeParamNames, member, ownerClass) {
+    useHelper('decorators');
+    useHelper('dynamic');
+    const methodName = visit(member.name);
+    const info = getFunctionParametersInfo(member.parameters ?? []);
+    if (info.signature.includes('...'))
+        throw new Error(`decorated method ${methodName}: rest/default parameters are not supported`);
+    const names = splitGoParameters(info.signature).map((p) => p.slice(0, p.indexOf(' ')));
+    const returnType = member.type ? getType(member.type) : '';
+    const result = returnType ? ` ${returnType}` : '';
+    const body = visit(member.body, { prefixBlockContent: info.prefixBlockContent });
+    const call = `${ownerClass}_${methodName}__decorated(${names.join(', ')})`;
+    const invoke = returnType ? `return TnAs[${returnType}](${call})` : call;
+    if ((member.modifiers ?? []).some((m) => m.kind === 'StaticKeyword')) {
+        return `func ${className}_${methodName}__undecorated(${info.signature})${result} ${body}\n\nfunc ${className}_${methodName}(${info.signature})${result} {\n\t\t${invoke}\n\t}\n\n`;
+    }
+    return (`func (self *${className}${typeParamNames}) ${methodName}__undecorated(${info.signature})${result} ${body}\n\n` +
+        `func (self *${className}${typeParamNames}) ${methodName}(${info.signature})${result} {\n\t\t__prevThis := TnThis\n\t\tTnThis = self\n\t\tdefer func() { TnThis = __prevThis }()\n\t\t${invoke}\n\t}\n\n`);
+}
+// Applies a class's decorators where it is defined (in source order): each decorated
+// method's function is wrapped bottom-up, then class decorators run
+function visitClassDecorators(node) {
+    const className = visit(node.name);
+    const statements = [];
+    for (const member of node.members ?? []) {
+        const decorators = getDecorators(member);
+        if (decorators.length === 0)
+            continue;
+        if (!isMethodDeclaration(member) || !member.body)
+            throw new Error(`${className}: only method and class decorators are supported`);
+        useHelper('decorators');
+        useHelper('dynamic');
+        const methodName = visit(member.name);
+        const isStatic = (member.modifiers ?? []).some((m) => m.kind === 'StaticKeyword');
+        const isPrivate = member.name?.kind === 'PrivateIdentifier';
+        const params = splitGoParameters(getFunctionParametersInfo(member.parameters ?? []).signature);
+        const paramTypes = params.map((p) => p.slice(p.indexOf(' ') + 1));
+        const returnType = member.type ? getType(member.type) : '';
+        const varName = `${className}_${methodName}__decorated`;
+        mainPackageVariables.push(`var ${varName} func(...interface{}) interface{}`);
+        const args = paramTypes.map((t, i) => `TnAs[${t}](__args[${i}])`).join(', ');
+        const target = isStatic
+            ? `${className}_${methodName}__undecorated(${args})`
+            : `TnThis.(interface{ ${methodName}__undecorated(${paramTypes.join(', ')})${returnType ? ` ${returnType}` : ''} }).${methodName}__undecorated(${args})`;
+        statements.push(`${varName} = func(__args ...interface{}) interface{} { ${returnType ? `return ${target}` : `${target}; return nil`} }`);
+        for (const decorator of [...decorators].reverse()) {
+            const context = `&TnDecoratorContext{kind: "method", name: ${toGoStringLiteral(isPrivate ? member.name.text : methodName)}, static: ${isStatic}, private: ${isPrivate}}`;
+            const call = `(${visit(decorator.expression)})(${varName}, ${context})`;
+            statements.push(decoratorReturnsValue(decorator) ? `${varName} = TnDecorate(${varName}, ${call})` : call);
+        }
+    }
+    for (const decorator of [...getDecorators(node)].reverse()) {
+        useHelper('decorators');
+        const context = `&TnDecoratorContext{kind: "class", name: ${toGoStringLiteral(className)}}`;
+        const call = `(${visit(decorator.expression)})(New${className}, ${context})`;
+        statements.push(decoratorReturnsValue(decorator) ? `TnDecorateClass(${call})` : call);
+    }
+    return statements.map((statement) => `${statement};\n\t`).join('');
+}
+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 +6883,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(', ')}]`;
 }
@@ -5626,6 +7045,14 @@ function visitCallArguments(node) {
     return result;
 }
 function withContextualParameters(fn, info) {
+    if (usesArgumentsObject(fn) && !info.signature.includes('...')) {
+        const names = (fn.parameters ?? []).map((p) => getParameterName(p, fn.parameters));
+        registerLocalVariable('arguments', '[]interface{}');
+        return {
+            signature: [info.signature, '__arguments ...interface{}'].filter((part) => part).join(', '),
+            prefixBlockContent: `${info.prefixBlockContent}arguments := append([]interface{}{${names.join(', ')}}, __arguments...)\n\t\t_ = arguments\n\t\t`
+        };
+    }
     const contextualFn = getContextualFunctionType(fn);
     const declaredCount = (fn.parameters ?? []).length;
     const contextualParams = contextualFn?.parameters ?? [];
@@ -5637,6 +7064,16 @@ function withContextualParameters(fn, info) {
     const signature = [info.signature, ...extra].filter((part) => part).join(', ');
     return { ...info, signature };
 }
+// A non-arrow function whose own body reads `arguments` (arrows see their parent's)
+function usesArgumentsObject(fn) {
+    if (isArrowFunction(fn) || !fn.body)
+        return false;
+    return containsNode(fn.body, (n) => {
+        if (n !== fn.body && (isFunctionDeclaration(n) || isFunctionExpression(n) || isMethodDeclaration(n)))
+            return false;
+        return isIdentifier(n) && n.text === 'arguments' && !isFieldNameIdentifier(n);
+    });
+}
 // Destructured parameters ({ a, b }: T / [x, y]: T[]) get a temporary name
 function getParameterName(param, parameters) {
     if (isIdentifier(param.name))
@@ -5737,7 +7174,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 +7202,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 +7212,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 +7234,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 +7253,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) {
@@ -5865,8 +7314,8 @@ function visitNewSet(node) {
         elementType = getArrayLiteralElementType(node.arguments[0]);
     }
     const args = node.arguments ?? [];
-    // new Set(otherSet/values()) — copy at runtime
-    if (args.length > 0 && !isArrayLiteralExpression(args[0])) {
+    // new Set(otherSet/values()) / new Set([...a, ...b]) — copy at runtime
+    if (args.length > 0 && (!isArrayLiteralExpression(args[0]) || (args[0].elements ?? []).some((e) => isSpreadElement(e)))) {
         useHelper('orderedMap');
         const src = getTempName('setsrc');
         const item = getTempName('item');
@@ -5901,9 +7350,11 @@ function normalizeCjsToEsm(code) {
     code = code.replace(/(?:module\.exports|exports)\.(\w+)\s*=\s*function\s*\w*\s*\(/g, 'export function $1(');
     return code;
 }
-function includeLocalImport(code, dir, goFileName) {
+function includeLocalImport(code, dir, goFileName, tsx = false) {
     const prevDir = currentFileDir;
+    const prevTsx = currentFileIsTsx;
     currentFileDir = dir;
+    currentFileIsTsx = tsx;
     // Normalize CommonJS modules to ES module syntax before parsing
     if (!code.includes('export ') && (code.includes('module.exports') || code.includes('exports.'))) {
         code = normalizeCjsToEsm(code);
@@ -5915,6 +7366,7 @@ function includeLocalImport(code, dir, goFileName) {
             visit(stmt, { addFunctionOutside: true });
         }
         currentFileDir = prevDir;
+        currentFileIsTsx = prevTsx;
         return;
     }
     // Separate-file mode (local TS imports): transpile to its own Go file.
@@ -5936,7 +7388,13 @@ function includeLocalImport(code, dir, goFileName) {
     }
     emittingModuleFile = prevEmittingModuleFile;
     const fileOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
-    const fileInline = inlineLines.join('\n');
+    const isDeclarationLine = (line) => /^(var|const|type|func|import)\b/.test(line.trim());
+    const declarationLines = inlineLines.filter(isDeclarationLine);
+    const statementLines = inlineLines.filter((line) => !isDeclarationLine(line));
+    const fileInline = [
+        ...declarationLines,
+        ...(statementLines.length > 0 ? [`func init() {\n\t${statementLines.join('\n\t')}\n}`] : [])
+    ].join('\n');
     // Computed after all visits: function bodies (outside nodes) register
     // packages too, and imports must be captured after those visits.
     // Helper-provided packages are only imported here if the file's own code
@@ -5967,6 +7425,7 @@ function includeLocalImport(code, dir, goFileName) {
     importedPackages.clear();
     for (const p of savedPackages)
         importedPackages.add(p);
+    currentFileIsTsx = prevTsx;
     for (const p of helperProvidedPackages)
         importedPackages.add(p);
     currentFileDir = prevDir;
@@ -6029,7 +7488,13 @@ 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'],
+    decorators: [],
+    jsx: [],
+    objectIntegrity: [],
+    structuredClone: [],
+    globalThis: ['dynamic'],
     namedGroups: ['orderedMap'],
     fancyRegex: ['orderedMap'],
     dynamic: ['error'],
@@ -6205,7 +7670,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 +7690,14 @@ const helperPackages = {
     moduleUrl: ['os'],
     asyncWait: ['sync'],
     timerWait: ['sync', 'time'],
+    uri: ['strings', 'fmt', 'net/url'],
     promiseAll: [],
+    promise: ['sync'],
+    decorators: [],
+    jsx: ['strings', 'html', 'reflect', 'strconv', 'fmt'],
+    objectIntegrity: ['sync', 'reflect'],
+    structuredClone: ['reflect', 'unsafe'],
+    globalThis: [],
     exec: ['os/exec', 'bytes', 'runtime'],
     execSync: ['os/exec', 'bytes', 'runtime'],
     runInherit: ['os/exec', 'os'],
@@ -6256,6 +7728,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 +7751,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 +7824,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 +7969,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 {
@@ -6620,14 +8136,30 @@ func TnIsNil(v interface{}) bool {
 	return false
 }`,
     typeOf: `func TnTypeOf(v interface{}) string {
-	switch v.(type) {
+	// an unset nullable primitive (*T nil) is undefined
+	switch t := v.(type) {
 	case nil:
 		return "undefined"
-	case string, *string:
+	case string:
+		return "string"
+	case *string:
+		if t == nil {
+			return "undefined"
+		}
 		return "string"
-	case float64, *float64:
+	case float64:
 		return "number"
-	case bool, *bool:
+	case *float64:
+		if t == nil {
+			return "undefined"
+		}
+		return "number"
+	case bool:
+		return "boolean"
+	case *bool:
+		if t == nil {
+			return "undefined"
+		}
 		return "boolean"
 	}
 	if reflect.ValueOf(v).Kind() == reflect.Func {
@@ -6673,7 +8205,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 +8236,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 +8271,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 +8354,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 +8498,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, 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)
+		}
+	}
+	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 TnRegexCompile(pattern string, global bool) *TnRegex {
-	if re, err := regexp.Compile(pattern); err == nil {
-		return &TnRegex{re: re, global: global}
+func TnRegexpFlags(re *regexp.Regexp) string {
+	if m := tnRegexpFlagPrefix.FindStringSubmatch(re.String()); m != nil {
+		return m[1]
 	}
-	return &TnRegex{bt: tnBtCompile(pattern), global: global}
+	return ""
 }
 
 func (r *TnRegex) Test(s string) bool {
@@ -7065,15 +8682,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 +8710,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 +8738,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 +8762,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 +9543,480 @@ 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{}{}`,
+    jsx: `// JSX renders to HTML: TnJsxNode is markup, plain strings are escaped text
+type TnJsxNode string
+
+type TnJsxAttr struct {
+	name  string
+	value interface{}
+}
+
+var tnJsxVoidTags = map[string]bool{"area": true, "base": true, "br": true, "col": true, "embed": true, "hr": true, "img": true, "input": true, "link": true, "meta": true, "source": true, "track": true, "wbr": true}
+
+func TnJsxElement(tag string, attrs []TnJsxAttr, children []interface{}) TnJsxNode {
+	var b strings.Builder
+	b.WriteString("<" + tag)
+	for _, a := range attrs {
+		name := a.name
+		switch name {
+		case "key", "ref":
+			continue
+		case "className":
+			name = "class"
+		case "htmlFor":
+			name = "for"
+		}
+		if a.value == nil {
+			continue
+		}
+		if v, ok := a.value.(bool); ok {
+			if v {
+				b.WriteString(" " + name)
+			}
+			continue
+		}
+		if reflect.ValueOf(a.value).Kind() == reflect.Func {
+			continue
+		}
+		b.WriteString(" " + name + "=\\"" + html.EscapeString(tnJsxString(a.value)) + "\\"")
+	}
+	if tnJsxVoidTags[tag] {
+		b.WriteString("/>")
+		return TnJsxNode(b.String())
+	}
+	b.WriteString(">")
+	b.WriteString(string(TnJsxChildren(children)))
+	b.WriteString("</" + tag + ">")
+	return TnJsxNode(b.String())
+}
+
+func TnJsxChildren(children []interface{}) TnJsxNode {
+	var b strings.Builder
+	for _, c := range children {
+		tnJsxWriteChild(&b, c)
+	}
+	return TnJsxNode(b.String())
+}
+
+// null / booleans render nothing; arrays render each item
+func tnJsxWriteChild(b *strings.Builder, c interface{}) {
+	switch v := c.(type) {
+	case nil, bool:
+		return
+	case TnJsxNode:
+		b.WriteString(string(v))
+		return
+	case string:
+		b.WriteString(html.EscapeString(v))
+		return
+	}
+	rv := reflect.ValueOf(c)
+	switch rv.Kind() {
+	case reflect.Slice:
+		for i := 0; i < rv.Len(); i++ {
+			tnJsxWriteChild(b, rv.Index(i).Interface())
+		}
+		return
+	case reflect.Pointer:
+		if !rv.IsNil() {
+			tnJsxWriteChild(b, rv.Elem().Interface())
+		}
+		return
+	}
+	b.WriteString(html.EscapeString(tnJsxString(c)))
+}
+
+func tnJsxString(v interface{}) string {
+	switch t := v.(type) {
+	case string:
+		return t
+	case TnJsxNode:
+		return string(t)
+	case float64:
+		return strconv.FormatFloat(t, 'f', -1, 64)
+	}
+	return fmt.Sprint(v)
+}`,
+    decorators: `// this inside plain functions: the receiver of the decorated method being called
+var TnThis interface{}
+
+// The context a decorator receives (kind is "method" or "class")
+type TnDecoratorContext struct {
+	kind    string
+	name    string
+	static  bool
+	private bool
+}
+
+// A method decorator's result replaces the method; undefined keeps it
+func TnDecorate(prev func(...interface{}) interface{}, result interface{}) func(...interface{}) interface{} {
+	if result == nil {
+		return prev
+	}
+	if f, ok := result.(func(...interface{}) interface{}); ok && f != nil {
+		return f
+	}
+	return prev
+}
+
+// Class decorators may not replace a class (a Go type)
+func TnDecorateClass(result interface{}) {
+	if result != nil {
+		panic("class decorators cannot replace the class")
+	}
+}`,
+    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)
@@ -8118,7 +10201,21 @@ function visitImportDeclaration(node) {
             const resolved = fileResolver(moduleSpec, currentFileDir);
             if (resolved) {
                 const goFileName = specifierToGoFileName(moduleSpec);
-                includeLocalImport(resolved.content, resolved.dir, goFileName);
+                includeLocalImport(resolved.content, resolved.dir, goFileName, !!resolved.tsx);
+            }
+        }
+        // Renamed bindings refer to the original declaration (one Go package)
+        const bindings = node.importClause?.namedBindings;
+        if (bindings && isNamespaceImport(bindings))
+            defaultImportNamespaces.add(bindings.name.text);
+        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 '';
@@ -8166,7 +10263,8 @@ function visitImportDeclaration(node) {
 // variables (a variable named `big` would shadow the package name)
 const goImportAliases = {
     'math/big': 'tnbig',
-    'net/url': 'tnurl'
+    'net/url': 'tnurl',
+    'golang.org/x/text/unicode/norm': 'tnnorm'
 };
 function goImportLine(pkg) {
     const alias = goImportAliases[pkg];