@xnoxs/flux-lang 4.0.7 → 4.0.9

package/dist/flux-cli.js

@@ -1,4 +1,9 @@
-/*! flux-lang v4.0.7 - MIT License */
+/*!
+ * flux-lang v4.0.9
+ * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
+ * (c) 2026 Flux Lang Contributors
+ * Released under the MIT License
+ */
 "use strict";
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __commonJS = (cb, mod) => function __require() {
@@ -9,9 +14,10 @@ var __commonJS = (cb, mod) => function __require() {
   }
 };
 
-// ../../../tmp/flux-publish-v5/src/self/lexer.js
+// src/lexer.js
 var require_lexer = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/lexer.js"(exports2, module2) {
+  "src/lexer.js"(exports2, module2) {
+    "use strict";
     var T = { NUMBER: "NUMBER", STRING: "STRING", BOOL: "BOOL", NULL: "NULL", IDENT: "IDENT", VAR: "VAR", VAL: "VAL", FN: "FN", RETURN: "RETURN", IF: "IF", ELSE: "ELSE", FOR: "FOR", IN: "IN", WHILE: "WHILE", BREAK: "BREAK", CONTINUE: "CONTINUE", DO: "DO", CLASS: "CLASS", EXTENDS: "EXTENDS", SELF: "SELF", NEW: "NEW", INTERFACE: "INTERFACE", IMPLEMENTS: "IMPLEMENTS", PRIVATE: "PRIVATE", PUBLIC: "PUBLIC", PROTECTED: "PROTECTED", READONLY: "READONLY", STATIC: "STATIC", ABSTRACT: "ABSTRACT", OVERRIDE: "OVERRIDE", MATCH: "MATCH", WHEN: "WHEN", IMPORT: "IMPORT", EXPORT: "EXPORT", FROM: "FROM", AS: "AS", DEFAULT: "DEFAULT", AND: "AND", OR: "OR", NOT: "NOT", ASYNC: "ASYNC", AWAIT: "AWAIT", TRY: "TRY", CATCH: "CATCH", FINALLY: "FINALLY", THROW: "THROW", TYPEOF: "TYPEOF", INSTANCEOF: "INSTANCEOF", TYPE: "TYPE", ENUM: "ENUM", SATISFIES: "SATISFIES", IS: "IS", CONST: "CONST", PLUS: "PLUS", MINUS: "MINUS", STAR: "STAR", SLASH: "SLASH", PERCENT: "PERCENT", REGEX: "REGEX", STARSTAR: "STARSTAR", EQ: "EQ", EQEQ: "EQEQ", NEQ: "NEQ", EQEQEQ: "EQEQEQ", NEQEQ: "NEQEQ", LT: "LT", LTE: "LTE", GT: "GT", GTE: "GTE", PLUSEQ: "PLUSEQ", MINUSEQ: "MINUSEQ", STAREQ: "STAREQ", SLASHEQ: "SLASHEQ", PERCENTEQ: "PERCENTEQ", PLUSPLUS: "PLUSPLUS", MINUSMINUS: "MINUSMINUS", AMPERSAND: "AMPERSAND", ANDAND: "ANDAND", PIPEB: "PIPEB", OROR: "OROR", CARET: "CARET", TILDE: "TILDE", LSHIFT: "LSHIFT", RSHIFT: "RSHIFT", ARROW: "ARROW", FATARROW: "FATARROW", PIPE: "PIPE", DOTDOT: "DOTDOT", DOTDOTDOT: "DOTDOTDOT", WILDCARD: "WILDCARD", NULLISH: "NULLISH", QUESTIONDOT: "QUESTIONDOT", BANG: "BANG", AT: "AT", LPAREN: "LPAREN", RPAREN: "RPAREN", LBRACKET: "LBRACKET", RBRACKET: "RBRACKET", LBRACE: "LBRACE", RBRACE: "RBRACE", COMMA: "COMMA", DOT: "DOT", COLON: "COLON", QUESTION: "QUESTION", NEWLINE: "NEWLINE", INDENT: "INDENT", DEDENT: "DEDENT", EOF: "EOF" };
     module2.exports.T = T;
     var TokenType = T;
@@ -78,7 +84,7 @@ var require_lexer = __commonJS({
             if (e == "n") {
               s += "\n";
             } else if (e == "t") {
-              s += "	";
+              s += "  ";
             } else if (e == "`") {
               s += "`";
             } else if (e == "\\") {
@@ -129,7 +135,7 @@ var require_lexer = __commonJS({
             if (e == "n") {
               text += "\n";
             } else if (e == "t") {
-              text += "	";
+              text += "  ";
             } else if (e == '"') {
               text += '"';
             } else if (e == "'") {
@@ -246,8 +252,8 @@ var require_lexer = __commonJS({
           if (bol) {
             bol = false;
             let indent = 0;
-            while (this.ch() == " " || this.ch() == "	") {
-              if (this.ch() == "	") {
+            while (this.ch() == " " || this.ch() == "  ") {
+              if (this.ch() == "  ") {
                 indent = indent + 4;
               } else {
                 indent = indent + 1;
@@ -299,7 +305,7 @@ var require_lexer = __commonJS({
             }
             continue;
           }
-          if (cur == " " || cur == "	") {
+          if (cur == " " || cur == "  ") {
             this.adv();
             continue;
           }
@@ -383,7 +389,7 @@ var require_lexer = __commonJS({
                 if (e == "n") {
                   sq += "\n";
                 } else if (e == "t") {
-                  sq += "	";
+                  sq += "  ";
                 } else if (e == "r") {
                   sq += "\r";
                 } else if (e == "'") {
@@ -617,9 +623,10 @@ var require_lexer = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/parser.js
+// src/parser.js
 var require_parser = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/parser.js"(exports2, module2) {
+  "src/parser.js"(exports2, module2) {
+    "use strict";
     var { T } = require_lexer();
     function makeParseError(msg, tok) {
       const line = (tok == null ? void 0 : tok.line) ?? "?";
@@ -2129,41 +2136,42 @@ var require_parser = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/codegen.js
+// src/codegen.js
 var require_codegen = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/codegen.js"(exports2, module2) {
+  "src/codegen.js"(exports2, module2) {
+    "use strict";
     var { Lexer, lexerize, T } = require_lexer();
     var { Parser, makeParser } = require_parser();
-    function _a(_e) {
-      const ci = _e.lastIndexOf(":");
+    function extractFormatSpec(raw) {
+      const ci = raw.lastIndexOf(":");
       if (ci < 1) {
         return null;
       }
-      const spec = _e.slice(ci + 1).trim();
+      const spec = raw.slice(ci + 1).trim();
       if (spec.length > 0 && /[.<>^,dbeEfFgGoOxXs%bcn]/.test(spec) && /^([.<>^0\-+ #,]*[0-9]*\.?[0-9]*[dbeEfFgGoOxXs%bcn]?[,]?)$/.test(spec)) {
-        return { expr: _e.slice(0, ci).trim(), fmt: spec };
+        return { expr: raw.slice(0, ci).trim(), fmt: spec };
       }
       return null;
     }
-    var _b = "function _fmt(v, s) {\n  if (s === ',') return (+v).toLocaleString();\n  if (s === '%') return ((+v)*100).toFixed(0)+'%';\n  var m = s.match(/^([0-9,]*)?\\.([0-9]+)([fdgGeEb%x])$/);\n  if (m) {\n    var d=+m[2], t=m[3], comma=s[0]===',';\n    if (t==='f'||t==='d') return comma ? (+v).toLocaleString(void 0,{minimumFractionDigits:d,maximumFractionDigits:d}) : (+v).toFixed(d);\n    if (t==='e'||t==='E') return (+v).toExponential(d);\n    if (t==='%') return ((+v)*100).toFixed(d)+'%';\n    if (t==='b') return Math.round(+v).toString(2);\n    if (t==='x') return Math.round(+v).toString(16);\n  }\n  var m2 = s.match(/^([0-9]*)d$/); if (m2) return Math.round(+v).toString();\n  return String(v);\n}";
-    function _c(_f) {
+    var FMT_HELPER = "function _fmt(v, s) {\n  if (s === ',') return (+v).toLocaleString();\n  if (s === '%') return ((+v)*100).toFixed(0)+'%';\n  var m = s.match(/^([0-9,]*)?\\.([0-9]+)([fdgGeEb%x])$/);\n  if (m) {\n    var d=+m[2], t=m[3], comma=s[0]===',';\n    if (t==='f'||t==='d') return comma ? (+v).toLocaleString(void 0,{minimumFractionDigits:d,maximumFractionDigits:d}) : (+v).toFixed(d);\n    if (t==='e'||t==='E') return (+v).toExponential(d);\n    if (t==='%') return ((+v)*100).toFixed(d)+'%';\n    if (t==='b') return Math.round(+v).toString(2);\n    if (t==='x') return Math.round(+v).toString(16);\n  }\n  var m2 = s.match(/^([0-9]*)d$/); if (m2) return Math.round(+v).toString();\n  return String(v);\n}";
+    function buildClassRegistry(ast) {
       const reg = {};
-      for (const _g of _f.body) {
-        const n = _g.type == "ExportDecl" ? _g.decl : _g;
+      for (const node of ast.body) {
+        const n = node.type == "ExportDecl" ? node.decl : node;
         if (n.type == "ClassDecl") {
           reg[n.name] = { fields: n.fields, superClass: n.superClass };
         }
       }
       return reg;
     }
-    function _d(_h, _i, _j) {
-      const vis = _j ?? /* @__PURE__ */ new Set([]);
-      if (!_h || !_i[_h] || vis.has(_h)) {
+    function getAllFields(name, reg, visited) {
+      const vis = visited ?? /* @__PURE__ */ new Set([]);
+      if (!name || !reg[name] || vis.has(name)) {
         return [];
       }
-      vis.add(_h);
-      const parent = _d(_i[_h].superClass, _i, vis);
-      return [...parent, ..._i[_h].fields];
+      vis.add(name);
+      const parent = getAllFields(reg[name].superClass, reg, vis);
+      return [...parent, ...reg[name].fields];
     }
     var CodeGenerator = class {
       constructor(ind, level, lines, clsReg, smBuilder, _needsFmt, _loopDepth, _fnDepth, _version) {
@@ -2186,11 +2194,11 @@ var require_codegen = __commonJS({
         }
         return s;
       }
-      emit(_k) {
-        this.lines.push(this.i() + _k);
+      emit(s) {
+        this.lines.push(this.i() + s);
       }
-      emitRaw(_k) {
-        this.lines.push(_k);
+      emitRaw(s) {
+        this.lines.push(s);
       }
       blank() {
         this.lines.push("");
@@ -2203,171 +2211,171 @@ var require_codegen = __commonJS({
           this.level = this.level - 1;
         }
       }
-      generate(_f) {
-        this.clsReg = _c(_f);
+      generate(ast) {
+        this.clsReg = buildClassRegistry(ast);
         this.lines = [];
         this.level = 0;
         this._needsFmt = false;
         this.emit("// Generated by Flux Transpiler v" + (this._version ?? "3.5.3") + " (self-hosted)");
         this.emit('"use strict";');
         this.blank();
-        for (const _g of _f.body) {
-          this.genStmt(_g);
+        for (const node of ast.body) {
+          this.genStmt(node);
         }
         if (this._needsFmt) {
-          this.lines.splice(2, 0, _b);
+          this.lines.splice(2, 0, FMT_HELPER);
         }
         return { code: this.lines.join("\n"), smBuilder: this.smBuilder };
       }
-      genStmt(_g) {
-        if (_g.type == "VarDecl") {
-          this.genVar(_g);
-        } else if (_g.type == "DestructureDecl") {
-          this.genDestructure(_g);
-        } else if (_g.type == "FnDecl") {
-          this.genFn(_g, "");
-        } else if (_g.type == "ClassDecl") {
-          this.genClass(_g);
-        } else if (_g.type == "IfStmt") {
-          this.genIf(_g);
-        } else if (_g.type == "ForInStmt") {
-          this.genFor(_g);
-        } else if (_g.type == "WhileStmt") {
-          this.genWhile(_g);
-        } else if (_g.type == "MatchStmt") {
-          this.genMatch(_g);
-        } else if (_g.type == "ReturnStmt") {
-          this.genReturn(_g);
-        } else if (_g.type == "TryCatchStmt") {
-          this.genTryCatch(_g);
-        } else if (_g.type == "ThrowStmt") {
-          this.genThrow(_g);
-        } else if (_g.type == "DoWhileStmt") {
-          this.genDoWhile(_g);
-        } else if (_g.type == "BreakStmt") {
+      genStmt(node) {
+        if (node.type == "VarDecl") {
+          this.genVar(node);
+        } else if (node.type == "DestructureDecl") {
+          this.genDestructure(node);
+        } else if (node.type == "FnDecl") {
+          this.genFn(node, "");
+        } else if (node.type == "ClassDecl") {
+          this.genClass(node);
+        } else if (node.type == "IfStmt") {
+          this.genIf(node);
+        } else if (node.type == "ForInStmt") {
+          this.genFor(node);
+        } else if (node.type == "WhileStmt") {
+          this.genWhile(node);
+        } else if (node.type == "MatchStmt") {
+          this.genMatch(node);
+        } else if (node.type == "ReturnStmt") {
+          this.genReturn(node);
+        } else if (node.type == "TryCatchStmt") {
+          this.genTryCatch(node);
+        } else if (node.type == "ThrowStmt") {
+          this.genThrow(node);
+        } else if (node.type == "DoWhileStmt") {
+          this.genDoWhile(node);
+        } else if (node.type == "BreakStmt") {
           this.emit("break;");
-        } else if (_g.type == "ContinueStmt") {
+        } else if (node.type == "ContinueStmt") {
           this.emit("continue;");
-        } else if (_g.type == "ImportDecl") {
-          this.genImport(_g);
-        } else if (_g.type == "ExportDecl") {
-          this.genExport(_g);
-        } else if (_g.type == "TypeDecl") {
-          this.genTypeDecl(_g);
-        } else if (_g.type == "InterfaceDecl") {
-          this.genInterfaceDecl(_g);
-        } else if (_g.type == "EnumDecl") {
-          this.genEnumDecl(_g);
-        } else if (_g.type == "DeclareDecl") {
+        } else if (node.type == "ImportDecl") {
+          this.genImport(node);
+        } else if (node.type == "ExportDecl") {
+          this.genExport(node);
+        } else if (node.type == "TypeDecl") {
+          this.genTypeDecl(node);
+        } else if (node.type == "InterfaceDecl") {
+          this.genInterfaceDecl(node);
+        } else if (node.type == "EnumDecl") {
+          this.genEnumDecl(node);
+        } else if (node.type == "DeclareDecl") {
           return;
-        } else if (_g.type == "ExprStmt") {
-          this.emit(this.genExpr(_g.expr) + ";");
+        } else if (node.type == "ExprStmt") {
+          this.emit(this.genExpr(node.expr) + ";");
         } else {
-          throw new Error(`Unknown statement: ${_g.type}`);
+          throw new Error(`Unknown statement: ${node.type}`);
         }
       }
-      genVar(_g) {
-        const kw = _g.kind == "val" ? "const" : "let";
-        const init = _g.init ? " = " + this.genExpr(_g.init) : "";
-        this.emit(kw + " " + _g.name + init + ";");
+      genVar(node) {
+        const kw = node.kind == "val" ? "const" : "let";
+        const init = node.init ? " = " + this.genExpr(node.init) : "";
+        this.emit(kw + " " + node.name + init + ";");
       }
-      genObjPair(_l) {
-        if (_l.spread) {
-          return "..." + this.genExpr(_l.value);
+      genObjPair(p) {
+        if (p.spread) {
+          return "..." + this.genExpr(p.value);
         }
-        const isIdent = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(_l.key);
-        const keyStr = isIdent ? _l.key : '"' + _l.key + '"';
-        if (isIdent && _l.value && _l.value.type == "Identifier" && _l.value.name == _l.key) {
-          return _l.key;
+        const isIdent = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.key);
+        const keyStr = isIdent ? p.key : '"' + p.key + '"';
+        if (isIdent && p.value && p.value.type == "Identifier" && p.value.name == p.key) {
+          return p.key;
         }
-        return keyStr + ": " + this.genExpr(_l.value);
+        return keyStr + ": " + this.genExpr(p.value);
       }
-      genDestructProp(_l) {
-        if (_l.rest) {
-          return "..." + _l.key;
+      genDestructProp(p) {
+        if (p.rest) {
+          return "..." + p.key;
         }
-        let _k = _l.alias != _l.key ? _l.key + ": " + _l.alias : _l.key;
-        if (_l.defaultVal) {
-          _k = _k + " = " + this.genExpr(_l.defaultVal);
+        let s = p.alias != p.key ? p.key + ": " + p.alias : p.key;
+        if (p.defaultVal) {
+          s = s + " = " + this.genExpr(p.defaultVal);
         }
-        return _k;
+        return s;
       }
-      genDestructItem(_l) {
-        if (!_l) {
+      genDestructItem(p) {
+        if (!p) {
           return "";
         }
-        if (_l.rest) {
-          return "..." + _l.name;
+        if (p.rest) {
+          return "..." + p.name;
         }
-        let _k = _l.name;
-        if (_l.defaultVal) {
-          _k = _k + " = " + this.genExpr(_l.defaultVal);
+        let s = p.name;
+        if (p.defaultVal) {
+          s = s + " = " + this.genExpr(p.defaultVal);
         }
-        return _k;
+        return s;
       }
-      genDestructure(_g) {
-        const kw = _g.kind == "val" ? "const" : "let";
-        const init = this.genExpr(_g.init);
-        if (_g.patternType == "object") {
-          const props = _g.pattern.map((_l) => this.genDestructProp(_l)).join(", ");
+      genDestructure(node) {
+        const kw = node.kind == "val" ? "const" : "let";
+        const init = this.genExpr(node.init);
+        if (node.patternType == "object") {
+          const props = node.pattern.map((p) => this.genDestructProp(p)).join(", ");
           this.emit(kw + " { " + props + " } = " + init + ";");
         } else {
-          const items = _g.pattern.map((_l) => this.genDestructItem(_l)).join(", ");
+          const items = node.pattern.map((p) => this.genDestructItem(p)).join(", ");
           this.emit(kw + " [" + items + "] = " + init + ";");
         }
       }
-      genFn(_g, _m) {
-        const asyncKw = _g.async ? "async " : "";
-        const _h = _g.name ?? "";
-        const params = _g.params.map((_l) => _l.rest ? "..." + _l.name : _l.defaultVal ? _l.name + " = " + this.genExpr(_l.defaultVal) : _l.name).join(", ");
-        if (_g.inline) {
-          this.emit(_m + asyncKw + "function " + _h + "(" + params + ") { return " + this.genExpr(_g.body) + "; }");
+      genFn(node, prefix) {
+        const asyncKw = node.async ? "async " : "";
+        const name = node.name ?? "";
+        const params = node.params.map((p) => p.rest ? "..." + p.name : p.defaultVal ? p.name + " = " + this.genExpr(p.defaultVal) : p.name).join(", ");
+        if (node.inline) {
+          this.emit(prefix + asyncKw + "function " + name + "(" + params + ") { return " + this.genExpr(node.body) + "; }");
         } else {
-          this.emit(_m + asyncKw + "function " + _h + "(" + params + ") {");
+          this.emit(prefix + asyncKw + "function " + name + "(" + params + ") {");
           this.indIn();
           this._fnDepth = this._fnDepth + 1;
-          for (const _k of _g.body) {
-            this.genStmt(_k);
+          for (const s of node.body) {
+            this.genStmt(s);
           }
           this._fnDepth = this._fnDepth - 1;
           this.indOut();
           this.emit("}");
         }
       }
-      genClass(_g) {
-        const ext = _g.superClass ? " extends " + _g.superClass : "";
-        this.emit("class " + _g.name + ext + " {");
+      genClass(node) {
+        const ext = node.superClass ? " extends " + node.superClass : "";
+        this.emit("class " + node.name + ext + " {");
         this.indIn();
-        const allFields = _d(_g.name, this.clsReg, null);
+        const allFields = getAllFields(node.name, this.clsReg, null);
         if (allFields.length > 0) {
-          const params = allFields.map((_n) => _n.name).join(", ");
+          const params = allFields.map((f) => f.name).join(", ");
           this.emit("constructor(" + params + ") {");
           this.indIn();
-          if (_g.superClass && this.clsReg[_g.superClass]) {
-            const parentFields = _d(_g.superClass, this.clsReg, null);
+          if (node.superClass && this.clsReg[node.superClass]) {
+            const parentFields = getAllFields(node.superClass, this.clsReg, null);
             if (parentFields.length > 0) {
-              this.emit("super(" + parentFields.map((_n) => _n.name).join(", ") + ");");
+              this.emit("super(" + parentFields.map((f) => f.name).join(", ") + ");");
             }
           }
-          for (const _n of _g.fields) {
-            this.emit("this." + _n.name + " = " + _n.name + ";");
+          for (const f of node.fields) {
+            this.emit("this." + f.name + " = " + f.name + ";");
           }
           this.indOut();
           this.emit("}");
           this.blank();
         }
-        for (const _o of _g.methods) {
-          const asyncKw = _o.async ? "async " : "";
-          const staticKw = _o.modifiers && _o.modifiers.has("static") ? "static " : "";
-          const params = _o.params.map((_l) => _l.rest ? "..." + _l.name : _l.defaultVal ? _l.name + " = " + this.genExpr(_l.defaultVal) : _l.name).join(", ");
-          if (_o.inline) {
-            this.emit(staticKw + asyncKw + _o.name + "(" + params + ") { return " + this.genExpr(_o.body) + "; }");
+        for (const m of node.methods) {
+          const asyncKw = m.async ? "async " : "";
+          const staticKw = m.modifiers && m.modifiers.has("static") ? "static " : "";
+          const params = m.params.map((p) => p.rest ? "..." + p.name : p.defaultVal ? p.name + " = " + this.genExpr(p.defaultVal) : p.name).join(", ");
+          if (m.inline) {
+            this.emit(staticKw + asyncKw + m.name + "(" + params + ") { return " + this.genExpr(m.body) + "; }");
           } else {
-            this.emit(staticKw + asyncKw + _o.name + "(" + params + ") {");
+            this.emit(staticKw + asyncKw + m.name + "(" + params + ") {");
             this.indIn();
             this._fnDepth = this._fnDepth + 1;
-            for (const _k of _o.body) {
-              this.genStmt(_k);
+            for (const s of m.body) {
+              this.genStmt(s);
             }
             this._fnDepth = this._fnDepth - 1;
             this.indOut();
@@ -2379,71 +2387,71 @@ var require_codegen = __commonJS({
         this.emit("}");
         this.blank();
       }
-      genIf(_g) {
-        this.emit("if (" + this.genExpr(_g.cond) + ") {");
+      genIf(node) {
+        this.emit("if (" + this.genExpr(node.cond) + ") {");
         this.indIn();
-        for (const _k of _g.then) {
-          this.genStmt(_k);
+        for (const s of node.then) {
+          this.genStmt(s);
         }
         this.indOut();
         this.emit("}");
-        for (const _p of _g.elseifs) {
-          this.emitRaw(this.i() + "else if (" + this.genExpr(_p.cond) + ") {");
+        for (const ei of node.elseifs) {
+          this.emitRaw(this.i() + "else if (" + this.genExpr(ei.cond) + ") {");
           this.indIn();
-          for (const _k of _p.body) {
-            this.genStmt(_k);
+          for (const s of ei.body) {
+            this.genStmt(s);
           }
           this.indOut();
           this.emit("}");
         }
-        if (_g.else_) {
+        if (node.else_) {
           this.emitRaw(this.i() + "else {");
           this.indIn();
-          for (const _k of _g.else_) {
-            this.genStmt(_k);
+          for (const s of node.else_) {
+            this.genStmt(s);
           }
           this.indOut();
           this.emit("}");
         }
       }
-      genFor(_g) {
-        const varName = _g["var"];
-        const iter = _g.iter;
+      genFor(node) {
+        const varName = node["var"];
+        const iter = node.iter;
         if (iter.type == "RangeExpr") {
-          const _k = this.genExpr(iter.start);
+          const s = this.genExpr(iter.start);
           const e = this.genExpr(iter.end);
-          this.emit("for (let " + varName + " = " + _k + "; " + varName + " < " + e + "; " + varName + "++) {");
-        } else if (_g.isAwait) {
+          this.emit("for (let " + varName + " = " + s + "; " + varName + " < " + e + "; " + varName + "++) {");
+        } else if (node.isAwait) {
           this.emit("for await (const " + varName + " of " + this.genExpr(iter) + ") {");
         } else {
           this.emit("for (const " + varName + " of " + this.genExpr(iter) + ") {");
         }
         this._loopDepth = this._loopDepth + 1;
         this.indIn();
-        for (const _k of _g.body) {
-          this.genStmt(_k);
+        for (const s of node.body) {
+          this.genStmt(s);
         }
         this.indOut();
         this._loopDepth = this._loopDepth - 1;
         this.emit("}");
       }
-      genWhile(_g) {
-        this.emit("while (" + this.genExpr(_g.cond) + ") {");
+      genWhile(node) {
+        this.emit("while (" + this.genExpr(node.cond) + ") {");
         this._loopDepth = this._loopDepth + 1;
         this.indIn();
-        for (const _k of _g.body) {
-          this.genStmt(_k);
+        for (const s of node.body) {
+          this.genStmt(s);
         }
         this.indOut();
         this._loopDepth = this._loopDepth - 1;
         this.emit("}");
       }
-      genMatch(_g) {
-        const subj = this.genExpr(_g.subject);
-        const arms = _g.arms;
+      genMatch(node) {
+        const subj = this.genExpr(node.subject);
+        const arms = node.arms;
         let hasOpenIf = false;
-        for (const _q of arms) {
-          const pat = _q.pattern;
+        for (const arm of arms) {
+          const pat = arm.pattern;
           let cond = "";
           const bindings = [];
           if (pat.type == "WildcardPat") {
@@ -2455,8 +2463,8 @@ var require_codegen = __commonJS({
           } else if (pat.type == "VariantPat") {
             cond = subj + '?.__type === "' + pat.variant + '"';
             let bi = 0;
-            for (const _r of pat.bindings) {
-              bindings.push("const " + _r + " = " + subj + ".__args[" + bi + "];");
+            for (const b of pat.bindings) {
+              bindings.push("const " + b + " = " + subj + ".__args[" + bi + "];");
               bi = bi + 1;
             }
           } else {
@@ -2467,10 +2475,10 @@ var require_codegen = __commonJS({
               cond = subj + " === " + patExpr;
             }
           }
-          if (_q.guard) {
-            const guardSrc = this.genExpr(_q.guard);
+          if (arm.guard) {
+            const guardSrc = this.genExpr(arm.guard);
             if (bindings.length > 0) {
-              const rebindings = bindings.map((_s) => _s.replace("const ", "var ")).join(" ");
+              const rebindings = bindings.map((bx) => bx.replace("const ", "var ")).join(" ");
               const iife = "(function(){ " + rebindings + " return (" + guardSrc + "); }())";
               cond = cond ? "(" + cond + ") && " + iife : iife;
             } else {
@@ -2489,11 +2497,11 @@ var require_codegen = __commonJS({
             this.emitRaw(this.i() + "else {");
           }
           this.indIn();
-          for (const _r of bindings) {
-            this.emit(_r);
+          for (const b of bindings) {
+            this.emit(b);
           }
-          if (_q.inline) {
-            const exprSrc = this.genExpr(_q.body[0].expr);
+          if (arm.inline) {
+            const exprSrc = this.genExpr(arm.body[0].expr);
             if (this._loopDepth > 0) {
               this.emit(exprSrc + ";");
             } else if (this._fnDepth > 0) {
@@ -2502,114 +2510,114 @@ var require_codegen = __commonJS({
               this.emit(exprSrc + ";");
             }
           } else {
-            for (const _k of _q.body) {
-              this.genStmt(_k);
+            for (const s of arm.body) {
+              this.genStmt(s);
             }
           }
           this.indOut();
           this.emit("}");
         }
       }
-      genInterfaceDecl(_g) {
+      genInterfaceDecl(node) {
         this.blank();
-        this.emit("// interface " + _g.name);
+        this.emit("// interface " + node.name);
         this.blank();
       }
-      genEnumDecl(_g) {
+      genEnumDecl(node) {
         this.blank();
-        const pairs = _g.members.map((_o) => _o.name + ": " + this.genExpr(_o.value)).join(", ");
-        this.emit("const " + _g.name + " = Object.freeze({ " + pairs + " });");
+        const pairs = node.members.map((m) => m.name + ": " + this.genExpr(m.value)).join(", ");
+        this.emit("const " + node.name + " = Object.freeze({ " + pairs + " });");
         this.blank();
       }
-      genTypeDecl(_g) {
+      genTypeDecl(node) {
         this.blank();
-        this.emit("// ADT type: " + _g.name);
-        for (const _t of _g.variants) {
-          if (_t.fields.length == 0) {
-            this.emit("const " + _t.name + ' = Object.freeze({ __type: "' + _t.name + '", __args: [] });');
+        this.emit("// ADT type: " + node.name);
+        for (const v of node.variants) {
+          if (v.fields.length == 0) {
+            this.emit("const " + v.name + ' = Object.freeze({ __type: "' + v.name + '", __args: [] });');
           } else {
-            const params = _t.fields.join(", ");
-            const argsArr = "[" + _t.fields.join(", ") + "]";
-            const fieldsObj = _t.fields.map((_n) => _n + ": " + _n).join(", ");
-            this.emit("function " + _t.name + "(" + params + ') { return Object.freeze({ __type: "' + _t.name + '", __args: ' + argsArr + ", " + fieldsObj + " }); }");
+            const params = v.fields.join(", ");
+            const argsArr = "[" + v.fields.join(", ") + "]";
+            const fieldsObj = v.fields.map((f) => f + ": " + f).join(", ");
+            this.emit("function " + v.name + "(" + params + ') { return Object.freeze({ __type: "' + v.name + '", __args: ' + argsArr + ", " + fieldsObj + " }); }");
           }
         }
         this.blank();
       }
-      genReturn(_g) {
-        if (_g.value) {
-          this.emit("return " + this.genExpr(_g.value) + ";");
+      genReturn(node) {
+        if (node.value) {
+          this.emit("return " + this.genExpr(node.value) + ";");
         } else {
           this.emit("return;");
         }
       }
-      genTryCatch(_g) {
+      genTryCatch(node) {
         this.emit("try {");
         this.indIn();
-        for (const _k of _g.tryBody) {
-          this.genStmt(_k);
+        for (const s of node.tryBody) {
+          this.genStmt(s);
         }
         this.indOut();
         this.emit("}");
-        if (_g.catchBody) {
-          const param = _g.catchParam ? "(" + _g.catchParam + ")" : "(_err)";
+        if (node.catchBody) {
+          const param = node.catchParam ? "(" + node.catchParam + ")" : "(_err)";
           this.emitRaw(this.i() + "catch " + param + " {");
           this.indIn();
-          for (const _k of _g.catchBody) {
-            this.genStmt(_k);
+          for (const s of node.catchBody) {
+            this.genStmt(s);
           }
           this.indOut();
           this.emit("}");
         }
-        if (_g.finallyBody) {
+        if (node.finallyBody) {
           this.emitRaw(this.i() + "finally {");
           this.indIn();
-          for (const _k of _g.finallyBody) {
-            this.genStmt(_k);
+          for (const s of node.finallyBody) {
+            this.genStmt(s);
           }
           this.indOut();
           this.emit("}");
         }
       }
-      genThrow(_g) {
-        this.emit("throw " + this.genExpr(_g.value) + ";");
+      genThrow(node) {
+        this.emit("throw " + this.genExpr(node.value) + ";");
       }
-      genDoWhile(_g) {
+      genDoWhile(node) {
         this.emit("do {");
         this.indIn();
-        for (const _k of _g.body) {
-          this.genStmt(_k);
+        for (const s of node.body) {
+          this.genStmt(s);
         }
         this.indOut();
-        this.emit("} while (" + this.genExpr(_g.cond) + ");");
-      }
-      genImport(_g) {
-        const src = String(_g.source);
-        if (_g.namespaceName) {
-          this.emit("const " + _g.namespaceName + ' = require("' + src + '");');
-        } else if (_g.defaultName) {
-          this.emit("const " + _g.defaultName + ' = require("' + src + '");');
-        } else if (_g.names.length) {
-          const parts = _g.names.map((_u) => typeof _u == "string" ? _u : _u.name != _u.alias ? _u.name + ": " + _u.alias : _u.name).join(", ");
+        this.emit("} while (" + this.genExpr(node.cond) + ");");
+      }
+      genImport(node) {
+        const src = String(node.source);
+        if (node.namespaceName) {
+          this.emit("const " + node.namespaceName + ' = require("' + src + '");');
+        } else if (node.defaultName) {
+          this.emit("const " + node.defaultName + ' = require("' + src + '");');
+        } else if (node.names.length) {
+          const parts = node.names.map((n) => typeof n == "string" ? n : n.name != n.alias ? n.name + ": " + n.alias : n.name).join(", ");
           this.emit("const { " + parts + ' } = require("' + src + '");');
         }
       }
-      genExport(_g) {
-        if (_g.isDefault) {
-          this.emit("module.exports = " + this.genExpr(_g.decl) + ";");
+      genExport(node) {
+        if (node.isDefault) {
+          this.emit("module.exports = " + this.genExpr(node.decl) + ";");
           return;
         }
-        const decl = _g.decl;
+        const decl = node.decl;
         if (decl.type == "FnDecl") {
           const asyncKw = decl.async ? "async " : "";
-          const params = decl.params.map((_l) => _l.rest ? "..." + _l.name : _l.defaultVal ? _l.name + " = " + this.genExpr(_l.defaultVal) : _l.name).join(", ");
+          const params = decl.params.map((p) => p.rest ? "..." + p.name : p.defaultVal ? p.name + " = " + this.genExpr(p.defaultVal) : p.name).join(", ");
           if (decl.inline) {
             this.emit(asyncKw + "function " + decl.name + "(" + params + ") { return " + this.genExpr(decl.body) + "; }");
           } else {
             this.emit(asyncKw + "function " + decl.name + "(" + params + ") {");
             this.indIn();
-            for (const _k of decl.body) {
-              this.genStmt(_k);
+            for (const s of decl.body) {
+              this.genStmt(s);
             }
             this.indOut();
             this.emit("}");
@@ -2620,8 +2628,8 @@ var require_codegen = __commonJS({
           this.emit("module.exports." + decl.name + " = " + decl.name + ";");
         } else if (decl.type == "TypeDecl") {
           this.genTypeDecl(decl);
-          for (const _t of decl.variants) {
-            this.emit("module.exports." + _t.name + " = " + _t.name + ";");
+          for (const v of decl.variants) {
+            this.emit("module.exports." + v.name + " = " + v.name + ";");
           }
         } else if (decl.type == "InterfaceDecl") {
           this.genInterfaceDecl(decl);
@@ -2636,112 +2644,112 @@ var require_codegen = __commonJS({
           this.genStmt(decl);
         }
       }
-      genExpr(_g) {
-        if (!_g) {
+      genExpr(node) {
+        if (!node) {
           return "undefined";
         }
-        if (_g.type == "NumberLit") {
-          return String(_g.value);
+        if (node.type == "NumberLit") {
+          return String(node.value);
         }
-        if (_g.type == "BoolLit") {
-          return String(_g.value);
+        if (node.type == "BoolLit") {
+          return String(node.value);
         }
-        if (_g.type == "NullLit") {
+        if (node.type == "NullLit") {
           return "null";
         }
-        if (_g.type == "SelfExpr") {
+        if (node.type == "SelfExpr") {
           return "this";
         }
-        if (_g.type == "Identifier") {
-          return _g.name == "print" ? "console.log" : _g.name;
+        if (node.type == "Identifier") {
+          return node.name == "print" ? "console.log" : node.name;
         }
-        if (_g.type == "StringLit") {
-          return JSON.stringify(_g.value);
+        if (node.type == "StringLit") {
+          return JSON.stringify(node.value);
         }
-        if (_g.type == "RegexLit") {
-          return "/" + _g.value.pattern + "/" + _g.value.flags;
+        if (node.type == "RegexLit") {
+          return "/" + node.value.pattern + "/" + node.value.flags;
         }
-        if (_g.type == "TemplateLit") {
-          return this.genTemplate(_g.parts);
+        if (node.type == "TemplateLit") {
+          return this.genTemplate(node.parts);
         }
-        if (_g.type == "BinaryExpr") {
-          return "(" + this.genExpr(_g.left) + " " + _g.op + " " + this.genExpr(_g.right) + ")";
+        if (node.type == "BinaryExpr") {
+          return "(" + this.genExpr(node.left) + " " + node.op + " " + this.genExpr(node.right) + ")";
         }
-        if (_g.type == "UnaryExpr") {
-          return _g.op + this.genExpr(_g.operand);
+        if (node.type == "UnaryExpr") {
+          return node.op + this.genExpr(node.operand);
         }
-        if (_g.type == "UpdateExpr") {
-          if (_g.prefix) {
-            return _g.op + this.genExpr(_g.operand);
+        if (node.type == "UpdateExpr") {
+          if (node.prefix) {
+            return node.op + this.genExpr(node.operand);
           }
-          return this.genExpr(_g.operand) + _g.op;
+          return this.genExpr(node.operand) + node.op;
         }
-        if (_g.type == "TernaryExpr") {
-          return "(" + this.genExpr(_g.cond) + " ? " + this.genExpr(_g.then) + " : " + this.genExpr(_g.else_) + ")";
+        if (node.type == "TernaryExpr") {
+          return "(" + this.genExpr(node.cond) + " ? " + this.genExpr(node.then) + " : " + this.genExpr(node.else_) + ")";
         }
-        if (_g.type == "AssignExpr") {
-          return this.genExpr(_g.target) + " " + _g.op + " " + this.genExpr(_g.value);
+        if (node.type == "AssignExpr") {
+          return this.genExpr(node.target) + " " + node.op + " " + this.genExpr(node.value);
         }
-        if (_g.type == "AwaitExpr") {
-          return "await " + this.genExpr(_g.operand);
+        if (node.type == "AwaitExpr") {
+          return "await " + this.genExpr(node.operand);
         }
-        if (_g.type == "TypeofExpr") {
-          return "typeof " + this.genExpr(_g.operand);
+        if (node.type == "TypeofExpr") {
+          return "typeof " + this.genExpr(node.operand);
         }
-        if (_g.type == "SpreadExpr") {
-          return "..." + this.genExpr(_g.expr);
+        if (node.type == "SpreadExpr") {
+          return "..." + this.genExpr(node.expr);
         }
-        if (_g.type == "CallExpr") {
-          const callee = this.genExpr(_g.callee);
-          const args = _g.args.map((_v) => this.genExpr(_v)).join(", ");
+        if (node.type == "CallExpr") {
+          const callee = this.genExpr(node.callee);
+          const args = node.args.map((a) => this.genExpr(a)).join(", ");
           return callee + "(" + args + ")";
         }
-        if (_g.type == "MemberExpr") {
-          const objSrc = this.genExpr(_g.obj);
-          const wrapped = _g.obj.type == "NumberLit" ? "(" + objSrc + ")" : objSrc;
-          return wrapped + "." + _g.prop;
+        if (node.type == "MemberExpr") {
+          const objSrc = this.genExpr(node.obj);
+          const wrapped = node.obj.type == "NumberLit" ? "(" + objSrc + ")" : objSrc;
+          return wrapped + "." + node.prop;
         }
-        if (_g.type == "OptMemberExpr") {
-          return this.genExpr(_g.obj) + "?." + _g.prop;
+        if (node.type == "OptMemberExpr") {
+          return this.genExpr(node.obj) + "?." + node.prop;
         }
-        if (_g.type == "OptIndexExpr") {
-          return this.genExpr(_g.obj) + "?.[" + this.genExpr(_g.idx) + "]";
+        if (node.type == "OptIndexExpr") {
+          return this.genExpr(node.obj) + "?.[" + this.genExpr(node.idx) + "]";
         }
-        if (_g.type == "OptCallExpr") {
-          const args = _g.args.map((_v) => this.genExpr(_v)).join(", ");
-          return this.genExpr(_g.callee) + "?.(" + args + ")";
+        if (node.type == "OptCallExpr") {
+          const args = node.args.map((a) => this.genExpr(a)).join(", ");
+          return this.genExpr(node.callee) + "?.(" + args + ")";
         }
-        if (_g.type == "IndexExpr") {
-          return this.genExpr(_g.obj) + "[" + this.genExpr(_g.idx) + "]";
+        if (node.type == "IndexExpr") {
+          return this.genExpr(node.obj) + "[" + this.genExpr(node.idx) + "]";
         }
-        if (_g.type == "NewExpr") {
-          const args = _g.args.map((_v) => this.genExpr(_v)).join(", ");
-          return "new " + _g.callee + "(" + args + ")";
+        if (node.type == "NewExpr") {
+          const args = node.args.map((a) => this.genExpr(a)).join(", ");
+          return "new " + node.callee + "(" + args + ")";
         }
-        if (_g.type == "LambdaExpr") {
-          const params = _g.params.map((_l) => _l.rest ? "..." + _l.name : _l.name).join(", ");
-          return "(" + params + ") => " + this.genExpr(_g.body);
+        if (node.type == "LambdaExpr") {
+          const params = node.params.map((p) => p.rest ? "..." + p.name : p.name).join(", ");
+          return "(" + params + ") => " + this.genExpr(node.body);
         }
-        if (_g.type == "FnDecl") {
-          const asyncKw = _g.async ? "async " : "";
-          const params = _g.params.map((_l) => _l.rest ? "..." + _l.name : _l.defaultVal ? _l.name + " = " + this.genExpr(_l.defaultVal) : _l.name).join(", ");
-          if (_g.inline) {
-            return asyncKw + "function(" + params + ") { return " + this.genExpr(_g.body) + "; }";
+        if (node.type == "FnDecl") {
+          const asyncKw = node.async ? "async " : "";
+          const params = node.params.map((p) => p.rest ? "..." + p.name : p.defaultVal ? p.name + " = " + this.genExpr(p.defaultVal) : p.name).join(", ");
+          if (node.inline) {
+            return asyncKw + "function(" + params + ") { return " + this.genExpr(node.body) + "; }";
           }
           const saved = this.lines.length;
           const savedLevel = this.level;
           this.emit(asyncKw + "function(" + params + ") {");
           this.indIn();
-          for (const _k of _g.body) {
-            this.genStmt(_k);
+          for (const s of node.body) {
+            this.genStmt(s);
           }
           this.indOut();
           this.emit("}");
-          const block = this.lines.splice(saved).map((_w) => _w.trimStart()).join(" ");
+          const block = this.lines.splice(saved).map((l) => l.trimStart()).join(" ");
           this.level = savedLevel;
           return block;
         }
-        if (_g.type == "MatchStmt") {
+        if (node.type == "MatchStmt") {
           const saved = this.lines.length;
           const savedLevel = this.level;
           const savedLoop = this._loopDepth;
@@ -2749,53 +2757,53 @@ var require_codegen = __commonJS({
           this._fnDepth = this._fnDepth + 1;
           this.emit("(() => {");
           this.indIn();
-          this.genMatch(_g);
+          this.genMatch(node);
           this.indOut();
           this.emit("})()");
           this._fnDepth = this._fnDepth - 1;
           this._loopDepth = savedLoop;
-          const block = this.lines.splice(saved).map((_w) => _w.trimStart()).join(" ");
+          const block = this.lines.splice(saved).map((l) => l.trimStart()).join(" ");
           this.level = savedLevel;
           return block;
         }
-        if (_g.type == "ArrayExpr") {
-          return "[" + _g.items.map((_x) => this.genExpr(_x)).join(", ") + "]";
+        if (node.type == "ArrayExpr") {
+          return "[" + node.items.map((i) => this.genExpr(i)).join(", ") + "]";
         }
-        if (_g.type == "ObjectExpr") {
-          const pairs = _g.pairs.map((_l) => this.genObjPair(_l)).join(", ");
+        if (node.type == "ObjectExpr") {
+          const pairs = node.pairs.map((p) => this.genObjPair(p)).join(", ");
           return "{ " + pairs + " }";
         }
-        if (_g.type == "RangeExpr") {
-          return "Array.from({ length: " + this.genExpr(_g.end) + " - " + this.genExpr(_g.start) + " }, (_, i) => i + " + this.genExpr(_g.start) + ")";
+        if (node.type == "RangeExpr") {
+          return "Array.from({ length: " + this.genExpr(node.end) + " - " + this.genExpr(node.start) + " }, (_, i) => i + " + this.genExpr(node.start) + ")";
         }
-        if (_g.type == "PipeExpr") {
-          return this.genPipe(_g);
+        if (node.type == "PipeExpr") {
+          return this.genPipe(node);
         }
-        if (_g.type == "CastExpr") {
-          return this.genExpr(_g.expr);
+        if (node.type == "CastExpr") {
+          return this.genExpr(node.expr);
         }
-        if (_g.type == "AsConstExpr") {
-          return "Object.freeze(" + this.genExpr(_g.expr) + ")";
+        if (node.type == "AsConstExpr") {
+          return "Object.freeze(" + this.genExpr(node.expr) + ")";
         }
-        if (_g.type == "SatisfiesExpr") {
-          return this.genExpr(_g.expr);
+        if (node.type == "SatisfiesExpr") {
+          return this.genExpr(node.expr);
         }
-        if (_g.type == "IsExpr") {
-          return this.genExpr(_g.expr);
+        if (node.type == "IsExpr") {
+          return this.genExpr(node.expr);
         }
-        if (_g.type == "NonNullExpr") {
-          return this.genExpr(_g.expr);
+        if (node.type == "NonNullExpr") {
+          return this.genExpr(node.expr);
         }
-        throw new Error(`Unknown expression: ${_g.type}`);
+        throw new Error(`Unknown expression: ${node.type}`);
       }
-      genTemplate(_y) {
+      genTemplate(parts) {
         let result = "`";
-        for (const _l of _y) {
-          if (_l.type == "text") {
-            result += _l.value.replace(/`/g, "\\`").replace(/\$/g, "\\$");
+        for (const p of parts) {
+          if (p.type == "text") {
+            result += p.value.replace(/`/g, "\\`").replace(/\$/g, "\\$");
           } else {
-            const fmtInfo = _a(_l.value);
-            const exprSrc = fmtInfo ? fmtInfo.expr : _l.value;
+            const fmtInfo = extractFormatSpec(p.value);
+            const exprSrc = fmtInfo ? fmtInfo.expr : p.value;
             const fmt = fmtInfo ? fmtInfo.fmt : null;
             try {
               const tokens = lexerize(exprSrc).tokenize();
@@ -2807,42 +2815,43 @@ var require_codegen = __commonJS({
               } else {
                 result += "${" + gen + "}";
               }
-            } catch (_z) {
-              result += "${" + _l.value + "}";
+            } catch (err) {
+              result += "${" + p.value + "}";
             }
           }
         }
         result += "`";
         return result;
       }
-      genPipe(_g) {
-        const left = this.genExpr(_g.left);
-        const right = _g.right;
+      genPipe(node) {
+        const left = this.genExpr(node.left);
+        const right = node.right;
         if (right.type == "Identifier") {
           return this.genExpr(right) + "(" + left + ")";
         }
         if (right.type == "CallExpr") {
           const fn_ = this.genExpr(right.callee);
-          const rest = right.args.map((_v) => this.genExpr(_v)).join(", ");
+          const rest = right.args.map((a) => this.genExpr(a)).join(", ");
           return rest ? fn_ + "(" + left + ", " + rest + ")" : fn_ + "(" + left + ")";
         }
         return "(" + this.genExpr(right) + ")(" + left + ")";
       }
     };
     module2.exports.CodeGenerator = CodeGenerator;
-    function makeCodeGen(_aa) {
-      const ind = (_aa == null ? void 0 : _aa.indent) ?? "    ";
-      const smb = (_aa == null ? void 0 : _aa.smBuilder) ?? null;
-      const ver = (_aa == null ? void 0 : _aa.version) ?? "3.5.3";
+    function makeCodeGen(opts) {
+      const ind = (opts == null ? void 0 : opts.indent) ?? "    ";
+      const smb = (opts == null ? void 0 : opts.smBuilder) ?? null;
+      const ver = (opts == null ? void 0 : opts.version) ?? "3.5.3";
       return new CodeGenerator(ind, 0, [], {}, smb, false, 0, ver);
     }
     module2.exports.makeCodeGen = makeCodeGen;
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/css-preprocessor.js
+// src/css-preprocessor.js
 var require_css_preprocessor = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/css-preprocessor.js"(exports2, module2) {
+  "src/css-preprocessor.js"(exports2, module2) {
+    "use strict";
     var CSS_PROP_MAP = { bg: "background", fg: "color", p: "padding", px: "padding-inline", py: "padding-block", pt: "padding-top", pb: "padding-bottom", pl: "padding-left", pr: "padding-right", m: "margin", mx: "margin-inline", my: "margin-block", mt: "margin-top", mb: "margin-bottom", ml: "margin-left", mr: "margin-right", radius: "border-radius", w: "width", h: "height", "min-w": "min-width", "max-w": "max-width", "min-h": "min-height", "max-h": "max-height", gap: "gap", "col-gap": "column-gap", "row-gap": "row-gap", text: "font-size", font: "font-family", weight: "font-weight", tracking: "letter-spacing", leading: "line-height", shadow: "box-shadow", opacity: "opacity", border: "border", outline: "outline", transition: "transition", cursor: "cursor", overflow: "overflow", "overflow-x": "overflow-x", "overflow-y": "overflow-y", z: "z-index", transform: "transform", content: "content", resize: "resize", appearance: "appearance", "object-fit": "object-fit", "accent-color": "accent-color", direction: "flex-direction", wrap: "flex-wrap", align: "align-items", justify: "justify-content", "align-self": "align-self", "justify-self": "justify-self", grow: "flex-grow", shrink: "flex-shrink", basis: "flex-basis", order: "order", cols: "grid-template-columns", rows: "grid-template-rows", "col-span": "grid-column", "row-span": "grid-row", "place-items": "place-items", "place-content": "place-content", "list-style": "list-style", "text-align": "text-align", decoration: "text-decoration", "text-transform": "text-transform", "white-space": "white-space", "word-break": "word-break", "user-select": "user-select", "pointer-events": "pointer-events", "vertical-align": "vertical-align", backdrop: "backdrop-filter", filter: "filter", clip: "clip-path", animation: "animation", position: "position", top: "top", right: "right", bottom: "bottom", left: "left", inset: "inset", color: "color", background: "background" };
     module2.exports.CSS_PROP_MAP = CSS_PROP_MAP;
     var CSS_BOOL_MAP = { flex: "display: flex", grid: "display: grid", block: "display: block", inline: "display: inline", "inline-flex": "display: inline-flex", "inline-block": "display: inline-block", "inline-grid": "display: inline-grid", bold: "font-weight: 700", italic: "font-style: italic", relative: "position: relative", absolute: "position: absolute", fixed: "position: fixed", sticky: "position: sticky", hidden: "display: none", pointer: "cursor: pointer", underline: "text-decoration: underline", "line-through": "text-decoration: line-through", capitalize: "text-transform: capitalize", uppercase: "text-transform: uppercase", lowercase: "text-transform: lowercase", truncate: "overflow: hidden; text-overflow: ellipsis; white-space: nowrap", "select-none": "user-select: none", "no-wrap": "white-space: nowrap", "no-list": "list-style: none", "no-outline": "outline: none", "no-border": "border: none", "no-bg": "background: transparent", "no-padding": "padding: 0", "no-margin": "margin: 0", "no-resize": "resize: none", center: "text-align: center", "items-center": "align-items: center", "justify-center": "justify-content: center", "place-center": "place-items: center", "flex-col": "flex-direction: column", "flex-row": "flex-direction: row", "flex-wrap": "flex-wrap: wrap", "flex-1": "flex: 1", "w-full": "width: 100%", "h-full": "height: 100%", "w-screen": "width: 100vw", "h-screen": "height: 100vh", "box-border": "box-sizing: border-box" };
@@ -3112,7 +3121,7 @@ var require_css_preprocessor = __commonJS({
           const charAfter = this.src[this.pos + 3] ?? "";
           if (!/[a-zA-Z0-9_]/.test(charBefore) && !/[a-zA-Z0-9_]/.test(charAfter)) {
             let j = this.pos + 3;
-            while (j < this.src.length && (this.src[j] == " " || this.src[j] == "	" || this.src[j] == "\n" || this.src[j] == "\r")) {
+            while (j < this.src.length && (this.src[j] == " " || this.src[j] == "   " || this.src[j] == "\n" || this.src[j] == "\r")) {
               j = j + 1;
             }
             if (this.src[j] == "{") {
@@ -3201,9 +3210,9 @@ var require_css_preprocessor = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/jsx.js
+// src/jsx.js
 var require_jsx = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/jsx.js"(exports2, module2) {
+  "src/jsx.js"(exports2, module2) {
     "use strict";
     var JSX_STYLE_VALUE_PROPS = { bg: (v) => "background:" + v, fg: (v) => "color:" + v, color: (v) => "color:" + v, p: (v) => "padding:" + v, px: (v) => "paddingLeft:" + v + ",paddingRight:" + v, py: (v) => "paddingTop:" + v + ",paddingBottom:" + v, pt: (v) => "paddingTop:" + v, pb: (v) => "paddingBottom:" + v, pl: (v) => "paddingLeft:" + v, pr: (v) => "paddingRight:" + v, m: (v) => "margin:" + v, mx: (v) => "marginLeft:" + v + ",marginRight:" + v, my: (v) => "marginTop:" + v + ",marginBottom:" + v, mt: (v) => "marginTop:" + v, mb: (v) => "marginBottom:" + v, ml: (v) => "marginLeft:" + v, mr: (v) => "marginRight:" + v, radius: (v) => "borderRadius:" + v, w: (v) => "width:" + v, h: (v) => "height:" + v, "min-w": (v) => "minWidth:" + v, "max-w": (v) => "maxWidth:" + v, "min-h": (v) => "minHeight:" + v, "max-h": (v) => "maxHeight:" + v, gap: (v) => "gap:" + v, "col-gap": (v) => "columnGap:" + v, "row-gap": (v) => "rowGap:" + v, text: (v) => "fontSize:" + v, font: (v) => "fontFamily:" + v, weight: (v) => "fontWeight:" + v, tracking: (v) => "letterSpacing:" + v, leading: (v) => "lineHeight:" + v, shadow: (v) => "boxShadow:" + v, opacity: (v) => "opacity:" + v, border: (v) => "border:" + v, outline: (v) => "outline:" + v, transition: (v) => "transition:" + v, cursor: (v) => "cursor:" + v, overflow: (v) => "overflow:" + v, z: (v) => "zIndex:" + v, transform: (v) => "transform:" + v, direction: (v) => "flexDirection:" + v, align: (v) => "alignItems:" + v, justify: (v) => "justifyContent:" + v, "align-self": (v) => "alignSelf:" + v, "place-items": (v) => "placeItems:" + v, grow: (v) => "flexGrow:" + v, shrink: (v) => "flexShrink:" + v, basis: (v) => "flexBasis:" + v, cols: (v) => "gridTemplateColumns:" + v, rows: (v) => "gridTemplateRows:" + v, inset: (v) => "inset:" + v, top: (v) => "top:" + v, right: (v) => "right:" + v, bottom: (v) => "bottom:" + v, left: (v) => "left:" + v, "object-fit": (v) => "objectFit:" + v, "line-height": (v) => "lineHeight:" + v, "text-align": (v) => "textAlign:" + v, decoration: (v) => "textDecoration:" + v, clip: (v) => "clipPath:" + v, filter: (v) => "filter:" + v, backdrop: (v) => "backdropFilter:" + v, animation: (v) => "animation:" + v };
     var JSX_STYLE_BOOL_PROPS = { flex: 'display:"flex"', grid: 'display:"grid"', block: 'display:"block"', "inline-flex": 'display:"inline-flex"', "inline-block": 'display:"inline-block"', bold: "fontWeight:700", italic: 'fontStyle:"italic"', underline: 'textDecoration:"underline"', pointer: 'cursor:"pointer"', hidden: 'display:"none"', relative: 'position:"relative"', absolute: 'position:"absolute"', fixed: 'position:"fixed"', sticky: 'position:"sticky"', "flex-col": 'flexDirection:"column"', "flex-row": 'flexDirection:"row"', "flex-wrap": 'flexWrap:"wrap"', "flex-1": "flex:1", "w-full": 'width:"100%"', "h-full": 'height:"100%"', center: 'textAlign:"center"', truncate: 'overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"', "select-none": 'userSelect:"none"', "no-wrap": 'whiteSpace:"nowrap"', "no-list": 'listStyle:"none"', "no-outline": 'outline:"none"', "no-border": 'border:"none"', "box-border": 'boxSizing:"border-box"' };
@@ -3279,7 +3288,7 @@ var require_jsx = __commonJS({
           return false;
         }
         let i = this.pos - 1;
-        while (i >= 0 && (this.src[i] == " " || this.src[i] == "	")) {
+        while (i >= 0 && (this.src[i] == " " || this.src[i] == "   ")) {
           i = i - 1;
         }
         if (i < 0) {
@@ -3533,7 +3542,7 @@ var require_jsx = __commonJS({
         }
       }
       skipWs() {
-        while (this.pos < this.src.length && (this.src[this.pos] == " " || this.src[this.pos] == "	")) {
+        while (this.pos < this.src.length && (this.src[this.pos] == " " || this.src[this.pos] == "   ")) {
           this.pos = this.pos + 1;
         }
       }
@@ -3552,9 +3561,9 @@ var require_jsx = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/checker.js
+// src/checker.js
 var require_checker = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/checker.js"(exports2, module2) {
+  "src/checker.js"(exports2, module2) {
     "use strict";
     var CheckError = class {
       constructor(message, loc, hint, name, line, col) {
@@ -3843,9 +3852,10 @@ var require_checker = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/type-checker.js
+// src/type-checker.js
 var require_type_checker = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/type-checker.js"(exports2, module2) {
+  "src/type-checker.js"(exports2, module2) {
+    "use strict";
     var T_ANY = Object.freeze({ kind: "any" });
     module2.exports.T_ANY = T_ANY;
     var T_UNKNOWN = Object.freeze({ kind: "unknown" });
@@ -4891,9 +4901,9 @@ var require_type_checker = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/transpiler.js
+// src/transpiler.js
 var require_transpiler = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/transpiler.js"(exports2, module2) {
+  "src/transpiler.js"(exports2, module2) {
     "use strict";
     var { Lexer, lexerize, T } = require_lexer();
     var { Parser, makeParser } = require_parser();
@@ -4987,9 +4997,9 @@ var require_transpiler = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/bundler.js
+// src/bundler.js
 var require_bundler = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/bundler.js"(exports2, module2) {
+  "src/bundler.js"(exports2, module2) {
     "use strict";
     var Fs2 = require("fs");
     var Path2 = require("path");
@@ -5002,24 +5012,17 @@ var require_bundler = __commonJS({
     }
     function extractModuleInfo(ast, fromFile) {
       const imports = [];
-      const npmImports = [];
       const exports3 = [];
       const body = [];
       const dir = Path2.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 = Path2.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 = Path2.resolve(dir, src);
+          imports.push({ names: node.names, source: node.source, absPath });
         } else if (node.type == "ExportDecl") {
           const inner = node.decl;
           if (inner.type == "FnDecl") {
@@ -5036,7 +5039,7 @@ var require_bundler = __commonJS({
           body.push(node);
         }
       }
-      return { cleanAst: { type: "Program", body }, imports, npmImports, exports: exports3 };
+      return { cleanAst: { type: "Program", body }, imports, exports: exports3 };
     }
     function codegenModule(ast) {
       const cg = makeCodeGen({ indent: "    " });
@@ -5096,6 +5099,9 @@ var require_bundler = __commonJS({
           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) {
@@ -5164,9 +5170,10 @@ var require_bundler = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/formatter.js
+// src/formatter.js
 var require_formatter = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/formatter.js"(exports2, module2) {
+  "src/formatter.js"(exports2, module2) {
+    "use strict";
     function normalizeOperators(line) {
       if ((line.match(/:/g) ?? []).length > 2) {
         return line;
@@ -5273,9 +5280,10 @@ var require_formatter = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/linter.js
+// src/linter.js
 var require_linter = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/linter.js"(exports2, module2) {
+  "src/linter.js"(exports2, module2) {
+    "use strict";
     var { lexerize } = require_lexer();
     var { makeParser } = require_parser();
     var BUILTIN_NAMES = /* @__PURE__ */ new Set(["self", "this", "arguments", "exports", "module", "require", "__dirname", "__filename", "process", "console", "Math", "JSON", "Object", "Array", "String", "Number", "Boolean", "Promise", "Error", "Symbol", "Map", "Set", "WeakMap", "WeakSet", "Proxy", "Reflect", "undefined", "null", "true", "false", "NaN", "Infinity", "parseInt", "parseFloat", "isNaN", "isFinite", "setTimeout", "clearTimeout", "setInterval", "clearInterval", "fetch", "globalThis", "print", "truncate", "range", "sum", "first", "last", "zip", "flatten", "groupBy", "unique", "sortBy", "chunk"]);
@@ -6037,9 +6045,10 @@ var require_linter = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/test-runner.js
+// src/test-runner.js
 var require_test_runner = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/test-runner.js"(exports2, module2) {
+  "src/test-runner.js"(exports2, module2) {
+    "use strict";
     var Fs2 = require("fs");
     var Path2 = require("path");
     var Os2 = require("os");
@@ -6204,28 +6213,16 @@ function __runTest(name, fn) {
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/config.js
+// src/config.js
 var require_config = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/config.js"(exports2, module2) {
+  "src/config.js"(exports2, module2) {
     "use strict";
     var Fs2 = require("fs");
     var Path2 = require("path");
-    var 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.npmjs.org", pkg: { name: "", version: "1.0.0", description: "", author: "", license: "MIT", deps: {}, devDeps: {} } };
+    var 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: {} } };
     module2.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
     function loadConfig2(cwd_) {
       const cwd = cwd_ ?? process.cwd();
-      const pkgJsonPath = Path2.join(cwd, "package.json");
-      if (Fs2.existsSync(pkgJsonPath)) {
-        try {
-          const raw = Fs2.readFileSync(pkgJsonPath, "utf8");
-          const parsed = JSON.parse(raw);
-          if (parsed.flux && typeof parsed.flux == "object") {
-            return mergeConfig(DEFAULT_CONFIG, parsed.flux);
-          }
-        } catch (e) {
-          throw new Error("Invalid package.json: " + e.message);
-        }
-      }
       const jsonPath = Path2.join(cwd, "flux.json");
       if (Fs2.existsSync(jsonPath)) {
         try {
@@ -6236,6 +6233,15 @@ var require_config = __commonJS({
           throw new Error("Invalid flux.json: " + e.message);
         }
       }
+      const jsPath = Path2.join(cwd, "flux.config.js");
+      if (Fs2.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 };
     }
     module2.exports.loadConfig = loadConfig2;
@@ -6255,17 +6261,9 @@ var require_config = __commonJS({
     module2.exports.mergeConfig = mergeConfig;
     function writeConfig(config, cwd_) {
       const cwd = cwd_ ?? process.cwd();
-      const pkgPath = Path2.join(cwd, "package.json");
-      let pkg = {};
-      if (Fs2.existsSync(pkgPath)) {
-        try {
-          pkg = JSON.parse(Fs2.readFileSync(pkgPath, "utf8"));
-        } catch (e) {
-          pkg = {};
-        }
-      }
-      pkg.flux = config;
-      Fs2.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+      const jsonPath = Path2.join(cwd, "flux.json");
+      const content = JSON.stringify(config, null, 2) + "\n";
+      Fs2.writeFileSync(jsonPath, content, "utf8");
     }
     module2.exports.writeConfig = writeConfig;
     function validateConfig(config) {
@@ -6281,18 +6279,18 @@ var require_config = __commonJS({
     module2.exports.validateConfig = validateConfig;
     function readPackage(cwd_) {
       const cwd = cwd_ ?? process.cwd();
-      const pkgJson = Path2.join(cwd, "package.json");
       const fluxJson = Path2.join(cwd, "flux.json");
-      if (Fs2.existsSync(pkgJson)) {
+      const pkgJson = Path2.join(cwd, "package.json");
+      if (Fs2.existsSync(fluxJson)) {
         try {
-          return JSON.parse(Fs2.readFileSync(pkgJson, "utf8"));
+          return JSON.parse(Fs2.readFileSync(fluxJson, "utf8"));
         } catch (e) {
           return null;
         }
       }
-      if (Fs2.existsSync(fluxJson)) {
+      if (Fs2.existsSync(pkgJson)) {
         try {
-          return JSON.parse(Fs2.readFileSync(fluxJson, "utf8"));
+          return JSON.parse(Fs2.readFileSync(pkgJson, "utf8"));
         } catch (e2) {
           return null;
         }
@@ -6303,18 +6301,19 @@ var require_config = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/pkg.js
+// src/pkg.js
 var require_pkg = __commonJS({
-  "../../../tmp/flux-publish-v5/src/self/pkg.js"(exports2, module2) {
+  "src/pkg.js"(exports2, module2) {
     "use strict";
     var Fs2 = require("fs");
     var Path2 = require("path");
     var Https = require("https");
     var Http = require("http");
     var Os2 = require("os");
-    var { readPackage } = require_config();
+    var { readPackage, writeConfig, loadConfig: loadConfig2 } = require_config();
     var REGISTRY_URL = "https://registry.npmjs.org";
-    var ESC = "\\u001b";
+    var PKG_FILE = "flux.json";
+    var ESC = "\x1B";
     var C2 = { reset: ESC + "[0m", bold: ESC + "[1m", dim: ESC + "[2m", red: ESC + "[31m", green: ESC + "[32m", yellow: ESC + "[33m", blue: ESC + "[34m", cyan: ESC + "[36m", gray: ESC + "[90m" };
     function clr2(c, s) {
       return c + s + C2.reset;
@@ -6336,7 +6335,7 @@ var require_pkg = __commonJS({
       }
       let frame = 0;
       function tick() {
-        stdout.write("\\r" + clr2(C2.cyan, SPIN_FRAMES[frame % SPIN_FRAMES.length]) + " " + label + "   ");
+        stdout.write("\r" + clr2(C2.cyan, SPIN_FRAMES[frame % SPIN_FRAMES.length]) + " " + label + "   ");
         frame = frame + 1;
       }
       const timer = setInterval(tick, 80);
@@ -6347,7 +6346,7 @@ var require_pkg = __commonJS({
         return;
       }
       clearInterval(timer);
-      stdout.write("\\r" + ESC + "[2K");
+      stdout.write("\r" + ESC + "[2K");
     }
     async function fetchJson(url) {
       const mod = url.startsWith("https") ? Https : Http;
@@ -6371,6 +6370,21 @@ var require_pkg = __commonJS({
       }
       return new Promise(doRequest);
     }
+    function ensureFluxJson(cwd_) {
+      const cwd = cwd_ ?? process.cwd();
+      const file = Path2.join(cwd, PKG_FILE);
+      if (!Fs2.existsSync(file)) {
+        const pkg = { name: Path2.basename(cwd), version: "1.0.0", description: "", author: "", license: "MIT", 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" }, dependencies: {}, devDependencies: {} };
+        Fs2.writeFileSync(file, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+        ok("Created flux.json");
+      }
+      return JSON.parse(Fs2.readFileSync(file, "utf8"));
+    }
+    function saveFluxJson(pkg, cwd_) {
+      const cwd = cwd_ ?? process.cwd();
+      const file = Path2.join(cwd, PKG_FILE);
+      Fs2.writeFileSync(file, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    }
     function parsePackageSpec(spec) {
       const atIdx = spec.lastIndexOf("@");
       if (atIdx > 0) {
@@ -6379,58 +6393,116 @@ var require_pkg = __commonJS({
       return { name: spec, version: "latest" };
     }
     async function cmdAdd2(specs, opts) {
-      const { execSync } = require("child_process");
+      var _a, _b;
       const isDev = (opts == null ? void 0 : opts.dev) ?? false;
       const cwd = process.cwd();
+      const pkg = ensureFluxJson(cwd);
       for (const spec of specs) {
         const { name, version } = parsePackageSpec(spec);
-        const spinner = startSpinner("Adding " + clr2(C2.bold, name) + clr2(C2.gray, "@" + version) + " ...");
+        const spinner = startSpinner("Fetching " + clr2(C2.bold, name) + clr2(C2.gray, "@" + version) + " ...");
         try {
-          const saveFlag = isDev ? "--save-dev" : "--save";
-          const pkgSpec = version == "latest" ? name : name + "@" + version;
+          const info_ = await fetchJson(REGISTRY_URL + "/" + name);
+          const resolvedVersion = version == "latest" ? ((_a = info_["dist-tags"]) == null ? void 0 : _a.latest) ?? "1.0.0" : version;
+          const versionInfo = (_b = info_.versions) == null ? void 0 : _b[resolvedVersion];
           stopSpinner(spinner);
-          console.log(clr2(C2.cyan, "  Adding ") + clr2(C2.bold, pkgSpec) + clr2(C2.gray, " to node_modules/ and package.json..."));
-          execSync("npm install " + pkgSpec + " " + saveFlag, { cwd, stdio: "inherit" });
-          ok("Added " + clr2(C2.bold, name) + " to node_modules/ and package.json");
+          if (!versionInfo) {
+            err("Version " + resolvedVersion + " not found for " + name);
+            continue;
+          }
+          const depKey = isDev ? "devDependencies" : "dependencies";
+          if (!pkg[depKey]) {
+            pkg[depKey] = {};
+          }
+          pkg[depKey][name] = "^" + resolvedVersion;
+          saveFluxJson(pkg, cwd);
+          const desc = versionInfo.description ? clr2(C2.gray, " \u2014 " + versionInfo.description) : "";
+          ok(name + clr2(C2.green, "@" + resolvedVersion) + desc);
+          info("Added to " + (isDev ? "devDependencies" : "dependencies"));
         } catch (e) {
           stopSpinner(spinner);
-          err("Failed to add " + name + ": " + e.message);
+          err("Failed to fetch " + name + ": " + e.message);
         }
       }
       console.log();
+      console.log(clr2(C2.gray, "  Run ") + clr2(C2.yellow, "flux install") + clr2(C2.gray, " to install packages"));
+      console.log();
     }
     module2.exports.cmdAdd = cmdAdd2;
     function cmdRemove2(names, opts) {
-      const { execSync } = require("child_process");
       const cwd = process.cwd();
+      const pkg = ensureFluxJson(cwd);
+      let removed = 0;
       for (const name of names) {
-        try {
-          console.log(clr2(C2.cyan, "  Removing ") + clr2(C2.bold, name) + " ...");
-          execSync("npm uninstall " + name, { cwd, stdio: "inherit" });
+        let found = false;
+        if (pkg.dependencies && pkg.dependencies[name]) {
+          delete pkg.dependencies[name];
+          found = true;
+        }
+        if (pkg.devDependencies && pkg.devDependencies[name]) {
+          delete pkg.devDependencies[name];
+          found = true;
+        }
+        if (found) {
           ok("Removed " + clr2(C2.bold, name));
-        } catch (e) {
-          err("Failed to remove " + name + ": " + e.message);
+          removed = removed + 1;
+        } else {
+          err(name + " not found in flux.json");
         }
       }
+      if (removed > 0) {
+        saveFluxJson(pkg, cwd);
+      }
     }
     module2.exports.cmdRemove = cmdRemove2;
     async function cmdInstall2(opts) {
       const { execSync } = require("child_process");
       const cwd = process.cwd();
-      const pkgJsonPath = Path2.join(cwd, "package.json");
-      if (!Fs2.existsSync(pkgJsonPath)) {
-        err("No package.json found. Run: flux init");
+      const pkg = ensureFluxJson(cwd);
+      const fluxModDir = Path2.join(cwd, "flux_modules");
+      const deps = pkg.dependencies ?? {};
+      const devDeps = pkg.devDependencies ?? {};
+      const all = { ...deps, ...devDeps };
+      const names = Object.keys(all);
+      if (names.length == 0) {
+        info("No dependencies found in flux.json");
         return;
       }
-      console.log(clr2(C2.cyan, "\n  Installing dependencies from package.json...\n"));
+      console.log(clr2(C2.cyan, "\n  Installing ") + names.length + " package(s) into flux_modules/...\n");
+      for (const name of names) {
+        const spec = all[name];
+        console.log(clr2(C2.gray, "  \u25CB ") + name + clr2(C2.gray, "@" + spec));
+      }
+      console.log();
+      if (!Fs2.existsSync(fluxModDir)) {
+        Fs2.mkdirSync(fluxModDir, { recursive: true });
+      }
+      const fluxPkgFile = Path2.join(fluxModDir, "package.json");
+      if (!Fs2.existsSync(fluxPkgFile)) {
+        const fluxPkg = { name: pkg.name + "-flux-modules", version: "1.0.0", private: true };
+        Fs2.writeFileSync(fluxPkgFile, JSON.stringify(fluxPkg, null, 2) + "\n", "utf8");
+      }
+      const prodNames = Object.keys(deps);
+      const devNames = Object.keys(devDeps);
       try {
-        execSync("npm install", { cwd, stdio: "inherit" });
+        if (prodNames.length > 0) {
+          const prodPkgs = prodNames.map((n) => n + "@" + (deps[n] ?? "latest")).join(" ");
+          const installCmd = "npm install --prefix " + fluxModDir + " " + prodPkgs;
+          info("Running: " + installCmd);
+          execSync(installCmd, { cwd, stdio: "inherit" });
+        }
+        if (devNames.length > 0) {
+          const devPkgs = devNames.map((n) => n + "@" + (devDeps[n] ?? "latest")).join(" ");
+          const devCmd = "npm install --prefix " + fluxModDir + " --save-dev " + devPkgs;
+          info("Running: " + devCmd);
+          execSync(devCmd, { cwd, stdio: "inherit" });
+        }
         console.log();
-        ok("Dependencies installed into node_modules/");
+        ok(names.length + " package(s) installed into flux_modules/node_modules/");
+        info("Packages resolve automatically when using: flux run, flux bundle");
       } catch (e) {
         console.log();
         err("Install failed: " + e.message);
-        info("Try manually: npm install");
+        info("Try manually: npm install --prefix ./flux_modules <package>");
       }
       console.log();
     }
@@ -6439,7 +6511,7 @@ var require_pkg = __commonJS({
       const cwd = process.cwd();
       const pkg = readPackage(cwd);
       if (!pkg) {
-        err("No package.json found. Run: flux init");
+        err("No flux.json found. Run: flux init");
         return;
       }
       console.log();
@@ -6529,12 +6601,11 @@ var require_pkg = __commonJS({
     module2.exports.cmdInfo = cmdInfo2;
     async function cmdUpgrade(opts) {
       var _a;
-      const { execSync } = require("child_process");
       const isCheck = (opts == null ? void 0 : opts.check) ?? false;
       const cwd = process.cwd();
       const pkg = readPackage(cwd);
       if (!pkg) {
-        err("No package.json found. Run: flux init");
+        err("No flux.json found. Run: flux init");
         return;
       }
       const deps = pkg.dependencies ?? {};
@@ -6572,9 +6643,11 @@ var require_pkg = __commonJS({
             if (isCheck) {
               console.log("  " + clr2(C2.yellow, "\u2191 ") + clr2(C2.bold, name) + clr2(C2.gray, "  " + current + " \u2192 ") + clr2(C2.green, "^" + latest));
             } else {
+              const isDev = devDeps[name] != null;
+              const depKey = isDev ? "devDependencies" : "dependencies";
+              pkg[depKey][name] = "^" + latest;
               updated = updated + 1;
               console.log("  " + clr2(C2.green, "\u2713 ") + clr2(C2.bold, name) + clr2(C2.gray, "  " + current + " \u2192 ") + clr2(C2.green, "^" + latest));
-              execSync("npm install " + name + "@" + latest + " --save", { cwd, stdio: "pipe" });
             }
           }
         } catch (e) {
@@ -6594,7 +6667,9 @@ var require_pkg = __commonJS({
         if (updated == 0) {
           ok("All packages are already up to date");
         } else {
-          ok(updated + " package(s) updated in node_modules/ and package.json");
+          saveFluxJson(pkg, cwd);
+          ok(updated + " package(s) updated in flux.json");
+          console.log(clr2(C2.gray, "  Run ") + clr2(C2.yellow, "flux install") + clr2(C2.gray, " to install updated versions"));
         }
       }
       console.log();
@@ -6604,19 +6679,20 @@ var require_pkg = __commonJS({
       const cwd = process.cwd();
       const pkg = readPackage(cwd);
       if (!pkg) {
-        err("No package.json found. Run: flux init");
+        err("No flux.json found. Run: flux init");
         return;
       }
       console.log();
       console.log(clr2(C2.cyan, "  Publishing ") + clr2(C2.bold, pkg.name + "@" + pkg.version) + " ...");
       console.log();
-      info("Checking package.json...");
+      info("Building package...");
+      info("Checking flux.json...");
       if (!pkg.name) {
-        err("package.json must have a name field");
+        err("flux.json must have a name field");
         return;
       }
       if (!pkg.version) {
-        err("package.json must have a version field");
+        err("flux.json must have a version field");
         return;
       }
       console.log();
@@ -6629,7 +6705,7 @@ var require_pkg = __commonJS({
   }
 });
 
-// ../../../tmp/flux-publish-v5/src/self/cli.js
+// src/cli.js
 var Fs = require("fs");
 var Path = require("path");
 var Os = require("os");
@@ -6681,20 +6757,32 @@ function showHelp() {
   console.log(bold("USAGE:"));
   console.log("  flux <command> [options]\n");
   console.log(bold("COMPILER:"));
-  const compilerCmds = [["compile <file.flux>", "Compile .flux \u2192 .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"]];
-  compilerCmds.forEach((pair) => console.log("  " + green(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1])));
+  const compilerCmds = [["compile <file.flux>", "Compile .flux \u2192 .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"]];
+  for (const __item__ of compilerCmds) {
+    const [cmd, desc] = __item__;
+    console.log("  " + green(("flux " + cmd).padEnd(36)) + " " + gray(desc));
+  }
   console.log();
   console.log(bold("TOOLING:"));
   const toolCmds = [["lint    <file.flux>", "Full lint: types + style + immutability"], ["fmt     <file.flux>", "Format source code in-place"], ["test    [dir]", "Run *.test.flux files"], ["repl", "Interactive REPL mode"], ["tokens  <file.flux>", "Show lexer token list"], ["ast     <file.flux>", "Show Abstract Syntax Tree (JSON)"]];
-  toolCmds.forEach((pair) => console.log("  " + green(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1])));
+  for (const __item__ of toolCmds) {
+    const [cmd, desc] = __item__;
+    console.log("  " + green(("flux " + cmd).padEnd(36)) + " " + gray(desc));
+  }
   console.log();
   console.log(bold("PACKAGE MANAGER:"));
-  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"]];
-  pkgCmds.forEach((pair) => console.log("  " + cyan(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1])));
+  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"]];
+  for (const __item__ of pkgCmds) {
+    const [cmd, desc] = __item__;
+    console.log("  " + cyan(("flux " + cmd).padEnd(36)) + " " + gray(desc));
+  }
   console.log();
   console.log(bold("SELF-HOSTED:"));
   const selfCmds = [["self-hosted", "Show self-hosted compiler status"], ["self-hosted build", "Bootstrap: compile compiler with itself"], ["self-hosted verify", "Verify self-hosted output matches stage-0"]];
-  selfCmds.forEach((pair) => console.log("  " + yellow(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1])));
+  for (const __item__ of selfCmds) {
+    const [cmd, desc] = __item__;
+    console.log("  " + yellow(("flux " + cmd).padEnd(36)) + " " + gray(desc));
+  }
   console.log();
   console.log(bold("OPTIONS:"));
   console.log("  " + yellow("--out, -o <file>  ") + "  Output file");
@@ -6704,12 +6792,11 @@ 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", template: null };
+  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 positional = [];
   let i = 0;
   while (i < args.length) {
@@ -6738,9 +6825,6 @@ function parseArgs(argv) {
     } else if (a == "--jsx-target") {
       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);
     }
@@ -6808,21 +6892,6 @@ 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));
@@ -6856,21 +6925,6 @@ 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\u2717 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\u2717 Compile error"));
@@ -7031,10 +7085,6 @@ 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("\u2713 Bundle done") + gray(" (" + elapsed + "ms) ") + Path.basename(abs) + gray(" + " + (result.modules - 1) + " module(s) \u2192 ") + cyan(Path.relative(process.cwd(), outFile)) + gray(" [" + kb + " KB]"));
@@ -7160,7 +7210,6 @@ 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("\u2717 Directory already exists: " + projectName));
@@ -7169,77 +7218,38 @@ 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 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} \u2014 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("\u2713 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;
-  }
-  if (template == "server") {
-    const serverFlux = '// {projectName} \u2014 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("\u2713 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 \u2014 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("\u2713 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 \u2192 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;
+  const mainFlux = '// {projectName} \u2014 built with Flux Lang v{VERSION}\n// Run: flux run src/main.flux\n\n// \u2500\u2500 Algebraic Data Types + Pattern Matching \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\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// \u2500\u2500 Result type \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\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// \u2500\u2500 Utility functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\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// \u2500\u2500 Pipe operator + stdlib \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\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// \u2500\u2500 Main \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\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// \u2500\u2500 Functions under test \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\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// \u2500\u2500 Test functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\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} \u2014 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\u251C\u2500\u2500 src/\n\u2502   \u251C\u2500\u2500 main.flux        # Entry point\n\u2502   \u2514\u2500\u2500 utils.flux       # Utility functions\n\u251C\u2500\u2500 tests/\n\u2502   \u2514\u2500\u2500 main.test.flux   # Test suite\n\u251C\u2500\u2500 flux_modules/        # Packages installed by `flux install` (gitignored)\n\u251C\u2500\u2500 flux.json            # Project config & dependencies\n\u2514\u2500\u2500 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("\u2713 Created: ") + bold(projectName + "/"));
+  console.log();
+  console.log(gray("  Files:"));
+  for (const f of allFiles) {
+    console.log("  " + cyan(f));
   }
-  console.error(red("\u2717 Unknown template: " + template));
-  console.error(gray("  Available templates: script, server, webapp"));
-  process.exit(1);
+  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();
 }
 function cmdSelfHosted(sub, opts) {
   const SELF = Path.join(__dirname, ".");
@@ -7388,8 +7398,6 @@ function main() {
     return cmdAst(positional[1], opts);
   } else if (cmd === "repl") {
     return cmdRepl(opts);
-  } else if (cmd === "test") {
-    return runTests(positional[1] ?? "tests/", (src) => transpile(src, {}));
   } else if (cmd === "init") {
     return cmdInit(positional[1], opts);
   } else if (cmd === "add") {