@xnoxs/flux-lang 4.0.2 → 4.0.4

package/index.js

@@ -3,17 +3,17 @@
 /**
  * Flux Lang — Public API
  *
- * const { transpile } = require('flux-lang');
- * import { transpile, format, buildStdlib } from 'flux-lang';
+ * const { transpile } = require('@xnoxs/flux-lang');
+ * import { transpile, format, buildStdlib } from '@xnoxs/flux-lang';
  */
 
-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');
+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');
 
 module.exports = {
   transpile,
@@ -26,5 +26,4 @@ module.exports = {
   bundle,
   loadConfig,
   mergeConfig,
-  defineConfig,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnoxs/flux-lang",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "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,9 +9,8 @@
     "flux": "./bin/flux.js"
   },
   "scripts": {
-    "build": "node scripts/build.js",
-    "prepublishOnly": "npm test && npm run build",
-    "test": "node src/cli.js test tests/",
+    "build": "node -e \"console.log(\"build skipped\")\"",
+    "test": "node src/self/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",
@@ -84,4 +83,4 @@
   "devDependencies": {
     "esbuild": "^0.28.1"
   }
-}
+}

package/src/self/bundler.flux

@@ -124,11 +124,10 @@ export class Bundler:
 
       for imp in mod.imports:
         val srcId = toModuleId(imp.absPath)
-        if imp.names.length == 1:
-          lines.push('    var ' + imp.names[0] + ' = ' + srcId + ';')
-        else:
-          for name in imp.names:
-            lines.push('    var ' + name + ' = ' + srcId + '._exports ? ' + srcId + '._exports.' + name + ' : ' + srcId + '.' + name + ';')
+        for name in imp.names:
+          val localName = name.alias ?? name.name
+          val importedName = name.name
+          lines.push('    var ' + localName + ' = ' + srcId + '._exports ? ' + srcId + '._exports.' + importedName + ' : ' + srcId + '.' + importedName + ';')
 
       if mod.imports.length > 0: lines.push('')
 

package/src/self/bundler.js

@@ -1,3 +1,5 @@
+/* compiled from src/self/bundler.flux by Flux Lang */
+'use strict';
 // ── Flux stdlib ──
 
 function findIndex(arr, fn) { return arr.findIndex(fn); }
@@ -29,17 +31,25 @@ 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")) {
-      let src = node.source;
-      if (!src.endsWith(".flux")) {
-        src = (src + ".flux");
+      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);
       }
-      const absPath = Path.resolve(dir, src);
-      imports.push({ names: node.names, source: node.source, absPath });
     }
     else if ((node.type == "ExportDecl")) {
       const inner = node.decl;
@@ -58,7 +68,7 @@ function extractModuleInfo(ast, fromFile) {
       body.push(node);
     }
   }
-  return { cleanAst: { type: "Program", body }, imports, exports };
+  return { cleanAst: { type: "Program", body }, imports, npmImports, exports };
 }
 function codegenModule(ast) {
   const cg = makeCodeGen({ indent: "    " });
@@ -122,9 +132,6 @@ 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) {
@@ -142,13 +149,10 @@ class Bundler {
       }
       for (const imp of mod.imports) {
         const srcId = toModuleId(imp.absPath);
-        if ((imp.names.length == 1)) {
-          lines.push((((("    var " + imp.names[0]) + " = ") + srcId) + ";"));
-        }
-        else {
-          for (const name of imp.names) {
-            lines.push((((((((((((("    var " + name) + " = ") + srcId) + "._exports ? ") + srcId) + "._exports.") + name) + " : ") + srcId) + ".") + name) + ";"));
-          }
+        for (const name of imp.names) {
+          const localName = (name.alias ?? name.name);
+          const importedName = name.name;
+          lines.push((((((((((((("    var " + localName) + " = ") + srcId) + "._exports ? ") + srcId) + "._exports.") + importedName) + " : ") + srcId) + ".") + importedName) + ";"));
         }
       }
       if ((mod.imports.length > 0)) {

package/src/self/cli.js

@@ -1,10 +1,8 @@
+/* compiled from src/self/cli.flux by Flux Lang */
+'use strict';
 // ── Flux stdlib ──
 
-function map(arr, fn) { return arr.map(fn); }
-
-function filter(arr, fn) { return arr.filter(fn); }
-
-function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }
+function find(arr, fn) { return arr.find(fn); }
 
 function some(arr, fn) { return arr.some(fn); }
 
@@ -14,10 +12,6 @@ function clamp(val, min, max) {
   return Math.min(Math.max(val, min), max);
 }
 
-function sum(arr) {
-  return arr.reduce(function(a, b) { return a + b; }, 0);
-}
-
 function max(arr) {
   if (arguments.length > 1) return Math.max.apply(null, arguments);
   return Math.max.apply(null, arr);
@@ -96,7 +90,7 @@ function showHelp() {
   console.log(bold("USAGE:"));
   console.log("  flux <command> [options]\n");
   console.log(bold("COMPILER:"));
-  const compilerCmds = [["compile <file.flux>", "Compile .flux → .js"], ["bundle  <entry.flux>", "Bundle multiple files into one .js"], ["run     <file.flux>", "Compile and run immediately"], ["watch   <file.flux>", "Watch for changes, auto-compile"], ["check   <file.flux>", "Type-check and static analysis"]];
+  const compilerCmds = [["compile <file.flux>", "Compile .flux → .js"], ["bundle  <entry.flux>", "Bundle multi-file project into one .js"], ["run     <file.flux>", "Compile and run a single-file script"], ["watch   <file.flux>", "Watch for changes, auto-compile"], ["check   <file.flux>", "Type-check and static analysis"]];
   for (const __item__ of compilerCmds) {
     const [cmd, desc] = __item__;
     console.log(((("  " + green(("flux " + cmd).padEnd(36))) + " ") + gray(desc)));
@@ -110,7 +104,7 @@ function showHelp() {
   }
   console.log();
   console.log(bold("PACKAGE MANAGER:"));
-  const pkgCmds = [["init    [name]", "Scaffold a new Flux project"], ["add     <pkg[@version]>", "Add a dependency"], ["remove  <pkg>", "Remove a dependency"], ["install", "Install all dependencies"], ["list", "List installed packages"], ["search  <query>", "Search the package registry"], ["info    <pkg>", "Show package details"], ["publish", "Publish package to registry"]];
+  const pkgCmds = [["init    [name] [--template]", "Scaffold a new Flux project"], ["add     <pkg[@version]>", "Add a dependency (npm install --save)"], ["remove  <pkg>", "Remove a dependency (npm uninstall)"], ["install", "Install all dependencies (npm install)"], ["list", "List installed packages"], ["search  <query>", "Search the npm registry"], ["info    <pkg>", "Show package details"], ["publish", "Publish package to npm registry"]];
   for (const __item__ of pkgCmds) {
     const [cmd, desc] = __item__;
     console.log(((("  " + cyan(("flux " + cmd).padEnd(36))) + " ") + gray(desc)));
@@ -131,11 +125,12 @@ function showHelp() {
   console.log((("  " + yellow("--typecheck       ")) + "  Enable type checking"));
   console.log((("  " + yellow("--stdout          ")) + "  Print to terminal"));
   console.log((("  " + yellow("--no-color        ")) + "  Disable colors"));
+  console.log((("  " + yellow("--template        ")) + "  Init template: script, server, webapp"));
   console.log();
 }
 function parseArgs(argv) {
   const args = argv.slice(2);
-  const opts = { out: null, sourcemap: false, mangle: false, typecheck: false, strict: false, stdout: false, watch: false, dev: false, verbose: false, jsx: false, jsxTarget: "browser" };
+  const opts = { out: null, sourcemap: false, mangle: false, typecheck: false, strict: false, stdout: false, watch: false, dev: false, verbose: false, jsx: false, jsxTarget: "browser", template: null };
   const positional = [];
   let i = 0;
   while ((i < args.length)) {
@@ -175,6 +170,10 @@ function parseArgs(argv) {
       i = (i + 1);
       opts.jsxTarget = args[i];
     }
+    else if (((a == "--template") || (a == "-t"))) {
+      i = (i + 1);
+      opts.template = args[i];
+    }
     else if (!a.startsWith("--")) {
       positional.push(a);
     }
@@ -243,6 +242,21 @@ function printErrors(errors, source, filePath) {
   }
   console.error();
 }
+function findFluxImports(source) {
+  const found = [];
+  const lines = source.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const m = trimmed.match(/^import\s+.+\s+from\s+["'](\.[^"']+)["']/);
+    if (m) {
+      const src = m[1];
+      if (((!src.endsWith(".js") && !src.endsWith(".json")) && !src.endsWith(".node"))) {
+        found.push(src);
+      }
+    }
+  }
+  return found;
+}
 function cmdCompile(filePath, opts) {
   const { source, abs } = readFluxFile(filePath);
   const cfg = loadConfig(Path.dirname(abs));
@@ -276,6 +290,21 @@ function cmdCompile(filePath, opts) {
 }
 function cmdRun(filePath, opts) {
   const { source, abs } = readFluxFile(filePath);
+  const fluxImports = findFluxImports(source);
+  if ((fluxImports.length > 0)) {
+    const example = fluxImports[0];
+    const entryRel = Path.relative(process.cwd(), abs);
+    const outFile = (Path.basename(abs, ".flux") + ".js");
+    console.error(red("\n✗ Cannot run a multi-file Flux project with `flux run`.\n"));
+    console.error(("  Found: " + yellow((("import ... from \"" + example) + "\""))));
+    console.error();
+    console.error((("  Use " + cyan("flux bundle")) + " to compile all files into one, then run it:\n"));
+    console.error(("    " + yellow(((("flux bundle " + entryRel) + " -o dist/") + outFile))));
+    console.error(("    " + yellow(("node dist/" + outFile))));
+    console.error();
+    console.error((("  Or use " + cyan("flux run")) + " only for single-file scripts (no inter-file .flux imports).\n"));
+    process.exit(1);
+  }
   const result = transpile(source, { jsx: (opts.jsx ?? false), jsxTarget: (opts.jsxTarget ?? "browser"), mangle: false });
   if (!result.success) {
     console.error(red("\n✗ Compile error"));
@@ -443,6 +472,10 @@ function cmdBundle(entryPath, opts) {
     console.log(result.code);
     return;
   }
+  const outDir = Path.dirname(Path.resolve(outFile));
+  if (!Fs.existsSync(outDir)) {
+    Fs.mkdirSync(outDir, { recursive: true });
+  }
   Fs.writeFileSync(outFile, result.code, "utf8");
   const kb = (result.code.length / 1024).toFixed(1);
   console.log((((((green("✓ Bundle done") + gray(((" (" + elapsed) + "ms) "))) + Path.basename(abs)) + gray(((" + " + (result.modules - 1)) + " module(s) → "))) + cyan(Path.relative(process.cwd(), outFile))) + gray(((" [" + kb) + " KB]"))));
@@ -573,6 +606,7 @@ function cmdRepl(opts) {
 }
 function cmdInit(name, opts) {
   const projectName = (name ?? "my-flux-app");
+  const template = (opts.template ?? "script");
   const dir = Path.resolve(projectName);
   if (Fs.existsSync(dir)) {
     console.error(red(("✗ Directory already exists: " + projectName)));
@@ -581,38 +615,77 @@ function cmdInit(name, opts) {
   Fs.mkdirSync(dir, { recursive: true });
   Fs.mkdirSync(Path.join(dir, "src"), { recursive: true });
   Fs.mkdirSync(Path.join(dir, "tests"), { recursive: true });
-  const mainFlux = "// {projectName} — built with Flux Lang v{VERSION}\n// Run: flux run src/main.flux\n\n// ── Algebraic Data Types + Pattern Matching ───────────────────\ntype Shape = Circle(radius) | Rect(width, height) | Triangle(base, height)\n\nfn area(shape):\n  match shape:\n    when Circle(r):      return Math.PI * r * r\n    when Rect(w, h):     return w * h\n    when Triangle(b, h): return 0.5 * b * h\n\nfn describe(shape):\n  match shape:\n    when Circle(r):      return \"Circle(r={r:.2f})\"\n    when Rect(w, h):     return \"Rect({w:.1f}x{h:.1f})\"\n    when Triangle(b, h): return \"Triangle(b={b:.1f}, h={h:.1f})\"\n\n// ── Result type ───────────────────────────────────────────────\ntype Result = Ok(value) | Err(message)\n\nfn safeDivide(a, b):\n  if b == 0: return Err(\"division by zero\")\n  return Ok(a / b)\n\n// ── Utility functions ─────────────────────────────────────────\nfn greet(name): return \"Hello from Flux, {name}!\"\n\nfn formatList(items):\n  if items.length == 0: return \"(empty)\"\n  return \"[\" + items.join(\", \") + \"]\"\n\nfn clamp(value, lo, hi):\n  if value < lo: return lo\n  if value > hi: return hi\n  return value\n\n// ── Pipe operator + stdlib ────────────────────────────────────\nval numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]\nval processed = numbers\n  |> filter(n -> n > 3)\n  |> map(n -> n * n)\n  |> sort\n\n// ── Main ──────────────────────────────────────────────────────\nprint(greet(\"{projectName}\"))\nprint(\"Squares > 3: {formatList(processed)}\")\nprint(\"clamp(12, 0, 10) = {clamp(12, 0, 10)}\")\n\nval shapes = [Circle(5.0), Rect(8.0, 3.0), Triangle(6.0, 4.0)]\nfor shape in shapes:\n  val a = area(shape)\n  print(\"{describe(shape)}  area={a:.2f}\")\n\nmatch safeDivide(10.0, 3.0):\n  when Ok(v):  print(\"10 / 3 = {v:.4f}\")\n  when Err(e): print(\"Error: {e}\")";
-  const utilsFlux = "// Utility functions for {projectName}\n// Use with: flux bundle src/main.flux (bundles imports automatically)\n\nexport fn greet(name):\n  return \"Hello from Flux, {name}!\"\n\nexport fn formatList(items):\n  if items.length == 0: return \"(empty)\"\n  return \"[\" + items.join(\", \") + \"]\"\n\nexport fn clamp(value, lo, hi):\n  if value < lo: return lo\n  if value > hi: return hi\n  return value\n\nexport fn sum(nums):\n  return nums.reduce((acc, x) -> acc + x, 0)\n\nexport fn average(nums):\n  if nums.length == 0: return 0\n  return sum(nums) / nums.length";
-  const testFlux = "// Tests for {projectName}\n// Run: flux test tests/\n\n// ── Functions under test ──────────────────────────────────────\nfn add(a, b):\n    return a + b\n\nfn mul(a, b):\n    return a * b\n\nfn clamp(value, lo, hi):\n    if value < lo: return lo\n    if value > hi: return hi\n    return value\n\nfn average(nums):\n    if nums.length == 0: return 0\n    return nums.reduce((s, x) -> s + x, 0) / nums.length\n\ntype Result = Ok(value) | Err(message)\n\nfn safeDivide(a, b):\n    if b == 0: return Err(\"div by zero\")\n    return Ok(a / b)\n\n// ── Test functions ────────────────────────────────────────────\nfn test_add():\n    assert(add(1, 2) == 3, \"1+2=3\")\n    assert(add(0, 0) == 0, \"0+0=0\")\n    assert(add(-1, 1) == 0, \"-1+1=0\")\n\nfn test_mul():\n    assert(mul(3, 4) == 12, \"3*4=12\")\n    assert(mul(0, 5) == 0, \"0*5=0\")\n\nfn test_clamp():\n    assert(clamp(5, 0, 10) == 5, \"within range\")\n    assert(clamp(-1, 0, 10) == 0, \"below min\")\n    assert(clamp(15, 0, 10) == 10, \"above max\")\n\nfn test_average():\n    assert(average([2, 4, 6]) == 4, \"average of 2,4,6\")\n    assert(average([]) == 0, \"empty list\")\n\nfn test_safe_divide():\n    val ok = safeDivide(10, 2)\n    match ok:\n        when Ok(v):  assert(v == 5, \"10/2=5\")\n        when Err(e): assert(false, \"unexpected error\")\n    val err = safeDivide(10, 0)\n    match err:\n        when Ok(v):  assert(false, \"expected error\")\n        when Err(e): assert(e == \"div by zero\", \"error message\")\n\nfn test_pipe_operator():\n    val result = [1, 2, 3, 4, 5] |> filter(n -> n > 2) |> map(n -> n * 2)\n    assert(result.length == 3, \"filter length\")\n    assert(result[0] == 6, \"first element\")\n    assert(result[2] == 10, \"last element\")";
-  const fluxJson = { name: projectName, version: "1.0.0", description: (("A Flux Lang v" + VERSION) + " project"), author: "", license: "MIT", entry: "src/main.flux", outDir: "dist", sourcemap: false, typecheck: true, scripts: { start: "flux run src/main.flux", build: "flux bundle src/main.flux -o dist/bundle.js", dev: "flux watch src/main.flux", check: "flux check src/main.flux", test: "flux test tests/", fmt: "flux fmt src/", lint: "flux lint src/" }, dependencies: {  }, devDependencies: { "@xnoxs/flux-lang": ("^" + VERSION) } };
-  const gitignore = "node_modules/\ndist/\nflux_modules/\n*.js.map\n.DS_Store\n";
-  const readme = "# {projectName}\n\nA project built with [Flux Lang](https://flux-lang.dev) v{VERSION} — the self-hosted compiler.\n\n## Quick Start\n\n```bash\nflux run src/main.flux\n```\n\n## Project Structure\n\n```\n{projectName}/\n├── src/\n│   ├── main.flux        # Entry point\n│   └── utils.flux       # Utility functions\n├── tests/\n│   └── main.test.flux   # Test suite\n├── flux_modules/        # Packages installed by `flux install` (gitignored)\n├── flux.json            # Project config & dependencies\n└── README.md\n```\n\n## Commands\n\n| Command | Description |\n|---|---|\n| `flux run src/main.flux` | Run the project |\n| `flux bundle src/main.flux -o dist/bundle.js` | Bundle to single file |\n| `flux watch src/main.flux` | Watch mode |\n| `flux check src/main.flux` | Type check + static analysis |\n| `flux test tests/` | Run all tests |\n| `flux fmt src/` | Format source code |\n| `flux lint src/` | Lint for issues |\n| `flux add <package>` | Add a dependency |";
-  const allFiles = [(projectName + "/src/main.flux"), (projectName + "/src/utils.flux"), (projectName + "/tests/main.test.flux"), (projectName + "/flux.json"), (projectName + "/.gitignore"), (projectName + "/README.md")];
-  Fs.writeFileSync(Path.join(dir, "src", "main.flux"), mainFlux, "utf8");
-  Fs.writeFileSync(Path.join(dir, "src", "utils.flux"), utilsFlux, "utf8");
-  Fs.writeFileSync(Path.join(dir, "tests", "main.test.flux"), testFlux, "utf8");
-  Fs.writeFileSync(Path.join(dir, "flux.json"), (JSON.stringify(fluxJson, null, 2) + "\n"), "utf8");
-  Fs.writeFileSync(Path.join(dir, ".gitignore"), gitignore, "utf8");
-  Fs.writeFileSync(Path.join(dir, "README.md"), readme, "utf8");
-  console.log();
-  console.log((green("✓ Created: ") + bold((projectName + "/"))));
-  console.log();
-  console.log(gray("  Files:"));
-  for (const f of allFiles) {
-    console.log(("  " + cyan(f)));
+  const gitignore = "node_modules/\ndist/\n*.js.map\n.DS_Store\n";
+  const testFlux = "// Tests for {projectName}\n// Run: flux test tests/\n\nfn add(a, b):\n    return a + b\n\nfn clamp(value, lo, hi):\n    if value < lo: return lo\n    if value > hi: return hi\n    return value\n\nfn test_add():\n    assert(add(1, 2) == 3, \"1+2=3\")\n    assert(add(0, 0) == 0, \"0+0=0\")\n    assert(add(-1, 1) == 0, \"-1+1=0\")\n\nfn test_clamp():\n    assert(clamp(5, 0, 10) == 5, \"within range\")\n    assert(clamp(-1, 0, 10) == 0, \"below min\")\n    assert(clamp(15, 0, 10) == 10, \"above max\")";
+  if ((template == "script")) {
+    const mainFlux = "// {projectName} — a Flux script\n// Run: npm run dev  (or: node_modules/.bin/flux run src/main.flux)\n\nimport Fs   from \"fs\"\nimport Path from \"path\"\n\nfn main():\n    print(\"Hello from Flux!\")\n    print(\"Node version: {process.version}\")\n\nmain()";
+    const pkgJson = { name: projectName, version: "1.0.0", description: "A Flux project", main: "dist/main.js", scripts: { dev: "flux run src/main.flux", build: "flux bundle src/main.flux -o dist/main.js", start: "node dist/main.js", test: "flux test tests/" }, flux: { entry: "src/main.flux", outDir: "dist", mangle: false, sourcemap: false }, dependencies: { "@xnoxs/flux-lang": ("^" + VERSION) }, devDependencies: {  } };
+    Fs.writeFileSync(Path.join(dir, "src", "main.flux"), mainFlux, "utf8");
+    Fs.writeFileSync(Path.join(dir, "tests", "main.test.flux"), testFlux, "utf8");
+    Fs.writeFileSync(Path.join(dir, "package.json"), (JSON.stringify(pkgJson, null, 2) + "\n"), "utf8");
+    Fs.writeFileSync(Path.join(dir, ".gitignore"), gitignore, "utf8");
+    console.log();
+    console.log((((green("✓ Project ") + bold((projectName + "/"))) + green(" created with template ")) + cyan("script")));
+    console.log();
+    console.log(bold("  Next steps:"));
+    console.log(("    " + yellow(("cd " + projectName))));
+    console.log(("    " + yellow("npm install")));
+    console.log(("    " + yellow("npm run dev")));
+    console.log();
+    console.log(gray("  Add packages:"));
+    console.log(("    " + yellow("flux add <package>")));
+    console.log();
+    return;
   }
-  console.log();
-  console.log(bold("  Next steps:"));
-  console.log(("    " + yellow(("cd " + projectName))));
-  console.log(("    " + yellow("flux run src/main.flux")));
-  console.log();
-  console.log(gray("  Add packages (installed into flux_modules/):"));
-  console.log(("    " + yellow("flux add <package>")));
-  console.log(("    " + yellow("flux install")));
-  console.log();
-  console.log(gray("  Or run the test suite:"));
-  console.log(("    " + yellow("flux test tests/")));
-  console.log();
+  if ((template == "server")) {
+    const serverFlux = "// {projectName} — Flux HTTP server\n// Run:   npm run dev\n// Build: npm run build && npm start\n\nimport Express from \"express\"\n\nval app  = Express()\nval PORT = process.env.PORT or 3000\n\napp.use(Express.json())\n\napp.get(\"/\", (req, res) ->\n    res.json({ status: \"ok\", message: \"Hello from Flux!\", port: PORT })\n)\n\napp.listen(PORT, -> print(\"Server running at http://localhost:{PORT}\"))";
+    const pkgJson = { name: projectName, version: "1.0.0", description: "A Flux HTTP server", main: "dist/server.js", scripts: { dev: "flux run src/server.flux", build: "flux bundle src/server.flux -o dist/server.js", start: "node dist/server.js", test: "flux test tests/" }, flux: { entry: "src/server.flux", outDir: "dist", mangle: false, sourcemap: false }, dependencies: { "@xnoxs/flux-lang": ("^" + VERSION), express: "^4.18.0" }, devDependencies: {  } };
+    Fs.writeFileSync(Path.join(dir, "src", "server.flux"), serverFlux, "utf8");
+    Fs.writeFileSync(Path.join(dir, "tests", "main.test.flux"), testFlux, "utf8");
+    Fs.writeFileSync(Path.join(dir, "package.json"), (JSON.stringify(pkgJson, null, 2) + "\n"), "utf8");
+    Fs.writeFileSync(Path.join(dir, ".gitignore"), gitignore, "utf8");
+    console.log();
+    console.log((((green("✓ Project ") + bold((projectName + "/"))) + green(" created with template ")) + cyan("server")));
+    console.log();
+    console.log(bold("  Next steps:"));
+    console.log(("    " + yellow(("cd " + projectName))));
+    console.log(("    " + yellow("npm install")));
+    console.log(("    " + yellow("npm run dev")));
+    console.log();
+    console.log(gray("  Build for production:"));
+    console.log(("    " + yellow("npm run build && npm start")));
+    console.log();
+    return;
+  }
+  if ((template == "webapp")) {
+    const utilsFlux = "// Utility functions\nexport fn formatDate(date):\n    val d = new Date(date)\n    return d.toISOString().split(\"T\")[0]\n\nexport fn paginate(items, page, perPage):\n    val start = (page - 1) * perPage\n    return items.slice(start, start + perPage)";
+    const routesFlux = "// Route handlers\nimport { formatDate, paginate } from \"./utils\"    // inter-file .flux import\n\nval items = [\n    { id: 1, name: \"Item A\", date: \"2024-01-01\" },\n    { id: 2, name: \"Item B\", date: \"2024-02-01\" },\n    { id: 3, name: \"Item C\", date: \"2024-03-01\" },\n]\n\nexport fn setupRoutes(app):\n    app.get(\"/items\", (req, res) ->\n        val page    = parseInt(req.query.page or \"1\")\n        val perPage = parseInt(req.query.per_page or \"10\")\n        val data    = paginate(items, page, perPage)\n        res.json({ data, page })\n    )\n\n    app.get(\"/items/:id\", (req, res) ->\n        val item = items.find(i -> i.id == parseInt(req.params.id))\n        if item == null:\n            res.status(404).json({ error: \"Not found\" })\n        else:\n            res.json({ data: item, date: formatDate(item.date) })\n    )";
+    const serverFlux = "// Entry point — MUST be compiled with: npm run build\n// Inter-file .flux imports only work via flux bundle, NOT flux run\nimport Express         from \"express\"\nimport { setupRoutes } from \"./routes\"    // inter-file .flux import\n\nval app  = Express()\nval PORT = process.env.PORT or 3000\n\napp.use(Express.json())\nsetupRoutes(app)\n\napp.listen(PORT, -> print(\"{projectName} running at http://localhost:{PORT}\"))";
+    const pkgJson = { name: projectName, version: "1.0.0", description: "A Flux web app", main: "dist/server.js", scripts: { build: "flux bundle src/server.flux -o dist/server.js", start: "node dist/server.js", dev: "flux bundle src/server.flux -o dist/server.js && node dist/server.js", watch: "flux watch src/server.flux", test: "flux test tests/" }, flux: { entry: "src/server.flux", outDir: "dist", mangle: false, sourcemap: true }, dependencies: { "@xnoxs/flux-lang": ("^" + VERSION), express: "^4.18.0" }, devDependencies: {  } };
+    Fs.writeFileSync(Path.join(dir, "src", "utils.flux"), utilsFlux, "utf8");
+    Fs.writeFileSync(Path.join(dir, "src", "routes.flux"), routesFlux, "utf8");
+    Fs.writeFileSync(Path.join(dir, "src", "server.flux"), serverFlux, "utf8");
+    Fs.writeFileSync(Path.join(dir, "tests", "main.test.flux"), testFlux, "utf8");
+    Fs.writeFileSync(Path.join(dir, "package.json"), (JSON.stringify(pkgJson, null, 2) + "\n"), "utf8");
+    Fs.writeFileSync(Path.join(dir, ".gitignore"), gitignore, "utf8");
+    console.log();
+    console.log((((green("✓ Project ") + bold((projectName + "/"))) + green(" created with template ")) + cyan("webapp")));
+    console.log();
+    console.log(bold("  Next steps:"));
+    console.log(("    " + yellow(("cd " + projectName))));
+    console.log((("    " + yellow("npm install")) + gray("              # install dependencies")));
+    console.log((("    " + yellow("npm run build")) + gray("            # compile all .flux → dist/server.js")));
+    console.log((("    " + yellow("npm start")) + gray("                # run the server")));
+    console.log();
+    console.log((yellow("  Note: ") + gray("This project uses multiple .flux files.")));
+    console.log(((gray("  Always build with ") + yellow("npm run build")) + gray(" (flux bundle) before running.")));
+    console.log(((gray("  Do NOT use ") + red("flux run")) + gray(" on files that import other .flux files.")));
+    console.log();
+    return;
+  }
+  console.error(red(("✗ Unknown template: " + template)));
+  console.error(gray("  Available templates: script, server, webapp"));
+  process.exit(1);
 }
 function cmdSelfHosted(sub, opts) {
   const SELF = Path.join(__dirname, ".");

package/src/self/codegen.flux

@@ -54,6 +54,7 @@ export class CodeGenerator:
   smBuilder: any
   _needsFmt: bool
   _loopDepth: int
+  _fnDepth: int
   _version: string
 
   fn i():
@@ -166,7 +167,9 @@ export class CodeGenerator:
     else:
       self.emit(prefix + asyncKw + 'function ' + name + '(' + params + ') {')
       self.indIn()
+      self._fnDepth = self._fnDepth + 1
       for s in node.body: self.genStmt(s)
+      self._fnDepth = self._fnDepth - 1
       self.indOut()
       self.emit('}')
 
@@ -200,7 +203,9 @@ export class CodeGenerator:
       else:
         self.emit(staticKw + asyncKw + m.name + '(' + params + ') {')
         self.indIn()
+        self._fnDepth = self._fnDepth + 1
         for s in m.body: self.genStmt(s)
+        self._fnDepth = self._fnDepth - 1
         self.indOut()
         self.emit('}')
       self.blank()
@@ -304,8 +309,10 @@ export class CodeGenerator:
         val exprSrc = self.genExpr(arm.body[0].expr)
         if self._loopDepth > 0:
           self.emit(exprSrc + ';')
-        else:
+        else if self._fnDepth > 0:
           self.emit('return ' + exprSrc + ';')
+        else:
+          self.emit(exprSrc + ';')
       else:
         for s in arm.body: self.genStmt(s)
       self.indOut()
@@ -492,11 +499,13 @@ export class CodeGenerator:
       val savedLevel = self.level
       val savedLoop = self._loopDepth
       self._loopDepth = 0
+      self._fnDepth = self._fnDepth + 1
       self.emit('(() => {')
       self.indIn()
       self.genMatch(node)
       self.indOut()
       self.emit('})()')
+      self._fnDepth = self._fnDepth - 1
       self._loopDepth = savedLoop
       val block = self.lines.splice(saved).map(l -> l.trimStart()).join(' ')
       self.level = savedLevel