typenative 0.0.17 → 0.0.19

package/bin/transpiler.js

@@ -17,7 +17,22 @@ const interfacePropertyTypes = new Map();
 const typeAliases = new Map();
 const enumNames = new Set();
 const enumBaseTypes = new Map();
-export function transpileToNative(code) {
+// Maps local TS name → Go qualified name (e.g. 'Println' → 'fmt.Println', 'myFmt' → 'fmt')
+const importAliases = new Map();
+// Callback for resolving import specifiers to source code.
+// specifier: the raw import string (relative path or package name)
+// fromDir: directory of the file containing the import (null = main file's dir)
+// Returns the file content and its directory (for resolving that file's own imports)
+let fileResolver = null;
+// Directory of the file currently being processed (null = main entry file)
+let currentFileDir = null;
+// Tracks already-included files by a stable key to prevent duplicates/cycles
+const includedLocalImports = new Set();
+// Collects Go source files generated from local TS imports (filename → content)
+let localImportFiles = new Map();
+export function transpileToNative(code, options) {
+    fileResolver = options?.readFile ?? null;
+    currentFileDir = null;
     const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
     TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
     importedPackages.clear();
@@ -34,17 +49,21 @@ export function transpileToNative(code) {
     typeAliases.clear();
     enumNames.clear();
     enumBaseTypes.clear();
+    importAliases.clear();
+    includedLocalImports.clear();
+    localImportFiles = new Map();
     const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
     const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
-    return `package main
-
-${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
-
-func main() {
-    ${transpiledCode.trim()}
-}
- 
+    const main = `package main
+
+${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
+
+func main() {
+    ${transpiledCode.trim()}
+}
+
 ${transpiledCodeOutside.trim()}`;
+    return { main, files: localImportFiles };
 }
 export function visit(node, options = {}) {
     let code = '';
@@ -57,6 +76,9 @@ export function visit(node, options = {}) {
     else if (ts.isIdentifier(node)) {
         if (node.text === 'undefined')
             return 'nil';
+        const goAlias = importAliases.get(node.text);
+        if (goAlias)
+            return goAlias;
         return getSafeName(node.text);
     }
     else if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
@@ -237,9 +259,23 @@ export function visit(node, options = {}) {
         })}; ${visit(node.incrementor, { inline: true })}${visit(node.statement)}`;
     }
     else if (ts.isForOfStatement(node)) {
-        return `for _,${visit(node.initializer, { inline: true })}= range ${visit(node.expression, {
-            inline: true
-        })}${visit(node.statement)}`;
+        const iterExpr = visit(node.expression, { inline: true });
+        const iterType = inferExpressionType(node.expression);
+        if (iterType && iterType.startsWith('map[')) {
+            const valueType = extractMapValueType(iterType);
+            const isSet = valueType === 'struct{}';
+            const varInfo = getForOfVarNames(node.initializer);
+            if (isSet) {
+                return `for ${varInfo[0]} := range ${iterExpr}${visit(node.statement)}`;
+            }
+            else if (varInfo.length >= 2) {
+                return `for ${varInfo[0]}, ${varInfo[1]} := range ${iterExpr}${visit(node.statement)}`;
+            }
+            else {
+                return `for ${varInfo[0]} := range ${iterExpr}${visit(node.statement)}`;
+            }
+        }
+        return `for _,${visit(node.initializer, { inline: true })}= range ${iterExpr}${visit(node.statement)}`;
     }
     else if (ts.isWhileStatement(node)) {
         return `for ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
@@ -281,6 +317,20 @@ export function visit(node, options = {}) {
     else if (ts.isBreakStatement(node)) {
         return 'break';
     }
+    else if (ts.isThrowStatement(node)) {
+        const expr = node.expression;
+        if (ts.isNewExpression(expr) &&
+            ts.isIdentifier(expr.expression) &&
+            expr.expression.text === 'Error') {
+            const args = expr.arguments ?? [];
+            const msg = args.length > 0 ? visit(args[0]) : '""';
+            return `panic(${msg})` + (options.inline ? '' : ';\n\t');
+        }
+        return `panic(${visit(expr)})` + (options.inline ? '' : ';\n\t');
+    }
+    else if (ts.isTryStatement(node)) {
+        return visitTryStatement(node, options);
+    }
     else if (ts.isReturnStatement(node)) {
         // Handle return new Promise(...)
         if (node.expression &&
@@ -296,26 +346,41 @@ export function visit(node, options = {}) {
             outsideNodes.push(node);
             return '';
         }
-        const name = visit(node.name, { inline: true });
-        const safeName = getSafeName(name);
         const typeParams = getTypeParameters(node.typeParameters);
         const parameterInfo = getFunctionParametersInfo(node.parameters);
-        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        if (node.body && ts.isBlock(node.body)) {
+            prescanVariableDeclarations(node.body);
+        }
+        const inferredRetType = inferFunctionBodyReturnType(node);
+        const returnType = inferredRetType ? ` ${inferredRetType}` : '';
         if (options.isOutside) {
+            const name = node.name ? visit(node.name, { inline: true }) : '';
+            const safeName = getSafeName(name);
             return `func ${safeName}${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
                 prefixBlockContent: parameterInfo.prefixBlockContent
             })}`;
         }
+        if (!node.name) {
+            return `func${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
+                prefixBlockContent: parameterInfo.prefixBlockContent
+            })}`;
+        }
+        const name = visit(node.name, { inline: true });
+        const safeName = getSafeName(name);
         return `${safeName} := func${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
             prefixBlockContent: parameterInfo.prefixBlockContent
         })}`;
     }
     else if (ts.isArrowFunction(node)) {
         const parameterInfo = getFunctionParametersInfo(node.parameters);
-        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        const inferredRetType = inferFunctionBodyReturnType(node);
+        const returnType = inferredRetType ? ` ${inferredRetType}` : '';
         if (parameterInfo.prefixBlockContent && !ts.isBlock(node.body)) {
             return `func(${parameterInfo.signature})${returnType} {\n\t\t${parameterInfo.prefixBlockContent}return ${visit(node.body)};\n\t}`;
         }
+        if (!ts.isBlock(node.body)) {
+            return `func(${parameterInfo.signature})${returnType} { return ${visit(node.body)}; }`;
+        }
         return `func(${parameterInfo.signature})${returnType} ${visit(node.body, {
             prefixBlockContent: parameterInfo.prefixBlockContent
         })}`;
@@ -480,6 +545,12 @@ export function visit(node, options = {}) {
             }
             return `regexp.MustCompile("")`;
         }
+        if (className === 'Map') {
+            return visitNewMap(node);
+        }
+        if (className === 'Set') {
+            return visitNewSet(node);
+        }
         const typeArgs = getTypeArguments(node.typeArguments);
         const args = node.arguments ? node.arguments.map((a) => visit(a)) : [];
         return `New${className}${typeArgs}(${args.join(', ')})`;
@@ -506,6 +577,12 @@ export function visit(node, options = {}) {
     else if (ts.isNonNullExpression(node)) {
         return visit(node.expression);
     }
+    else if (ts.isImportDeclaration(node)) {
+        return visitImportDeclaration(node);
+    }
+    else if (ts.isExportDeclaration(node) || ts.isExportAssignment(node)) {
+        return '';
+    }
     const syntaxKind = ts.SyntaxKind[node.kind];
     if (!['FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
         console.log(ts.SyntaxKind[node.kind], node.getText());
@@ -571,7 +648,50 @@ function inferExpectedTypeFromContext(node) {
     }
     return undefined;
 }
+function prescanVariableDeclarations(block) {
+    for (const stmt of block.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) && !variableGoTypes.has(decl.name.text)) {
+                    if (decl.type) {
+                        variableGoTypes.set(decl.name.text, getType(decl.type));
+                    }
+                    else if (decl.initializer) {
+                        const inferredType = inferExpressionType(decl.initializer);
+                        if (inferredType)
+                            variableGoTypes.set(decl.name.text, inferredType);
+                    }
+                }
+            }
+        }
+    }
+}
+function inferFunctionBodyReturnType(node) {
+    if (node.type)
+        return getType(node.type);
+    if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+        return inferExpressionType(node.body);
+    }
+    if (node.body && ts.isBlock(node.body)) {
+        for (const stmt of node.body.statements) {
+            if (ts.isReturnStatement(stmt) && stmt.expression) {
+                const exprType = inferExpressionType(stmt.expression);
+                if (exprType)
+                    return exprType;
+            }
+        }
+    }
+    return undefined;
+}
+function inferArrowFunctionGoType(node) {
+    const params = node.parameters.map((p) => (p.type ? getType(p.type) : 'interface{}')).join(', ');
+    const retType = inferFunctionBodyReturnType(node);
+    return `func(${params})${retType ? ` ${retType}` : ''}`;
+}
 function inferExpressionType(expr) {
+    if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
+        return inferArrowFunctionGoType(expr);
+    }
     if (ts.isParenthesizedExpression(expr))
         return inferExpressionType(expr.expression);
     if (ts.isNonNullExpression(expr))
@@ -599,6 +719,15 @@ function inferExpressionType(expr) {
         const firstElementType = inferExpressionType(expr.elements[0]) ?? 'interface{}';
         return `[]${firstElementType}`;
     }
+    if (ts.isNewExpression(expr) && ts.isIdentifier(expr.expression)) {
+        const ctorName = expr.expression.text;
+        if (ctorName === 'Map' && expr.typeArguments && expr.typeArguments.length === 2) {
+            return `map[${getType(expr.typeArguments[0])}]${getType(expr.typeArguments[1])}`;
+        }
+        if (ctorName === 'Set' && expr.typeArguments && expr.typeArguments.length === 1) {
+            return `map[${getType(expr.typeArguments[0])}]struct{}`;
+        }
+    }
     if (ts.isPropertyAccessExpression(expr)) {
         if (ts.isIdentifier(expr.expression) && enumNames.has(expr.expression.text)) {
             const enumType = getSafeName(expr.expression.text);
@@ -634,6 +763,12 @@ function inferExpressionType(expr) {
     if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) {
         const methodName = expr.expression.name.text;
         const ownerType = inferExpressionType(expr.expression.expression);
+        if (ownerType && ownerType.startsWith('map[')) {
+            if (methodName === 'has')
+                return 'bool';
+            if (methodName === 'get')
+                return extractMapValueType(ownerType);
+        }
         if (isArrayLikeGoType(ownerType)) {
             const elementType = getArrayElementTypeFromGoType(ownerType);
             if (methodName === 'map') {
@@ -866,6 +1001,9 @@ function visitArrayHigherOrderCall(node) {
         ? getArrayElementTypeFromGoType(ownerType)
         : 'interface{}';
     if (methodName === 'join') {
+        // Only intercept array.join — if owner type is unknown/not array, fall through to callHandlers
+        if (!isArrayLikeGoType(ownerType))
+            return undefined;
         importedPackages.add('strings');
         importedPackages.add('fmt');
         const separator = node.arguments[0] ? visit(node.arguments[0]) : '""';
@@ -1026,6 +1164,13 @@ function getType(typeNode, getArrayType = false) {
         // Non-nullable union or multi-type union → interface{}
         return 'interface{}';
     }
+    if (ts.isFunctionTypeNode(typeNode)) {
+        const params = typeNode.parameters
+            .map((p) => (p.type ? getType(p.type) : 'interface{}'))
+            .join(', ');
+        const ret = typeNode.type ? ` ${getType(typeNode.type)}` : '';
+        return `func(${params})${ret}`;
+    }
     if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
         if (enumNames.has(name)) {
@@ -1041,6 +1186,15 @@ function getType(typeNode, getArrayType = false) {
         if (name === 'RegExp') {
             return '*regexp.Regexp';
         }
+        if (name === 'Map' && typeNode.typeArguments && typeNode.typeArguments.length === 2) {
+            const keyType = getType(typeNode.typeArguments[0]);
+            const valueType = getType(typeNode.typeArguments[1]);
+            return `map[${keyType}]${valueType}`;
+        }
+        if (name === 'Set' && typeNode.typeArguments && typeNode.typeArguments.length === 1) {
+            const elementType = getType(typeNode.typeArguments[0]);
+            return `map[${elementType}]struct{}`;
+        }
         const typeArgs = getTypeArguments(typeNode.typeArguments);
         if (classNames.has(name)) {
             return `*${name}${typeArgs}`;
@@ -1091,6 +1245,10 @@ function getTypeCategory(typeNode) {
     }
     if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
+        if (name === 'Map')
+            return 'Map';
+        if (name === 'Set')
+            return 'Set';
         if (classNames.has(name))
             return 'class';
         return name;
@@ -1131,6 +1289,9 @@ function getAcessString(leftSide, rightSide, objectType) {
     if (rightSide === 'length' && objectType !== 'class') {
         return `float64(len(${leftSide}))`;
     }
+    if (rightSide === 'size' && (objectType === 'Map' || objectType === 'Set')) {
+        return `float64(len(${leftSide}))`;
+    }
     return `${leftSide}.${rightSide}`;
 }
 const callHandlers = {
@@ -1286,6 +1447,25 @@ const arrayMethodHandlers = {
         return `fmt.Sprintf("%v", ${obj})`;
     }
 };
+const mapMethodHandlers = {
+    set: (obj, args) => `${obj}[${args[0]}] = ${args[1]}`,
+    get: (obj, args) => `${obj}[${args[0]}]`,
+    has: (obj, args) => {
+        const tmp = getTempName('ok');
+        return `func() bool { _, ${tmp} := ${obj}[${args[0]}]; return ${tmp} }()`;
+    },
+    delete: (obj, args) => `delete(${obj}, ${args[0]})`,
+    clear: (obj) => `clear(${obj})`
+};
+const setMethodHandlers = {
+    add: (obj, args) => `${obj}[${args[0]}] = struct{}{}`,
+    has: (obj, args) => {
+        const tmp = getTempName('ok');
+        return `func() bool { _, ${tmp} := ${obj}[${args[0]}]; return ${tmp} }()`;
+    },
+    delete: (obj, args) => `delete(${obj}, ${args[0]})`,
+    clear: (obj) => `clear(${obj})`
+};
 function getDynamicCallHandler(caller, objectType) {
     if (promiseResolveName && caller === promiseResolveName) {
         return (_caller, args) => `ch <- ${args[0]}`;
@@ -1314,6 +1494,12 @@ function getDynamicCallHandler(caller, objectType) {
         else if (objectType === 'RegExp') {
             handler = regexpMethodHandlers[methodName];
         }
+        else if (objectType === 'Map') {
+            handler = mapMethodHandlers[methodName];
+        }
+        else if (objectType === 'Set') {
+            handler = setMethodHandlers[methodName];
+        }
         else {
             // Unknown type: try both maps for backward compatibility
             handler =
@@ -1415,9 +1601,7 @@ function getFunctionParametersInfo(parameters) {
             prefixBlockContent: ''
         };
     }
-    const hasRequiredAfterDefault = parameters
-        .slice(firstDefaultIndex)
-        .some((p) => !p.initializer);
+    const hasRequiredAfterDefault = parameters.slice(firstDefaultIndex).some((p) => !p.initializer);
     if (hasRequiredAfterDefault) {
         return {
             signature: parameters.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`).join(', '),
@@ -1503,3 +1687,302 @@ function visitNewPromise(node) {
     promiseResolveName = prevResolveName;
     return `func() chan ${channelType} {\n\t\tch := make(chan ${channelType})\n\t\tgo func() ${body.trimEnd()}()\n\t\treturn ch;\n\t}()`;
 }
+function extractMapValueType(mapType) {
+    // mapType is "map[K]V" — find the closing bracket of K accounting for nesting
+    if (!mapType.startsWith('map['))
+        return 'interface{}';
+    let depth = 0;
+    for (let i = 4; i < mapType.length; i++) {
+        if (mapType[i] === '[')
+            depth++;
+        else if (mapType[i] === ']') {
+            if (depth === 0)
+                return mapType.substring(i + 1);
+            depth--;
+        }
+    }
+    return 'interface{}';
+}
+function visitNewMap(node) {
+    let keyType = 'interface{}';
+    let valueType = 'interface{}';
+    if (node.typeArguments && node.typeArguments.length === 2) {
+        keyType = getType(node.typeArguments[0]);
+        valueType = getType(node.typeArguments[1]);
+    }
+    const mapType = `map[${keyType}]${valueType}`;
+    const args = node.arguments;
+    if (!args || args.length === 0 || !ts.isArrayLiteralExpression(args[0])) {
+        return `make(${mapType})`;
+    }
+    const initArg = args[0];
+    const tmp = getTempName('map');
+    const entries = initArg.elements
+        .filter((el) => ts.isArrayLiteralExpression(el) && el.elements.length >= 2)
+        .map((el) => {
+        const pair = el;
+        return `${tmp}[${visit(pair.elements[0])}] = ${visit(pair.elements[1])}`;
+    })
+        .join('; ');
+    return `func() ${mapType} { ${tmp} := make(${mapType}); ${entries}; return ${tmp} }()`;
+}
+function visitNewSet(node) {
+    let elementType = 'interface{}';
+    if (node.typeArguments && node.typeArguments.length === 1) {
+        elementType = getType(node.typeArguments[0]);
+    }
+    const setType = `map[${elementType}]struct{}`;
+    const args = node.arguments;
+    if (!args || args.length === 0 || !ts.isArrayLiteralExpression(args[0])) {
+        return `make(${setType})`;
+    }
+    const initArg = args[0];
+    const tmp = getTempName('set');
+    const values = initArg.elements.map((el) => `${tmp}[${visit(el)}] = struct{}{}`).join('; ');
+    return `func() ${setType} { ${tmp} := make(${setType}); ${values}; return ${tmp} }()`;
+}
+function specifierToGoFileName(specifier) {
+    const segments = specifier.split(/[/\\]/);
+    let name = segments[segments.length - 1] || segments[segments.length - 2] || 'import';
+    // Strip all extensions (e.g. .spec.ts → '', .ts → '')
+    name = name.replace(/(\.[^.]+)+$/, '');
+    name = name.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+    if (!name)
+        name = 'import';
+    // Deduplicate filename if already taken by a different import
+    let candidate = name + '.go';
+    let i = 2;
+    while (localImportFiles.has(candidate)) {
+        candidate = `${name}_${i}.go`;
+        i++;
+    }
+    return candidate;
+}
+function normalizeCjsToEsm(code) {
+    // Remove 'use strict' directive
+    code = code.replace(/['"]use strict['"];?\n?/g, '');
+    // module.exports.X = function(...) { } or exports.X = function(...) { }
+    code = code.replace(/(?:module\.exports|exports)\.(\w+)\s*=\s*function\s*\w*\s*\(/g, 'export function $1(');
+    return code;
+}
+function includeLocalImport(code, dir, goFileName) {
+    const prevDir = currentFileDir;
+    currentFileDir = dir;
+    // Normalize CommonJS modules to ES module syntax before parsing
+    if (!code.includes('export ') && (code.includes('module.exports') || code.includes('exports.'))) {
+        code = normalizeCjsToEsm(code);
+    }
+    if (!goFileName) {
+        // Inline mode (npm packages): pull declarations into the current transpilation context
+        const sf = ts.createSourceFile('imported.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+        for (const stmt of sf.statements) {
+            visit(stmt, { addFunctionOutside: true });
+        }
+        currentFileDir = prevDir;
+        return;
+    }
+    // Separate-file mode (local TS imports): transpile to its own Go file
+    const savedOutsideNodes = outsideNodes;
+    const savedPackages = [...importedPackages];
+    outsideNodes = [];
+    importedPackages.clear();
+    const sf = ts.createSourceFile('imported.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    const inlineLines = [];
+    for (const stmt of sf.statements) {
+        const result = visit(stmt, { addFunctionOutside: true });
+        if (result.trim())
+            inlineLines.push(result);
+    }
+    const fileImports = [...importedPackages].map((pkg) => `import "${pkg}"`).join('\n');
+    const fileOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
+    const fileInline = inlineLines.join('\n');
+    const parts = ['package main'];
+    if (fileImports)
+        parts.push(fileImports);
+    if (fileInline.trim())
+        parts.push(fileInline.trim());
+    if (fileOutside.trim())
+        parts.push(fileOutside.trim());
+    localImportFiles.set(goFileName, parts.join('\n\n'));
+    // Restore main-file state
+    outsideNodes = savedOutsideNodes;
+    importedPackages.clear();
+    for (const p of savedPackages)
+        importedPackages.add(p);
+    currentFileDir = prevDir;
+}
+function registerGoPackageAliases(node, goPkg) {
+    const pkgName = goPkg.split('/').pop();
+    if (!node.importClause)
+        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.namedBindings) {
+        if (ts.isNamespaceImport(clause.namedBindings)) {
+            // `import * as myFmt from 'go:fmt'`
+            const localName = clause.namedBindings.name.text;
+            if (localName !== pkgName) {
+                importAliases.set(localName, pkgName);
+            }
+        }
+        else if (ts.isNamedImports(clause.namedBindings)) {
+            // `import { Println, Sprintf as Spf } from 'go:fmt'`
+            for (const el of clause.namedBindings.elements) {
+                if (el.isTypeOnly)
+                    continue;
+                const localName = el.name.text;
+                const importedName = el.propertyName?.text ?? localName;
+                importAliases.set(localName, `${pkgName}.${importedName}`);
+            }
+        }
+    }
+}
+function getImportLocalName(node) {
+    const clause = node.importClause;
+    if (!clause)
+        return null;
+    if (clause.name)
+        return clause.name.text;
+    if (clause.namedBindings) {
+        if (ts.isNamespaceImport(clause.namedBindings))
+            return clause.namedBindings.name.text;
+    }
+    return null;
+}
+// Per-module table: maps Node.js function name → Go expression template.
+// For default/namespace imports (e.g. `import path from 'node:path'`), entries are registered
+// as `callHandlers[localName.funcName]`. For named imports (e.g. `import { join } from 'node:path'`),
+// the Go identifier is stored in importAliases so bare calls like `join(...)` resolve correctly.
+const nodeModuleMappings = {
+    path: {
+        goPackage: 'path/filepath',
+        functions: {
+            join: (args) => `filepath.Join(${args.join(', ')})`,
+            dirname: (args) => `filepath.Dir(${args[0]})`,
+            basename: (args) => args[1]
+                ? `strings.TrimSuffix(filepath.Base(${args[0]}), ${args[1]})`
+                : `filepath.Base(${args[0]})`,
+            extname: (args) => `filepath.Ext(${args[0]})`,
+            resolve: (args) => `func() string { p, _ := filepath.Abs(filepath.Join(${args.join(', ')})); return p }()`
+        }
+    }
+    // Future node stdlib modules can be added here as additional keys:
+    // fs: { goPackage: 'os', functions: { ... } },
+    // os: { goPackage: 'os', functions: { ... } },
+};
+// Mapping from Node.js stdlib module names to Go setup functions.
+// Each entry adds the required Go imports and registers call handlers for the local identifier.
+function setupNodeModuleImport(node, nodeModule) {
+    const mapping = nodeModuleMappings[nodeModule];
+    if (!mapping)
+        return;
+    importedPackages.add(mapping.goPackage);
+    const clause = node.importClause;
+    if (!clause)
+        return;
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+        // 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 fn = mapping.functions[importedName];
+            if (fn) {
+                // Register a call handler keyed on the local name
+                callHandlers[localName] = (_caller, args) => fn(args);
+            }
+        }
+    }
+    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, fn] of Object.entries(mapping.functions)) {
+            callHandlers[`${localName}.${funcName}`] = (_caller, args) => fn(args);
+        }
+    }
+}
+function visitImportDeclaration(node) {
+    if (!ts.isStringLiteral(node.moduleSpecifier))
+        return '';
+    const moduleSpec = node.moduleSpecifier.text;
+    // Relative imports → transpile to a separate Go file
+    if (moduleSpec.startsWith('.') || moduleSpec.startsWith('/')) {
+        // Key combines current dir + specifier to avoid cross-package collisions
+        const key = `${currentFileDir ?? ''}::${moduleSpec}`;
+        if (fileResolver && !includedLocalImports.has(key)) {
+            includedLocalImports.add(key);
+            const resolved = fileResolver(moduleSpec, currentFileDir);
+            if (resolved) {
+                const goFileName = specifierToGoFileName(moduleSpec);
+                includeLocalImport(resolved.content, resolved.dir, goFileName);
+            }
+        }
+        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);
+        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)) {
+        includedLocalImports.add(npmKey);
+        const resolved = fileResolver(moduleSpec, currentFileDir);
+        if (resolved) {
+            const goFileName = specifierToGoFileName(moduleSpec);
+            includeLocalImport(resolved.content, resolved.dir, goFileName);
+        }
+    }
+    return '';
+}
+function getForOfVarNames(initializer) {
+    if (!ts.isVariableDeclarationList(initializer) || initializer.declarations.length === 0) {
+        return ['_'];
+    }
+    const decl = initializer.declarations[0];
+    if (ts.isArrayBindingPattern(decl.name)) {
+        return decl.name.elements.map((el) => {
+            if (ts.isOmittedExpression(el))
+                return '_';
+            return visit(el.name);
+        });
+    }
+    return [visit(decl.name)];
+}
+function visitTryStatement(node, options) {
+    const deferreds = [];
+    // Register finally first (LIFO: runs last after catch)
+    if (node.finallyBlock) {
+        const finallyBody = node.finallyBlock.statements.map((s) => visit(s)).join('\t');
+        deferreds.push(`defer func() {\n\t\t\t${finallyBody}\t\t\t}()`);
+    }
+    // Register catch second (LIFO: runs first, handles panic via recover)
+    if (node.catchClause) {
+        const varDecl = node.catchClause.variableDeclaration;
+        const catchVar = varDecl ? visit(varDecl.name) : '_r';
+        const catchBody = node.catchClause.block.statements.map((s) => visit(s)).join('\t');
+        deferreds.push(`defer func() {\n\t\t\tif r := recover(); r != nil {\n\t\t\t\t${catchVar} := r\n\t\t\t\t_ = ${catchVar}\n\t\t\t\t${catchBody}\t\t\t}\n\t\t\t}()`);
+    }
+    const tryBody = node.tryBlock.statements.map((s) => visit(s)).join('\t');
+    const body = [...deferreds, tryBody].join('\n\t\t\t');
+    return `func() {\n\t\t\t${body}\n\t\t\t}()` + (options.inline ? '' : ';\n\t');
+}

package/go.d.ts

@@ -0,0 +1 @@
+/// <reference path="types/typenative-go.d.ts" />

package/index.d.ts

@@ -0,0 +1 @@
+/// <reference path="types/typenative.d.ts" />

package/npm.d.ts

@@ -0,0 +1 @@
+/// <reference path="types/typenative-npm.d.ts" />