typenative 0.1.3 → 0.2.0

package/bin/transpiler.js

@@ -1,3 +1,46 @@
+import { createNodeRegistry } from './node/registry.js';
+import { registerPath } from './node/path.js';
+import { registerFs } from './node/fs.js';
+import { registerUrl } from './node/url.js';
+import { registerOs } from './node/os.js';
+import { registerChildProcess } from './node/child_process.js';
+import { registerReadline } from './node/readline.js';
+import { registerCore, registerConstants } from './node/core.js';
+import { registerBuffer } from './node/buffer.js';
+import { registerProcess } from './node/process.js';
+import { registerUtil } from './node/util.js';
+import { registerUtilExtra } from './node/util_extra.js';
+import { registerConsole } from './node/console.js';
+import { registerAssert } from './node/assert.js';
+import { registerPunycode } from './node/punycode.js';
+import { registerQuerystring } from './node/querystring.js';
+import { registerStringDecoder } from './node/string_decoder.js';
+import { registerCrypto } from './node/crypto.js';
+import { registerCryptoKeys } from './node/crypto_keys.js';
+import { registerZlib } from './node/zlib.js';
+import { registerTimers } from './node/timers.js';
+import { registerEvents } from './node/events.js';
+import { registerStream } from './node/stream.js';
+import { registerDiagnosticsChannel } from './node/diagnostics_channel.js';
+import { registerNet } from './node/net.js';
+import { registerDns } from './node/dns.js';
+import { registerHttp } from './node/http.js';
+import { registerTls } from './node/tls.js';
+import { registerDgram } from './node/dgram.js';
+import { registerSqlite } from './node/sqlite.js';
+import { registerFetch } from './node/fetch.js';
+import { registerStreamWeb } from './node/stream_web.js';
+import { registerAsyncHooks } from './node/async_hooks.js';
+import { registerTest } from './node/test.js';
+import { registerWorkerThreads } from './node/worker_threads.js';
+import { registerCluster } from './node/cluster.js';
+import { registerHttp2 } from './node/http2.js';
+import { registerSystemExtra } from './node/system_extra.js';
+import { goStdlib } from './go/stdlib.generated.js';
+import { goPackage, goTypeInfo as goMetaTypeInfo, hasGoPackage, isGoNumeric as isGoNumericType } from './go/metadata.js';
+import { bindConvertServices, initConvertPaths, isGoBasicKind, isGoNumericKind, toGo as toGoType, fromGo as fromGoType } from './go/convert.js';
+import { goPathAliases } from './go/overrides.js';
+import { bindBridgeServices, resetGoBridge, initKnownPaths, goLocalType, ensureGoTypePackages, registerGoBuiltin, registerGoImport, goQualifier, goPathOf, goMemberOf, visitGoCall, visitGoMethod, visitGoNew, inferGoType, goFieldType, isGoRefCall, goTupleTypes, goCallbackResultType, ensureGoQualifier } from './go/bridge.js';
 // Shim over the removed `typescript` import: predicates and kind names operate
 // on the normalized JSON AST ({kind: 'Xxx', ...} plain objects) produced by
 // src/parse-node.ts (Node) or the tsparser Go tool (self-hosted).
@@ -260,6 +303,8 @@ const mainPackageVariables = [];
 // True while emitting a separate Go file, whose top-level statements sit at package scope
 let emittingModuleFile = false;
 const importedPackages = new Set();
+// Side-effect `import 'go:time/tzdata'` packages, imported as `_`
+const goSideEffectImports = new Set();
 let outsideNodes = [];
 const classNames = new Set();
 let promiseResolveName = '';
@@ -305,7 +350,7 @@ const referenceArrays = new Set();
 function setVarGoType(name, goType) {
     if (!name)
         return;
-    if (goType && goType.startsWith('[]') && goType !== '[]interface{}') {
+    if (goType && goType.startsWith('[]') && goType !== '[]interface{}' && goType !== '[]byte') {
         variableGoTypes.set(name, `*${goType}`);
         referenceArrays.add(name);
         return;
@@ -795,17 +840,26 @@ export function transpileToNative(code, options) {
     fileResolver = options?.readFile ?? null;
     parseFunction = options?.parse ?? defaultParseFunction;
     currentFileIsTsx = !!options?.tsx;
+    consoleGroupsUsed = code.includes('console.group');
     declaredFunctions.clear();
     declaredInterfaces.clear();
     declaredTypeAliases.clear();
     variableTypeNodes.clear();
+    goRefVariables.clear();
     narrowedVariables.clear();
-    nodeCallResultTypes.clear();
+    bindNodeRegistryServices();
+    nodeLocalNames.clear();
+    goPackageLocalNames.clear();
+    resetGoBridge();
+    initKnownPaths();
+    initConvertPaths();
+    nodeParentClassKeys.clear();
     asyncFunctionNames.clear();
     generatorFunctionNames.clear();
     currentFileDir = null;
     const sourceFile = parseSource(code);
     importedPackages.clear();
+    goSideEffectImports.clear();
     outsideNodes = [];
     classNames.clear();
     promiseResolveName = '';
@@ -828,6 +882,7 @@ export function transpileToNative(code, options) {
     classGetterMethods.clear();
     classSetterMethods.clear();
     classIteratorMethods.clear();
+    seedNodeClassTables();
     declaredClasses.clear();
     classParentNames.clear();
     referenceArrays.clear();
@@ -838,25 +893,49 @@ export function transpileToNative(code, options) {
     const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
     // Keep the process alive until detached async work and timers settle
     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()');
+    // The event loop runs until no timers, async work or open handles remain
+    if (usedHelpers.has('eventLoop'))
+        drains.push('TnRunLoop()');
+    // process.exitCode
+    if (usedHelpers.has('nodeProcess'))
+        drains.push('TnProcessExit()');
     const drainCode = drains.length > 0 ? `\n\t${drains.join('\n\t')}` : '';
+    // Go bridge types are qualified by path internally (net/http.Cookie)
+    const mainCode = localizeGoPaths(transpiledCode);
+    const outsideCode = localizeGoPaths(transpiledCodeOutside);
+    const packageVariables = mainPackageVariables.map((v) => localizeGoPaths(v));
+    // Go bridge packages pulled in for a type that never got emitted
+    // (a method's result type, a param type needing no conversion) would be
+    // unused imports, which Go rejects.
+    const emitted = stripGoStrings(`${mainCode}\n${outsideCode}\n${packageVariables.join('\n')}`);
+    const helpersCode = emitGoHelpers();
+    const mainImports = [...importedPackages].filter((pkg) => {
+        if (!hasGoPackage(pkg))
+            return true;
+        const pkgName = goPathAliases[pkg] ?? pkg.split('/').pop();
+        return referencesQualifier(emitted, pkgName) || referencesQualifier(helpersCode, pkgName);
+    });
+    for (const pkg of goSideEffectImports) {
+        if (!mainImports.includes(pkg))
+            mainImports.push(pkg);
+    }
+    const importLine = (pkg) => goSideEffectImports.has(pkg) && !importedPackages.has(pkg)
+        ? `import _ "${pkg}"`
+        : goImportLine(pkg);
+    // process.on('uncaughtException'): a throw in the top-level code is handed to it too
+    const body = usedHelpers.has('nodeUncaught') ? `func() {\n\tdefer TnMainRecover()\n\t${mainCode.trim()}\n\t}()` : mainCode.trim();
     const main = `package main
 
-${[...importedPackages].sort().map((pkg) => goImportLine(pkg)).join('\n')}
+${mainImports.sort().map((pkg) => importLine(pkg)).join('\n')}
 
-${mainPackageVariables.join('\n')}
+${packageVariables.join('\n')}
 
 func main() {
-    ${transpiledCode.trim()}${drainCode}
+    ${body}${drainCode}
 }
 
-${transpiledCodeOutside.trim()}
-${emitGoHelpers()}`.trimEnd();
+${outsideCode.trim()}
+${helpersCode}`.trimEnd();
     return { main, files: localImportFiles };
 }
 export // Property map of an interface, including inherited properties (flattened —
@@ -919,10 +998,25 @@ function visit(node, options = {}) {
         }
         if (node.text === 'undefined')
             return 'nil';
+        // resolve / reject passed as values (setTimeout(resolve, ms)): closures over the channel
+        const isCallee = isCallExpression(node.parent) && node.parent.expression === node;
+        if (!isCallee && promiseResolveName && node.text === promiseResolveName) {
+            useHelper('promise');
+            return 'TnResolver(ch)';
+        }
+        if (!isCallee && promiseRejectName && node.text === promiseRejectName) {
+            useHelper('promise');
+            return 'TnRejecter(ch)';
+        }
         if (node.text === 'NaN' || node.text === 'Infinity') {
             importedPackages.add('math');
             return node.text === 'NaN' ? 'math.NaN()' : 'math.Inf(1)';
         }
+        if (nodeLocalNames.size > 0 || nodeRegistry.globals[node.text]) {
+            const nodeValue = visitNodeValue(node);
+            if (nodeValue !== undefined)
+                return nodeValue;
+        }
         const goAlias = importAliases.get(node.text);
         if (goAlias)
             return goAlias;
@@ -1049,6 +1143,11 @@ function visit(node, options = {}) {
         if (isStringLiteral(node.argumentExpression)) {
             return `${visit(node.expression)}[${visit(node.argumentExpression)}]`;
         }
+        // Buffer / Uint8Array elements read as numbers
+        if (targetType === '[]byte' && !isAssignmentTarget(node)) {
+            useHelper('dynamic');
+            return `float64(TnAt(${visit(node.expression)}, ${visit(node.argumentExpression)}))`;
+        }
         // Reading past the end of an array gives undefined in JS: the zero value here
         if (targetType?.startsWith('[]') && !isAssignmentTarget(node)) {
             useHelper('dynamic');
@@ -1057,9 +1156,28 @@ function visit(node, options = {}) {
         return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
     }
     else if (isPropertyAccessExpression(node)) {
+        if (isMockAccess(node)) {
+            nodeRegistry.helper('nodeTest');
+            return `TnMockOf(${visit(node.expression)})`;
+        }
+        if (isProcessEnv(node.expression) && !isCallee(node) && !isAssignmentTarget(node)) {
+            useHelper('getenv');
+            return `TnGetenv("${node.name.text}")`;
+        }
+        if (!isCallee(node) && !isAssignmentTarget(node)) {
+            const nodeValue = visitNodeValue(node);
+            if (nodeValue !== undefined)
+                return nodeValue;
+        }
         const regexProperty = visitRegexProperty(node);
         if (regexProperty)
             return regexProperty;
+        // Go package member or field on a Go value.
+        if (!isCallee(node) || isCallee(node)) {
+            const goProp = visitGoProperty(node);
+            if (goProp !== undefined)
+                return goProp;
+        }
         // import.meta.url — the file URL of the running program
         if (isNewTargetNode(node.expression) && node.name.text === 'name')
             return '__newTarget';
@@ -1137,20 +1255,34 @@ function visit(node, options = {}) {
         return getAcessString(leftSide, rightSide, objectType);
     }
     else if (isVariableDeclaration(node)) {
+        const nodeAlias = visitNodeAliasDeclaration(node);
+        if (nodeAlias !== undefined)
+            return nodeAlias;
         // Object destructuring: const { x, y } = obj
         if (isObjectBindingPattern(node.name) && node.initializer) {
-            const initExpr = visit(node.initializer);
+            let initExpr = visit(node.initializer);
             const initType = inferExpressionType(node.initializer);
             const parts = [];
+            // Evaluate the initializer once (const { a, b } = new X())
+            if ((node.name.elements ?? []).length > 1 && !isIdentifier(node.initializer)) {
+                const source = getTempName('src');
+                parts.push(`${source} := ${initExpr}`);
+                initExpr = source;
+            }
             for (const el of node.name.elements ?? []) {
                 const localName = visit(el.name);
                 const rawProp = el.propertyName ?? el.name;
                 const propName = isIdentifier(rawProp) ? rawProp.text : visit(rawProp);
+                const structName = initType ? initType.replace(/^\*/, '') : '';
+                // Struct literal fields, or the properties of a class (Node classes included)
                 const fieldType = initType
-                    ? getStructFieldGoType(initType.replace(/^\*/, ''), propName)
+                    ? (getStructFieldGoType(structName, propName) ?? classPropertyTypes.get(structName)?.get(propName))
                     : undefined;
                 const defaultVal = el.initializer;
-                if (defaultVal) {
+                if (!defaultVal && classGetterMethods.has(`${structName}.${propName}`)) {
+                    parts.push(`${localName} := (${initExpr}).Get_${goFieldName(propName)}()`);
+                }
+                else if (defaultVal) {
                     // Missing property (nil) takes the default
                     const defType = inferExpressionType(defaultVal) ?? fieldType ?? 'interface{}';
                     const tmp = getTempName('destructure');
@@ -1172,8 +1304,22 @@ function visit(node, options = {}) {
                 : visit(node.initializer);
             const tmpVar = getTempName('arr');
             const elemType = initGoType?.startsWith('[]') ? initGoType.slice(2) : undefined;
+            // Multi-value Go calls: each element asserts back to its own type
+            const tupleTypes = goTupleTypes(unwrapParentheses(node.initializer));
             const parts = [`${tmpVar} := ${initExpr}`];
             node.name.elements.forEach((el, idx) => {
+                const tupleType = tupleTypes?.[idx];
+                if (tupleType && !isOmittedExpression(el) && isIdentifier(el.name) && !el.initializer) {
+                    const localName = visit(el.name);
+                    if (localName === '_' || localName.startsWith('_')) {
+                        parts.push(`_ = ${tmpVar}`);
+                        return;
+                    }
+                    ensureGoTypePackages(tupleType);
+                    parts.push(`${localName} := ${tmpVar}[${idx}].(${goLocalType(tupleType)})`);
+                    registerLocalVariable(localName, tupleType);
+                    return;
+                }
                 if (isOmittedExpression(el))
                     return;
                 const bindEl = el;
@@ -1231,6 +1377,10 @@ function visit(node, options = {}) {
                 variableTypeNodes.set(node.name.text, node.type);
             else
                 variableTypeNodes.delete(node.name.text);
+            if (node.initializer && isGoRefCall(node.initializer))
+                goRefVariables.add(node.name.text);
+            else
+                goRefVariables.delete(node.name.text);
             if (node.type && !isInferredAny) {
                 variableGoTypes.set(node.name.text, getType(node.type));
             }
@@ -1309,7 +1459,8 @@ function visit(node, options = {}) {
         const packageType = type === ':' ? variableGoTypes.get(node.name.text) : type;
         if (isMainTopLevel && packageType && packageType !== 'nil' && isIdentifier(node.name)) {
             const name = getSafeName(node.name.text);
-            mainPackageVariables.push(`var ${name} ${packageType}`);
+            ensureGoTypePackages(packageType);
+            mainPackageVariables.push(`var ${name} ${goLocalType(packageType)}`);
             return initializer ? `${name} ${initializer}` : '';
         }
         const declName = isIdentifier(node.name) ? getSafeName(node.name.text) : visit(node.name);
@@ -1318,9 +1469,14 @@ function visit(node, options = {}) {
         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}`;
+            const initType = inferExpressionType(node.initializer) ?? '';
+            ensureGoTypePackages(initType);
+            return `var ${declName} ${goLocalType(initType)}\n\t\t${declName} ${initializer}`;
         }
-        return `${type === ':' ? '' : 'var '}${declName} ${type}${type === ':' ? '' : ' '}${initializer}`;
+        const emitType = type === ':' ? type : goLocalType(type);
+        if (type !== ':')
+            ensureGoTypePackages(type);
+        return `${type === ':' ? '' : 'var '}${declName} ${emitType}${type === ':' ? '' : ' '}${initializer}`;
     }
     else if (isCallExpression(node)) {
         if (hasQuestionDot(node) ||
@@ -1333,6 +1489,26 @@ function visit(node, options = {}) {
                 return visitNullablePrimitiveOptionalCall(node, visit(node.expression.expression), receiverType);
             }
         }
+        const nodeCall = visitNodeCall(node);
+        if (nodeCall !== undefined)
+            return nodeCall;
+        const goCall = visitGoCall(node);
+        if (goCall !== undefined)
+            return goCall;
+        // Method call on a Go-typed receiver (pkg.Type value).
+        if (isPropertyAccessExpression(node.expression)) {
+            const recvType = inferExpressionType(node.expression.expression);
+            if (recvType && recvType.startsWith('chan ')) {
+                const chanCall = visitGoChanCall(node, visit(node.expression.expression));
+                if (chanCall !== undefined)
+                    return chanCall;
+            }
+            if (recvType && goMetaTypeInfo(recvType)) {
+                const goMethod = visitGoMethod(node, visit(node.expression.expression), recvType);
+                if (goMethod !== undefined)
+                    return goMethod;
+            }
+        }
         const recordCall = visitRecordFunctionCall(node);
         if (recordCall)
             return recordCall;
@@ -1387,7 +1563,12 @@ function visit(node, options = {}) {
                 const recv = visit(node.expression.expression);
                 const cbs = (node.arguments ?? []).map((a) => visit(a));
                 const cbExpr = cbs[0] ?? 'func(interface{}) {}';
-                return `__tnWaitGroup.Add(1)\n\t\tgo func() {\n\t\t\tdefer __tnWaitGroup.Done()\n\t\t\t__v := <-(${recv})\n\t\t\t(${cbExpr})(__v)\n\t\t}()`;
+                useHelper('eventLoop');
+                // A callback without parameters (then(() => …)) takes no value
+                const takesValue = !(cb && (isArrowFunction(cb) || isFunctionExpression(cb)) && (cb.parameters ?? []).length === 0);
+                const receive = takesValue ? `__v := <-(${recv})` : `<-(${recv})`;
+                const invoke = takesValue ? `(${cbExpr})(__v)` : `(${cbExpr})()`;
+                return `__tnWaitGroup.Add(1)\n\t\tgo func(__tnCtx TnAsyncContext) {\n\t\t\t${receive}\n\t\t\tTnLoopPost(func() {\n\t\t\t\tdefer __tnWaitGroup.Done()\n\t\t\t\tTnAsyncRun(__tnCtx, func() { ${invoke} })\n\t\t\t})\n\t\t}(TnAsyncSnapshot())`;
             }
         }
         // Array.from(arrayLike, mapFn) — array-likes are { length } structs
@@ -1453,6 +1634,19 @@ function visit(node, options = {}) {
             useHelper('dynamic');
             return `float64(^TnInt32(${visit(node.operand)}))`;
         }
+        // -10n / -x on bigints (*big.Int)
+        if (node.operator === 'MinusToken' && node.operand.kind === 'BigIntLiteral') {
+            useHelper('bigint');
+            return `TnBigInt("-${String(node.operand.text).replace(/n$/, '')}")`;
+        }
+        if (node.operator === 'MinusToken' && inferExpressionType(node.operand) === '*tnbig.Int') {
+            return `new(tnbig.Int).Neg(${visit(node.operand)})`;
+        }
+        // -0: Go constant arithmetic has no negative zero
+        if (node.operator === 'MinusToken' && isNumericLiteral(node.operand) && Number(node.operand.text) === 0) {
+            importedPackages.add('math');
+            return 'math.Copysign(0, -1)';
+        }
         return `${getOperatorText(node.operator)}${visit(node.operand)}`;
     }
     else if (isPostfixUnaryExpression(node)) {
@@ -1480,11 +1674,22 @@ function visit(node, options = {}) {
         if (node.operatorToken.kind === 'QuestionQuestionToken') {
             return visitNullishCoalescingExpression(node);
         }
+        if (node.operatorToken.kind === 'InstanceOfKeyword' &&
+            isIdentifier(node.right) &&
+            (node.right.text === 'Error' || BUILTIN_ERROR_NAMES.has(node.right.text)) &&
+            !classNames.has(node.right.text)) {
+            useHelper('error');
+            return `TnIsErrorOf(${visit(node.left)}, ${toGoStringLiteral(node.right.text)})`;
+        }
         if (node.operatorToken.kind === 'InstanceOfKeyword' && isIdentifier(node.right)) {
             // x instanceof C: the runtime type is C's pointer type
             return `func() bool { _, ok := interface{}(${visit(node.left)}).(*${getSafeName(node.right.text)}); return ok }()`;
         }
         if (node.operatorToken.kind === 'InKeyword') {
+            if (isProcessEnv(node.right)) {
+                useHelper('nodeProcess');
+                return `TnHasEnv(${visit(node.left)})`;
+            }
             if (isDynamicValue(node.right)) {
                 useHelper('dynamic');
                 return `TnHas(${visit(node.right)}, ${visit(node.left)})`;
@@ -1527,8 +1732,22 @@ function visit(node, options = {}) {
         const bigRight = inferExpressionType(node.right);
         if (bigLeft === '*tnbig.Int' || bigRight === '*tnbig.Int') {
             useHelper('bigint');
-            const bl = visit(node.left);
-            const br = visit(node.right);
+            let bl = visit(node.left);
+            let br = visit(node.right);
+            // number | bigint values (node:sqlite's changes): === is true only for an
+            // equal bigint; other operators convert the dynamic side
+            const dynamicSide = bigLeft === 'interface{}' ? bl : bigRight === 'interface{}' ? br : '';
+            if (dynamicSide) {
+                const bigSide = dynamicSide === bl ? br : bl;
+                if (op === '==')
+                    return `TnBigSame(${dynamicSide}, ${bigSide})`;
+                if (op === '!=')
+                    return `!TnBigSame(${dynamicSide}, ${bigSide})`;
+                if (dynamicSide === bl)
+                    bl = `TnToBigInt(${bl})`;
+                else
+                    br = `TnToBigInt(${br})`;
+            }
             if (op === '==')
                 return `${bl}.Cmp(${br}) == 0`;
             if (op === '!=')
@@ -1558,6 +1777,19 @@ function visit(node, options = {}) {
             importedPackages.add('math');
             return `math.Pow(${visit(node.left)}, ${visit(node.right)})`;
         }
+        // Named Go numerics (time.Duration): coerce the float64 side so Go's
+        // operator type-checks (time.Second * 2 → time.Second * time.Duration(2)).
+        if (['<', '>', '<=', '>=', '-', '*', '/', '+', '+=', '-=', '*=', '/='].includes(op)) {
+            const numericCoercion = visitGoNumericArithmetic(node, op);
+            if (numericCoercion)
+                return numericCoercion;
+        }
+        // x.Kind() === reflect.String: the method result reads as a number
+        if (op === '==' || op === '!=') {
+            const numericEquality = visitGoNumericArithmetic(node, op);
+            if (numericEquality)
+                return numericEquality;
+        }
         if (op === '**=') {
             importedPackages.add('math');
             const target = visit(node.left);
@@ -1620,6 +1852,17 @@ function visit(node, options = {}) {
             const other = isNewTargetNode(node.left) ? node.right : node.left;
             return `__newTarget ${op} ${isIdentifier(other) ? toGoStringLiteral(other.text) : '""'}`;
         }
+        const nodeAssignment = visitNodeAssignment(node);
+        if (nodeAssignment !== undefined)
+            return nodeAssignment;
+        const goFieldAssignment = visitGoFieldAssignment(node, op);
+        if (goFieldAssignment !== undefined)
+            return goFieldAssignment;
+        // buf[i] = v on a Buffer / Uint8Array: bytes wrap modulo 256
+        if (op === '=' && isElementAccessExpression(node.left) && inferExpressionType(node.left.expression) === '[]byte') {
+            useHelper('buffer');
+            return `${visit(node.left.expression)}[int(${visit(node.left.argumentExpression)})] = TnByte(${visit(node.right)})`;
+        }
         // obj[key] = v on any
         if (op === '=' && isElementAccessExpression(node.left) && isDynamicValue(node.left.expression)) {
             useHelper('dynamic');
@@ -1699,11 +1942,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)}`;
+        // Promises are channels: TnAwait keeps the event loop running while it waits
+        // (a bare receive would block it, e.g. in async callbacks)
+        useHelper('promise');
+        return `TnAwait(${visit(node.expression)})`;
     }
     else if (isVariableDeclarationList(node)) {
         return ((node.declarations ?? []).map((n) => visit(n)).join(options.inline ? ';' : ';\n\t') +
@@ -1718,7 +1960,7 @@ function visit(node, options = {}) {
             !emittingModuleFile) {
             useHelper('asyncWait');
             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 `__tnWaitGroup.Add(1)\n\t\tTnDetach(${visit(exprStmt)});\n\t`;
         }
         return visit(node.expression) + (options.inline ? '' : ';\n\t');
     }
@@ -1748,10 +1990,17 @@ function visit(node, options = {}) {
             iterNode.arguments.length > 0) {
             iterNode = iterNode.arguments[0];
         }
-        const iterExpr = isDynamicValue(iterNode)
+        let iterExpr = isDynamicValue(iterNode)
             ? toGoValueOfType(iterNode, '[]interface{}')
             : visit(iterNode, { inline: true });
-        const iterType = inferExpressionType(iterNode);
+        let iterType = inferExpressionType(iterNode);
+        // Node class instances iterate through their iterator method (URLSearchParams → entries())
+        const nodeIterator = iterType ? nodeRegistry.iterators[iterType] : undefined;
+        if (iterType && nodeIterator) {
+            const cls = nodeRegistry.classes[nodeRegistry.classByGoType[iterType]];
+            iterExpr = `${iterExpr}.${nodeIterator}()`;
+            iterType = cls?.methods[nodeIterator] ?? iterType;
+        }
         if (iterType && iterType.startsWith('*TnMap[')) {
             const valueType = extractMapValueType(iterType);
             const isSet = valueType === 'struct{}';
@@ -1861,7 +2110,13 @@ function visit(node, options = {}) {
         const enclosingFn = getEnclosingFunction(node);
         const isAsync = enclosingFn?.modifiers?.some((m) => m.kind === 'AsyncKeyword');
         const returnGoType = enclosingFn && !isAsync ? inferFunctionBodyReturnType(enclosingFn) : undefined;
-        const value = node.expression ? toGoValueOfType(node.expression, returnGoType) : '';
+        // TS closures passed as Go callbacks return the Go result type
+        const goCallbackResult = enclosingFn ? goCallbackResultType(enclosingFn) : undefined;
+        const value = !node.expression
+            ? ''
+            : goCallbackResult !== undefined
+                ? toGoType(visit(node.expression), inferExpressionType(node.expression) ?? '', goCallbackResult)
+                : toGoValueOfType(node.expression, returnGoType);
         const terminator = options.inline ? '' : ';\n\t';
         if (tryReturn && enclosingFn === tryReturn.fn)
             return tryAwareReturn(value) + terminator;
@@ -1918,7 +2173,11 @@ function visit(node, options = {}) {
         if (!isBlock(node.body)) {
             // void-style calls (console.*, assert) emit statements, not values
             if (isVoidStatementCall(node.body) || !inferredRetType) {
-                return `func(${parameterInfo.signature})${returnType} { ${visit(node.body)}; }`;
+                // `(c) => (body += c)`: the parenthesized expression is a statement
+                let statement = node.body;
+                while (statement.kind === 'ParenthesizedExpression')
+                    statement = statement.expression;
+                return `func(${parameterInfo.signature})${returnType} { ${visit(statement)}; }`;
             }
             return `func(${parameterInfo.signature})${returnType} { return ${visit(node.body)}; }`;
         }
@@ -2090,7 +2349,7 @@ function visit(node, options = {}) {
             let parentClassName = null;
             for (const clause of node.heritageClauses ?? []) {
                 if (clause.token === 'ExtendsKeyword') {
-                    parentClassName = visit(clause.types[0].expression);
+                    parentClassName = nodeParentGoName(clause.types[0].expression) || visit(clause.types[0].expression);
                 }
             }
             if (parentClassName && parentClassName !== 'Error') {
@@ -2126,13 +2385,14 @@ function visit(node, options = {}) {
         if ((node.heritageClauses ?? [])) {
             for (const clause of (node.heritageClauses ?? [])) {
                 if (clause.token === 'ExtendsKeyword') {
-                    parentClass = visit(clause.types[0].expression);
+                    parentClass = nodeParentGoName(clause.types[0].expression) || visit(clause.types[0].expression);
                 }
             }
         }
         const extendsError = parentClass === 'Error';
         if (extendsError)
             useHelper('error');
+        applyNodeHookTypes(parentClass, node);
         if (parentClass && !extendsError)
             classParentNames.set(name, parentClass);
         const isAbstractClass = (node.modifiers ?? []).some((m) => m.kind === 'AbstractKeyword');
@@ -2184,7 +2444,7 @@ function visit(node, options = {}) {
             const parentInit = parentClass && !extendsError && !superCalledInCtor
                 ? `self.${goFieldName(parentClass)} = *${parentConstructorCall(parentClass, [])}\n\t\t`
                 : '';
-            const ctorBody = `{\n\t\tself := &${name}${typeParamNames}{}\n\t\t${ctorParameterInfo.prefixBlockContent}${parentInit}${fieldInitializers(node)}${parameterAssignments}${bodyStatements}return self;\n\t}`;
+            const ctorBody = `{\n\t\tself := &${name}${typeParamNames}{}\n\t\t${nodeSelfLink(parentClass)}${ctorParameterInfo.prefixBlockContent}${parentInit}${fieldInitializers(node)}${parameterAssignments}${bodyStatements}${nodeSelfLink(parentClass, node)}return self;\n\t}`;
             result += emitConstructor(name, typeParams, typeParamNames, ctorParameterInfo.signature, ctorBody);
         }
         else if (extendsError) {
@@ -2193,7 +2453,7 @@ function visit(node, options = {}) {
         }
         else {
             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}`;
+            const ctorBody = `{\n\t\tself := &${name}${typeParamNames}{}\n\t\t${parentInit}${fieldInitializers(node)}${nodeSelfLink(parentClass, node)}return self\n\t}`;
             result += emitConstructor(name, typeParams, typeParamNames, '', ctorBody);
         }
         // Inherited concrete methods are copied onto the subclass: Go embedding
@@ -2342,6 +2602,16 @@ function visit(node, options = {}) {
         return result.trim();
     }
     else if (isNewExpression(node)) {
+        const nodeNew = visitNodeNew(node);
+        if (nodeNew !== undefined)
+            return nodeNew;
+        const goTarget = goNewTarget(node);
+        if (goTarget) {
+            importedPackages.add(goTarget.path);
+            const goNew = visitGoNew(node, goTarget.path, goTarget.typeName);
+            if (goNew !== undefined)
+                return goNew;
+        }
         const className = visit(node.expression);
         if (className === 'Promise') {
             return visitNewPromise(node);
@@ -2365,17 +2635,25 @@ function visit(node, options = {}) {
         if (className === 'Set') {
             return visitNewSet(node);
         }
+        // new TypeError(message) & co.: a TnError with that name
+        if (BUILTIN_ERROR_NAMES.has(className) && !classNames.has(className)) {
+            useHelper('error');
+            const msg = (node.arguments ?? [])[0] ? visit(node.arguments[0]) : '""';
+            return withErrorOptions(`TnNodeError(${toGoStringLiteral(className)}, "", ${msg})`, (node.arguments ?? [])[1]);
+        }
         // new Error(message) → a TnError value with a .message
         if (className === 'Error') {
             useHelper('error');
             const msg = (node.arguments ?? [])[0] ? visit(node.arguments[0]) : '""';
-            return `TnNewError(${msg})`;
+            return withErrorOptions(`TnNewError(${msg})`, (node.arguments ?? [])[1]);
         }
         // new Date() / new Date(ms) → Go time
         if (className === 'Date') {
             importedPackages.add('time');
-            if ((node.arguments ?? []).length === 0)
-                return 'time.Now()';
+            if ((node.arguments ?? []).length === 0) {
+                useHelper('clock');
+                return 'TnTimeNow()';
+            }
             return `time.UnixMilli(int64(${visit(node.arguments[0])})).UTC()`;
         }
         // new Array<number>(3) → make([]float64, 3)
@@ -2509,6 +2787,8 @@ function toGoValueOfType(expr, goType) {
     }
     // Array reference slots (*[]T): literals take an address, aliases pass through
     if (goType && goType.startsWith('*[]')) {
+        // Go bridge element types are qualified (*[]io/fs.DirEntry)
+        goType = goLocalType(goType);
         if (isIdentifier(expr) && referenceArrays.has(expr.text)) {
             return getSafeName(expr.text);
         }
@@ -2519,6 +2799,14 @@ function toGoValueOfType(expr, goType) {
                 ? `&${code}`
                 : `func() ${goType} { __v := ${code}; return &__v }()`;
         }
+        // (x as string[]) on an any value, or (rows as Row[]) on an array of any
+        // values (node:sqlite's all()): convert, then box
+        const castSource = isAsExpression(expr) ? expr.expression : expr;
+        const dynamicElements = goType !== '*[]interface{}' && inferExpressionType(castSource) === '[]interface{}';
+        if (isDynamicValue(castSource) || dynamicElements) {
+            useHelper('dynamic');
+            return `func() ${goType} { __v := TnAs[${goType.slice(1)}](${visit(castSource)}); return &__v }()`;
+        }
         return `func() ${goType} { __v := ${visit(expr)}; return &__v }()`;
     }
     const code = visit(expr);
@@ -2592,10 +2880,13 @@ function isProcessEnv(expr) {
     while (isParenthesizedExpression(expr) || isAsExpression(expr) || isNonNullExpression(expr)) {
         expr = expr.expression;
     }
-    return (isPropertyAccessExpression(expr) &&
+    if (isPropertyAccessExpression(expr) &&
         isIdentifier(expr.expression) &&
         expr.expression.text === 'process' &&
-        expr.name.text === 'env');
+        expr.name.text === 'env') {
+        return true;
+    }
+    return resolveNodeKey(expr) === 'process.env';
 }
 // Whether an expression is (part of) an optional chain: a?.b, a?.b(), a?.b().c
 function isOptionalChain(expr) {
@@ -2765,18 +3056,41 @@ function visitUsingDeclaration(statement, rest) {
         return head + visitBlockStatements(rest);
     return `func() {\n\t\t${head}${visitBlockStatements(rest)}}()\n\t`;
 }
+// Binary arithmetic with a bridged named numeric: coerce the float64 side.
+function visitGoNumericArithmetic(node, op) {
+    const leftType = inferExpressionType(node.left);
+    const rightType = inferExpressionType(node.right);
+    const leftNumeric = leftType && isGoNumericType(leftType) ? leftType : undefined;
+    const rightNumeric = rightType && isGoNumericType(rightType) ? rightType : undefined;
+    if (!leftNumeric && !rightNumeric)
+        return undefined;
+    if (leftNumeric && rightNumeric)
+        return undefined;
+    const numericType = leftNumeric ?? rightNumeric;
+    if (!numericType)
+        return undefined;
+    const left = leftNumeric ? visit(node.left) : `${numericType}(${visit(node.left)})`;
+    const right = rightNumeric ? visit(node.right) : `${numericType}(${visit(node.right)})`;
+    if (['+=', '-=', '*=', '/='].includes(op)) {
+        const target = visit(node.left);
+        const baseOp = op.slice(0, -1);
+        return `${target} = ${left} ${baseOp} ${right}`;
+    }
+    return `${left} ${op} ${right}`;
+}
 function visitDynamicArithmetic(node, op) {
     const leftDynamic = isDynamicValue(node.left);
     const rightDynamic = isDynamicValue(node.right);
     if (!leftDynamic && !rightDynamic)
         return undefined;
-    const isConcat = op === '+' && [node.left, node.right].some((side) => inferExpressionType(side) === 'string');
+    const isConcat = (op === '+' || op === '+=') && [node.left, node.right].some((side) => inferExpressionType(side) === 'string');
     const operand = (side, dynamic) => {
         if (!dynamic)
             return visit(side);
         if (isConcat) {
-            importedPackages.add('fmt');
-            return `fmt.Sprint(${visit(side)})`;
+            // String(x) as JS renders it (Buffers decode, numbers in JS notation)
+            useHelper('dynamic');
+            return `TnJSString(${visit(side)})`;
         }
         useHelper('dynamic');
         return `TnAs[float64](${visit(side)})`;
@@ -2886,6 +3200,10 @@ function getStructFieldGoType(structType, field) {
 function jsStringOf(code, goType) {
     if (goType === 'string')
         return code;
+    if (goType === '[]byte') {
+        useHelper('buffer');
+        return `TnBufferToString(${code}, "")`;
+    }
     if (goType === 'float64') {
         useHelper('dynamic');
         return `TnNumStr(${code})`;
@@ -2894,10 +3212,27 @@ function jsStringOf(code, goType) {
         importedPackages.add('strconv');
         return `strconv.FormatBool(${code})`;
     }
+    if (goType === 'interface{}') {
+        useHelper('dynamic');
+        useHelper('error');
+        return `TnJSString(${code})`;
+    }
+    // Node classes with a toString() (MIMEType, X509Certificate, …)
+    const nodeKey = goType ? nodeRegistry.classByGoType[goType] : undefined;
+    if (nodeKey && 'toString' in nodeRegistry.classes[nodeKey].methods)
+        return `${code}.toString()`;
     importedPackages.add('fmt');
     return `fmt.Sprintf("%v", ${code})`;
 }
 // JS bitwise operators work on 32-bit integers (ToInt32 / ToUint32)
+// Go-typed numeric operands (typed constants like x509.KeyUsageCertSign,
+// int fields) read as float64 so the TnInt32 helpers accept them
+function asFloatOperand(node, code) {
+    const goType = inferExpressionType(node);
+    if (goType && goType !== 'float64' && isGoNumericKind(goType))
+        return `float64(${code})`;
+    return code;
+}
 function visitBitwise(node, op) {
     const kind = node.operatorToken.kind;
     const base = {
@@ -2918,8 +3253,8 @@ function visitBitwise(node, op) {
     if (!bitOp)
         return undefined;
     useHelper('dynamic');
-    const left = visit(node.left);
-    const right = visit(node.right);
+    const left = asFloatOperand(node.left, visit(node.left));
+    const right = asFloatOperand(node.right, visit(node.right));
     let value;
     if (bitOp === '>>>')
         value = `float64(TnUint32(${left}) >> (TnUint32(${right}) & 31))`;
@@ -2938,6 +3273,10 @@ function visitDelete(node) {
     const key = isPropertyAccessExpression(target)
         ? toGoStringLiteral(target.name.text)
         : visit(target.argumentExpression);
+    if (isProcessEnv(object)) {
+        importedPackages.add('os');
+        return `func() bool { os.Unsetenv(${key}); return true }()`;
+    }
     const objectType = inferExpressionType(object);
     if (objectType?.startsWith('*TnMap['))
         return `${visit(object)}.Delete(${key})`;
@@ -2990,7 +3329,60 @@ 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
+// Subclass instances of Node classes with overridable methods register
+// themselves on the embedded struct (`self.TnTransform.tnSelf = self`)
+function nodeSelfLink(parentClass, classNode) {
+    if (!parentClass || !nodeParentClassKeys.has(parentClass))
+        return '';
+    const key = nodeParentClassKeys.get(parentClass) ?? '';
+    const cls = nodeRegistry.classes[key];
+    if (!cls || !('tnSelf' in cls.props))
+        return '';
+    let code = `self.${parentClass}.tnSelf = self\n\t\t`;
+    // Overridden hook methods (_transform …) are registered on the embedded struct
+    if (classNode && nodeRegistry.hookPrefixes[key]) {
+        for (const member of classNode.members ?? []) {
+            if (!isMethodDeclaration(member) || !member.name || !isIdentifier(member.name))
+                continue;
+            const name = member.name.text;
+            if (name in nodeRegistry.hookParams)
+                code += `self.${parentClass}.setHook(${toGoStringLiteral(name)}, self.${name})\n\t\t`;
+        }
+    }
+    return code;
+}
+// Hook methods of subclasses of Node classes take the hooks' parameter types
+function applyNodeHookTypes(parentClass, classNode) {
+    if (!parentClass || !nodeParentClassKeys.has(parentClass))
+        return;
+    if (!nodeRegistry.hookPrefixes[nodeParentClassKeys.get(parentClass) ?? ''])
+        return;
+    for (const member of classNode.members ?? []) {
+        if (!isMethodDeclaration(member) || !member.name || !isIdentifier(member.name))
+            continue;
+        const name = member.name.text;
+        if (name in nodeRegistry.hookParams)
+            member.tnParamTypes = nodeRegistry.hookParams[name];
+    }
+}
+// class X extends EventEmitter: the parent is a Node helper struct
+const nodeParentClassKeys = new Map();
+function nodeParentGoName(expr) {
+    const key = resolveNodeKey(expr);
+    const cls = key ? nodeRegistry.classes[key] : undefined;
+    if (!cls || !cls.goType.startsWith('*') || !nodeRegistry.constructors[key])
+        return '';
+    const goName = cls.goType.slice(1);
+    nodeParentClassKeys.set(goName, key);
+    return goName;
+}
 function parentConstructorCall(parentClass, args) {
+    if (nodeParentClassKeys.has(parentClass)) {
+        const key = nodeParentClassKeys.get(parentClass) ?? '';
+        const call = { args, nodes: [], types: args.map(() => ''), recv: '' };
+        const ctor = nodeRegistry.constructors[key](call);
+        return ctor;
+    }
     if (!usesNewTarget(parentClass))
         return `New${parentClass}(${args.join(', ')})`;
     return `new${parentClass}As(${['__newTarget', ...args].join(', ')})`;
@@ -3139,6 +3531,9 @@ function toFieldGoType(goType) {
     return !goType || goType === 'nil' ? 'interface{}' : goType;
 }
 function isDictionaryLiteral(node) {
+    // Keys that are not Go identifiers ('Content-Type') can't be struct fields
+    if (hasNonIdentifierKeys(node))
+        return true;
     const declaration = node.parent;
     if (!isVariableDeclaration(declaration) || !isIdentifier(declaration.name))
         return false;
@@ -3153,6 +3548,24 @@ function isDictionaryLiteral(node) {
         n.expression.text === name &&
         !isStringLiteral(n.argumentExpression));
 }
+function hasNonIdentifierKeys(node) {
+    if (!isObjectLiteralExpression(node))
+        return false;
+    let sawKey = false;
+    for (const p of node.properties ?? []) {
+        if (!isPropertyAssignment(p)) {
+            if (p.kind === 'SpreadAssignment' || isMethodDeclaration(p) || isGetAccessor(p) || isSetAccessor(p))
+                return false;
+            continue;
+        }
+        // Go identifiers have no `$` ({ $id: 1 }, node:sqlite's named parameters)
+        if (isStringLiteral(p.name) && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(p.name.text))
+            sawKey = true;
+        if (isIdentifier(p.name) && p.name.text.includes('$'))
+            sawKey = true;
+    }
+    return sawKey;
+}
 function containsNode(root, predicate) {
     for (const child of childNodes(root)) {
         if (predicate(child) || containsNode(child, predicate))
@@ -3253,6 +3666,9 @@ function getAsExpressionType(node) {
         return inferExpressionType(node.expression) ?? 'interface{}';
     }
     const target = getType(node.type);
+    // (x as File): dynamic values holding Node class instances assert to them
+    if (nodeRegistry.classByGoType[target])
+        return target;
     if (isDynamicValue(node.expression) && (isStructGoType(target) || target.startsWith('*'))) {
         return 'interface{}';
     }
@@ -3554,6 +3970,8 @@ function getMemberTypeNode(typeNode, name) {
 // (TypeScript's "contextual type"), derived syntactically from declarations
 // Declared type nodes of variables/parameters in scope (latest declaration wins)
 const variableTypeNodes = new Map();
+// Variables initialized by go:builtin ref<T>() (their `.value` dereferences)
+const goRefVariables = new Set();
 // Declared type (as a type node) of an assignable expression, when known
 function getExpressionTypeNode(expr) {
     if (isIdentifier(expr))
@@ -3890,16 +4308,43 @@ function inferFunctionBodyReturnType(node) {
     if (contextualFn?.type)
         return getType(contextualFn.type);
     if (isArrowFunction(node) && !isBlock(node.body)) {
-        return inferExpressionType(node.body);
+        const bodyType = inferExpressionType(node.body);
+        // `() => undefined`: nil is not a Go type
+        return bodyType === 'nil' ? 'interface{}' : bodyType;
     }
     if (node.body && isBlock(node.body)) {
-        for (const stmt of node.body.statements) {
+        let returnsNil = false;
+        for (const stmt of node.body.statements ?? []) {
             if (isReturnStatement(stmt) && stmt.expression) {
                 const exprType = inferExpressionType(stmt.expression);
-                if (exprType)
+                if (exprType === 'nil')
+                    returnsNil = true;
+                else if (exprType)
                     return exprType;
             }
         }
+        if (returnsNil)
+            return 'interface{}';
+    }
+    return undefined;
+}
+function getEnclosingParameterType(expr) {
+    const primitives = ['NumberKeyword', 'StringKeyword', 'BooleanKeyword', 'BigIntKeyword'];
+    for (let node = expr.parent; node; node = node.parent) {
+        if (!isArrowFunction(node) && !isFunctionExpression(node) && node.kind !== 'FunctionDeclaration' && !isMethodDeclaration(node)) {
+            continue;
+        }
+        const param = (node.parameters ?? []).find((p) => isIdentifier(p.name) && p.name.text === expr.text);
+        if (!param)
+            continue;
+        if (!param.type || param.questionToken || param.initializer)
+            return undefined;
+        // ...values: number[] reads as []float64 in the body
+        if (param.dotDotDotToken) {
+            const elem = param.type.kind === 'ArrayType' ? param.type.elementType : undefined;
+            return elem && primitives.includes(elem.kind) ? `[]${getType(elem)}` : undefined;
+        }
+        return primitives.includes(param.type.kind) ? getParameterGoType(param) : undefined;
     }
     return undefined;
 }
@@ -3916,7 +4361,15 @@ function inferArrowFunctionGoType(node) {
     const retType = inferFunctionBodyReturnType(node);
     return `func(${params})${retType ? ` ${retType}` : ''}`;
 }
+// fn.mock on a function value: the call record of a node:test mock (functions have no fields in Go)
+function isMockAccess(node) {
+    if (!isPropertyAccessExpression(node) || node.name.text !== 'mock' || !nodeRegistry.modules['test'])
+        return false;
+    return !!inferExpressionType(node.expression)?.startsWith('func(');
+}
 function inferExpressionType(expr) {
+    if (isMockAccess(expr))
+        return '*TnMockFunctionContext';
     if (isAwaitExpression(expr)) {
         // await unwraps the promise channel
         const inner = inferExpressionType(expr.expression);
@@ -3935,6 +4388,12 @@ function inferExpressionType(expr) {
         return getAsExpressionType(expr);
     if (isTypeAssertionExpression(expr))
         return getType(expr.type);
+    const nodeType = inferNodeExpressionType(expr);
+    if (nodeType !== undefined)
+        return nodeType === '' ? undefined : nodeType;
+    const goType = inferGoExpressionType(expr);
+    if (goType !== undefined)
+        return goType;
     if (isStringLiteral(expr) ||
         isNoSubstitutionTemplateLiteral(expr) ||
         isTemplateExpression(expr)) {
@@ -3954,6 +4413,14 @@ function inferExpressionType(expr) {
         return 'TnJsxNode';
     if (expr.kind === 'TaggedTemplateExpression' && isStringRawTag(expr.tag))
         return 'string';
+    // sql`…` with a Node class method as the tag (node:sqlite's tag store)
+    if (expr.kind === 'TaggedTemplateExpression' && isPropertyAccessExpression(expr.tag)) {
+        const recvType = inferExpressionType(expr.tag.expression);
+        const cls = recvType ? nodeRegistry.classes[nodeRegistry.classByGoType[recvType]] : undefined;
+        const result = cls?.methods[expr.tag.name.text];
+        if (result)
+            return result;
+    }
     if (isRegularExpressionLiteral(expr)) {
         const lastSlash = expr.text.lastIndexOf('/');
         if (needsStatefulRegex(expr.text.substring(1, lastSlash), expr.text.substring(lastSlash + 1))) {
@@ -3971,6 +4438,12 @@ function inferExpressionType(expr) {
     if (isIdentifier(expr) && expr.text === 'undefined')
         return 'nil';
     if (isIdentifier(expr)) {
+        // A primitive-typed parameter of an enclosing function: its annotation,
+        // not a same-named variable registered earlier (inferring the return type
+        // of an arrow before it is visited)
+        const enclosingParamType = getEnclosingParameterType(expr);
+        if (enclosingParamType)
+            return enclosingParamType;
         let varType = variableGoTypes.get(expr.text);
         // Array references are read as the slice they point to
         if (varType?.startsWith('*[]'))
@@ -3986,7 +4459,7 @@ function inferExpressionType(expr) {
         const ctorName = expr.expression.text;
         if (classNames.has(ctorName))
             return `*${ctorName}`;
-        if (ctorName === 'Error')
+        if (ctorName === 'Error' || (BUILTIN_ERROR_NAMES.has(ctorName) && !classNames.has(ctorName)))
             return '*TnError';
         if (ctorName === 'Promise' && (expr.typeArguments ?? []).length > 0) {
             return `chan ${getType(expr.typeArguments[0]) || 'struct{}'}`;
@@ -4076,13 +4549,10 @@ function inferExpressionType(expr) {
             if (fn)
                 return `chan ${getGeneratorYieldType(fn)}`;
         }
-        const nodeResultType = callee ? nodeCallResultTypes.get(callee) : undefined;
         if (callee && BUILTIN_CALL_TYPES[callee])
             return BUILTIN_CALL_TYPES[callee];
         if (callee?.startsWith('Math.'))
             return 'float64';
-        if (nodeResultType)
-            return nodeResultType;
     }
     // Object.keys(map) / Object.values(map)
     if (isCallExpression(expr) &&
@@ -4181,6 +4651,15 @@ function inferExpressionType(expr) {
         const leftType = inferExpressionType(expr.expression);
         if (expr.name.text === 'length')
             return 'float64';
+        // record.key reads the Record's value type
+        if (leftType?.startsWith('*TnMap[') && expr.name.text !== 'size' && !isCallee(expr)) {
+            const objectType = resolveExpressionType(expr.expression);
+            if (objectType === 'Record' || objectType === 'Map' || objectType === undefined) {
+                const valueType = extractMapValueType(leftType);
+                if (valueType !== 'struct{}')
+                    return valueType;
+            }
+        }
         const resolvedLeftType = leftType?.replace(/^\*/, '').replace(/\[.*\]$/, '');
         const resolvedPropertyType = resolvedLeftType
             ? (classPropertyTypes.get(resolvedLeftType)?.get(expr.name.text) ??
@@ -4292,6 +4771,10 @@ function inferExpressionType(expr) {
                 return ownerType;
             if (methodName === 'reduceRight' && expr.arguments?.[1])
                 return inferExpressionType(expr.arguments[1]);
+            // the accumulator: the initial value's type, else the element type
+            if (methodName === 'reduce') {
+                return (expr.arguments?.[1] ? inferExpressionType(expr.arguments[1]) : undefined) ?? elementType;
+            }
             if (methodName === 'flat' && elementType.startsWith('[]'))
                 return elementType;
             if (methodName === 'flat' || methodName === 'flatMap')
@@ -4562,7 +5045,7 @@ const BUILTIN_FUNCTION_TYPES = {
     parseInt: 'float64',
     Number: 'float64',
     String: 'string',
-    setTimeout: '*time.Timer',
+    setTimeout: '*TnTimeout',
     setInterval: '*TnInterval'
 };
 const STRING_METHOD_RETURN_TYPES = {
@@ -4919,12 +5402,18 @@ function getMapLookup(expr) {
     return undefined;
 }
 function isNilableGoType(goType) {
-    return (goType.startsWith('*') ||
+    if (goType.startsWith('*') ||
         goType.startsWith('[]') ||
         goType.startsWith('map[') ||
         goType.startsWith('func') ||
         goType.startsWith('chan ') ||
-        goType === 'interface{}');
+        goType === 'interface{}' ||
+        goType === 'error') {
+        return true;
+    }
+    // Go bridge named types over nil-able kinds (net.IP, io.Reader, http.Header)
+    const kind = goMetaTypeInfo(goType)?.kind;
+    return kind === 'interface' || kind === 'slice' || kind === 'map' || kind === 'func' || kind === 'chan';
 }
 function visitOptionalPropertyAccess(node) {
     const baseExpr = visit(node.expression);
@@ -4944,7 +5433,10 @@ function visitOptionalPropertyAccess(node) {
         'interface{}';
     const nullableType = makeNullableType(propertyType);
     const tmp = getTempName('opt');
-    const propertyAccess = `${tmp}.${visit(node.name)}`;
+    // Class getters (also Node classes' accessors such as err.syscall) are calls
+    const propertyAccess = classGetterMethods.has(`${className}.${node.name.text}`)
+        ? `${tmp}.Get_${visit(node.name)}()`
+        : `${tmp}.${visit(node.name)}`;
     if (nullableType.startsWith('*') && nullableType.slice(1) === propertyType) {
         const valueTemp = getTempName('optv');
         return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; ${valueTemp} := ${propertyAccess}; return &${valueTemp} }()`;
@@ -5051,10 +5543,18 @@ function inferArrayCallbackReturnType(callback, elementType, fallbackType) {
             const explicitType = getType(callback.type);
             return explicitType || fallbackType;
         }
-        if (isBlock(callback.body)) {
-            return inferFunctionBodyReturnType(callback) ?? fallbackType;
-        }
-        const inferred = inferExpressionType(callback.body);
+        // The element parameter has the element type while the body is inferred
+        const param = (callback.parameters ?? [])[0];
+        const paramName = param && isIdentifier(param.name) && !param.type ? param.name.text : '';
+        const hadParam = paramName ? variableGoTypes.has(paramName) : false;
+        const savedParam = paramName ? variableGoTypes.get(paramName) : undefined;
+        if (paramName)
+            variableGoTypes.set(paramName, elementType);
+        const inferred = isBlock(callback.body) ? inferFunctionBodyReturnType(callback) : inferExpressionType(callback.body);
+        if (paramName && hadParam && savedParam !== undefined)
+            variableGoTypes.set(paramName, savedParam);
+        else if (paramName)
+            variableGoTypes.delete(paramName);
         return inferred ?? fallbackType;
     }
     if (isIdentifier(callback)) {
@@ -5493,7 +5993,10 @@ function getType(typeNode, getArrayType = false) {
         const params = (typeNode.parameters ?? [])
             .map((p) => {
             const paramType = p.type ? getType(p.type) : 'interface{}';
-            return p.dotDotDotToken && paramType.startsWith('[]') ? `...${paramType.slice(2)}` : paramType;
+            if (p.dotDotDotToken && paramType.startsWith('[]'))
+                return `...${paramType.slice(2)}`;
+            // optional parameters are nullable (as in declarations and at call sites)
+            return p.questionToken ? makeNullableType(paramType) : paramType;
         })
             .join(', ');
         const ret = typeNode.type ? ` ${getType(typeNode.type)}` : '';
@@ -5508,6 +6011,11 @@ function getType(typeNode, getArrayType = false) {
         useHelper('symbol');
         return '*TnSymbol';
     }
+    if (isTypeReferenceNode(typeNode)) {
+        const nodeClassKey = nodeClassKeyOfTypeName(typeNode.typeName);
+        if (nodeClassKey)
+            return nodeRegistry.classes[nodeClassKey].goType;
+    }
     if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
         if (enumNames.has(name)) {
@@ -5529,12 +6037,28 @@ function getType(typeNode, getArrayType = false) {
         if (name === 'RegExp') {
             return '*regexp.Regexp';
         }
-        if (name === 'Error') {
+        // go:builtin GoError values are Go errors.
+        if (name === 'GoError') {
+            return 'error';
+        }
+        if (name === 'GoChan' && typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+            const inner = getType(typeNode.typeArguments[0]);
+            return `chan ${inner || 'interface{}'}`;
+        }
+        if (name === 'GoRef' && typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+            const inner = getType(typeNode.typeArguments[0]);
+            return `*${inner || 'interface{}'}`;
+        }
+        if (name === 'Error' || (BUILTIN_ERROR_NAMES.has(name) && !classNames.has(name))) {
             return '*TnError';
         }
         if (name === 'RegExpExecArray' || name === 'RegExpMatchArray') {
             return '[]string';
         }
+        // Uint8Array / Buffer / ArrayBuffer annotations are Go []byte.
+        if (name === 'Uint8Array' || name === 'Buffer' || name === 'ArrayBuffer') {
+            return '[]byte';
+        }
         if (name === 'TemplateStringsArray' || name === 'ReadonlyArray') {
             return name === 'TemplateStringsArray' ? '[]string' : getType(typeNode.typeArguments?.[0]);
         }
@@ -5608,6 +6132,11 @@ function getTypeCategory(typeNode) {
         if (nonNullTypes.length === 1)
             return getTypeCategory(nonNullTypes[0]);
     }
+    if (isTypeReferenceNode(typeNode)) {
+        const nodeClassKey = nodeClassKeyOfTypeName(typeNode.typeName);
+        if (nodeClassKey)
+            return nodeRegistry.classes[nodeClassKey].category;
+    }
     if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
         if (name === 'Map')
@@ -5649,16 +6178,25 @@ function goTypeCategory(goType) {
         return undefined;
     if (goType.startsWith('*TnMap['))
         return extractMapValueType(goType) === 'struct{}' ? 'Set' : 'Map';
+    const nodeClassKey = nodeRegistry.classByGoType[goType];
+    if (nodeClassKey)
+        return nodeRegistry.classes[nodeClassKey].category;
     if (goType.startsWith('*[]'))
         goType = goType.slice(1);
-    if (goType.startsWith('[]'))
+    if (goType.startsWith('[]')) {
+        if (goType === '[]byte')
+            return 'Buffer';
         return 'array';
+    }
     if (goType === 'string')
         return 'string';
     if (goType === '*regexp.Regexp' || goType === '*TnRegex')
         return 'RegExp';
     if (goType === 'time.Time')
         return 'Date';
+    // Bridged Go values: methods pass through as Go methods.
+    if (goMetaTypeInfo(goType))
+        return 'class';
     return undefined;
 }
 function isNilLiteral(node) {
@@ -5677,6 +6215,10 @@ function getAcessString(leftSide, rightSide, objectType) {
     if (rightSide === 'length' && objectType !== 'class') {
         return `float64(len(${leftSide}))`;
     }
+    // Buffers / Uint8Arrays / ArrayBuffers are []byte
+    if (rightSide === 'byteLength' && objectType === 'Buffer') {
+        return `float64(len(${leftSide}))`;
+    }
     if (rightSide === 'size' && (objectType === 'Map' || objectType === 'Set')) {
         return `float64(${leftSide}.Len())`;
     }
@@ -5739,18 +6281,61 @@ const callHandlers = {
         const message = args.length > 1 ? args[1] : '"Assertion failed"';
         return `if !(${args[0]}) {\n\t\tpanic(${message})\n\t}`;
     },
-    'console.log': (_caller, args) => {
-        importedPackages.add('fmt');
-        return `fmt.Println(${args.join(', ')})`;
+    'console.log': (_caller, args) => consoleOut('Stdout', args),
+    'console.info': (_caller, args) => consoleOut('Stdout', args),
+    'console.debug': (_caller, args) => consoleOut('Stdout', args),
+    'console.trace': (_caller, args) => consoleOut('Stderr', args, 'Trace:'),
+    'console.dir': (_caller, args) => {
+        useHelper('nodeUtil');
+        return consoleOut('Stdout', [`TnInspect(${args.join(', ')})`], '', true);
+    },
+    'console.assert': (_caller, args) => {
+        const condition = args[0] ?? 'false';
+        currentCallArgTypes = currentCallArgTypes.slice(1);
+        const message = consoleOut('Stderr', args.slice(1), args.length > 1 ? 'Assertion failed:' : 'Assertion failed');
+        return `if !(${condition}) {\n\t\t${message}\n\t}`;
+    },
+    'console.table': (_caller, args) => {
+        useHelper('nodeUtil');
+        return consoleOut('Stdout', [`TnConsoleTableString(${args.join(', ')})`], '', true);
+    },
+    'console.count': (_caller, args) => {
+        useHelper('console');
+        return `TnConsoleCount(${args.join(', ')})`;
+    },
+    'console.countReset': (_caller, args) => {
+        useHelper('console');
+        return `TnConsoleCountReset(${args.join(', ')})`;
+    },
+    'console.group': (_caller, args) => {
+        useHelper('console');
+        return `TnConsoleGroup(${consoleArgs(args).join(', ')})`;
+    },
+    'console.groupCollapsed': (_caller, args) => {
+        useHelper('console');
+        return `TnConsoleGroup(${consoleArgs(args).join(', ')})`;
+    },
+    'console.groupEnd': () => {
+        useHelper('console');
+        return 'TnConsoleGroupEnd()';
     },
     'console.time': (_caller, args) => {
-        importedPackages.add('time');
-        return `${getTimerName(args[0])} := time.Now()`;
+        useHelper('console');
+        return `TnConsoleTime(${args.slice(0, 1).join(', ')})`;
     },
     'console.timeEnd': (_caller, args) => {
-        importedPackages.add('time');
+        useHelper('console');
+        return `TnConsoleTimeEnd(${args.slice(0, 1).join(', ')})`;
+    },
+    'console.timeLog': (_caller, args) => {
+        useHelper('console');
+        const label = args[0] ?? '"default"';
+        currentCallArgTypes = currentCallArgTypes.slice(1);
+        const extra = args.length > 1 ? consoleArgs(args.slice(1)) : [];
         importedPackages.add('fmt');
-        return `fmt.Println("Elapsed time:", time.Since(${getTimerName(args[0])}))`;
+        importedPackages.add('strings');
+        const text = extra.length > 0 ? `strings.TrimSuffix(fmt.Sprintln(${extra.join(', ')}), "\\n")` : '""';
+        return `TnConsoleTimeLog(${label}, ${text})`;
     },
     'Math.hypot': (_caller, args) => mathCall('Hypot', args),
     'Math.cbrt': (_caller, args) => mathCall('Cbrt', args),
@@ -5925,18 +6510,11 @@ const callHandlers = {
     },
     'Date.now': () => {
         importedPackages.add('time');
-        return 'float64(time.Now().UnixMilli())';
-    },
-    'console.error': (_caller, args) => {
-        importedPackages.add('fmt');
-        importedPackages.add('os');
-        return `fmt.Fprintln(os.Stderr, ${args.join(', ')})`;
-    },
-    'console.warn': (_caller, args) => {
-        importedPackages.add('fmt');
-        importedPackages.add('os');
-        return `fmt.Fprintln(os.Stderr, ${args.join(', ')})`;
+        useHelper('clock');
+        return 'float64(TnTimeNow().UnixMilli())';
     },
+    'console.error': (_caller, args) => consoleOut('Stderr', args),
+    'console.warn': (_caller, args) => consoleOut('Stderr', args),
     'Array.isArray': (_caller, args) => {
         importedPackages.add('reflect');
         return `(reflect.ValueOf(${args[0]}).Kind() == reflect.Slice)`;
@@ -5970,6 +6548,59 @@ const callHandlers = {
     },
     'Boolean': (_caller, args) => `(${truthinessCheck(args[0] ?? 'false', currentCallArgTypes[0] ?? 'interface{}')})`,
 };
+// Built-in Error subclasses (TnErrors carrying their name)
+const BUILTIN_ERROR_NAMES = new Set(['TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'EvalError', 'URIError']);
+// Whether the program uses console.group (then every console line is
+// written through the indentation-aware helper)
+let consoleGroupsUsed = false;
+// One console line to stdout / stderr, with an optional leading word
+function consoleOut(stream, args, prefix = '', formatted = false) {
+    let parts = formatted ? args : consoleArgs(args);
+    if (prefix)
+        parts = [toGoStringLiteral(prefix), ...parts];
+    importedPackages.add('fmt');
+    if (consoleGroupsUsed) {
+        useHelper('console');
+        importedPackages.add('os');
+        importedPackages.add('strings');
+        return `TnConsoleWrite(os.${stream}, strings.TrimSuffix(fmt.Sprintln(${parts.join(', ')}), "\\n"))`;
+    }
+    if (stream === 'Stdout')
+        return `fmt.Println(${parts.join(', ')})`;
+    importedPackages.add('os');
+    return `fmt.Fprintln(os.Stderr, ${parts.join(', ')})`;
+}
+// console.* arguments, printed like Node: strings as-is, numbers in JS
+// notation, everything else through util.inspect (and a format string first
+// argument through util.format)
+// The inferred type of call argument i ('' when unknown); a plain lookup keeps
+// the self-hosted build from dereferencing a missing (nil) entry
+function callArgType(i) {
+    if (i >= currentCallArgTypes.length)
+        return '';
+    const t = currentCallArgTypes[i];
+    return t ? t : '';
+}
+function consoleArgs(args) {
+    const types = args.map((_arg, i) => callArgType(i));
+    const isFormatString = args.length > 1 && types[0] === 'string' && args[0].includes('%');
+    const needsInspect = args.some((_arg, i) => !['string', 'float64', 'bool', '[]byte'].includes(types[i]));
+    if (isFormatString || needsInspect) {
+        useHelper('nodeUtil');
+        return [`TnUtilFormat(${args.join(', ')})`];
+    }
+    return args.map((arg, i) => {
+        if (types[i] === 'float64') {
+            useHelper('dynamic');
+            return `TnNumStr(${arg})`;
+        }
+        if (types[i] === '[]byte') {
+            useHelper('buffer');
+            return `TnBufferInspect(${arg})`;
+        }
+        return arg;
+    });
+}
 const stringMethodHandlers = {
     split: (obj, args) => {
         if (args[0]?.startsWith('regexp.MustCompile('))
@@ -6003,7 +6634,10 @@ const stringMethodHandlers = {
     },
     indexOf: (obj, args) => {
         importedPackages.add('strings');
-        return `float64(strings.Index(${obj}, ${args[0]}))`;
+        if (args.length < 2)
+            return `float64(strings.Index(${obj}, ${args[0]}))`;
+        // indexOf(x, from): search from the clamped position, index into the whole string
+        return `func() float64 { __s := ${obj}; __f := int(${args[1]}); if __f < 0 { __f = 0 }; if __f > len(__s) { __f = len(__s) }; __i := strings.Index(__s[__f:], ${args[0]}); if __i < 0 { return -1 }; return float64(__i + __f) }()`;
     },
     charCodeAt: (obj, args) => `float64(${obj}[int(${args[0]})])`,
     localeCompare: (obj, args) => {
@@ -6258,6 +6892,8 @@ function toGoRegexp(arg) {
 // A JS slice index: negative values count from the end
 // A JS slice index: negative values count from the end; out-of-range values clamp
 function sliceIndex(obj, index) {
+    if (index === undefined || index === '')
+        return '0';
     if (index.startsWith('-'))
         return `max(0, int(float64(len(${obj})) + ${index}))`;
     return `min(int(${index}), len(${obj}))`;
@@ -6296,9 +6932,21 @@ const setMethodHandlers = {
     isSupersetOf: (obj, args) => `${args[0]}.IsSubsetOf(${obj})`,
     isDisjointFrom: (obj, args) => `(${obj}.Intersection(${args[0]}).Len() == 0)`
 };
+// A table entry only when the table itself has it (not Object.prototype's valueOf …)
+function ownMethodHandler(table, key) {
+    return Object.hasOwn(table, key) ? table[key] : undefined;
+}
 function getDynamicCallHandler(caller, objectType) {
     if (promiseResolveName && caller === promiseResolveName) {
-        return (_caller, args) => `ch <- ${args[0]}`;
+        // The first resolution wins; later ones are ignored (as in JS)
+        return (_caller, args) => {
+            // resolve() without a value: the channel type's zero value
+            if (args.length === 0 || args[0] === 'nil') {
+                useHelper('promise');
+                return 'TnResolveZero(ch)';
+            }
+            return `select { case ch <- ${args[0]}: default: }`;
+        };
     }
     if (promiseRejectName && caller === promiseRejectName) {
         return (_caller, args) => {
@@ -6314,10 +6962,17 @@ function getDynamicCallHandler(caller, objectType) {
             return (c, args) => {
                 const obj = c.substring(0, dotIndex);
                 if (args.length > 0) {
+                    // bigint.toString(radix)
+                    if (currentReceiverGoType === '*tnbig.Int')
+                        return `${obj}.Text(int(${args[0]}))`;
                     importedPackages.add('strconv');
                     return `strconv.FormatInt(int64(${obj}), int(${args[0]}))`;
                 }
-                return jsStringOf(obj, objectType === 'number' || objectType === 'float64' ? 'float64' : undefined);
+                return jsStringOf(obj, objectType === 'number' || objectType === 'float64'
+                    ? 'float64'
+                    : currentReceiverGoType === 'interface{}'
+                        ? 'interface{}'
+                        : undefined);
             };
         }
         if (methodName === 'toPrecision') {
@@ -6338,29 +6993,29 @@ function getDynamicCallHandler(caller, objectType) {
             return null;
         let handler;
         if (objectType === 'string') {
-            handler = stringMethodHandlers[methodName];
+            handler = ownMethodHandler(stringMethodHandlers, methodName);
         }
         else if (objectType === 'array') {
-            handler = arrayMethodHandlers[methodName];
+            handler = ownMethodHandler(arrayMethodHandlers, methodName);
         }
         else if (objectType === 'RegExp') {
-            handler = regexpMethodHandlers[methodName];
+            handler = ownMethodHandler(regexpMethodHandlers, methodName);
         }
         else if (objectType === 'Date') {
-            handler = dateMethodHandlers[methodName];
+            handler = ownMethodHandler(dateMethodHandlers, methodName);
         }
         else if (objectType === 'Map') {
-            handler = mapMethodHandlers[methodName];
+            handler = ownMethodHandler(mapMethodHandlers, methodName);
         }
         else if (objectType === 'Set') {
-            handler = setMethodHandlers[methodName];
+            handler = ownMethodHandler(setMethodHandlers, methodName);
         }
         else {
             // Unknown type: try both maps for backward compatibility
             handler =
-                stringMethodHandlers[methodName] ??
-                    arrayMethodHandlers[methodName] ??
-                    regexpMethodHandlers[methodName];
+                ownMethodHandler(stringMethodHandlers, methodName) ??
+                    ownMethodHandler(arrayMethodHandlers, methodName) ??
+                    ownMethodHandler(regexpMethodHandlers, methodName);
         }
         if (handler) {
             return (c, args) => {
@@ -6373,7 +7028,10 @@ function getDynamicCallHandler(caller, objectType) {
 }
 function getCallString(caller, args, typeArgs = '', objectType) {
     // Parentheses from casts like `(mod as any).fn(...)` are stripped for lookup
-    const handler = callHandlers[caller] ?? callHandlers[caller.replace(/[()]/g, '')] ??
+    // (own entries only: a plain-object lookup would also find Object.prototype members)
+    const bare = caller.replace(/[()]/g, '');
+    const handler = (Object.hasOwn(callHandlers, caller) ? callHandlers[caller] : undefined) ??
+        (Object.hasOwn(callHandlers, bare) ? callHandlers[bare] : undefined) ??
         getDynamicCallHandler(caller, objectType);
     if (handler) {
         return handler(caller, args, typeArgs);
@@ -6474,11 +7132,15 @@ function visitDynamicMethodCall(node) {
         includes: 'TnIncludes',
         indexOf: 'TnIndexOf',
         slice: 'TnSlice',
-        concat: 'TnConcat'
+        concat: 'TnConcat',
+        toString: 'TnJSString'
     };
     const helper = dynamicHelpers[method];
-    if (!helper)
+    // (a plain-object lookup also finds Object.prototype members)
+    if (!helper || typeof helper !== 'string')
         return undefined;
+    if (method === 'toString')
+        useHelper('error');
     useHelper('dynamic');
     const args = (node.arguments ?? []).map((a) => visit(a));
     return `${helper}(${[visit(node.expression.expression), ...args].join(', ')})`;
@@ -6901,6 +7563,13 @@ function getTypeArguments(typeArguments) {
     return `[${args.join(', ')}]`;
 }
 function getParameterGoType(param) {
+    // Node callbacks / hooks: `any`-typed parameters take Node's types too
+    const nodeHookTypes = param.parent?.tnParamTypes;
+    if (nodeHookTypes && param.type?.kind === 'AnyKeyword' && !param.dotDotDotToken) {
+        const hookType = nodeHookTypes[(param.parent.parameters ?? []).indexOf(param)];
+        if (hookType)
+            return hookType;
+    }
     // Rest parameter: ...args — use variadic syntax
     if (param.dotDotDotToken) {
         if (param.type) {
@@ -6919,7 +7588,7 @@ function getParameterGoType(param) {
         // Array parameters are references (mutations are visible to the caller) —
         // except unbound type parameters (Go generics), template-tag arrays, and
         // dynamic []interface{} (runtime helper arrays)
-        if (explicitType.startsWith('[]') && explicitType !== '[]interface{}' && !param.dotDotDotToken) {
+        if (explicitType.startsWith('[]') && explicitType !== '[]interface{}' && explicitType !== '[]byte' && !param.dotDotDotToken) {
             const isTaggedTemplateArray = isTypeReferenceNode(param.type) &&
                 isIdentifier(param.type.typeName) &&
                 param.type.typeName.text === 'TemplateStringsArray';
@@ -6943,9 +7612,19 @@ function getParameterGoType(param) {
     const contextualFn = param.parent ? getContextualFunctionType(param.parent) : undefined;
     if (contextualFn) {
         const index = (param.parent.parameters ?? []).indexOf(param);
-        const contextualParamType = contextualFn.parameters?.[index]?.type;
-        if (contextualParamType)
-            return getType(contextualParamType);
+        const contextualParam = contextualFn.parameters?.[index];
+        const contextualParamType = contextualParam?.type;
+        if (contextualParamType) {
+            const contextualGoType = getType(contextualParamType);
+            return contextualParam.questionToken ? makeNullableType(contextualGoType) : contextualGoType;
+        }
+    }
+    // Callbacks of Node APIs: parameter types from the registry
+    const nodeParamTypes = param.parent?.tnParamTypes;
+    if (nodeParamTypes) {
+        const nodeParamType = nodeParamTypes[(param.parent.parameters ?? []).indexOf(param)];
+        if (nodeParamType)
+            return nodeParamType;
     }
     return 'interface{}';
 }
@@ -7153,8 +7832,27 @@ function getFunctionParametersInfo(parameters) {
         prefixBlockContent: prefixBlockContent + destructuring
     };
 }
+// Go packages the generated code may import: a user identifier with one of
+// these names would shadow the package, so it is renamed (unless the name is
+// itself a `go:` package import)
+const goPackageIdentifiers = new Set([
+    'aes', 'atomic', 'base64', 'binary', 'bufio', 'bytes', 'cipher', 'crc32', 'errors', 'exec', 'filepath',
+    'flate', 'fmt', 'fs', 'gzip', 'hash', 'hex', 'hkdf', 'hmac', 'html', 'io', 'iter', 'json', 'math', 'md5',
+    'net', 'os', 'pbkdf2', 'rand', 'reflect', 'regexp', 'runtime', 'sha1', 'sha256', 'sha3', 'sha512', 'signal',
+    'slices', 'sort', 'strconv', 'strings', 'subtle', 'sync', 'syscall', 'time', 'unicode', 'unsafe', 'user',
+    'utf16', 'utf8', 'zlib', 'asn1', 'bits', 'context', 'ecdh', 'ecdsa', 'ed25519', 'elliptic', 'encoding', 'http',
+    'log', 'mime', 'multipart', 'netip', 'pem', 'pkix', 'rsa', 'textproto', 'tls', 'x509',
+    // Aliased imports (math/big, crypto, net/url, crypto/rand)
+    'tnbig', 'tncrypto', 'tnurl', 'cryptorand',
+    // Go builtins: a package-level `var copy` would shadow copy() in the helpers
+    'append', 'cap', 'clear', 'close', 'complex', 'copy', 'imag', 'len', 'make', 'max', 'min', 'panic',
+    'print', 'println', 'real', 'recover', 'any', 'byte', 'error', 'float64', 'int', 'int64', 'rune',
+    'uint', 'uint8', 'uint32', 'nil', 'iota'
+]);
+// Local names of `go:` package imports (`import * as strings from 'go:strings'`)
+const goPackageLocalNames = new Set();
 function getSafeName(name) {
-    if (!dangerousNames.has(name)) {
+    if (!dangerousNames.has(name) && !(goPackageIdentifiers.has(name) && !goPackageLocalNames.has(name))) {
         return name;
     }
     if (!renamedFunctions.has(name)) {
@@ -7212,6 +7910,11 @@ function emitChannelFunction(node, isAsync) {
     const body = visit(node.body, { prefixBlockContent: parameterInfo.prefixBlockContent });
     asyncChannelVar = prevChannel;
     asyncFunctionNode = prevFn;
+    if (isAsync) {
+        // The body runs synchronously until its first await, holding the JS baton
+        useHelper('eventLoop');
+        return (`func ${name}${typeParams}(${parameterInfo.signature}) chan ${chanType} {\n\t${channelVar} := make(chan ${chanType}, 1)\n\tTnStartAsync(func() {\n\t\tdefer close(${channelVar})${rejectOnPanic}\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
@@ -7231,6 +7934,7 @@ function visitPromiseReturn(node, options) {
     if (!callback || (!isArrowFunction(callback) && !isFunctionExpression(callback))) {
         return `return ${visit(node)}` + (options.inline ? '' : ';\n\t');
     }
+    useHelper('promise');
     const channelType = getPromiseChannelType(node);
     const resolveParam = callback.parameters[0];
     const resolveName = resolveParam ? visit(resolveParam.name) : '';
@@ -7242,7 +7946,7 @@ function visitPromiseReturn(node, options) {
     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` +
+    return (`ch := make(chan ${channelType}, 1)\n\t\tfunc() {\n\t\t\tdefer TnRejectExecutor(ch)\n\t\t\tfunc() ${body.trimEnd()}()\n\t\t}()\n\t\treturn ch` +
         (options.inline ? '' : ';\n\t'));
 }
 function visitNewPromise(node) {
@@ -7261,7 +7965,10 @@ function visitNewPromise(node) {
     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}()`;
+    // Buffered: resolving never blocks (a loop task may resolve a promise its own goroutine awaits)
+    // The executor runs synchronously, as in JS (a throw rejects the promise)
+    useHelper('promise');
+    return `func() chan ${channelType} {\n\t\tch := make(chan ${channelType}, 1)\n\t\tfunc() {\n\t\t\tdefer TnRejectExecutor(ch)\n\t\t\tfunc() ${body.trimEnd()}()\n\t\t}()\n\t\treturn ch;\n\t}()`;
 }
 function extractMapValueType(mapType) {
     const args = splitMapTypeArgs(mapType);
@@ -7374,6 +8081,9 @@ function includeLocalImport(code, dir, goFileName, tsx = false) {
     // `package main`, so helpers are emitted once in the main output file.
     const savedOutsideNodes = outsideNodes;
     const savedPackages = [...importedPackages];
+    // Helper packages registered by the including file so far must survive this
+    // file's own tracking (the main file imports them for the helpers it carries)
+    const savedHelperPackages = [...helperProvidedPackages];
     outsideNodes = [];
     importedPackages.clear();
     helperProvidedPackages.clear();
@@ -7384,10 +8094,10 @@ function includeLocalImport(code, dir, goFileName, tsx = false) {
     for (const stmt of sf.statements) {
         const result = visit(stmt, { addFunctionOutside: true });
         if (result.trim())
-            inlineLines.push(result);
+            inlineLines.push(localizeGoPaths(result));
     }
     emittingModuleFile = prevEmittingModuleFile;
-    const fileOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
+    const fileOutside = localizeGoPaths(outsideNodes.map((n) => visit(n, { isOutside: true })).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));
@@ -7405,7 +8115,7 @@ function includeLocalImport(code, dir, goFileName, tsx = false) {
         .filter((pkg) => {
         if (!helperProvidedPackages.has(pkg))
             return true;
-        const pkgName = goImportAliases[pkg] ?? pkg.split('/').pop();
+        const pkgName = goPathAliases[pkg] ?? pkg.split('/').pop();
         return stripGoStrings(fileCode).includes(`${pkgName}.`);
     })
         .sort()
@@ -7426,6 +8136,8 @@ function includeLocalImport(code, dir, goFileName, tsx = false) {
     for (const p of savedPackages)
         importedPackages.add(p);
     currentFileIsTsx = prevTsx;
+    for (const p of savedHelperPackages)
+        helperProvidedPackages.add(p);
     for (const p of helperProvidedPackages)
         importedPackages.add(p);
     currentFileDir = prevDir;
@@ -7434,21 +8146,63 @@ function includeLocalImport(code, dir, goFileName, tsx = false) {
 function stripGoStrings(code) {
     return code.replace(/"(?:[^"\\\n]|\\.)*"|`[^`]*`/g, '""');
 }
-function registerGoPackageAliases(node, goPkg) {
-    const pkgName = goPkg.split('/').pop();
+// go:builtin is virtual: ref<T> → new(T), chan<T> → make(chan T),
+// GoError → *TnError. No Go import; local names map to inline emitters.
+function registerGoBuiltinAliases(node) {
     if (!node.importClause)
         return;
     const clause = node.importClause;
+    if (clause.name)
+        importAliases.set(clause.name.text, 'go:builtin');
+    const bindings = clause.namedBindings;
+    if (!bindings)
+        return;
+    if (isNamespaceImport(bindings)) {
+        importAliases.set(bindings.name.text, 'go:builtin');
+        return;
+    }
+    if (isNamedImports(bindings)) {
+        for (const el of bindings.elements ?? []) {
+            if (el.isTypeOnly)
+                continue;
+            const localName = el.name.text;
+            const importedName = el.propertyName?.text ?? localName;
+            importAliases.set(localName, `go:builtin.${importedName}`);
+            registerGoBuiltin(localName, importedName);
+        }
+    }
+}
+function registerGoPackageAliases(node, goPkg) {
+    // Real package name from metadata (math/rand/v2 → rand); fall back to the
+    // last path segment for packages without metadata.
+    const info = goPackage(goPkg);
+    const pkgName = info ? info.name : goPkg.split('/').pop();
+    // Collision alias (crypto/rand vs math/rand): the emitted qualifier.
+    const qualifier = goPathAliases[goPkg] ?? pkgName;
+    goPackageLocalNames.add(pkgName);
+    goPackageLocalNames.add(qualifier);
+    const named = [];
+    let defaultName = null;
+    let namespaceName = null;
+    if (!node.importClause) {
+        registerGoImport(goPkg, qualifier, null, null, []);
+        return;
+    }
+    const clause = node.importClause;
     // Default import: `import fmt from 'go:fmt'` or `import myFmt from 'go:fmt'`
-    if (clause.name && clause.name.text !== pkgName) {
-        importAliases.set(clause.name.text, pkgName);
+    if (clause.name) {
+        defaultName = clause.name.text;
+        if (clause.name.text !== pkgName && clause.name.text !== qualifier) {
+            importAliases.set(clause.name.text, qualifier);
+        }
     }
     if (clause.namedBindings) {
         if (isNamespaceImport(clause.namedBindings)) {
             // `import * as myFmt from 'go:fmt'`
             const localName = clause.namedBindings.name.text;
-            if (localName !== pkgName) {
-                importAliases.set(localName, pkgName);
+            namespaceName = localName;
+            if (localName !== pkgName && localName !== qualifier) {
+                importAliases.set(localName, qualifier);
             }
         }
         else if (isNamedImports(clause.namedBindings)) {
@@ -7458,10 +8212,12 @@ function registerGoPackageAliases(node, goPkg) {
                     continue;
                 const localName = el.name.text;
                 const importedName = el.propertyName?.text ?? localName;
-                importAliases.set(localName, `${pkgName}.${importedName}`);
+                importAliases.set(localName, `${qualifier}.${importedName}`);
+                named.push({ imported: importedName, local: localName });
             }
         }
     }
+    registerGoImport(goPkg, qualifier, defaultName, namespaceName, named);
 }
 function getImportLocalName(node) {
     const clause = node.importClause;
@@ -7489,7 +8245,10 @@ function needPkg(pkg) {
 const helperRequires = {
     objectAssign: ['orderedMap'],
     promiseAll: ['orderedMap', 'asyncWait', 'promise'],
-    promise: ['error'],
+    promise: ['error', 'eventLoop', 'asyncWait'],
+    goMust: ['error'],
+    bigint: ['error'],
+    goBlocking: ['error', 'eventLoop'],
     decorators: [],
     jsx: [],
     objectIntegrity: [],
@@ -7499,8 +8258,10 @@ const helperRequires = {
     fancyRegex: ['orderedMap'],
     dynamic: ['error'],
     moduleUrl: ['pathToFileURL'],
-    timerWait: [],
-    asyncWait: []
+    timerWait: ['eventLoop'],
+    clock: [],
+    asyncWait: ['eventLoop'],
+    eventLoop: []
 };
 function useHelper(id) {
     if (usedHelpers.has(id))
@@ -7510,159 +8271,85 @@ function useHelper(id) {
     if (id === 'namedGroups') {
         interfacePropertyTypes.set('TnMatch', new Map([['groups', '*TnMap[string, string]']]));
     }
-    for (const dep of helperRequires[id] ?? [])
+    for (const dep of helperRequires[id] ?? nodeRegistry.helperRequires[id] ?? [])
         useHelper(dep);
-    for (const pkg of helperPackages[id] ?? []) {
+    for (const pkg of helperPackages[id] ?? nodeRegistry.helperPackages[id] ?? []) {
         importedPackages.add(pkg);
         helperProvidedPackages.add(pkg);
     }
 }
-const nodeModuleMappings = {
-    path: {
-        functions: {
-            join: (args) => {
-                needPkg('path/filepath');
-                return `filepath.Join(${args.join(', ')})`;
-            },
-            dirname: (args) => {
-                needPkg('path/filepath');
-                return `filepath.Dir(${args[0]})`;
-            },
-            basename: (args) => {
-                needPkg('path/filepath');
-                if (args[1]) {
-                    needPkg('strings');
-                    return `strings.TrimSuffix(filepath.Base(${args[0]}), ${args[1]})`;
-                }
-                return `filepath.Base(${args[0]})`;
-            },
-            extname: (args) => {
-                needPkg('path/filepath');
-                return `filepath.Ext(${args[0]})`;
-            },
-            resolve: (args) => {
-                needPkg('path/filepath');
-                return `func() string { p, _ := filepath.Abs(filepath.Join(${args.join(', ')})); return p }()`;
-            }
-        }
-    },
-    fs: {
-        functions: {
-            readFileSync: (args) => {
-                useHelper('readFile');
-                return `TnReadFile(${args[0]})`;
-            },
-            writeFileSync: (args) => {
-                useHelper('writeFile');
-                return `TnWriteFile(${args[0]}, ${args[1]})`;
-            },
-            appendFileSync: (args) => {
-                useHelper('appendFile');
-                return `TnAppendFile(${args[0]}, ${args[1]})`;
-            },
-            existsSync: (args) => {
-                needPkg('os');
-                return `func() bool { _, err := os.Stat(${args[0]}); return !os.IsNotExist(err) }()`;
-            },
-            mkdirSync: (args) => {
-                useHelper('mkdirAll');
-                return `TnMkdirAll(${args[0]})`;
-            },
-            readdirSync: (args) => {
-                useHelper('readDir');
-                return `TnReadDir(${args[0]})`;
-            },
-            copyFileSync: (args) => {
-                useHelper('copyFile');
-                return `TnCopyFile(${args[0]}, ${args[1]})`;
-            },
-            rmSync: (args) => {
-                useHelper('removeAll');
-                return `TnRemoveAll(${args[0]})`;
-            },
-            unlinkSync: (args) => {
-                useHelper('removeAll');
-                return `TnRemoveAll(${args[0]})`;
-            }
-        }
-    },
-    url: {
-        functions: {
-            fileURLToPath: (args) => {
-                useHelper('fileURLToPath');
-                return `TnFileURLToPath(${args[0]})`;
-            },
-            pathToFileURL: (args) => {
-                useHelper('pathToFileURL');
-                return `TnPathToFileURL(${args[0]})`;
-            }
-        }
-    },
-    os: {
-        functions: {
-            platform: () => {
-                useHelper('osPlatform');
-                return 'TnOsPlatform()';
-            },
-            homedir: () => {
-                needPkg('os');
-                return `func() string { h, _ := os.UserHomeDir(); return h }()`;
-            },
-            tmpdir: () => {
-                needPkg('os');
-                return 'os.TempDir()';
-            }
-        }
-    },
-    child_process: {
-        functions: {
-            // exec(command) — run through the shell, returns { stdout, stderr, status }
-            exec: (args) => {
-                useHelper('exec');
-                return `TnExecShell(${args[0]})`;
-            },
-            // execSync(command) — run through the shell, returns stdout (panics on failure)
-            execSync: (args) => {
-                useHelper('exec');
-                useHelper('execSync');
-                return `TnExecShellSync(${args[0]})`;
-            },
-            // spawnSync(file, args, options) — matches Node's sync API.
-            // options with `inherit` → run with the parent's stdio (returns exit code);
-            // otherwise output is captured. Fields match Node: stdout/stderr/status.
-            spawnSync: (args) => {
-                useHelper('exec');
-                useHelper('runInherit');
-                // Untyped array literals visit as `[] {…}` — give them the []string
-                // type the variadic helper needs (`[]string{…}...` is valid Go spread)
-                const arrArg = args[1] ?? '[]string{}';
-                const typedArg = arrArg.startsWith('[]') && !arrArg.startsWith('[]string')
-                    ? arrArg.replace(/^\[\]\S* \{/, '[]string{')
-                    : arrArg;
-                if (args[2]?.includes('inherit')) {
-                    return `TnRunInherit(${args[0]}, ${typedArg}...)`;
-                }
-                if (args[2]?.includes('input')) {
-                    // {input: expr, ...} → run with expr as stdin
-                    useHelper('execInput');
-                    const m = /input:\s*([^,}]+)/.exec(args[2]);
-                    const inputExpr = m ? m[1] : '""';
-                    return `TnExecInput(${args[0]}, ${inputExpr}, ${typedArg}...)`;
-                }
-                return `TnExec(${args[0]}, ${typedArg}...)`;
-            }
-        }
-    },
-    readline: {
-        functions: {
-            // question(prompt) — print prompt and read one line from stdin (synchronous)
-            question: (args) => {
-                useHelper('question');
-                return `TnQuestion(${args[0] ?? '""'})`;
-            }
-        }
-    }
-};
+// Node.js standard library (src/node/*): functions, values and classes the
+// transpiler resolves imports and Node globals against
+// (services are bound in transpileToNative: a Go package-level initializer
+// referring to visit() would be an initialization cycle)
+const nodeRegistry = createNodeRegistry();
+function bindNodeRegistryServices() {
+    nodeRegistry.pkg = needPkg;
+    nodeRegistry.helper = useHelper;
+    nodeRegistry.temp = getTempName;
+    nodeRegistry.typeOf = (node) => inferExpressionType(node) ?? '';
+    nodeRegistry.visit = (node) => visit(node);
+    nodeRegistry.categoryOf = (node) => resolveExpressionType(node) ?? '';
+    bindConvertServices({
+        pkg: needPkg,
+        helper: useHelper,
+        typeOf: (node) => inferExpressionType(node) ?? '',
+        localType: goLocalType
+    });
+    bindBridgeServices({
+        pkg: needPkg,
+        helper: useHelper,
+        temp: getTempName,
+        typeOf: (node) => inferExpressionType(node) ?? '',
+        visit: (node) => visit(node),
+        categoryOf: (node) => resolveExpressionType(node) ?? '',
+        goTypeOf: (node) => getType(node),
+        isIdentifier: (node) => isIdentifier(node),
+        isPropertyAccess: (node) => isPropertyAccessExpression(node),
+        isArrowFunction: (node) => isArrowFunction(node),
+        isFunctionExpression: (node) => isFunctionExpression(node),
+        isObjectLiteral: (node) => isObjectLiteralExpression(node),
+        declareLocal: (name, goType) => registerLocalVariable(name, goType)
+    });
+}
+registerCore(nodeRegistry);
+registerBuffer(nodeRegistry);
+registerPath(nodeRegistry);
+registerFs(nodeRegistry);
+registerUrl(nodeRegistry);
+registerOs(nodeRegistry);
+registerProcess(nodeRegistry);
+registerUtil(nodeRegistry);
+registerUtilExtra(nodeRegistry);
+registerConsole(nodeRegistry);
+registerAssert(nodeRegistry);
+registerPunycode(nodeRegistry);
+registerQuerystring(nodeRegistry);
+registerStringDecoder(nodeRegistry);
+registerCrypto(nodeRegistry);
+registerCryptoKeys(nodeRegistry);
+registerZlib(nodeRegistry);
+registerTimers(nodeRegistry);
+registerEvents(nodeRegistry);
+registerStream(nodeRegistry);
+registerDiagnosticsChannel(nodeRegistry);
+registerConstants(nodeRegistry);
+registerChildProcess(nodeRegistry);
+registerReadline(nodeRegistry);
+registerNet(nodeRegistry);
+registerDns(nodeRegistry);
+registerTls(nodeRegistry);
+registerHttp(nodeRegistry);
+registerDgram(nodeRegistry);
+registerSqlite(nodeRegistry);
+registerFetch(nodeRegistry);
+registerStreamWeb(nodeRegistry);
+registerAsyncHooks(nodeRegistry);
+registerTest(nodeRegistry);
+registerWorkerThreads(nodeRegistry);
+registerCluster(nodeRegistry);
+registerHttp2(nodeRegistry);
+registerSystemExtra(nodeRegistry);
 // Go packages required by each helper, registered when the helper is used.
 const helperPackages = {
     regexReplaceFirst: ['regexp'],
@@ -7672,38 +8359,31 @@ const helperPackages = {
     typeOf: ['reflect'],
     dynamic: ['math', 'strings', 'fmt', 'sort', 'reflect', 'strconv', 'regexp', 'unsafe'],
     regexReplaceFunc: ['regexp'],
-    readFile: ['os'],
-    writeFile: ['os'],
-    appendFile: ['os'],
-    mkdirAll: ['os'],
-    readDir: ['os'],
-    copyFile: ['os', 'io', 'path/filepath'],
-    removeAll: ['os'],
-    fileURLToPath: ['net/url', 'path/filepath', 'strings'],
-    pathToFileURL: ['net/url', 'path/filepath'],
+    pathToFileURL: ['net/url', 'path/filepath', 'strings'],
     osPlatform: ['runtime'],
     error: [],
-    bigint: ['math/big'],
+    bigint: ['math/big', 'math'],
     symbol: [],
     fancyRegex: ['regexp', 'strings', 'strconv', 'fmt'],
     namedGroups: ['regexp'],
     moduleUrl: ['os'],
-    asyncWait: ['sync'],
-    timerWait: ['sync', 'time'],
+    asyncWait: [],
+    timerWait: ['sync', 'sync/atomic', 'time'],
+    clock: ['time'],
+    eventLoop: ['sync', 'sync/atomic', 'time'],
     uri: ['strings', 'fmt', 'net/url'],
     promiseAll: [],
     promise: ['sync'],
+    goMust: [],
+    goNums: [],
+    goStrings: [],
+    goBlocking: [],
     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'],
-    question: ['bufio', 'fmt', 'os', 'strings'],
     getenv: ['os'],
-    execInput: ['os/exec', 'bytes', 'strings']
 };
 // Go helper sources emitted (once) into the main output file when used.
 // Field names are intentionally lowercase: every generated file is `package main`,
@@ -7723,10 +8403,27 @@ func TnGet(obj interface{}, key string) interface{} {
 		if key == "length" {
 			return float64(len(o))
 		}
+	case interface{ TnProp(string) (interface{}, bool) }:
+		if v, ok := o.TnProp(key); ok || key != "length" {
+			return v
+		}
 	case *TnError:
 		if key == "message" {
 			return o.message
 		}
+		if key == "code" {
+			if o.code == "" {
+				return o.prop("code")
+			}
+			return o.code
+		}
+		if key == "name" {
+			return o.Get_name()
+		}
+		if key == "stack" {
+			return o.Get_stack()
+		}
+		return o.prop(key)
 	}
 	rv := reflect.ValueOf(obj)
 	if rv.Kind() == reflect.Pointer && !rv.IsNil() && rv.Elem().Kind() == reflect.Struct {
@@ -7743,6 +8440,27 @@ func TnGet(obj interface{}, key string) interface{} {
 	return nil
 }
 
+// new Error(message, { cause })
+func TnErrorWithOptions(e *TnError, options interface{}) *TnError {
+	if options == nil {
+		return e
+	}
+	if e.props == nil {
+		e.props = map[string]interface{}{}
+	}
+	if m, ok := options.(map[string]interface{}); ok {
+		if cause, present := m["cause"]; present {
+			e.props["cause"] = cause
+		}
+		return e
+	}
+	rv := reflect.ValueOf(options)
+	if rv.Kind() == reflect.Pointer && !rv.IsNil() && rv.Elem().Kind() == reflect.Struct && rv.Elem().FieldByName("cause").IsValid() {
+		e.props["cause"] = TnGet(options, "cause")
+	}
+	return e
+}
+
 func TnSet(obj interface{}, key string, value interface{}) {
 	if o, ok := obj.(map[string]interface{}); ok {
 		o[key] = value
@@ -7781,6 +8499,15 @@ func TnIndex(obj interface{}, key interface{}) interface{} {
 		if i, ok := key.(float64); ok && i >= 0 && int(i) < len(o) {
 			return string(o[int(i)])
 		}
+	case []byte:
+		if i, ok := key.(float64); ok && i >= 0 && int(i) < len(o) {
+			return float64(o[int(i)])
+		}
+	case interface{ TnProp(string) (interface{}, bool) }:
+		if k, ok := key.(string); ok {
+			v, _ := o.TnProp(k)
+			return v
+		}
 	}
 	return nil
 }
@@ -7831,6 +8558,44 @@ func TnLength(v interface{}) float64 {
 }
 
 // A value as JS prints it in a template literal (nil pointers are "undefined")
+// String(v) of a dynamic value, as JS renders it
+func TnJSString(v interface{}) string {
+	switch x := v.(type) {
+	case nil:
+		return "undefined"
+	case string:
+		return x
+	case float64:
+		return TnNumStr(x)
+	case bool:
+		if x {
+			return "true"
+		}
+		return "false"
+	case []byte:
+		return strings.ToValidUTF8(string(x), "�")
+	case []interface{}:
+		parts := make([]string, len(x))
+		for i, e := range x {
+			if e != nil {
+				parts[i] = TnJSString(e)
+			}
+		}
+		return strings.Join(parts, ",")
+	case []string:
+		return strings.Join(x, ",")
+	case map[string]interface{}:
+		return "[object Object]"
+	case *TnError:
+		return x.Get_name() + ": " + x.message
+	case fmt.Stringer:
+		return x.String()
+	case interface{ toString() string }:
+		return x.toString()
+	}
+	return fmt.Sprintf("%v", v)
+}
+
 func TnFormat(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if !rv.IsValid() || (rv.Kind() == reflect.Pointer && rv.IsNil()) {
@@ -8006,6 +8771,9 @@ func TnHas(obj interface{}, key interface{}) bool {
 }
 
 func TnKeys(obj interface{}) []string {
+	if record, ok := obj.(interface{ Keys() []string }); ok {
+		return append([]string{}, record.Keys()...)
+	}
 	o, _ := obj.(map[string]interface{})
 	keys := make([]string, 0, len(o))
 	for k := range o {
@@ -8093,6 +8861,10 @@ func TnAsPtr[T any](v interface{}) *T {
 	if t, ok := v.(T); ok {
 		return &t
 	}
+	var zero T
+	if converted, ok := TnConvertDynamic(v, reflect.TypeOf(&zero)); ok {
+		return converted.Interface().(*T)
+	}
 	return nil
 }
 
@@ -8100,25 +8872,108 @@ func TnAs[T any](v interface{}) T {
 	if p, ok := v.(*T); ok && p != nil {
 		return *p
 	}
-	t, _ := v.(T)
+	t, ok := v.(T)
+	if !ok && v != nil {
+		if converted, cok := TnConvertDynamic(v, reflect.TypeOf((*T)(nil)).Elem()); cok {
+			return converted.Interface().(T)
+		}
+	}
 	return t
 }
 
-func TnTruthy(v interface{}) bool {
-	switch t := v.(type) {
-	case nil:
-		return false
-	case bool:
-		return t
-	case float64:
-		return t != 0 && !math.IsNaN(t)
-	case string:
-		return t != ""
+// Converts a dynamic value (decoded JSON: maps, []interface{}, float64 …) to a
+// Go type: structs (and pointers to them) field by field, slices element by
+// element, numbers between kinds
+func TnConvertDynamic(v interface{}, t reflect.Type) (reflect.Value, bool) {
+	if v == nil {
+		return reflect.Zero(t), true
 	}
 	rv := reflect.ValueOf(v)
-	switch rv.Kind() {
-	case reflect.Pointer, reflect.Interface, reflect.Map, reflect.Slice:
-		return !rv.IsNil()
+	if rv.Type().AssignableTo(t) {
+		return rv, true
+	}
+	switch t.Kind() {
+	case reflect.Interface:
+		if rv.Type().Implements(t) {
+			return rv, true
+		}
+	case reflect.Pointer:
+		if rv.Kind() == reflect.Pointer && rv.IsNil() {
+			return reflect.Zero(t), true
+		}
+		inner, ok := TnConvertDynamic(v, t.Elem())
+		if !ok {
+			return reflect.Value{}, false
+		}
+		p := reflect.New(t.Elem())
+		p.Elem().Set(inner)
+		return p, true
+	case reflect.Struct:
+		m, ok := v.(map[string]interface{})
+		if props, isRecord := v.(interface{ Entries() [][]interface{} }); !ok && isRecord {
+			// A string-keyed TnMap (a Record, a node:sqlite row)
+			m, ok = map[string]interface{}{}, true
+			for _, e := range props.Entries() {
+				if k, isString := e[0].(string); isString {
+					m[k] = e[1]
+				}
+			}
+		}
+		if !ok {
+			return reflect.Value{}, false
+		}
+		out := reflect.New(t).Elem()
+		for i := 0; i < t.NumField(); i++ {
+			field := t.Field(i)
+			name := strings.TrimSuffix(field.Name, "_")
+			value, present := m[name]
+			if !present {
+				continue
+			}
+			converted, ok := TnConvertDynamic(value, field.Type)
+			if !ok {
+				continue
+			}
+			f := out.Field(i)
+			reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem().Set(converted)
+		}
+		return out, true
+	case reflect.Slice:
+		if rv.Kind() != reflect.Slice {
+			return reflect.Value{}, false
+		}
+		out := reflect.MakeSlice(t, rv.Len(), rv.Len())
+		for i := 0; i < rv.Len(); i++ {
+			converted, ok := TnConvertDynamic(rv.Index(i).Interface(), t.Elem())
+			if !ok {
+				return reflect.Value{}, false
+			}
+			out.Index(i).Set(converted)
+		}
+		return out, true
+	case reflect.Float64, reflect.Float32, reflect.Int, reflect.Int64, reflect.Int32:
+		if rv.CanConvert(t) && rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Float64 {
+			return rv.Convert(t), true
+		}
+	}
+	return reflect.Value{}, false
+}
+
+func TnTruthy(v interface{}) bool {
+	switch t := v.(type) {
+	case nil:
+		return false
+	case bool:
+		return t
+	case float64:
+		return t != 0 && !math.IsNaN(t)
+	case string:
+		return t != ""
+	}
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Pointer, reflect.Interface, reflect.Map, reflect.Slice:
+		return !rv.IsNil()
 	}
 	return true
 }
@@ -8243,6 +9098,31 @@ func tnJSONWrite(buf *bytes.Buffer, rv reflect.Value, indent string, depth int)
 		}
 		buf.WriteByte('}')
 	case reflect.Struct:
+		// Records (TnMap) keep their key order; reached through a pointer, the
+		// struct value needs Addr() for pointer-receiver methods
+		if rv.CanAddr() {
+			if m, ok := rv.Addr().Interface().(interface{ Entries() [][]interface{} }); ok {
+				buf.WriteByte('{')
+				for i, e := range m.Entries() {
+					if i > 0 {
+						buf.WriteByte(',')
+					}
+					tnJSONNewline(buf, indent, depth+1)
+					kd, _ := tnJSONMarshal(fmt.Sprint(e[0]))
+					buf.Write(kd)
+					buf.WriteByte(':')
+					if indent != "" {
+						buf.WriteByte(' ')
+					}
+					tnJSONWrite(buf, reflect.ValueOf(e[1]), indent, depth+1)
+				}
+				if len(m.Entries()) > 0 {
+					tnJSONNewline(buf, indent, depth)
+				}
+				buf.WriteByte('}')
+				return
+			}
+		}
 		if m, ok := rv.Interface().(json.Marshaler); ok {
 			data, err := m.MarshalJSON()
 			if err == nil {
@@ -8323,6 +9203,17 @@ func (m *TnMap[K, V]) Get(k K) V {
 	return m.values[k]
 }
 
+// A string key's value when the map is held in a dynamic value (a Record or a
+// node:sqlite row read as \`row.name\`): TnGet finds it through this method
+func (m *TnMap[K, V]) TnProp(key string) (interface{}, bool) {
+	k, ok := any(key).(K)
+	if !ok || m == nil {
+		return nil, false
+	}
+	v, present := m.values[k]
+	return v, present
+}
+
 func (m *TnMap[K, V]) Lookup(k K) (V, bool) {
 	if m == nil {
 		var zero V
@@ -8447,6 +9338,40 @@ func (m *TnMap[K, V]) All() iter.Seq2[K, V] {
 	}
 }
 
+// JSON objects decode in document order (json.Unmarshal into a ref)
+func (m *TnMap[K, V]) UnmarshalJSON(data []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(data))
+	tok, err := dec.Token()
+	if err != nil {
+		return err
+	}
+	if delim, ok := tok.(json.Delim); !ok || delim != '{' {
+		return fmt.Errorf("json: cannot unmarshal %v into an object", tok)
+	}
+	m.keys = nil
+	m.values = map[K]V{}
+	for dec.More() {
+		tok, err := dec.Token()
+		if err != nil {
+			return err
+		}
+		name, _ := tok.(string)
+		var key K
+		if p, ok := any(&key).(*string); ok {
+			*p = name
+		} else if err := json.Unmarshal([]byte(name), &key); err != nil {
+			return err
+		}
+		var value V
+		if err := dec.Decode(&value); err != nil {
+			return err
+		}
+		m.Set(key, value)
+	}
+	_, err = dec.Token()
+	return err
+}
+
 // JSON objects keep insertion order
 func (m *TnMap[K, V]) MarshalJSON() ([]byte, error) {
 	var buf bytes.Buffer
@@ -9424,81 +10349,17 @@ func TnGroup(groups []string, i int) string {
 		return groups[i]
 	}
 	return ""
-}`,
-    readFile: `func TnReadFile(path string) string {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		panic(err)
-	}
-	return string(data)
-}`,
-    writeFile: `func TnWriteFile(path string, content string) {
-	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-		panic(err)
-	}
-}`,
-    appendFile: `func TnAppendFile(path string, content string) {
-	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
-	if err != nil {
-		panic(err)
-	}
-	defer f.Close()
-	if _, err := f.WriteString(content); err != nil {
-		panic(err)
-	}
-}`,
-    mkdirAll: `func TnMkdirAll(path string) {
-	if err := os.MkdirAll(path, 0o755); err != nil {
-		panic(err)
-	}
-}`,
-    readDir: `func TnReadDir(path string) []string {
-	entries, err := os.ReadDir(path)
-	if err != nil {
-		panic(err)
-	}
-	names := make([]string, 0, len(entries))
-	for _, e := range entries {
-		names = append(names, e.Name())
-	}
-	return names
-}`,
-    copyFile: `func TnCopyFile(src string, dst string) {
-	in, err := os.Open(src)
-	if err != nil {
-		panic(err)
-	}
-	defer in.Close()
-	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
-		panic(err)
-	}
-	out, err := os.Create(dst)
-	if err != nil {
-		panic(err)
-	}
-	defer out.Close()
-	if _, err := io.Copy(out, in); err != nil {
-		panic(err)
-	}
-}`,
-    removeAll: `func TnRemoveAll(path string) {
-	if err := os.RemoveAll(path); err != nil {
-		panic(err)
-	}
-}`,
-    fileURLToPath: `func TnFileURLToPath(u string) string {
-	trimmed := strings.TrimPrefix(u, "file://")
-	if unescaped, err := tnurl.PathUnescape(trimmed); err == nil {
-		trimmed = unescaped
-	}
-	return filepath.FromSlash(trimmed)
 }`,
     pathToFileURL: `func TnPathToFileURL(path string) string {
 	abs, err := filepath.Abs(path)
 	if err != nil {
 		panic(err)
 	}
-	return "file://" + tnurl.PathEscape(filepath.ToSlash(abs))
+	slashed := filepath.ToSlash(abs)
+	if !strings.HasPrefix(slashed, "/") {
+		slashed = "/" + slashed
+	}
+	return "file://" + (&tnurl.URL{Path: slashed}).EscapedPath()
 }`,
     moduleUrl: `// import.meta.url: the file URL of the running program
 func TnModuleURL() string {
@@ -9517,22 +10378,223 @@ func TnModuleURL() string {
 	}
 	return runtime.GOOS
 }`,
-    error: `// TnError: JS Error values (thrown and caught) with a message
+    error: `// TnError: JS Error values (thrown and caught) with a message; Node
+// errors also carry a code ('ENOENT', 'ERR_ASSERTION') and extra properties
 type TnError struct {
 	message string
+	code    string
+	props   map[string]interface{}
+	goErr   error
 }
 
 func (e *TnError) Error() string { return e.message }
 
 func TnNewError(message string) *TnError {
 	return &TnError{message: message}
+}
+
+
+// x instanceof Error / TypeError / …
+func TnIsErrorOf(v interface{}, name string) bool {
+	if name == "Error" {
+		_, ok := v.(error)
+		return ok
+	}
+	e, ok := v.(*TnError)
+	return ok && e.Get_name() == name
+}
+
+// A Node error: name ('TypeError', 'AssertionError'), code and message
+func TnNodeError(name string, code string, message string) *TnError {
+	return &TnError{message: message, code: code, props: map[string]interface{}{"name": name}}
+}
+
+func (e *TnError) prop(key string) interface{} {
+	if e.props == nil {
+		return nil
+	}
+	return e.props[key]
+}
+
+func (e *TnError) Get_name() string {
+	if name, ok := e.prop("name").(string); ok {
+		return name
+	}
+	return "Error"
+}
+
+func (e *TnError) Get_stack() string { return e.Get_name() + ": " + e.message }
+
+func (e *TnError) Get_syscall() string {
+	s, _ := e.prop("syscall").(string)
+	return s
+}
+
+func (e *TnError) Get_path() string {
+	s, _ := e.prop("path").(string)
+	return s
+}
+
+func (e *TnError) Get_errno() float64 {
+	n, _ := e.prop("errno").(float64)
+	return n
+}
+
+func (e *TnError) Get_cause() interface{} { return e.prop("cause") }
+
+func (e *TnError) Get_hostname() string {
+	s, _ := e.prop("hostname").(string)
+	return s
+}
+
+func (e *TnError) Get_address() string {
+	s, _ := e.prop("address").(string)
+	return s
+}
+
+func (e *TnError) Get_port() float64 {
+	n, _ := e.prop("port").(float64)
+	return n
+}
+
+// AssertionError fields
+func (e *TnError) Get_actual() interface{} { return e.prop("actual") }
+
+func (e *TnError) Get_expected() interface{} { return e.prop("expected") }
+
+func (e *TnError) Get_operator() string {
+	s, _ := e.prop("operator").(string)
+	return s
+}
+
+func (e *TnError) Get_generatedMessage() bool {
+	b, _ := e.prop("generatedMessage").(bool)
+	return b
+}`,
+    asyncWait: `// Pending async work (promise callbacks, detached async calls) keeps the
+// event loop alive until it settles
+var __tnWaitGroup tnLoopGroup`,
+    bigint: `// Base from the literal's prefix (0x / 0o / 0b), decimal otherwise
+func TnBigInt(s string) *tnbig.Int {
+	v, ok := new(tnbig.Int).SetString(s, 0)
+	if !ok {
+		v, _ = new(tnbig.Int).SetString(s, 10)
+	}
+	return v
+}
+
+// x === 1n where x is a dynamic (number | bigint) value
+func TnBigSame(v interface{}, b *tnbig.Int) bool {
+	x, ok := v.(*tnbig.Int)
+	return ok && x != nil && b != nil && x.Cmp(b) == 0
+}
+
+// A dynamic value as a bigint operand: a bigint, or an integral number
+func TnToBigInt(v interface{}) *tnbig.Int {
+	switch x := v.(type) {
+	case *tnbig.Int:
+		if x != nil {
+			return x
+		}
+	case float64:
+		if x == math.Trunc(x) && !math.IsInf(x, 0) {
+			b, _ := new(tnbig.Float).SetFloat64(x).Int(nil)
+			return b
+		}
+	}
+	panic(TnNodeError("TypeError", "", "Cannot mix BigInt and other types, use explicit conversions"))
 }`,
-    asyncWait: `// Pending async work (promise callbacks, detached async calls) is drained
-// before the process exits
-var __tnWaitGroup sync.WaitGroup`,
-    bigint: `func TnBigInt(s string) *tnbig.Int {
-	v, _ := new(tnbig.Int).SetString(s, 10)
+    goMust: `// Go bridge: (T, error) results throw a *TnError carrying the Go error
+func tnGoError(err error) *TnError {
+	return &TnError{message: err.Error(), goErr: err}
+}
+
+func tnGoMust[T any](v T, err error) T {
+	if err != nil {
+		panic(tnGoError(err))
+	}
 	return v
+}
+
+func tnGoMust2[A any, B any](a A, b B, err error) (A, B) {
+	if err != nil {
+		panic(tnGoError(err))
+	}
+	return a, b
+}
+
+func tnGoCheck(err error) {
+	if err != nil {
+		panic(tnGoError(err))
+	}
+}`,
+    goNums: `// Go bridge: numeric slice conversion ([]int ↔ []float64)
+type tnGoNumber interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+		~float32 | ~float64
+}
+
+func tnGoNums[T tnGoNumber](s []float64) []T {
+	out := make([]T, len(s))
+	for i, v := range s {
+		out[i] = T(v)
+	}
+	return out
+}
+
+func tnGoFromNums[T tnGoNumber](s []T) []float64 {
+	out := make([]float64, len(s))
+	for i, v := range s {
+		out[i] = float64(v)
+	}
+	return out
+}`,
+    goStrings: `// Go bridge: first rune of a string (unicode funcs take rune)
+func tnGoRune(s string) rune {
+	for _, r := range s {
+		return r
+	}
+	return 0
+}`,
+    goBlocking: `// Go bridge: blocking calls run on a goroutine while the baton holder
+// pumps pending loop tasks, so timers and handlers keep running
+func tnGoBlocking(fn func() interface{}) interface{} {
+	done := make(chan interface{}, 1)
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				done <- r
+				return
+			}
+		}()
+		done <- fn()
+	}()
+	for {
+		select {
+		case v := <-done:
+			if err, ok := v.(*TnError); ok {
+				panic(err)
+			}
+			return v
+		default:
+		}
+		TnRunMicrotasks()
+		if TnLoopRunPending() {
+			continue
+		}
+		tnRelease()
+		select {
+		case v := <-done:
+			tnAcquire()
+			if err, ok := v.(*TnError); ok {
+				panic(err)
+			}
+			return v
+		case <-tnLoopSignal:
+			tnAcquire()
+		}
+	}
 }`,
     symbol: `// TnSymbol: JS symbol values (unique by identity)
 type TnSymbol struct {
@@ -9542,79 +10604,438 @@ type TnSymbol struct {
 func TnNewSymbol(description string) *TnSymbol {
 	return &TnSymbol{description: description}
 }`,
-    timerWait: `// Pending setTimeout timers are waited on before the process exits
-var __tnTimers sync.WaitGroup
+    timerWait: `// Timers: callbacks run on the event loop; pending (ref'ed) timers keep the process alive
+var __tnTimers tnLoopGroup
+
+// A setTimeout / setImmediate handle (Node's Timeout: ref / unref / hasRef / refresh / close)
+type TnTimeout struct {
+	timer  *time.Timer
+	ms     float64
+	fn     func()
+	refd   bool
+	active bool
+	gen    int
+}
+
+// node:test mock timers: when set (and the API is mocked) it takes over a timer;
+// run calls the callback and reports whether the timer repeats
+var tnMockTimerHook func(kind string, ms float64, run func() bool) bool
+
+func TnSetTimeout(ms float64, fn func()) *TnTimeout { return tnSetTimeout("setTimeout", ms, fn) }
+
+func TnSetImmediate(fn func()) *TnTimeout { return tnSetTimeout("setImmediate", 0, fn) }
 
-func TnSetTimeout(ms float64, fn func()) *time.Timer {
+func tnSetTimeout(kind string, ms float64, fn func()) *TnTimeout {
+	t := &TnTimeout{ms: ms, fn: TnAsyncWrap(fn), active: true}
+	if tnMockTimerHook != nil && tnMockTimerHook(kind, ms, func() bool {
+		if t.active {
+			t.active = false
+			t.fn()
+		}
+		return false
+	}) {
+		return t
+	}
 	__tnTimers.Add(1)
-	return time.AfterFunc(time.Duration(ms*float64(time.Millisecond)), func() {
-		defer __tnTimers.Done()
-		fn()
-		TnRunMicrotasks()
+	t.refd = true
+	t.arm()
+	return t
+}
+
+func (t *TnTimeout) arm() {
+	t.gen++
+	gen := t.gen
+	t.timer = time.AfterFunc(time.Duration(t.ms*float64(time.Millisecond)), func() {
+		TnLoopPost(func() {
+			if !t.active || gen != t.gen {
+				return
+			}
+			t.active = false
+			if t.refd {
+				t.refd = false
+				__tnTimers.Done()
+			}
+			t.fn()
+		})
 	})
 }
 
-// setInterval: fn every ms until cleared (the process lives until then)
+func (t *TnTimeout) ref() *TnTimeout {
+	if !t.refd && t.active {
+		t.refd = true
+		__tnTimers.Add(1)
+	}
+	return t
+}
+
+func (t *TnTimeout) unref() *TnTimeout {
+	if t.refd {
+		t.refd = false
+		__tnTimers.Done()
+	}
+	return t
+}
+
+func (t *TnTimeout) hasRef() bool { return t.refd }
+
+// refresh(): restarts the countdown (a fired timeout runs again)
+func (t *TnTimeout) refresh() *TnTimeout {
+	if t.timer == nil && t.active && !t.refd {
+		// A mocked timer: node:test's clock owns it
+		return t
+	}
+	if t.timer != nil {
+		t.timer.Stop()
+	}
+	if !t.active {
+		t.active = true
+		if !t.refd {
+			t.refd = true
+			__tnTimers.Add(1)
+		}
+	}
+	t.arm()
+	return t
+}
+
+func (t *TnTimeout) close() *TnTimeout {
+	TnClearTimeout(t)
+	return t
+}
+
+// setInterval: fn every ms until cleared (the process lives until then, unless unref'ed)
 type TnInterval struct {
-	stop chan struct{}
-	once sync.Once
+	stop    chan struct{}
+	once    sync.Once
+	stopped int32
+	refd    bool
+	ms      float64
+	fn      func()
 }
 
 func TnSetInterval(ms float64, fn func()) *TnInterval {
+	t := &TnInterval{stop: make(chan struct{}), ms: ms, fn: TnAsyncWrap(fn)}
+	if tnMockTimerHook != nil && tnMockTimerHook("setInterval", ms, func() bool {
+		if atomic.LoadInt32(&t.stopped) != 0 {
+			return false
+		}
+		t.fn()
+		return atomic.LoadInt32(&t.stopped) == 0
+	}) {
+		return t
+	}
 	__tnTimers.Add(1)
-	t := &TnInterval{stop: make(chan struct{})}
+	t.refd = true
+	t.start(t.stop)
+	return t
+}
+
+func (t *TnInterval) start(stop chan struct{}) {
 	go func() {
-		ticker := time.NewTicker(max(time.Duration(ms*float64(time.Millisecond)), time.Millisecond))
+		ticker := time.NewTicker(max(time.Duration(t.ms*float64(time.Millisecond)), time.Millisecond))
 		defer ticker.Stop()
 		for {
 			select {
-			case <-t.stop:
+			case <-stop:
 				return
 			case <-ticker.C:
-				fn()
-				TnRunMicrotasks()
+				TnLoopPost(func() {
+					if atomic.LoadInt32(&t.stopped) == 0 {
+						t.fn()
+					}
+				})
 			}
 		}
 	}()
-	return t
 }
 
 func TnClearInterval(t *TnInterval) {
 	if t != nil {
 		t.once.Do(func() {
+			atomic.StoreInt32(&t.stopped, 1)
 			close(t.stop)
-			__tnTimers.Done()
+			if t.refd {
+				t.refd = false
+				__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 (t *TnInterval) ref() *TnInterval {
+	if !t.refd && atomic.LoadInt32(&t.stopped) == 0 {
+		t.refd = true
+		__tnTimers.Add(1)
+	}
+	return t
+}
 
-func TnQueueMicrotask(fn func()) {
-	tnMicrotasksMu.Lock()
-	tnMicrotasks = append(tnMicrotasks, fn)
-	tnMicrotasksMu.Unlock()
+func (t *TnInterval) unref() *TnInterval {
+	if t.refd {
+		t.refd = false
+		__tnTimers.Done()
+	}
+	return t
 }
 
-func TnRunMicrotasks() {
-	for {
-		tnMicrotasksMu.Lock()
-		if len(tnMicrotasks) == 0 {
-			tnMicrotasksMu.Unlock()
-			return
-		}
-		fn := tnMicrotasks[0]
-		tnMicrotasks = tnMicrotasks[1:]
-		tnMicrotasksMu.Unlock()
+func (t *TnInterval) hasRef() bool { return t.refd }
+
+func (t *TnInterval) refresh() *TnInterval {
+	if atomic.LoadInt32(&t.stopped) == 0 {
+		close(t.stop)
+		t.stop = make(chan struct{})
+		t.start(t.stop)
+	}
+	return t
+}
+
+func (t *TnInterval) close() *TnInterval {
+	TnClearInterval(t)
+	return t
+}
+
+func TnClearTimeout(t *TnTimeout) {
+	if t != nil && t.active {
+		t.active = false
+		if t.timer != nil {
+			t.timer.Stop()
+		}
+		if t.refd {
+			t.refd = false
+			__tnTimers.Done()
+		}
+	}
+}`,
+    clock: `// The current time; node:test mock timers can replace it (Date.now / new Date())
+var tnClockHook func() time.Time
+
+func TnTimeNow() time.Time {
+	if tnClockHook != nil {
+		return tnClockHook()
+	}
+	return time.Now()
+}`,
+    eventLoop: `// The event loop. JS runs one thing at a time: whoever holds the
+// baton (main, a loop task, a running async function body) runs JS code; the
+// others wait. An await runs pending loop tasks, then hands the baton over
+// while it waits. Callbacks from timers, I/O and other goroutines are posted
+// as tasks. Refs (pending timers, async work, open handles) keep it alive.
+var tnLoopMu sync.Mutex
+var tnLoopTasks []func()
+var tnLoopSignal = make(chan struct{}, 1)
+var tnLoopRefs int64
+
+// The baton: free when it sits in the channel (main holds it at start).
+// A call of an async function lends it to the body until its first await.
+var tnBaton = make(chan struct{}, 1)
+var tnLendStack []chan struct{}
+
+// Async context (AsyncLocalStorage): the baton holder's current stores. Callbacks
+// scheduled by JS code capture it (TnAsyncWrap) and run with it restored; an await
+// resumes with the context it started with. Other loop tasks run without stores.
+type TnAsyncContext map[interface{}]interface{}
+
+var tnAsyncCtx TnAsyncContext
+
+func TnAsyncSnapshot() TnAsyncContext { return tnAsyncCtx }
+
+// Runs fn with ctx as the current context, restoring the previous one afterwards
+func TnAsyncRun(ctx TnAsyncContext, fn func()) {
+	saved := tnAsyncCtx
+	tnAsyncCtx = ctx
+	defer func() { tnAsyncCtx = saved }()
+	fn()
+}
+
+// fn bound to the current context (no-op when there is none to keep)
+func TnAsyncWrap(fn func()) func() {
+	ctx := tnAsyncCtx
+	if ctx == nil {
+		return fn
+	}
+	return func() { TnAsyncRun(ctx, fn) }
+}
+
+func tnAcquire() { <-tnBaton }
+
+func tnRelease() {
+	if n := len(tnLendStack); n > 0 {
+		lender := tnLendStack[n-1]
+		tnLendStack = tnLendStack[:n-1]
+		close(lender)
+		return
+	}
+	tnBaton <- struct{}{}
+}
+
+// Runs an async function body: synchronously until its first await (or the
+// end), then the caller continues while the body waits
+func TnStartAsync(body func()) {
+	yielded := make(chan struct{})
+	tnLendStack = append(tnLendStack, yielded)
+	ctx := tnAsyncCtx
+	go func() {
+		defer tnRelease()
+		tnAsyncCtx = ctx
+		body()
+	}()
+	<-yielded
+	tnAsyncCtx = ctx
+}
+
+func tnLoopNotify() {
+	select {
+	case tnLoopSignal <- struct{}{}:
+	default:
+	}
+}
+
+func TnLoopRef() { atomic.AddInt64(&tnLoopRefs, 1) }
+
+func TnLoopUnref() {
+	atomic.AddInt64(&tnLoopRefs, -1)
+	tnLoopNotify()
+}
+
+func TnLoopPost(fn func()) {
+	tnLoopMu.Lock()
+	tnLoopTasks = append(tnLoopTasks, fn)
+	tnLoopMu.Unlock()
+	tnLoopNotify()
+}
+
+// Runs a callback on the loop from a goroutine that does not hold the baton,
+// and waits for it
+func TnLoopCall(fn func()) {
+	done := make(chan struct{})
+	TnLoopPost(func() {
+		defer close(done)
 		fn()
+	})
+	<-done
+}
+
+// (baton holder) Runs the queued tasks, each followed by its microtasks
+func TnLoopRunPending() bool {
+	ran := false
+	for {
+		tnLoopMu.Lock()
+		if len(tnLoopTasks) == 0 {
+			tnLoopMu.Unlock()
+			return ran
+		}
+		fn := tnLoopTasks[0]
+		tnLoopTasks = tnLoopTasks[1:]
+		tnLoopMu.Unlock()
+		ran = true
+		tnRunTask(fn)
+		TnRunMicrotasks()
 	}
 }
 
-func TnClearTimeout(t *time.Timer) {
-	if t != nil && t.Stop() {
-		__tnTimers.Done()
+// Set by process.on('uncaughtException'): handles a throw escaping a loop task
+// (true when handled); 'beforeExit' runs when the loop drains (true when it emitted)
+var tnUncaughtHook func(err interface{}) bool
+var tnBeforeExitHook func() bool
+
+func tnRunTask(fn func()) {
+	if tnUncaughtHook != nil {
+		defer func() {
+			if r := recover(); r != nil {
+				if !tnUncaughtHook(r) {
+					panic(r)
+				}
+			}
+		}()
+	}
+	TnAsyncRun(nil, fn)
+}
+
+func tnLoopIdle() bool {
+	tnLoopMu.Lock()
+	defer tnLoopMu.Unlock()
+	return len(tnLoopTasks) == 0 && atomic.LoadInt64(&tnLoopRefs) <= 0
+}
+
+// The end of main: run until nothing is pending
+func TnRunLoop() {
+	for {
+		TnRunMicrotasks()
+		TnLoopRunPending()
+		if tnLoopIdle() {
+			if tnBeforeExitHook == nil || !tnBeforeExitHook() {
+				return
+			}
+			TnRunMicrotasks()
+			TnLoopRunPending()
+			if tnLoopIdle() {
+				return
+			}
+			continue
+		}
+		tnRelease()
+		select {
+		case <-tnLoopSignal:
+		case <-time.After(10 * time.Millisecond):
+		}
+		tnAcquire()
+	}
+}
+
+// (baton holder) Receives from a channel, running loop tasks while waiting
+func TnLoopReceive[T any](ch chan T) (T, bool) {
+	ctx := tnAsyncCtx
+	defer func() { tnAsyncCtx = ctx }()
+	for {
+		select {
+		case v, ok := <-ch:
+			return v, ok
+		default:
+		}
+		TnRunMicrotasks()
+		if TnLoopRunPending() {
+			continue
+		}
+		tnRelease()
+		select {
+		case v, ok := <-ch:
+			tnAcquire()
+			return v, ok
+		case <-tnLoopSignal:
+			tnAcquire()
+		}
+	}
+}
+
+// A wait group that keeps the loop alive (detached async calls, .then callbacks)
+type tnLoopGroup struct{}
+
+func (tnLoopGroup) Add(n int) { atomic.AddInt64(&tnLoopRefs, int64(n)) }
+func (tnLoopGroup) Done()     { TnLoopUnref() }
+func (tnLoopGroup) Wait()     { TnRunLoop() }
+
+// queueMicrotask: run after the current synchronous code (end of main or of a loop task)
+var tnMicrotasks []func()
+var tnMicrotasksMu sync.Mutex
+
+func TnQueueMicrotask(fn func()) {
+	fn = TnAsyncWrap(fn)
+	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()
+		TnAsyncRun(nil, fn)
 	}
 }`,
     uri: `// encodeURIComponent: escapes everything except A-Z a-z 0-9 - _ . ! ~ * ' ( )
@@ -9851,11 +11272,76 @@ func TnDecorateClass(result interface{}) {
     promise: `// Promises are channels; a rejected promise is a closed channel with a reason
 var tnRejections sync.Map
 
+// A throw inside a Promise executor rejects the promise
+func TnRejectExecutor[T any](ch chan T) {
+	if r := recover(); r != nil {
+		if _, rejected := tnRejections.Load(ch); !rejected && len(ch) == 0 {
+			TnReject(ch, r)
+		}
+	}
+}
+
+func TnResolveZero[T any](ch chan T) {
+	var zero T
+	select {
+	case ch <- zero:
+	default:
+	}
+}
+
+// resolve / reject of a Promise executor used as values
+func TnResolver[T any](ch chan T) func(...interface{}) {
+	return func(args ...interface{}) {
+		var v T
+		if len(args) > 0 {
+			if x, ok := args[0].(T); ok {
+				v = x
+			}
+		}
+		select {
+		case ch <- v:
+		default:
+		}
+	}
+}
+
+func TnRejecter[T any](ch chan T) func(...interface{}) {
+	return func(args ...interface{}) {
+		var reason interface{}
+		if len(args) > 0 {
+			reason = args[0]
+		}
+		if _, rejected := tnRejections.Load(ch); rejected || len(ch) > 0 {
+			return
+		}
+		TnReject(ch, reason)
+	}
+}
+
 func TnReject[T any](ch chan T, reason interface{}) {
 	tnRejections.Store(ch, reason)
 	close(ch)
 }
 
+// A detached call (\`main();\`): the process waits for it; a rejection is fatal
+// unless process.on('unhandledRejection') takes it
+var tnUnhandledHook func(reason interface{}) bool
+
+func TnDetach[T any](ch chan T) {
+	go func() {
+		defer __tnWaitGroup.Done()
+		_, reason, rejected := tnSettle(ch)
+		if rejected {
+			TnLoopCall(func() {
+				if tnUnhandledHook != nil && tnUnhandledHook(reason) {
+					return
+				}
+				panic(reason)
+			})
+		}
+	}()
+}
+
 // Deferred in async functions: a throw rejects the function's promise
 func TnRejectOnPanic[T any](ch chan T) {
 	if r := recover(); r != nil {
@@ -9863,9 +11349,7 @@ func TnRejectOnPanic[T any](ch chan T) {
 	}
 }
 
-// Waits for a promise: its value, or its rejection reason
-func tnSettle[T any](ch chan T) (T, interface{}, bool) {
-	v, ok := <-ch
+func tnSettled[T any](ch chan T, v T, ok bool) (T, interface{}, bool) {
 	if !ok {
 		if reason, rejected := tnRejections.Load(ch); rejected {
 			return v, reason, true
@@ -9874,9 +11358,16 @@ func tnSettle[T any](ch chan T) (T, interface{}, bool) {
 	return v, nil, false
 }
 
-// await: the value, or the rejection rethrown
+// Waits for a promise (helper goroutines, without the baton): its value, or its rejection reason
+func tnSettle[T any](ch chan T) (T, interface{}, bool) {
+	v, ok := <-ch
+	return tnSettled(ch, v, ok)
+}
+
+// await (baton holder): the value, or the rejection rethrown; loop tasks run meanwhile
 func TnAwait[T any](ch chan T) T {
-	v, reason, rejected := tnSettle(ch)
+	received, ok := TnLoopReceive(ch)
+	v, reason, rejected := tnSettled(ch, received, ok)
 	if rejected {
 		panic(reason)
 	}
@@ -9891,11 +11382,12 @@ func TnPromiseReject[T any](reason interface{}) chan T {
 
 func TnPromiseCatch[T any, E any](p chan T, onRejected func(E)) chan T {
 	out := make(chan T, 1)
+	ctx := TnAsyncSnapshot()
 	go func() {
 		v, reason, rejected := tnSettle(p)
 		if rejected {
 			e, _ := reason.(E)
-			onRejected(e)
+			TnLoopCall(func() { TnAsyncRun(ctx, func() { onRejected(e) }) })
 		}
 		out <- v
 		close(out)
@@ -9905,11 +11397,12 @@ func TnPromiseCatch[T any, E any](p chan T, onRejected func(E)) chan T {
 
 func TnPromiseCatchValue[T any, E any](p chan T, onRejected func(E) T) chan T {
 	out := make(chan T, 1)
+	ctx := TnAsyncSnapshot()
 	go func() {
 		v, reason, rejected := tnSettle(p)
 		if rejected {
 			e, _ := reason.(E)
-			v = onRejected(e)
+			TnLoopCall(func() { TnAsyncRun(ctx, func() { v = onRejected(e) }) })
 		}
 		out <- v
 		close(out)
@@ -9919,9 +11412,10 @@ func TnPromiseCatchValue[T any, E any](p chan T, onRejected func(E) T) chan T {
 
 func TnPromiseFinally[T any](p chan T, onFinally func()) chan T {
 	out := make(chan T, 1)
+	onFinally = TnAsyncWrap(onFinally)
 	go func() {
 		v, reason, rejected := tnSettle(p)
-		onFinally()
+		TnLoopCall(onFinally)
 		if rejected {
 			TnReject(out, reason)
 			return
@@ -10022,170 +11516,587 @@ func TnPromiseAll[T any](chs []chan T) chan []T {
 		close(out)
 	}()
 	return out
-}`,
-    exec: `type tnExecResult struct {
-	stdout   string
-	stderr   string
-	status   float64
-}
-
-func TnExec(name string, args ...string) tnExecResult {
-	cmd := exec.Command(name, args...)
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	err := cmd.Run()
-	status := 0.0
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			status = float64(exitErr.ExitCode())
-		} else {
-			panic(err)
-		}
-	}
-	return tnExecResult{stdout: stdout.String(), stderr: stderr.String(), status: status}
-}
-
-func TnExecShell(command string) tnExecResult {
-	if runtime.GOOS == "windows" {
-		return TnExec("cmd", "/C", command)
-	}
-	return TnExec("sh", "-c", command)
-}`,
-    execSync: `func TnExecShellSync(command string) string {
-	result := TnExecShell(command)
-	if result.status != 0 {
-		panic(result.stderr)
-	}
-	return result.stdout
 }`,
     getenv: `func TnGetenv(name string) string {
 	return os.Getenv(name)
 }`,
-    execInput: `func TnExecInput(name string, input string, args ...string) tnExecResult {
-	cmd := exec.Command(name, args...)
-	cmd.Stdin = strings.NewReader(input)
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	err := cmd.Run()
-	status := 0.0
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			status = float64(exitErr.ExitCode())
-		} else {
-			panic(err)
-		}
-	}
-	return tnExecResult{stdout: stdout.String(), stderr: stderr.String(), status: status}
-}`,
-    runInherit: `func TnRunInherit(name string, args ...string) tnExecResult {
-	cmd := exec.Command(name, args...)
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	err := cmd.Run()
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			return tnExecResult{status: float64(exitErr.ExitCode())}
-		}
-		panic(err)
-	}
-	return tnExecResult{}
-}`,
-    question: `var tnStdinReader = bufio.NewReader(os.Stdin)
-
-func TnQuestion(prompt string) string {
-	if prompt != "" {
-		fmt.Print(prompt)
-	}
-	// Reuse one buffered reader: a fresh reader per call would discard
-	// buffered stdin and hit EOF on the second question.
-	line, err := tnStdinReader.ReadString('\\n')
-	if err != nil && line == "" {
-		panic(err)
-	}
-	return strings.TrimRight(line, "\\r\\n")
-}`
 };
 // Returns the Go source for all helpers used in this transpilation, or '' if none.
 // Emitted only into the main output file: every generated file shares `package main`,
 // so helpers are visible across files and must not be duplicated.
 function emitGoHelpers() {
-    return [...usedHelpers]
+    const sources = [...usedHelpers]
         .sort()
-        .map((id) => goHelpers[id])
-        .filter(Boolean)
-        .join('\n\n');
-}
-// Result types of the mapped Node.js stdlib functions ('' = no result)
-const NODE_FUNCTION_TYPES = {
-    path: {
-        join: 'string',
-        resolve: 'string',
-        dirname: 'string',
-        basename: 'string',
-        extname: 'string',
-        relative: 'string',
-        normalize: 'string'
-    },
-    fs: {
-        readFileSync: 'string',
-        existsSync: 'bool',
-        readdirSync: '[]string',
-        writeFileSync: '',
-        appendFileSync: '',
-        mkdirSync: '',
-        copyFileSync: '',
-        rmSync: '',
-        unlinkSync: ''
-    },
-    os: { platform: 'string', homedir: 'string', tmpdir: 'string' },
-    url: { fileURLToPath: 'string', pathToFileURL: 'string' },
-    child_process: { execSync: 'string' },
-    readline: { question: 'string' }
-};
-// Result types of imported Node.js functions by their local callee text
-// (`join`, `path.join`)
-const nodeCallResultTypes = new Map();
-// Mapping from Node.js stdlib module names to Go setup functions.
-// Each entry adds the required Go imports and registers call handlers for the local identifier.
+        .map((id) => goHelpers[id] ?? nodeRegistry.goHelpers[id])
+        .filter(Boolean);
+    if (usedHelpers.has('nodeUtil')) {
+        const names = [...classNames].sort().map((name) => `${toGoStringLiteral(getSafeName(name))}: true`);
+        sources.push(`// Classes util.inspect prints as \`Name { … }\`\nvar tnInspectClassNames = map[string]bool{${names.join(', ')}}`);
+    }
+    return sources.join('\n\n');
+}
+/// Local names bound by Node.js imports → registry keys ('join' → 'path.join',
+// 'fs' → 'fs', 'fsp' → 'fs/promises', 'EventEmitter' → 'events.EventEmitter')
+const nodeLocalNames = new Map();
+// The registry name of a Node module specifier ('node:fs', 'fs', 'node:sys' → 'util'),
+// or '' when it is not a (supported) builtin
+function nodeModuleName(spec) {
+    const prefixed = spec.startsWith('node:');
+    let name = prefixed ? spec.slice(5) : spec;
+    if (nodeRegistry.aliases[name])
+        name = nodeRegistry.aliases[name];
+    if (nodeRegistry.modules[name])
+        return name;
+    if (prefixed)
+        console.warn(`[TypeNative] Unsupported Node.js module: ${spec}`);
+    return '';
+}
+// Binds the import's local names to registry keys
 function setupNodeModuleImport(node, nodeModule) {
-    const mapping = nodeModuleMappings[nodeModule];
-    if (!mapping)
-        return;
     const clause = node.importClause;
     if (!clause)
         return;
-    if (clause.namedBindings && isNamedImports(clause.namedBindings)) {
-        // Named imports: `import { join, dirname } from 'node:path'`
-        // Map each local name directly to its Go qualified function via importAliases,
-        // so bare calls like `join(...)` resolve to `filepath.Join(...)`.
-        for (const el of clause.namedBindings.elements) {
-            if (el.isTypeOnly)
-                continue;
-            const localName = el.name.text;
-            const importedName = el.propertyName?.text ?? localName;
-            const resultType = NODE_FUNCTION_TYPES[nodeModule]?.[importedName];
-            if (resultType !== undefined)
-                nodeCallResultTypes.set(localName, resultType);
-            const fn = mapping.functions[importedName];
-            if (fn) {
-                // Register a call handler keyed on the local name
-                callHandlers[localName] = (_caller, args) => fn(args);
+    const defaultKey = nodeRegistry.namespaces[`${nodeModule}.default`] || nodeModule;
+    if (clause.name)
+        nodeLocalNames.set(clause.name.text, defaultKey);
+    const bindings = clause.namedBindings;
+    if (!bindings)
+        return;
+    if (isNamespaceImport(bindings)) {
+        nodeLocalNames.set(bindings.name.text, nodeModule);
+        return;
+    }
+    for (const el of bindings.elements ?? []) {
+        const importedName = el.propertyName?.text ?? el.name.text;
+        if (importedName === 'default') {
+            nodeLocalNames.set(el.name.text, defaultKey);
+            continue;
+        }
+        const key = `${nodeModule}.${importedName}`;
+        nodeLocalNames.set(el.name.text, nodeRegistry.namespaces[key] || key);
+    }
+}
+// A Node global (Buffer, URL, process…) not shadowed by a user declaration
+function nodeGlobalKey(name) {
+    const key = nodeRegistry.globals[name];
+    if (!key || typeof key !== 'string')
+        return '';
+    if (variableGoTypes.has(name) || classNames.has(name) || declaredFunctions.has(name) || importAliases.has(name))
+        return '';
+    return key;
+}
+// Registry key of a Node binding expression (`join`, `fs.promises.readFile`,
+// `Buffer.from`, `(childProcess as any).spawnSync`), or '' when it is not one
+function resolveNodeKey(expr) {
+    if (!expr)
+        return '';
+    if (isIdentifier(expr)) {
+        if (nodeLocalNames.has(expr.text))
+            return nodeLocalNames.get(expr.text) ?? '';
+        return nodeGlobalKey(expr.text);
+    }
+    if (isParenthesizedExpression(expr) || isAsExpression(expr) || isNonNullExpression(expr)) {
+        return resolveNodeKey(expr.expression);
+    }
+    // util.promisify(fs.readFile) → fs/promises.readFile
+    if (isCallExpression(expr) && resolveNodeKey(expr.expression) === 'util.promisify') {
+        return nodePromisifiedKey((expr.arguments ?? [])[0]);
+    }
+    if (isPropertyAccessExpression(expr) && !expr.questionDotToken) {
+        const base = resolveNodeKey(expr.expression);
+        if (!base)
+            return '';
+        const key = `${base}.${expr.name.text}`;
+        return nodeRegistry.namespaces[key] || key;
+    }
+    return '';
+}
+// The promise variant of a Node function, '' when it has none
+function nodePromisifiedKey(fnExpr) {
+    let key = resolveNodeKey(fnExpr);
+    if (!key && isIdentifier(fnExpr) && (fnExpr.text === 'setTimeout' || fnExpr.text === 'setImmediate')) {
+        key = `timers.${fnExpr.text}`;
+    }
+    if (!key)
+        return '';
+    if (nodeRegistry.functions[`${key}.__promisify__`])
+        return `${key}.__promisify__`;
+    const dot = key.lastIndexOf('.');
+    const mod = key.slice(0, dot);
+    const name = key.slice(dot + 1);
+    const promisesKey = `${mod}/promises.${name}`;
+    if (nodeRegistry.functions[promisesKey])
+        return promisesKey;
+    return '';
+}
+// The Node class of a Go type ('*TnEventEmitter', '[]byte'), '' when none
+function nodeClassKeyOfType(goType) {
+    if (!goType)
+        return '';
+    return nodeRegistry.classByGoType[goType] ?? '';
+}
+// A user class extending a Node class (class X extends Transform): the Node
+// class key, for methods the user classes in the chain do not declare
+function nodeAncestorClassKey(goType, methodName) {
+    if (!goType || !goType.startsWith('*'))
+        return '';
+    let name = goType.slice(1).replace(/\[.*\]$/, '');
+    for (let depth = 0; depth < 20 && classParentNames.has(name); depth++) {
+        if (declaredClassHasMethod(name, methodName))
+            return '';
+        const parent = classParentNames.get(name) ?? '';
+        if (nodeParentClassKeys.has(parent))
+            return nodeParentClassKeys.get(parent) ?? '';
+        name = parent;
+    }
+    return '';
+}
+function declaredClassHasMethod(className, methodName) {
+    const decl = declaredClasses.get(className);
+    for (const member of decl?.members ?? []) {
+        if (member.name && isIdentifier(member.name) && member.name.text === methodName)
+            return true;
+    }
+    return false;
+}
+// The Node class key a type name refers to (imported or global), '' when none
+function nodeClassKeyOfName(name) {
+    const key = nodeLocalNames.has(name) ? (nodeLocalNames.get(name) ?? '') : nodeGlobalKey(name);
+    return key && nodeRegistry.classes[key] ? key : '';
+}
+// new Error(message, { cause }): the options set error.cause
+function withErrorOptions(errorExpr, options) {
+    if (!options)
+        return errorExpr;
+    useHelper('dynamic');
+    return `TnErrorWithOptions(${errorExpr}, ${visit(options)})`;
+}
+// The Node class key of a (qualified) type reference: `Stats`, `fs.Stats`, `NodeJS.ErrnoException`
+function nodeClassKeyOfTypeName(typeName) {
+    if (isIdentifier(typeName))
+        return nodeClassKeyOfName(typeName.text);
+    if (typeName?.kind === 'QualifiedName') {
+        const base = nodeQualifiedTypeBase(typeName.left);
+        if (!base)
+            return '';
+        const key = `${base}.${typeName.right.text}`;
+        return nodeRegistry.classes[key] ? key : '';
+    }
+    return '';
+}
+function nodeQualifiedTypeBase(left) {
+    if (isIdentifier(left))
+        return nodeLocalNames.has(left.text) ? (nodeLocalNames.get(left.text) ?? '') : nodeGlobalKey(left.text);
+    if (left?.kind === 'QualifiedName') {
+        const base = nodeQualifiedTypeBase(left.left);
+        return base ? `${base}.${left.right.text}` : '';
+    }
+    return '';
+}
+// Option-object methods of Node constructors: their parameters get Node's types
+function applyNodeOptionTypes(key, options) {
+    const typer = nodeRegistry.optionTypers[key];
+    if (!typer || !isObjectLiteralExpression(options))
+        return;
+    const types = typer(options);
+    for (const prop of options.properties ?? []) {
+        if (!prop.name || !isIdentifier(prop.name))
+            continue;
+        const name = prop.name.text;
+        if (!(name in types))
+            continue;
+        if (prop.kind === 'MethodDeclaration')
+            prop.tnParamTypes = types[name];
+        else if (isPropertyAssignment(prop) && (isArrowFunction(prop.initializer) || isFunctionExpression(prop.initializer))) {
+            prop.initializer.tnParamTypes = types[name];
+        }
+    }
+}
+// Applies the registry's callback parameter types to the callback argument
+function applyNodeParamTypes(key, args) {
+    const typer = nodeRegistry.paramTypers[key];
+    if (!typer)
+        return;
+    for (let i = args.length - 1; i >= 0; i--) {
+        if (isArrowFunction(args[i]) || isFunctionExpression(args[i])) {
+            args[i].tnParamTypes = typer(args);
+            return;
+        }
+    }
+}
+function makeNodeCall(node, recv) {
+    const nodes = node.arguments ?? [];
+    const hasSpread = nodes.some((a) => isSpreadElement(a));
+    const args = hasSpread ? visitSpreadCallArguments(node) : nodes.map((a) => visit(a));
+    const types = nodes.map((a) => inferExpressionType(a) ?? '');
+    return { args, nodes, types, recv };
+}
+// Calls of Node APIs: imported functions, statics (Buffer.from) and methods of
+// Node class instances
+function visitNodeCall(node) {
+    const callee = node.expression;
+    const key = resolveNodeKey(callee);
+    if (key) {
+        const emit = nodeRegistry.functions[key];
+        if (emit) {
+            applyNodeParamTypes(key, node.arguments ?? []);
+            return emit(makeNodeCall(node, ''));
+        }
+        // node:console re-exports the global console
+        if (key.startsWith('console.') && callHandlers[key]) {
+            const call = makeNodeCall(node, '');
+            currentCallArgTypes = call.types.map((t) => t || undefined);
+            const consoleCall = callHandlers[key](key, call.args, '');
+            return consoleCall;
+        }
+        return undefined;
+    }
+    if (!isPropertyAccessExpression(callee) || callee.questionDotToken)
+        return undefined;
+    const receiverType = inferExpressionType(callee.expression);
+    const classKey = nodeClassKeyOfType(receiverType) || nodeAncestorClassKey(receiverType, callee.name.text);
+    if (!classKey)
+        return undefined;
+    const cls = nodeRegistry.classes[classKey];
+    const methodKey = `${cls.key}#${callee.name.text}`;
+    const emit = nodeRegistry.methods[methodKey];
+    if (!emit && cls.category !== 'class')
+        return undefined;
+    applyNodeParamTypes(methodKey, node.arguments ?? []);
+    const call = makeNodeCall(node, visit(callee.expression));
+    if (emit)
+        return emit(call);
+    return `${call.recv}.${callee.name.text}(${call.args.join(', ')})`;
+}
+// Whether a registry key names a module or namespace object (path, fs/promises, process.stdout)
+function isNodeNamespaceKey(key) {
+    return !!nodeRegistry.modules[key] || !!nodeRegistry.objects[key];
+}
+// `const win = path.win32` / `const { join, sep } = path` bind local names to
+// registry keys instead of declaring Go variables
+function visitNodeAliasDeclaration(node) {
+    if (!node.initializer)
+        return undefined;
+    const key = resolveNodeKey(node.initializer);
+    // const readFileAsync = promisify(fs.readFile): an alias of the promise variant
+    if (key && isIdentifier(node.name) && isCallExpression(unwrapParentheses(node.initializer)) && nodeRegistry.functions[key]) {
+        nodeLocalNames.set(node.name.text, key);
+        return '';
+    }
+    if (!key || !isNodeNamespaceKey(key))
+        return undefined;
+    if (isIdentifier(node.name)) {
+        nodeLocalNames.set(node.name.text, key);
+        return '';
+    }
+    if (isObjectBindingPattern(node.name)) {
+        for (const el of node.name.elements ?? []) {
+            if (el.dotDotDotToken || el.initializer || !isIdentifier(el.name))
+                return undefined;
+        }
+        for (const el of node.name.elements ?? []) {
+            const member = (el.propertyName ?? el.name).text;
+            const memberKey = `${key}.${member}`;
+            nodeLocalNames.set(el.name.text, nodeRegistry.namespaces[memberKey] || memberKey);
+        }
+        return '';
+    }
+    return undefined;
+}
+// Reads of Node values (`path.sep`, `os.EOL`, an imported `sep`)
+function visitNodeValue(expr) {
+    const key = resolveNodeKey(expr);
+    if (!key)
+        return undefined;
+    if (key === 'process.env' && (isPropertyAccessExpression(expr.parent) || isElementAccessExpression(expr.parent)) && expr.parent.expression === expr) {
+        return undefined;
+    }
+    const emit = nodeRegistry.values[key];
+    if (!emit)
+        return undefined;
+    const value = emit(emptyNodeCall());
+    return value;
+}
+function emptyNodeCall() {
+    return { args: [], nodes: [], types: [], recv: '' };
+}
+// Writes of Node values (`process.exitCode = 1`): registered as 'key='
+function visitNodeAssignment(node) {
+    if (node.operatorToken.kind !== 'EqualsToken')
+        return undefined;
+    // process.env.X = v / process.env[k] = v
+    if ((isPropertyAccessExpression(node.left) || isElementAccessExpression(node.left)) && isProcessEnv(node.left.expression)) {
+        importedPackages.add('os');
+        const name = isPropertyAccessExpression(node.left) ? toGoStringLiteral(node.left.name.text) : visit(node.left.argumentExpression);
+        return `os.Setenv(${name}, ${jsStringOf(visit(node.right), inferExpressionType(node.right))})`;
+    }
+    const key = resolveNodeKey(node.left);
+    if (!key)
+        return undefined;
+    const emit = nodeRegistry.functions[`${key}=`];
+    if (!emit)
+        return undefined;
+    const call = { args: [visit(node.right)], nodes: [node.right], types: [inferExpressionType(node.right) ?? ''], recv: '' };
+    const assignment = emit(call);
+    return assignment;
+}
+// Writes of Go struct fields convert to the field type: h.Size = 5 →
+// h.Size = int64(5); h.Size += 1 → h.Size = int64(float64(h.Size) + 1)
+function visitGoFieldAssignment(node, op) {
+    if (!isPropertyAccessExpression(node.left))
+        return undefined;
+    const recvType = inferExpressionType(node.left.expression);
+    if (!recvType)
+        return undefined;
+    const field = goFieldType(recvType, node.left.name.text);
+    if (!field)
+        return undefined;
+    const target = `${visit(node.left.expression)}.${node.left.name.text}`;
+    ensureGoTypePackages(field);
+    if (op === '=') {
+        return `${target} = ${toGoType(visit(node.right), inferExpressionType(node.right) ?? '', field)}`;
+    }
+    if (['+=', '-=', '*=', '/='].includes(op) && isGoNumericKind(field)) {
+        const value = `${fromGoType(target, field)} ${op[0]} (${visit(node.right)})`;
+        return `${target} = ${toGoType(value, 'float64', field)}`;
+    }
+    return undefined;
+}
+// new X(…) of a Node class
+function visitNodeNew(node) {
+    const key = resolveNodeKey(node.expression);
+    if (!key)
+        return undefined;
+    const emit = nodeRegistry.constructors[key];
+    if (!emit)
+        return undefined;
+    applyNodeParamTypes(`${key}()`, node.arguments ?? []);
+    applyNodeOptionTypes(key, (node.arguments ?? [])[0]);
+    return emit(makeNodeCall(node, ''));
+}
+// The call a typer inspects: argument nodes and their Go types
+function nodeTypeCall(nodes) {
+    return { args: [], nodes, types: nodes.map((a) => inferExpressionType(a) ?? ''), recv: '' };
+}
+// Go types of Node API expressions; undefined when the expression is not one
+// Property read on a Go package or Go value: consts, vars, fields.
+function visitGoProperty(node) {
+    const base = node.expression;
+    // Package member: strings.ToUpper (as a value), math.Pi, os.Stdout.
+    const path = isIdentifier(base) ? goPathOf(base.text) : undefined;
+    if (path) {
+        const info = goPackage(path);
+        if (!info)
+            return undefined;
+        const member = node.name.text;
+        const qualifier = goQualifier(path);
+        if (info.funcs[member])
+            return `${qualifier}.${member}`;
+        if (info.consts[member]) {
+            const kind = info.consts[member].kind;
+            // Untyped consts arrive as TS numbers; typed consts (time.Second)
+            // keep their Go type so arithmetic stays well-typed.
+            if (kind === 'typed')
+                return `${qualifier}.${member}`;
+            if (kind === 'string')
+                return `${qualifier}.${member}`;
+            if (kind === 'bool')
+                return `${qualifier}.${member}`;
+            return `float64(${qualifier}.${member})`;
+        }
+        if (info.vars[member]) {
+            return `${qualifier}.${member}`;
+        }
+        if (info.types[member])
+            return `${qualifier}.${member}`;
+        return undefined;
+    }
+    // Field on a Go-typed value.
+    if (isCallee(node) || isAssignmentTarget(node))
+        return undefined;
+    const recvType = inferExpressionType(base);
+    if (!recvType)
+        return undefined;
+    const field = goFieldType(recvType, node.name.text);
+    if (field) {
+        const recv = visit(base);
+        return fromGoType(`${recv}.${node.name.text}`, field);
+    }
+    // GoRef<T>.value dereferences the pointer cell (structs with a real
+    // `value` field take the branch above). Only when the receiver is
+    // declared as GoRef<...> or initialized by ref<T>(), or points to a
+    // basic type (flag.String's *string has no fields to read).
+    if (node.name.text === 'value' && recvType.startsWith('*') && isIdentifier(base)) {
+        const base2 = recvType.slice(1);
+        const isBasic = base2 === 'string' || base2 === 'float64' || base2 === 'bool' || isGoBasicKind(base2);
+        if (isBasic || goRefVariables.has(base.text)) {
+            return `(*${visit(base)})`;
+        }
+        const typeNode = variableTypeNodes.get(base.text);
+        if (typeNode &&
+            isTypeReferenceNode(typeNode) &&
+            isIdentifier(typeNode.typeName) &&
+            typeNode.typeName.text === 'GoRef') {
+            return `(*${visit(base)})`;
+        }
+    }
+    return undefined;
+}
+// Channel method call: ch.send(v) → ch <- v, ch.recv() → <-ch,
+// ch.close() → close(ch).
+function visitGoChanCall(node, recv) {
+    if (!isPropertyAccessExpression(node.expression))
+        return undefined;
+    const method = node.expression.name.text;
+    const args = node.arguments ?? [];
+    if (method === 'send' && args.length === 1) {
+        return `${recv} <- ${visit(args[0])}`;
+    }
+    if (method === 'recv' && args.length === 0) {
+        return `<-${recv}`;
+    }
+    if (method === 'close' && args.length === 0) {
+        return `close(${recv})`;
+    }
+    return undefined;
+}
+// Package + type of a `new pkg.T(...)` expression, null when none.
+function goNewTarget(node) {
+    const ctor = node.expression;
+    if (!ctor)
+        return null;
+    if (isIdentifier(ctor)) {
+        const qualified = goMemberOf(ctor.text);
+        if (!qualified)
+            return null;
+        const dot = qualified.indexOf('.');
+        if (dot < 0)
+            return null;
+        const qualifier = qualified.slice(0, dot);
+        const typeName = qualified.slice(dot + 1);
+        for (const path of Object.keys(goStdlib)) {
+            if (goQualifier(path) === qualifier && goPackage(path)?.types[typeName]) {
+                return { path, typeName, qualifier };
             }
         }
+        return null;
     }
-    else {
-        // Default import (`import path from 'node:path'`) or
-        // namespace import (`import * as path from 'node:path'`)
-        const localName = getImportLocalName(node) ?? nodeModule;
-        for (const [funcName, resultType] of Object.entries(NODE_FUNCTION_TYPES[nodeModule] ?? {})) {
-            nodeCallResultTypes.set(`${localName}.${funcName}`, resultType);
+    if (isPropertyAccessExpression(ctor) && isIdentifier(ctor.expression)) {
+        const path = goPathOf(ctor.expression.text);
+        if (!path)
+            return null;
+        const typeName = ctor.name.text;
+        if (!goPackage(path)?.types[typeName])
+            return null;
+        return { path, typeName, qualifier: goQualifier(path) };
+    }
+    return null;
+}
+function inferGoExpressionType(expr) {
+    // ref<T>().value reads as the cell's element type.
+    if (isPropertyAccessExpression(expr) &&
+        expr.name.text === 'value' &&
+        isIdentifier(expr.expression) &&
+        goRefVariables.has(expr.expression.text)) {
+        const refType = variableGoTypes.get(expr.expression.text);
+        if (refType && refType.startsWith('*'))
+            return refType.slice(1);
+    }
+    if (isCallExpression(expr) || isIdentifier(expr) || isPropertyAccessExpression(expr)) {
+        return inferGoType(expr);
+    }
+    if (isNewExpression(expr)) {
+        const target = goNewTarget(expr);
+        if (target) {
+            const info = goPackage(target.path);
+            const type = info?.types[target.typeName];
+            if (type) {
+                for (const m of type.methods) {
+                    if (m.ptr)
+                        return `*${target.path}.${target.typeName}`;
+                }
+                return `${target.path}.${target.typeName}`;
+            }
+        }
+        return undefined;
+    }
+    return undefined;
+}
+function inferNodeExpressionType(expr) {
+    if (isCallExpression(expr)) {
+        const callee = expr.expression;
+        const key = resolveNodeKey(callee);
+        const nodes = expr.arguments ?? [];
+        if (key) {
+            const typer = nodeRegistry.typers[key];
+            if (typer)
+                return typer(nodeTypeCall(nodes));
+            if (key in nodeRegistry.results)
+                return nodeRegistry.results[key];
+            return undefined;
+        }
+        if (isPropertyAccessExpression(callee) && !callee.questionDotToken) {
+            const receiverType = inferExpressionType(callee.expression);
+            const classKey = nodeClassKeyOfType(receiverType) || nodeAncestorClassKey(receiverType, callee.name.text);
+            if (!classKey)
+                return undefined;
+            const methodKey = `${nodeRegistry.classes[classKey].key}#${callee.name.text}`;
+            const typer = nodeRegistry.typers[methodKey];
+            if (typer)
+                return typer(nodeTypeCall(nodes));
+            if (methodKey in nodeRegistry.results)
+                return nodeRegistry.results[methodKey];
+            const cls = nodeRegistry.classes[classKey];
+            const methodName = callee.name.text;
+            if (methodName in cls.methods)
+                return cls.methods[methodName];
         }
-        for (const [funcName, fn] of Object.entries(mapping.functions)) {
-            callHandlers[`${localName}.${funcName}`] = (_caller, args) => fn(args);
+        return undefined;
+    }
+    if (isNewExpression(expr)) {
+        const key = resolveNodeKey(expr.expression);
+        if (key && nodeRegistry.constructors[key]) {
+            const typer = nodeRegistry.typers[`${key}()`];
+            const nodes = expr.arguments ?? [];
+            if (typer)
+                return typer(nodeTypeCall(nodes));
+            return nodeRegistry.classes[key]?.goType;
         }
+        return undefined;
+    }
+    if (isIdentifier(expr) || isPropertyAccessExpression(expr)) {
+        const key = resolveNodeKey(expr);
+        if (key && key in nodeRegistry.valueTypes)
+            return nodeRegistry.valueTypes[key];
+        return undefined;
+    }
+    if (isElementAccessExpression(expr) && inferExpressionType(expr.expression) === '[]byte')
+        return 'float64';
+    return undefined;
+}
+// Node classes are pseudo-classes: their methods, fields and accessors feed the
+// class tables, so dispatch and inference treat them like user classes
+function seedNodeClassTables() {
+    for (const key of Object.keys(nodeRegistry.classes)) {
+        const cls = nodeRegistry.classes[key];
+        if (!cls.goType.startsWith('*'))
+            continue;
+        const goName = cls.goType.slice(1);
+        // Classes sharing a Go type (ErrnoException / AssertionError on *TnError) merge their tables
+        const methods = classMethodReturnTypes.get(goName) ?? new Map();
+        for (const name of Object.keys(cls.methods))
+            methods.set(name, cls.methods[name]);
+        classMethodReturnTypes.set(goName, methods);
+        const props = classPropertyTypes.get(goName) ?? new Map();
+        for (const name of Object.keys(cls.props))
+            props.set(name, cls.props[name]);
+        for (const name of Object.keys(cls.getters)) {
+            props.set(name, cls.getters[name]);
+            classGetterMethods.add(`${goName}.${name}`);
+        }
+        for (const name of Object.keys(cls.setters))
+            classSetterMethods.add(`${goName}.${name}`);
+        classPropertyTypes.set(goName, props);
     }
 }
 function visitImportDeclaration(node) {
@@ -10199,7 +12110,12 @@ function visitImportDeclaration(node) {
         if (fileResolver && !includedLocalImports.has(key)) {
             includedLocalImports.add(key);
             const resolved = fileResolver(moduleSpec, currentFileDir);
-            if (resolved) {
+            // The same file reached through different specifiers (./registry.js from
+            // a sibling, ./node/registry.js from the parent) is included once
+            const stem = (moduleSpec.split('/').pop() ?? moduleSpec).replace(/\.(js|ts|tsx|mjs)$/, '');
+            const fileKey = resolved ? `file::${resolved.dir}::${stem}` : '';
+            if (resolved && !includedLocalImports.has(fileKey)) {
+                includedLocalImports.add(fileKey);
                 const goFileName = specifierToGoFileName(moduleSpec);
                 includeLocalImport(resolved.content, resolved.dir, goFileName, !!resolved.tsx);
             }
@@ -10220,22 +12136,35 @@ function visitImportDeclaration(node) {
         }
         return '';
     }
+    // Node.js standard library (`node:path`, or a bare builtin name like `fs`):
+    // local names resolve against the registry; type-only imports bind types
+    const nodeModule = nodeModuleName(moduleSpec);
+    if (nodeModule) {
+        setupNodeModuleImport(node, nodeModule);
+        return '';
+    }
+    if (moduleSpec.startsWith('node:'))
+        return '';
     // Type-only imports contribute nothing to runtime
     if (node.importClause?.isTypeOnly)
         return '';
     // Go standard library: `import { Println } from 'go:fmt'` → import "fmt"
     if (moduleSpec.startsWith('go:')) {
         const goPkg = moduleSpec.slice(3);
+        // go:builtin is virtual (ref/chan/GoError): no Go import, just aliases.
+        if (goPkg === 'builtin') {
+            registerGoBuiltinAliases(node);
+            return '';
+        }
+        // Side-effect import (`import 'go:time/tzdata'`): blank Go import
+        if (!node.importClause) {
+            goSideEffectImports.add(goPkg);
+            return '';
+        }
         importedPackages.add(goPkg);
         registerGoPackageAliases(node, goPkg);
         return '';
     }
-    // Node.js standard library: `import path from 'node:path'` → mapped Go packages
-    if (moduleSpec.startsWith('node:')) {
-        const nodeModule = moduleSpec.slice(5);
-        setupNodeModuleImport(node, nodeModule);
-        return '';
-    }
     // npm package (bare specifier) → transpile to its own Go file
     const npmKey = `npm::${moduleSpec}`;
     if (fileResolver && !includedLocalImports.has(npmKey)) {
@@ -10260,14 +12189,39 @@ function visitImportDeclaration(node) {
     return '';
 }
 // Go packages imported under a fixed alias to avoid collisions with user
-// variables (a variable named `big` would shadow the package name)
-const goImportAliases = {
-    'math/big': 'tnbig',
-    'net/url': 'tnurl',
-    'golang.org/x/text/unicode/norm': 'tnnorm'
-};
+// variables (a variable named `big` would shadow the package name).
+// Table lives in src/go/overrides.ts (shared with the bridge qualifier).
+// Go bridge types are fully qualified internally (net/http.Cookie,
+// *[]io/fs.DirEntry); emitted code spells them with the import qualifier.
+// Rewrites path-qualified names outside string literals and comments, and
+// imports their packages.
+function localizeGoPaths(code) {
+    if (code.indexOf('/') < 0)
+        return code;
+    // String/rune literals and line comments match first and pass through
+    return code.replace(/"(?:[^"\\\n]|\\.)*"|`[^`]*`|'(?:[^'\\\n]|\\.)*'|\/\/[^\n]*|\b([a-z][a-z0-9_]*(?:\/[a-z0-9_]+)+)\./g, (match, path) => {
+        if (!path || !hasGoPackage(path))
+            return match;
+        ensureGoQualifier(path);
+        importedPackages.add(path);
+        return `${goQualifier(path)}.`;
+    });
+}
+// Whether Go code uses `name.` as a package qualifier (not the tail of a
+// longer identifier or selector: `ratio.` does not use `io`)
+function referencesQualifier(code, name) {
+    const needle = `${name}.`;
+    let at = code.indexOf(needle);
+    while (at >= 0) {
+        const prev = at > 0 ? code[at - 1] : ' ';
+        if (!/[A-Za-z0-9_.]/.test(prev))
+            return true;
+        at = code.indexOf(needle, at + 1);
+    }
+    return false;
+}
 function goImportLine(pkg) {
-    const alias = goImportAliases[pkg];
+    const alias = goPathAliases[pkg];
     return alias ? `import ${alias} "${pkg}"` : `import "${pkg}"`;
 }
 // Records the type of a variable introduced by a loop or binding
@@ -10286,9 +12240,89 @@ function registerLocalVariable(name, goType) {
         variableGoTypes.delete(name);
 }
 // for...of over arrays and strings (a string yields one-character strings)
+// Whether a Go type is an iter.Seq / Seq2 (range-over-func).
+function isGoIterSeq(goType) {
+    const base = goType.replace(/^\*/, '');
+    return base.startsWith('iter.Seq') || base.startsWith('import(\'go:iter\').Seq');
+}
+// Element type of an iter.Seq[V] (Seq2 yields its key type in for…of).
+function goIterElem(goType) {
+    const start = goType.indexOf('[');
+    const end = goType.lastIndexOf(']');
+    if (start < 0 || end < 0)
+        return 'interface{}';
+    const inner = goType.slice(start + 1, end);
+    let depth = 0;
+    for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === '[' || inner[i] === '(')
+            depth++;
+        else if (inner[i] === ']' || inner[i] === ')')
+            depth--;
+        else if (inner[i] === ',' && depth === 0)
+            return inner.slice(0, i).trim() || 'interface{}';
+    }
+    return inner.trim() || 'interface{}';
+}
+// Type args of an iter.Seq[V] / Seq2[K, V].
+function goIterElems(goType) {
+    const start = goType.indexOf('[');
+    const end = goType.lastIndexOf(']');
+    if (start < 0 || end < 0)
+        return [];
+    const inner = goType.slice(start + 1, end);
+    const out = [];
+    let depth = 0;
+    let from = 0;
+    for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === '[' || inner[i] === '(')
+            depth++;
+        else if (inner[i] === ']' || inner[i] === ')')
+            depth--;
+        else if (inner[i] === ',' && depth === 0) {
+            out.push(inner.slice(from, i).trim());
+            from = i + 1;
+        }
+    }
+    out.push(inner.slice(from).trim());
+    return out;
+}
 function visitForOfSequence(node, iterExpr, iterType) {
     if (iterType === 'interface{}')
         iterType = '[]interface{}';
+    // Go iter.Seq[V] / Seq2[K, V]: range the func directly.
+    if (iterType && isGoIterSeq(iterType)) {
+        const declaration = isVariableDeclarationList(node.initializer)
+            ? node.initializer.declarations[0]
+            : undefined;
+        // Go ints arrive under a temp and re-bind as TS numbers
+        let prefix = '';
+        const bindIterVar = (name, goType) => {
+            if (!name || isOmittedExpression(name) || !isIdentifier(name))
+                return '_';
+            const local = visit(name);
+            if (goType !== 'float64' && isGoNumericKind(goType)) {
+                const raw = getTempName('it');
+                prefix += `${local} := float64(${raw}); _ = ${local};\n\t\t`;
+                registerLocalVariable(name.text, 'float64');
+                return raw;
+            }
+            registerLocalVariable(name.text, goType);
+            return local;
+        };
+        // Seq2 destructures as [key, value]
+        if (declaration && isArrayBindingPattern(declaration.name) && goIterElems(iterType).length === 2) {
+            const elems = goIterElems(iterType);
+            const bound = declaration.name.elements.map((el, i) => bindIterVar(isOmittedExpression(el) ? undefined : el.name, elems[i] ?? 'interface{}'));
+            const key = bound[0] ?? '_';
+            const value = bound[1] ?? '_';
+            return `for ${key}, ${value} := range ${iterExpr}${visitLoopBody(node.statement, prefix)}`;
+        }
+        if (declaration && isIdentifier(declaration.name)) {
+            const loopVar = bindIterVar(declaration.name, goIterElem(iterType));
+            return `for ${loopVar} := range ${iterExpr}${visitLoopBody(node.statement, prefix)}`;
+        }
+        return `for _ = range ${iterExpr}${visitLoopBody(node.statement)}`;
+    }
     // An iterable class instance: range its Symbol_iterator channel
     if (iterType?.startsWith('*')) {
         const iterClass = iterType.slice(1).replace(/\[.*\]$/, '');
@@ -10309,10 +12343,49 @@ function visitForOfSequence(node, iterExpr, iterType) {
         const declaration = isVariableDeclarationList(node.initializer)
             ? node.initializer.declarations[0]
             : undefined;
+        // for await: receive through the event loop (the values may come from loop
+        // tasks — stream data, events — that must run while this loop waits)
+        if (node.awaitModifier) {
+            useHelper('eventLoop');
+            const chanVar = getTempName('chan');
+            const valueVar = declaration && isIdentifier(declaration.name) ? visit(declaration.name) : getTempName('item');
+            if (declaration && isIdentifier(declaration.name))
+                registerLocalVariable(declaration.name.text, elemType);
+            // A rejected iterator (a stream error) throws out of the loop
+            useHelper('promise');
+            let awaitPrefix = `${valueVar}, __ok := TnLoopReceive(${chanVar})\n\t\tif !__ok {\n\t\t\tif __reason, __rejected := tnRejections.Load(${chanVar}); __rejected {\n\t\t\t\tpanic(__reason)\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\t\t_ = ${valueVar}\n\t\t`;
+            if (declaration && isArrayBindingPattern(declaration.name)) {
+                const memberType = elemType.startsWith('[]') ? elemType.slice(2) : undefined;
+                useHelper('dynamic');
+                (declaration.name.elements ?? []).forEach((el, index) => {
+                    if (isOmittedExpression(el))
+                        return;
+                    const name = visit(el.name);
+                    registerLocalVariable(name, memberType);
+                    awaitPrefix += `${name} := TnAt(${valueVar}, ${index})\n\t\t_ = ${name}\n\t\t`;
+                });
+            }
+            return `${chanVar} := ${iterExpr}\n\t\tfor ${visitLoopBody(node.statement, awaitPrefix)}`;
+        }
         if (declaration && isIdentifier(declaration.name)) {
             registerLocalVariable(declaration.name.text, elemType);
             return `for ${visit(declaration.name)} := range ${iterExpr}${visitLoopBody(node.statement)}`;
         }
+        // for await (const [a, b] of channel) → a := item[0]; b := item[1]
+        if (declaration && isArrayBindingPattern(declaration.name)) {
+            const chanItem = getTempName('item');
+            const memberType = elemType.startsWith('[]') ? elemType.slice(2) : undefined;
+            let chanPrefix = '';
+            (declaration.name.elements ?? []).forEach((el, index) => {
+                if (isOmittedExpression(el))
+                    return;
+                const name = visit(el.name);
+                registerLocalVariable(name, memberType);
+                chanPrefix += `${name} := TnAt(${chanItem}, ${index})\n\t\t_ = ${name}\n\t\t`;
+            });
+            useHelper('dynamic');
+            return `for ${chanItem} := range ${iterExpr}${visitLoopBody(node.statement, chanPrefix)}`;
+        }
         return `for _ = range ${iterExpr}${visitLoopBody(node.statement)}`;
     }
     const elementType = iterType === 'string' ? 'string' : iterType?.startsWith('[]') ? iterType.slice(2) : undefined;
@@ -10371,6 +12444,8 @@ function visitReturningTryStatement(node, fn, options) {
     if (node.catchClause) {
         const varDecl = node.catchClause.variableDeclaration;
         const catchVar = varDecl ? visit(varDecl.name) : '_r';
+        if (varDecl && isIdentifier(varDecl.name))
+            registerLocalVariable(varDecl.name.text, 'interface{}');
         const catchBody = blockCode(node.catchClause.block, true);
         deferreds.push(`defer func() {\n\t\t\tif r := recover(); r != nil {\n\t\t\t\t${catchVar} := r\n\t\t\t\t_ = ${catchVar}\n\t\t\t\t${catchBody}\t\t\t}\n\t\t\t}()`);
     }