@xnoxs/flux-lang 4.0.8 → 4.0.9

package/index.js

@@ -3,17 +3,17 @@
 /**
  * Flux Lang — Public API
  *
- * const { transpile } = require('@xnoxs/flux-lang');
- * import { transpile, format, buildStdlib } from '@xnoxs/flux-lang';
+ * const { transpile } = require('flux-lang');
+ * import { transpile, format, buildStdlib } from 'flux-lang';
  */
 
-const { transpile }                        = require('./src/self/transpiler');
-const { format }                           = require('./src/self/formatter');
-const { buildStdlib, detectUsedSymbols, STDLIB_SYMBOLS } = require('./src/self/stdlib');
-const { Lexer }                            = require('./src/self/lexer');
-const { Parser }                           = require('./src/self/parser');
-const { bundle }                           = require('./src/self/bundler');
-const { loadConfig, mergeConfig }          = require('./src/self/config');
+const { transpile }                        = require('./src/transpiler');
+const { format }                           = require('./src/formatter');
+const { buildStdlib, detectUsedSymbols, STDLIB_SYMBOLS } = require('./src/stdlib');
+const { Lexer }                            = require('./src/lexer');
+const { Parser }                           = require('./src/parser');
+const { bundle }                           = require('./src/bundler');
+const { loadConfig, mergeConfig, defineConfig } = require('./src/config');
 
 module.exports = {
   transpile,
@@ -26,4 +26,5 @@ module.exports = {
   bundle,
   loadConfig,
   mergeConfig,
+  defineConfig,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnoxs/flux-lang",
-  "version": "4.0.8",
+  "version": "4.0.9",
   "description": "Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
   "main": "dist/flux.cjs.js",
   "module": "dist/flux.esm.js",
@@ -9,8 +9,9 @@
     "flux": "./bin/flux.js"
   },
   "scripts": {
-    "build": "node -e \"console.log(\"build skipped\")\"",
-    "test": "node src/self/cli.js test tests/",
+    "build": "node scripts/build.js",
+    "prepublishOnly": "npm test && npm run build",
+    "test": "node src/cli.js test tests/",
     "test:file": "node src/cli.js test",
     "check": "node src/cli.js check tests/01_basics.test.flux",
     "bench": "node benchmarks/bench.js",
@@ -83,4 +84,4 @@
   "devDependencies": {
     "esbuild": "^0.28.1"
   }
-}
+}

package/src/config.js

@@ -1,116 +1,101 @@
+/* compiled from src/self/config.flux by Flux Lang */
 'use strict';
+// ── Flux stdlib ──
 
-/**
- * Flux Lang — Project Config Loader
- *
- * Looks for flux.config.js (or .fluxrc.js) in the current working directory.
- * Returns a plain object with config values; returns {} if no config found.
- *
- * Config schema:
- *   module.exports = {
- *     jsxTarget : 'browser' | 'server' | 'react',  // default: 'browser'
- *     outDir    : './dist',      // output dir for compiled files
- *     sourcemap : false,         // generate .js.map files
- *     mangle    : true,          // obfuscate variable/function names
- *     ignore    : [],            // glob patterns to skip in `flux test`
- *     entry     : 'src/main.flux', // default bundle entry
- *   }
- *
- * CLI flags always take precedence over config values.
- */
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
 
-const fs   = require('fs');
-const path = require('path');
+function includes(arr, val) { return arr.includes(val); }
 
-const CONFIG_NAMES = [
-  'flux.config.js',
-  'flux.config.cjs',
-  '.fluxrc.js',
-];
+function keys(obj) { return Object.keys(obj); }
 
-/**
- * Load project config from CWD (or a given directory).
- * @param {string} [cwd] - directory to search (default: process.cwd())
- * @returns {object} raw config object (or {} if none found)
- */
-function loadConfig(cwd) {
-  const dir = cwd || process.cwd();
+function endsWith(s, suffix) { return String(s).endsWith(suffix); }
+// ── end stdlib ──
 
-  for (const name of CONFIG_NAMES) {
-    const configPath = path.join(dir, name);
-    if (!fs.existsSync(configPath)) continue;
-
-    // Bust require cache so tests can reload different configs
-    delete require.cache[require.resolve(configPath)];
+// Generated by Flux Transpiler v3.2.0
+"use strict";
 
+const Fs = require("fs");
+const Path = require("path");
+const DEFAULT_CONFIG = { entry: "src/main.flux", outDir: "dist", sourcemap: false, mangle: false, jsx: false, jsxTarget: "browser", typecheck: true, strict: false, watch: false, ignore: [], selfHosted: false, registry: "https://registry.flux-lang.dev", pkg: { name: "", version: "1.0.0", description: "", author: "", license: "MIT", deps: {  }, devDeps: {  } } };
+module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+function loadConfig(cwd_) {
+  const cwd = (cwd_ ?? process.cwd());
+  const jsonPath = Path.join(cwd, "flux.json");
+  if (Fs.existsSync(jsonPath)) {
     try {
-      const raw = require(configPath);
-      const cfg = raw && raw.default ? raw.default : raw;
-
-      if (typeof cfg !== 'object' || cfg === null) {
-        process.stderr.write(
-          `[flux] warning: ${name} must export a plain object — ignoring\n`
-        );
-        return {};
-      }
-
-      return cfg;
-    } catch (e) {
-      process.stderr.write(
-        `[flux] error loading ${name}: ${e.message}\n`
-      );
-      return {};
+      const raw = Fs.readFileSync(jsonPath, "utf8");
+      const parsed = JSON.parse(raw);
+      return mergeConfig(DEFAULT_CONFIG, parsed);
+    }
+    catch (e) {
+      throw new Error(("Invalid flux.json: " + e.message));
     }
   }
-
-  return {};
+  const jsPath = Path.join(cwd, "flux.config.js");
+  if (Fs.existsSync(jsPath)) {
+    try {
+      const loaded = require(jsPath);
+      return mergeConfig(DEFAULT_CONFIG, loaded);
+    }
+    catch (e2) {
+      throw new Error(("Invalid flux.config.js: " + e2.message));
+    }
+  }
+  return { ...DEFAULT_CONFIG };
 }
-
-/**
- * Merge file config with CLI opts (CLI flags win).
- * @param {object} fileConfig  - from loadConfig()
- * @param {object} cliOpts     - parsed CLI flags
- * @returns {object} merged options safe to pass to transpile()
- */
-function mergeConfig(fileConfig, cliOpts) {
-  const cfg = fileConfig || {};
-  const cli = cliOpts   || {};
-
-  return {
-    jsxTarget : cli.jsxTarget  !== undefined ? cli.jsxTarget  : (cfg.jsxTarget  || 'browser'),
-    outDir    : cli.outDir     !== undefined ? cli.outDir     : (cfg.outDir     || null),
-    sourcemap : cli.sourcemap  !== undefined ? cli.sourcemap  : (cfg.sourcemap  || false),
-    mangle    : cli.mangle     !== undefined ? cli.mangle     : (cfg.mangle     !== undefined ? cfg.mangle : true),
-    ignore    : cli.ignore     !== undefined ? cli.ignore     : (cfg.ignore     || []),
-    entry     : cli.entry      !== undefined ? cli.entry      : (cfg.entry      || null),
-  };
+module.exports.loadConfig = loadConfig;
+function mergeConfig(base, overrides) {
+  if (!overrides) {
+    return { ...base };
+  }
+  const result = { ...base };
+  for (const key of Object.keys(overrides)) {
+    const val_ = overrides[key];
+    if (((val_ != null) && (val_ != undefined))) {
+      result[key] = val_;
+    }
+  }
+  return result;
 }
-
-/**
- * Identity helper for IDE type-checking / autocompletion.
- * Usage in flux.config.js:  const { defineConfig } = require('@xnoxs/flux-lang/config');
- * @param {object} config
- * @returns {object}
- */
-function defineConfig(config) {
-  return config;
+module.exports.mergeConfig = mergeConfig;
+function writeConfig(config, cwd_) {
+  const cwd = (cwd_ ?? process.cwd());
+  const jsonPath = Path.join(cwd, "flux.json");
+  const content = (JSON.stringify(config, null, 2) + "\n");
+  Fs.writeFileSync(jsonPath, content, "utf8");
 }
-
-/**
- * Minimal glob-pattern matcher (also used by test-runner shim to avoid circular require).
- */
-function matchIgnore(filePath, patterns) {
-  if (!patterns || patterns.length === 0) return false;
-  const normalize = p => p.replace(/\\/g, '/');
-  const fp = normalize(filePath);
-  for (const pattern of patterns) {
-    let re = normalize(pattern).replace(/\*\*/g, '\x00DS\x00');
-    re = re.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-    re = re.replace(/\*/g, '[^/]*');
-    re = re.replace(/\x00DS\x00\//g, '(.+/)?').replace(/\x00DS\x00/g, '.*');
-    if (new RegExp('(^|/)' + re + '$').test(fp)) return true;
+module.exports.writeConfig = writeConfig;
+function validateConfig(config) {
+  const errors = [];
+  if ((config.entry && !config.entry.endsWith(".flux"))) {
+    errors.push("entry must be a .flux file");
   }
-  return false;
+  if ((config.jsxTarget && !["browser", "server", "react"].includes(config.jsxTarget))) {
+    errors.push("jsxTarget must be 'browser', 'server', or 'react'");
+  }
+  return { valid: (errors.length == 0), errors };
 }
-
-module.exports = { loadConfig, mergeConfig, defineConfig, matchIgnore };
+module.exports.validateConfig = validateConfig;
+function readPackage(cwd_) {
+  const cwd = (cwd_ ?? process.cwd());
+  const fluxJson = Path.join(cwd, "flux.json");
+  const pkgJson = Path.join(cwd, "package.json");
+  if (Fs.existsSync(fluxJson)) {
+    try {
+      return JSON.parse(Fs.readFileSync(fluxJson, "utf8"));
+    }
+    catch (e) {
+      return null;
+    }
+  }
+  if (Fs.existsSync(pkgJson)) {
+    try {
+      return JSON.parse(Fs.readFileSync(pkgJson, "utf8"));
+    }
+    catch (e2) {
+      return null;
+    }
+  }
+  return null;
+}
+module.exports.readPackage = readPackage;

package/src/formatter.js

@@ -1,140 +1,135 @@
+/* compiled from src/self/formatter.flux by Flux Lang */
 'use strict';
+// ── Flux stdlib ──
 
-// ── Flux Code Formatter ───────────────────────────────────────────────────────
-// Normalizes Flux source code:
-//   • 4-space indentation
-//   • Strips trailing whitespace
-//   • Max 1 consecutive blank line
-//   • Blank line after top-level fn/class/type declarations
-//   • Spacing around binary operators
-//   • Consistent colon / arrow spacing
+function map(arr, fn) { return arr.map(fn); }
 
-function format(source) {
-  const lines = source.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+
+function max(arr) {
+  if (arguments.length > 1) return Math.max.apply(null, arguments);
+  return Math.max.apply(null, arr);
+}
+
+function round(n, decimals) {
+  if (decimals == null) return Math.round(n);
+  var f = Math.pow(10, decimals);
+  return Math.round(n * f) / f;
+}
+
+function trimStart(s) { return String(s).trimStart(); }
+
+function trimEnd(s) { return String(s).trimEnd(); }
 
-  // ── 1. Detect indentation unit from the first indented line ─────────────
+function startsWith(s, prefix) { return String(s).startsWith(prefix); }
+
+function repeat(s, n) { return String(s).repeat(n); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.2.0
+"use strict";
+
+function normalizeOperators(line) {
+  if (((line.match(/:/g) ?? []).length > 2)) {
+    return line;
+  }
+  let result = line;
+  result = result.replace(/([^=!<>+\-*\/%])=(?!=|>)/g, "$1 = ");
+  result = result.replace(/\s{2,}=/g, " =");
+  result = result.replace(/([^\s])  +/g, "$1 ");
+  result = result.replace(/,(?!\s)/g, ", ");
+  result = result.replace(/\s*->\s*/g, " -> ");
+  result = result.replace(/\s*=>\s*/g, " => ");
+  result = result.trimEnd();
+  return result;
+}
+function format(source) {
+  const lines = source.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
   let indentUnit = 4;
   for (const line of lines) {
     const m = line.match(/^( +)\S/);
     if (m) {
       const w = m[1].length;
-      if (w > 0 && w < indentUnit) indentUnit = w;
+      if (((w > 0) && (w < indentUnit))) {
+        indentUnit = w;
+      }
       break;
     }
   }
-  if (indentUnit < 1) indentUnit = 4;
-
-  // ── 2. Strip trailing whitespace + normalize indent to 4 spaces ─────────
-  const normalized = lines.map(line => {
+  if ((indentUnit < 1)) {
+    indentUnit = 4;
+  }
+  function normalizeLine(line) {
     const stripped = line.trimEnd();
-    if (!stripped) return '';
-    const m = stripped.match(/^( *)/);
-    const spaces = m ? m[1].length : 0;
-    const level  = Math.round(spaces / indentUnit);
+    if (!stripped) {
+      return "";
+    }
+    const m2 = stripped.match(/^( *)/);
+    const spaces = (m2 ? m2[1].length : 0);
+    const level = Math.round((spaces / indentUnit));
     const content = stripped.trimStart();
-
-    // Normalize spacing around operators in the content (only when not a string literal line)
-    const formatted = content.startsWith('//') || content.startsWith('*')
-      ? content
-      : normalizeOperators(content);
-
-    return '    '.repeat(level) + formatted;
-  });
-
-  // ── 3. Collapse multiple blank lines → max 1 ────────────────────────────
+    let formatted = normalizeOperators(content);
+    if ((content.startsWith("//") || content.startsWith("*"))) {
+      formatted = content;
+    }
+    return ("    ".repeat(level) + formatted);
+  }
+  const normalized = lines.map((line) => normalizeLine(line));
   const collapsed = [];
   let blankRun = 0;
   for (const line of normalized) {
-    if (line === '') {
-      blankRun++;
-      if (blankRun <= 1) collapsed.push('');
-    } else {
+    if ((line == "")) {
+      blankRun = (blankRun + 1);
+      if ((blankRun <= 1)) {
+        collapsed.push("");
+      }
+    }
+    else {
       blankRun = 0;
       collapsed.push(line);
     }
   }
-
-  // ── 4. Add blank line after top-level fn/class/type/async fn blocks ──────
   const withSpacing = [];
-  for (let i = 0; i < collapsed.length; i++) {
+  let i = 0;
+  while ((i < collapsed.length)) {
     withSpacing.push(collapsed[i]);
-    const cur  = collapsed[i].trimStart();
-    const next = (collapsed[i + 1] || '').trimStart();
-    const indent = collapsed[i].match(/^( *)/)[1].length;
-
-    // After dedented fn/class/type at indent=0 or indent=4, add blank line
-    if (indent <= 4 && /^(fn |async fn |class |type )/.test(cur)) {
-      // No blank needed if next line is blank already
-      if (next !== '' && !/^(fn |async fn |class |type )/.test(next)) {
-        // skip — next content comes right after declaration line, part of fn
-      }
-    }
-
-    // After closing a fn/class block at top level (no indent dedent signal,
-    // but we detect when a non-indented line follows an indented block)
-    if (i > 0) {
-      const prevIndent = collapsed[i - 1].match(/^( *)/)[1].length;
-      if (prevIndent >= 4 && indent === 0 && cur !== '') {
-        // We just came back to top-level — add blank if last added wasn't blank
-        if (withSpacing[withSpacing.length - 2] !== '') {
-          withSpacing.splice(withSpacing.length - 1, 0, '');
+    const indent = (collapsed[i].match(/^( *)/) ?? ["", ""])[1].length;
+    if ((i > 0)) {
+      const prevIndent = (collapsed[(i - 1)].match(/^( *)/) ?? ["", ""])[1].length;
+      const cur = collapsed[i].trimStart();
+      if ((((prevIndent >= 4) && (indent == 0)) && (cur != ""))) {
+        if ((withSpacing[(withSpacing.length - 2)] != "")) {
+          withSpacing.splice((withSpacing.length - 1), 0, "");
         }
       }
     }
+    i = (i + 1);
   }
-
-  // ── 5. Trim leading/trailing blank lines + ensure single trailing newline ─
   let out = withSpacing;
-  while (out.length > 0 && out[0] === '') out.shift();
-  while (out.length > 0 && out[out.length - 1] === '') out.pop();
-  out.push('');
-
-  return out.join('\n');
-}
-
-// ── Operator spacing normalizer ──────────────────────────────────────────────
-// Ensures spaces around binary operators without touching strings/comments
-function normalizeOperators(line) {
-  // Skip lines that look like CSS / strings (heuristic: too many : or { })
-  if ((line.match(/:/g) || []).length > 2) return line;
-
-  let result = line;
-
-  // Add space around = (but not ==, !=, <=, >=, ->, =>, +=, -=, *=, /=, %=)
-  result = result.replace(/([^=!<>+\-*/%])=(?!=|>)/g, '$1 = ');
-  result = result.replace(/\s{2,}=/g, ' =');
-
-  // Normalize multiple spaces inside (but not at start = indentation)
-  result = result.replace(/([^\s])  +/g, '$1 ');
-
-  // Ensure space after comma
-  result = result.replace(/,(?!\s)/g, ', ');
-
-  // Ensure space before/after -> and =>
-  result = result.replace(/\s*->\s*/g, ' -> ');
-  result = result.replace(/\s*=>\s*/g, ' => ');
-
-  // Trim end
-  result = result.trimEnd();
-
-  return result;
+  while (((out.length > 0) && (out[0] == ""))) {
+    out.shift();
+  }
+  while (((out.length > 0) && (out[(out.length - 1)] == ""))) {
+    out.pop();
+  }
+  out.push("");
+  return out.join("\n");
 }
-
-// ── Diff output ──────────────────────────────────────────────────────────────
+module.exports.format = format;
 function diff(original, formatted) {
-  const origLines = original.split('\n');
-  const fmtLines  = formatted.split('\n');
-  const changes   = [];
-
+  const origLines = original.split("\n");
+  const fmtLines = formatted.split("\n");
+  const changes = [];
   const maxLen = Math.max(origLines.length, fmtLines.length);
-  for (let i = 0; i < maxLen; i++) {
-    const o = origLines[i];
-    const f = fmtLines[i];
-    if (o !== f) {
-      changes.push({ line: i + 1, original: o, formatted: f });
+  let j = 0;
+  while ((j < maxLen)) {
+    const o = origLines[j];
+    const f = fmtLines[j];
+    if ((o != f)) {
+      changes.push({ line: (j + 1), original: o, formatted: f });
     }
+    j = (j + 1);
   }
   return changes;
 }
-
-module.exports = { format, diff };
+module.exports.diff = diff;

package/src/self/bundler.flux

@@ -3,8 +3,6 @@
 //  src/self/bundler.flux — written in Flux, compiled by stage-0
 //
 //  Bundles multiple Flux modules into a single JS file.
-//  Resolves all inter-file .flux imports recursively.
-//  npm packages (non-relative imports) remain as require() calls.
 // ============================================================
 
 import Fs   from "fs"
@@ -18,25 +16,17 @@ fn toModuleId(absPath):
   return '_flux_' + base.replace(/[^a-zA-Z0-9]/g, '_')
 
 fn extractModuleInfo(ast, fromFile):
-  val imports    = []
-  val npmImports = []
-  val exports    = []
-  val body       = []
-  val dir        = Path.dirname(fromFile)
+  val imports = []
+  val exports = []
+  val body    = []
+  val dir     = Path.dirname(fromFile)
 
   for node in ast.body:
     if node.type == 'ImportDecl':
-      val src = node.source
-      // Relative import → resolve as .flux file
-      if src.startsWith('./') or src.startsWith('../'):
-        var resolved = src
-        if not resolved.endsWith('.flux'): resolved = resolved + '.flux'
-        val absPath = Path.resolve(dir, resolved)
-        imports.push({ names: node.names, source: node.source, absPath })
-      else:
-        // npm package import — keep as-is (require in output)
-        npmImports.push({ names: node.names, source: src })
-        body.push(node)
+      var src = node.source
+      if not src.endsWith('.flux'): src = src + '.flux'
+      val absPath = Path.resolve(dir, src)
+      imports.push({ names: node.names, source: node.source, absPath })
 
     else if node.type == 'ExportDecl':
       val inner = node.decl
@@ -48,7 +38,7 @@ fn extractModuleInfo(ast, fromFile):
     else:
       body.push(node)
 
-  return { cleanAst: { type: 'Program', body }, imports, npmImports, exports }
+  return { cleanAst: { type: 'Program', body }, imports, exports }
 
 fn codegenModule(ast):
   val cg = makeCodeGen({ indent: '    ' })
@@ -90,7 +80,6 @@ export class Bundler:
     val info = extractModuleInfo(ast, absPath)
     self.modules.set(absPath, { cleanAst: info.cleanAst, imports: info.imports, exports: info.exports, source, absPath })
 
-    // Recursively collect all .flux imports
     for imp in info.imports:
       self.collect(imp.absPath)
 
@@ -109,6 +98,12 @@ export class Bundler:
       lines.push('"use strict";')
       lines.push('')
 
+    // flux_modules resolver: patches Module._resolveFilename so require() looks in
+    // flux_modules/node_modules/ first (packages installed via `flux install`).
+    lines.push('// flux_modules resolver')
+    lines.push("(function(){var _p=require('path'),_fs=require('fs'),_M=require('module'),_d=_p.join(process.cwd(),'flux_modules','node_modules');if(_fs.existsSync(_d)){var _o=_M._resolveFilename.bind(_M);_M._resolveFilename=function(r,p,m,op){if(!r.startsWith('.')&&!r.startsWith('/')&&!r.startsWith('node:')){var _fp=_p.join(_d,r.split('/')[0]);if(_fs.existsSync(_fp)){try{return _o(_p.join(_d,r),p,m,op);}catch(_e){}}}return _o(r,p,m,op);};}})();")
+    lines.push('')
+
     lines.push('(function() {')
     lines.push('')
 
@@ -130,7 +125,7 @@ export class Bundler:
       for imp in mod.imports:
         val srcId = toModuleId(imp.absPath)
         for name in imp.names:
-          val localName    = name.alias ?? name.name
+          val localName = name.alias ?? name.name
           val importedName = name.name
           lines.push('    var ' + localName + ' = ' + srcId + '._exports ? ' + srcId + '._exports.' + importedName + ' : ' + srcId + '.' + importedName + ';')
 

package/src/self/bundler.js

@@ -1,6 +1,23 @@
-/* compiled from src/self/bundler.flux */
+/* compiled from src/self/bundler.flux by Flux Lang */
 'use strict';
-// Generated by Flux Transpiler v3.5.3 (self-hosted)
+// ── Flux stdlib ──
+
+function findIndex(arr, fn) { return arr.findIndex(fn); }
+
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+
+function includes(arr, val) { return arr.includes(val); }
+
+function trim(s) { return String(s).trim(); }
+
+function startsWith(s, prefix) { return String(s).startsWith(prefix); }
+
+function endsWith(s, suffix) { return String(s).endsWith(suffix); }
+
+function repeat(s, n) { return String(s).repeat(n); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.2.0
 "use strict";
 
 const Fs = require("fs");
@@ -14,25 +31,17 @@ function toModuleId(absPath) {
 }
 function extractModuleInfo(ast, fromFile) {
   const imports = [];
-  const npmImports = [];
   const exports = [];
   const body = [];
   const dir = Path.dirname(fromFile);
   for (const node of ast.body) {
     if ((node.type == "ImportDecl")) {
-      const src = node.source;
-      if ((src.startsWith("./") || src.startsWith("../"))) {
-        let resolved = src;
-        if (!resolved.endsWith(".flux")) {
-          resolved = (resolved + ".flux");
-        }
-        const absPath = Path.resolve(dir, resolved);
-        imports.push({ names: node.names, source: node.source, absPath });
-      }
-      else {
-        npmImports.push({ names: node.names, source: src });
-        body.push(node);
+      let src = node.source;
+      if (!src.endsWith(".flux")) {
+        src = (src + ".flux");
       }
+      const absPath = Path.resolve(dir, src);
+      imports.push({ names: node.names, source: node.source, absPath });
     }
     else if ((node.type == "ExportDecl")) {
       const inner = node.decl;
@@ -51,7 +60,7 @@ function extractModuleInfo(ast, fromFile) {
       body.push(node);
     }
   }
-  return { cleanAst: { type: "Program", body }, imports, npmImports, exports };
+  return { cleanAst: { type: "Program", body }, imports, exports };
 }
 function codegenModule(ast) {
   const cg = makeCodeGen({ indent: "    " });
@@ -115,6 +124,9 @@ class Bundler {
       lines.push("\"use strict\";");
       lines.push("");
     }
+    lines.push("// flux_modules resolver");
+    lines.push("(function(){var _p=require('path'),_fs=require('fs'),_M=require('module'),_d=_p.join(process.cwd(),'flux_modules','node_modules');if(_fs.existsSync(_d)){var _o=_M._resolveFilename.bind(_M);_M._resolveFilename=function(r,p,m,op){if(!r.startsWith('.')&&!r.startsWith('/')&&!r.startsWith('node:')){var _fp=_p.join(_d,r.split('/')[0]);if(_fs.existsSync(_fp)){try{return _o(_p.join(_d,r),p,m,op);}catch(_e){}}}return _o(r,p,m,op);};}})();");
+    lines.push("");
     lines.push("(function() {");
     lines.push("");
     for (const absPath of this.order) {