typenative 0.0.18 → 0.0.19

package/.github/workflows/npm-publish-github-packages.yml

@@ -24,6 +24,8 @@ jobs:
         with:
           go-version: '1.21'
       - run: npm ci
+      - run: npm ci
+        working-directory: test
       - run: npm test
 
   release:

package/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to TypeNative will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.19] - 2026-03-07
+
+### Added
+
+- Module/import support: `import { x } from './file'` transpiled to Go package imports for local TypeScript files
+- Node.js built-in module imports: `import { join } from 'node:path'` and similar mapped to corresponding Go standard library packages
+- npm package imports: `import { x } from 'pkg'` mapped to Go module imports via `typenative-npm.d.ts` type definitions
+- Go package imports: `import { x } from 'go:package'` to import a Go library package
+- Named exports: `export function` and `export const` declarations now transpiled correctly
+
 ## [0.0.18] - 2026-03-03
 
 ### Added

package/README.md

@@ -49,37 +49,37 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 
 **Control Flow**
 
-| Feature            | Supported | Notes                              |
-| ------------------ | :-------: | ---------------------------------- |
-| If/Else statements |    ✅     | Fully supported                    |
-| Switch statements  |    ✅     | Case and default statements        |
-| For loops          |    ✅     | Standard `for` loops               |
-| For...of loops     |    ✅     | Iteration over arrays              |
-| While loops        |    ✅     | Transpiled to Go's `for` loops     |
-| Do...while loops   |    ✅     | Implemented with conditional break |
+| Feature            | Supported | Notes                                                  |
+| ------------------ | :-------: | ------------------------------------------------------ |
+| If/Else statements |    ✅     | Fully supported                                        |
+| Switch statements  |    ✅     | Case and default statements                            |
+| For loops          |    ✅     | Standard `for` loops                                   |
+| For...of loops     |    ✅     | Iteration over arrays                                  |
+| While loops        |    ✅     | Transpiled to Go's `for` loops                         |
+| Do...while loops   |    ✅     | Implemented with conditional break                     |
 | Try/Catch/Finally  |    ✅     | `throw` → `panic`; catch/finally via `defer`/`recover` |
 
 **Data Structures & Array Methods**
 
-| Feature                    | Supported | Notes                                                            |
-| -------------------------- | :-------: | ---------------------------------------------------------------- |
-| Arrays                     |    ✅     | Basic array operations                                           |
-| Array methods              |    ✅     | `push`, `join`, `slice`                                          |
-| Higher-order array methods |    ✅     | `.map()`, `.filter()`, `.some()`, `.find()`                      |
-| Method chaining            |    ✅     | Chaining array methods such as `.map(...).filter(...).join(...)` |
+| Feature                    | Supported | Notes                                                                                      |
+| -------------------------- | :-------: | ------------------------------------------------------------------------------------------ |
+| Arrays                     |    ✅     | Basic array operations                                                                     |
+| Array methods              |    ✅     | `push`, `join`, `slice`                                                                    |
+| Higher-order array methods |    ✅     | `.map()`, `.filter()`, `.some()`, `.find()`                                                |
+| Method chaining            |    ✅     | Chaining array methods such as `.map(...).filter(...).join(...)`                           |
 | Map                        |    ✅     | `Map<K, V>` → Go `map[K]V`; `.set()`, `.get()`, `.has()`, `.delete()`, `.clear()`, `.size` |
-| Set                        |    ✅     | `Set<T>` → Go `map[T]struct{}`; `.add()`, `.has()`, `.delete()`, `.clear()`, `.size` |
+| Set                        |    ✅     | `Set<T>` → Go `map[T]struct{}`; `.add()`, `.has()`, `.delete()`, `.clear()`, `.size`       |
 
 **Functions**
 
-| Feature                      | Supported | Notes                                                        |
-| ---------------------------- | :-------: | ------------------------------------------------------------ |
-| Function declarations        |    ✅     | Transpiled to Go functions                                   |
-| Arrow functions              |    ✅     | Transpiled to anonymous functions                            |
-| Closures over mutable state  |    ✅     | Functions capturing and mutating outer variables             |
-| Function types               |    ✅     | `() => number`, `(x: number) => string` as type annotations  |
-| Generics (functions/classes) |    ✅     | Type parameters via Go generics                              |
-| Default parameter values     |    ✅     | `function(x = defaultValue)`                                 |
+| Feature                      | Supported | Notes                                                       |
+| ---------------------------- | :-------: | ----------------------------------------------------------- |
+| Function declarations        |    ✅     | Transpiled to Go functions                                  |
+| Arrow functions              |    ✅     | Transpiled to anonymous functions                           |
+| Closures over mutable state  |    ✅     | Functions capturing and mutating outer variables            |
+| Function types               |    ✅     | `() => number`, `(x: number) => string` as type annotations |
+| Generics (functions/classes) |    ✅     | Type parameters via Go generics                             |
+| Default parameter values     |    ✅     | `function(x = defaultValue)`                                |
 
 **Classes & Interfaces**
 
@@ -145,10 +145,14 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | test()         |    ✅     | Mapped to `regexp.MatchString`                      |
 | exec()         |    ✅     | Mapped to `regexp.FindStringSubmatch`               |
 
-**Unsupported / Roadmap**
+**Modules & Imports**
 
-| Feature         | Supported | Notes                            |
-| --------------- | :-------: | -------------------------------- |
-| Modules/Imports |    ❌     | `import` / `export` declarations |
+| Feature                  | Supported | Notes                                                        |
+| ------------------------ | :-------: | ------------------------------------------------------------ |
+| Local file imports       |    ✅     | `import { x } from './file'` transpiled to Go package import |
+| Node.js built-in imports |    ✅     | `import { join } from 'node:path'` mapped to Go stdlib       |
+| Go package imports       |    ✅     | `import { x } from 'go:pkg'`                                 |
+| npm package imports      |    ✅     | `import { x } from 'pkg'` mapped to Go module imports        |
+| Named exports            |    ✅     | `export function` / `export const` declarations              |
 
 TypeNative is currently in early development and new features are being added regularly. The goal for `1.0` release is for TypeNative to transpile itself.

package/TODO.md

@@ -0,0 +1,29 @@
+**index.ts needs:**
+
+| Feature                         | Example                                                             |
+| ------------------------------- | ------------------------------------------------------------------- |
+| Default imports                 | `import inquirer from 'inquirer'`, `import fs from 'fs-extra'`      |
+| `process` global                | `process.argv`, `process.platform`                                  |
+| Array `findIndex`               | `process.argv.findIndex(a => a === '--script')`                     |
+| `JSON.parse` / `JSON.stringify` | `JSON.parse(fs.readFileSync(...))`, `JSON.stringify(pckg, null, 2)` |
+| Named async IIFE                | `(async function main() { ... })()`                                 |
+
+**transpiler.ts additionally needs:**
+
+| Feature                             | Example                                             |
+| ----------------------------------- | --------------------------------------------------- |
+| Default imports                     | `import ts from 'typescript'`                       |
+| Spread in array literals            | `[...importedPackages]`, `[...arr1, ...arr2]`       |
+| `for...of` with tuple destructuring | `for (const [funcName, fn] of Object.entries(...))` |
+| `Object.entries()`                  | `Object.entries(mapping.functions)`                 |
+| Arrow function IIFE                 | `(() => { ... })()`                                 |
+| Array `findIndex`                   | `parameters.findIndex(p => !!p.initializer)`        |
+
+**Priority order** (most blocking first):
+
+1. **Default imports** — used at the top of both files, nothing runs without this
+2. **Spread in array literals** — used throughout transpiler.ts for array construction
+3. **`for...of` with tuple destructuring + `Object.entries`** — used for iterating import mappings
+4. **`process` global** — core to CLI argument parsing in index.ts
+5. **IIFE** — the entire entry point of index.ts is an async IIFE
+6. **`findIndex`**, **`JSON.parse/stringify`** — utility methods used in both files

package/bin/index.js

@@ -1,145 +1,281 @@
 #!/usr/bin/env node
 import inquirer from 'inquirer';
 import fs from 'fs-extra';
-import path from 'path';
+import path from 'node:path';
 import { execa } from 'execa';
 import { transpileToNative } from './transpiler.js';
-import { fileURLToPath } from 'url';
+import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 (async function main() {
-  const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
-  const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
-  const sourceIndex = process.argv.findIndex((a) => a === '--source');
-  const source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
-  const outputIndex = process.argv.findIndex((a) => a === '--output');
-  const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
-  const answers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'projectName',
-      message: 'Enter Project Name:',
-      when: newCommand,
-      validate: (input) => input.trim() !== ''
-    },
-    {
-      type: 'confirm',
-      name: 'installDependencies',
-      message: 'Do you want to install dependencies?',
-      when: newCommand
-    },
-    {
-      type: 'input',
-      name: 'path',
-      message: 'Enter Path to typescript main file:',
-      when: !newCommand && !scriptMode && !source,
-      validate: (input) => input.trim() !== ''
-    },
-    {
-      type: 'input',
-      name: 'output',
-      message: 'Enter Output Path:',
-      when: !newCommand && !scriptMode && !output,
-      validate: (input) => input.trim() !== ''
-    },
-    {
-      type: 'editor',
-      name: 'tsCode',
-      message: 'Write your typescript code here:',
-      when: !newCommand && scriptMode && !source,
-      default: `console.log('Hello, World!');`
+    const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
+    const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
+    const sourceIndex = process.argv.findIndex((a) => a === '--source');
+    const source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
+    const outputIndex = process.argv.findIndex((a) => a === '--output');
+    const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter Project Name:',
+            when: newCommand,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'confirm',
+            name: 'installDependencies',
+            message: 'Do you want to install dependencies?',
+            when: newCommand
+        },
+        {
+            type: 'input',
+            name: 'path',
+            message: 'Enter Path to typescript main file:',
+            when: !newCommand && !scriptMode && !source,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'input',
+            name: 'output',
+            message: 'Enter Output Path:',
+            when: !newCommand && !scriptMode && !output,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'editor',
+            name: 'tsCode',
+            message: 'Write your typescript code here:',
+            when: !newCommand && scriptMode && !source,
+            default: `console.log('Hello, World!');`
+        }
+    ]);
+    if (newCommand) {
+        const projectName = answers.projectName.trim();
+        await fs.ensureDir(projectName);
+        await fs.writeFile(path.join(projectName, 'main.ts'), `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`, { encoding: 'utf-8' });
+        await fs.writeFile(path.join(projectName, 'tsconfig.json'), getTsConfig(), {
+            encoding: 'utf-8'
+        });
+        await fs.writeFile(path.join(projectName, 'package.json'), getPackageJson(projectName), {
+            encoding: 'utf-8'
+        });
+        await fs.writeFile(path.join(projectName, '.gitignore'), getGitIgnore(), {
+            encoding: 'utf-8'
+        });
+        await fs.writeFile(path.join(projectName, 'README.md'), getReadMe(projectName), {
+            encoding: 'utf-8'
+        });
+        console.log(`Project "${projectName}" created successfully!`);
+        if (answers.installDependencies) {
+            console.log('Installing dependencies...');
+            await execa('npm', ['install'], { cwd: projectName, stdio: 'inherit' });
+            console.log('Dependencies installed successfully!');
+        }
+        return;
     }
-  ]);
-  if (newCommand) {
-    const projectName = answers.projectName.trim();
-    await fs.ensureDir(projectName);
-    await fs.writeFile(
-      path.join(projectName, 'main.ts'),
-      `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`,
-      { encoding: 'utf-8' }
-    );
-    await fs.writeFile(path.join(projectName, 'tsconfig.json'), getTsConfig(), {
-      encoding: 'utf-8'
-    });
-    await fs.writeFile(path.join(projectName, 'package.json'), getPackageJson(projectName), {
-      encoding: 'utf-8'
-    });
-    await fs.writeFile(path.join(projectName, '.gitignore'), getGitIgnore(), {
-      encoding: 'utf-8'
-    });
-    await fs.writeFile(path.join(projectName, 'README.md'), getReadMe(projectName), {
-      encoding: 'utf-8'
-    });
-    console.log(`Project "${projectName}" created successfully!`);
-    if (answers.installDependencies) {
-      console.log('Installing dependencies...');
-      await execa('npm', ['install'], { cwd: projectName, stdio: 'inherit' });
-      console.log('Dependencies installed successfully!');
+    const sourcePath = answers.tsCode ? null : (source ?? answers.path ?? null);
+    const tsCode = answers.tsCode
+        ? answers.tsCode
+        : await fs.readFile(sourcePath, { encoding: 'utf-8' });
+    const sourceDir = sourcePath ? path.dirname(path.resolve(sourcePath)) : null;
+    const transpileResult = transpileToNative(tsCode, sourceDir
+        ? {
+            readFile: (specifier, fromDir) => {
+                const baseDir = fromDir ?? sourceDir;
+                // Relative or absolute path → resolve from baseDir
+                if (specifier.startsWith('.') || specifier.startsWith('/')) {
+                    for (const candidate of [specifier + '.ts', specifier]) {
+                        try {
+                            const fullPath = path.resolve(baseDir, candidate);
+                            return {
+                                content: fs.readFileSync(fullPath, 'utf-8'),
+                                dir: path.dirname(fullPath)
+                            };
+                        }
+                        catch {
+                            /* not found */
+                        }
+                    }
+                    return null;
+                }
+                // npm package — walk up from baseDir looking for node_modules/<name>
+                const resolved = resolveNpmPackage(baseDir, specifier);
+                if (!resolved)
+                    return null;
+                let { content, dir } = resolved;
+                // Normalize CommonJS to ES module syntax
+                if (!content.includes('export ') && (content.includes('module.exports') || content.includes('exports.'))) {
+                    content = normalizeCjsContent(content);
+                }
+                // Inject types from a local ambient .d.ts if available
+                const typed = tryInjectDtsTypes(content, specifier, sourceDir);
+                if (typed)
+                    content = typed;
+                return { content, dir };
+            }
+        }
+        : undefined);
+    const exeName = process.platform === 'win32' ? 'native.exe' : 'native';
+    const exePath = `dist/${exeName}`;
+    await fs.ensureDir('dist');
+    // Clean up stale Go files from previous runs before writing new ones
+    for (const existing of await fs.readdir('dist')) {
+        if (existing.endsWith('.go'))
+            await fs.remove(`dist/${existing}`);
+    }
+    await fs.writeFile('dist/code.go', transpileResult.main, { encoding: 'utf-8' });
+    const goFiles = ['dist/code.go'];
+    for (const [filename, content] of transpileResult.files) {
+        await fs.writeFile(`dist/${filename}`, content, { encoding: 'utf-8' });
+        goFiles.push(`dist/${filename}`);
     }
-    return;
-  }
-  const tsCode = answers.tsCode
-    ? answers.tsCode
-    : await fs.readFile(source ?? answers.path, { encoding: 'utf-8' });
-  const nativeCode = transpileToNative(tsCode);
-  const exeName = process.platform === 'win32' ? 'native.exe' : 'native';
-  const exePath = `dist/${exeName}`;
-  await fs.ensureDir('dist');
-  await fs.writeFile('dist/code.go', nativeCode, { encoding: 'utf-8' });
-  await execa('go', ['build', '-o', exePath, 'dist/code.go'], {
-    stdio: 'inherit'
-  });
-  // await fs.remove('dist/code.go');
-  if (scriptMode) {
-    await execa(exePath, {
-      stdio: 'inherit'
+    await execa('go', ['build', '-o', exePath, ...goFiles], {
+        stdio: 'inherit'
     });
-    //await fs.remove(exePath);
-  } else if (output || answers.output) {
-    await fs.copy(exePath, output ?? answers.output, { overwrite: true });
-    //await fs.remove(exePath);
-    console.log(`Created native executable at: ${output ?? answers.output}`);
-  }
+    // await fs.remove('dist/code.go');
+    if (scriptMode) {
+        await execa(exePath, {
+            stdio: 'inherit'
+        });
+        //await fs.remove(exePath);
+    }
+    else if (output || answers.output) {
+        await fs.copy(exePath, output ?? answers.output, { overwrite: true });
+        //await fs.remove(exePath);
+        console.log(`Created native executable at: ${output ?? answers.output}`);
+    }
 })();
-function getPackageJson(projectName) {
-  const exeName = process.platform === 'win32' ? `${projectName}.exe` : projectName;
-  const pckg = {
-    name: projectName,
-    version: '1.0.0',
-    scripts: {
-      execute: 'npx typenative --source main.ts --script',
-      build: `npx typenative --source main.ts --output bin/${exeName}`
-    },
-    devDependencies: {
-      typenative: '^0.0.16'
+function normalizeCjsContent(code) {
+    code = code.replace(/['"]use strict['"];?\n?/g, '');
+    code = code.replace(/(?:module\.exports|exports)\.(\w+)\s*=\s*function\s*\w*\s*\(/g, 'export function $1(');
+    return code;
+}
+function tryInjectDtsTypes(jsContent, packageName, searchDir) {
+    if (!searchDir)
+        return null;
+    // Look for *.d.ts files in searchDir that declare the module
+    let dtsBody = null;
+    try {
+        const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        for (const file of fs.readdirSync(searchDir)) {
+            if (!file.endsWith('.d.ts'))
+                continue;
+            const content = fs.readFileSync(path.join(searchDir, file), 'utf-8');
+            const match = content.match(new RegExp(`declare module ['"]${escaped}['"][^{]*\\{([\\s\\S]*?)\\}`));
+            if (match) {
+                dtsBody = match[1];
+                break;
+            }
+        }
     }
-  };
-  return JSON.stringify(pckg, null, 2);
+    catch {
+        return null;
+    }
+    if (!dtsBody)
+        return null;
+    // Extract typed function signatures from the .d.ts module body
+    const signatures = new Map();
+    const sigRegex = /export function (\w+)\(([^)]*)\)\s*:\s*([^\n;]+)/g;
+    let m;
+    while ((m = sigRegex.exec(dtsBody)) !== null) {
+        signatures.set(m[1], { params: m[2].trim(), returnType: m[3].trim() });
+    }
+    if (signatures.size === 0)
+        return null;
+    // Replace untyped signatures in the normalized JS with typed ones from .d.ts
+    return jsContent.replace(/export function (\w+)\s*\(([^)]*)\)/g, (match, name) => {
+        const sig = signatures.get(name);
+        if (!sig)
+            return match;
+        return `export function ${name}(${sig.params}): ${sig.returnType}`;
+    });
 }
-function getTsConfig() {
-  const tsConfig = {
-    include: ['**/*.ts'],
-    compilerOptions: {
-      target: 'es2020',
-      lib: [],
-      types: ['./node_modules/typenative/types/typenative.d.ts'],
-      rootDir: '.',
-      strict: true,
-      noImplicitAny: true
+function resolveNpmPackage(fromDir, packageName) {
+    // Walk up the directory tree looking for node_modules/<packageName>
+    let searchDir = fromDir;
+    while (true) {
+        const pkgDir = path.join(searchDir, 'node_modules', packageName);
+        const pkgJsonPath = path.join(pkgDir, 'package.json');
+        try {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+            // Build candidate entry points: TypeScript preferred, JavaScript as fallback
+            const tsCandidates = [];
+            const jsCandidates = [];
+            for (const field of ['source', 'main', 'module']) {
+                const entry = pkgJson[field];
+                if (!entry)
+                    continue;
+                if (entry.endsWith('.ts'))
+                    tsCandidates.push(entry);
+                else if (entry.endsWith('.js')) {
+                    tsCandidates.push(entry.replace(/\.js$/, '.ts'));
+                    jsCandidates.push(entry);
+                }
+            }
+            tsCandidates.push('index.ts', 'src/index.ts');
+            jsCandidates.push('index.js', 'src/index.js');
+            const candidates = [...tsCandidates, ...jsCandidates];
+            for (const candidate of candidates) {
+                const fullPath = path.resolve(pkgDir, candidate);
+                try {
+                    return { content: fs.readFileSync(fullPath, 'utf-8'), dir: path.dirname(fullPath) };
+                }
+                catch {
+                    /* try next candidate */
+                }
+            }
+        }
+        catch {
+            /* no package.json here, keep walking up */
+        }
+        const parent = path.dirname(searchDir);
+        if (parent === searchDir)
+            break; // filesystem root
+        searchDir = parent;
     }
-  };
-  return JSON.stringify(tsConfig, null, 2);
+    return null;
+}
+function getPackageJson(projectName) {
+    const exeName = process.platform === 'win32' ? `${projectName}.exe` : projectName;
+    const pckg = {
+        name: projectName,
+        version: '1.0.0',
+        scripts: {
+            execute: 'npx typenative --source main.ts --script',
+            build: `npx typenative --source main.ts --output bin/${exeName}`
+        },
+        devDependencies: {
+            typenative: '^0.0.19'
+        }
+    };
+    return JSON.stringify(pckg, null, 2);
+}
+function getTsConfig() {
+    const tsConfig = {
+        include: ['**/*.ts'],
+        compilerOptions: {
+            target: 'es2020',
+            lib: [],
+            types: ['typenative', 'typenative/go', 'typenative/npm'],
+            rootDir: '.',
+            strict: true,
+            noImplicitAny: true,
+            allowSyntheticDefaultImports: true
+        }
+    };
+    return JSON.stringify(tsConfig, null, 2);
 }
 function getGitIgnore() {
-  return `# TypeNative generated files
+    return `# TypeNative generated files
 node_modules/
 dist/
 bin/
 `;
 }
 function getReadMe(projectName) {
-  const exeName = process.platform === 'win32' ? `${projectName}.exe` : projectName;
-  return `# ${projectName}
+    const exeName = process.platform === 'win32' ? `${projectName}.exe` : projectName;
+    return `# ${projectName}
 
 This project was created using TypeNative, a tool to transpile TypeScript code to native Go code.
 

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
+    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)) {
@@ -555,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());
@@ -656,9 +684,7 @@ function inferFunctionBodyReturnType(node) {
     return undefined;
 }
 function inferArrowFunctionGoType(node) {
-    const params = node.parameters
-        .map((p) => (p.type ? getType(p.type) : 'interface{}'))
-        .join(', ');
+    const params = node.parameters.map((p) => (p.type ? getType(p.type) : 'interface{}')).join(', ');
     const retType = inferFunctionBodyReturnType(node);
     return `func(${params})${retType ? ` ${retType}` : ''}`;
 }
@@ -975,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]) : '""';
@@ -1572,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(', '),
@@ -1714,6 +1741,219 @@ function visitNewSet(node) {
     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 ['_'];

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" />

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "typenative",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Build native applications using Typescript.",
   "type": "module",
   "bin": {
     "typenative": "bin/index.js"
   },
+  "types": "./index.d.ts",
   "scripts": {
     "build": "tsc",
     "watch": "tsc --watch",
@@ -35,7 +36,11 @@
     "test21": "node ./bin/index --source test/Test21.spec.ts --script",
     "test22": "node ./bin/index --source test/Test22.spec.ts --script",
     "test23": "node ./bin/index --source test/Test23.spec.ts --script",
-    "test24": "node ./bin/index --source test/Test24.spec.ts --script"
+    "test24": "node ./bin/index --source test/Test24.spec.ts --script",
+    "test25": "node ./bin/index --source test/Test25.spec.ts --script",
+    "test25_export": "node ./bin/index --source test/Test25-export.spec.ts --script",
+    "test26": "node ./bin/index --source test/Test26.spec.ts --script",
+    "test27": "node ./bin/index --source test/Test27.spec.ts --script"
   },
   "repository": {
     "type": "git",
@@ -50,13 +55,13 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.9",
-    "@types/node": "^25.2.3",
-    "rimraf": "^6.1.2"
+    "@types/node": "^25.3.5",
+    "rimraf": "^6.1.3"
   },
   "dependencies": {
     "execa": "^9.6.1",
-    "fs-extra": "^11.3.3",
-    "inquirer": "^13.2.4",
+    "fs-extra": "^11.3.4",
+    "inquirer": "^13.3.0",
     "nanoid": "^5.1.6",
     "typescript": "^5.9.3"
   }

package/types/typenative-go.d.ts

@@ -0,0 +1,15 @@
+// Type definitions for TypeNative go standard library modules
+
+declare module 'go:fmt' {
+  export function Println(...args: any[]): void;
+  export function Sprintf(format: string, ...args: any[]): string;
+}
+
+declare module 'go:strconv' {
+  export function FormatBool(value: boolean): string;
+}
+
+declare module 'go:strings' {
+  export function ToUpper(s: string): string;
+  export function ToLower(s: string): string;
+}

package/types/typenative-npm.d.ts

@@ -0,0 +1,5 @@
+// Type definitions for TypeNative NPM standard library modules
+
+declare module 'node:path' {
+  export function join(...parts: string[]): string;
+}

package/types/typenative.d.ts

@@ -1,3 +1,5 @@
+// Type definitions for TypeNative
+
 interface Boolean {}
 
 interface CallableFunction extends Function {}
@@ -197,7 +199,7 @@ interface Error {
 }
 
 interface ErrorConstructor {
-  new(message?: string): Error;
+  new (message?: string): Error;
 }
 
 declare var Error: ErrorConstructor;