@xnoxs/flux-lang 4.0.8 → 4.0.9

package/src/self/pkg.flux

@@ -3,11 +3,11 @@
 //  src/self/pkg.flux — written in Flux, compiled by stage-0
 //
 //  Commands:
-//    flux add <pkg[@version]>   install a package (npm install --save)
-//    flux remove <pkg>          remove a package  (npm uninstall)
-//    flux install               install all from package.json (npm install)
+//    flux add <pkg[@version]>   install a flux package
+//    flux remove <pkg>          remove a package
+//    flux install               install all from flux.json
 //    flux list                  list installed packages
-//    flux search <query>        search the npm registry
+//    flux search <query>        search the registry
 //    flux publish               publish to registry
 //    flux info <pkg>            show package info
 // ============================================================
@@ -17,9 +17,11 @@ import Path  from "path"
 import Https from "https"
 import Http  from "http"
 import Os    from "os"
-import { readPackage } from "./config"
+import { readPackage, writeConfig, loadConfig } from "./config"
 
 val REGISTRY_URL = "https://registry.npmjs.org"
+val FLUX_PKG_DIR = "flux_modules"
+val PKG_FILE     = "flux.json"
 
 // ── ANSI colors ───────────────────────────────────────────────
 val ESC = "\u001b"
@@ -75,6 +77,36 @@ async fn fetchJson(url):
     mod.get(url, { headers: { "User-Agent": "flux-pkg/1.0" } }, onRes).on("error", reject)
   return new Promise(doRequest)
 
+// ── Ensure flux.json exists ───────────────────────────────────
+fn ensureFluxJson(cwd_):
+  val cwd  = cwd_ ?? process.cwd()
+  val file = Path.join(cwd, PKG_FILE)
+  if not Fs.existsSync(file):
+    val pkg = {
+      name:        Path.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: {},
+    }
+    Fs.writeFileSync(file, JSON.stringify(pkg, null, 2) + "\n", "utf8")
+    ok("Created flux.json")
+  return JSON.parse(Fs.readFileSync(file, "utf8"))
+
+// ── Save flux.json ────────────────────────────────────────────
+fn saveFluxJson(pkg, cwd_):
+  val cwd  = cwd_ ?? process.cwd()
+  val file = Path.join(cwd, PKG_FILE)
+  Fs.writeFileSync(file, JSON.stringify(pkg, null, 2) + "\n", "utf8")
+
 // ── Resolve package name@version ─────────────────────────────
 fn parsePackageSpec(spec):
   val atIdx = spec.lastIndexOf("@")
@@ -83,63 +115,124 @@ fn parsePackageSpec(spec):
   return { name: spec, version: "latest" }
 
 // ── flux add <pkg[@version]> [--dev] ─────────────────────────
-// Equivalent to: npm install <pkg> --save (or --save-dev)
 export async fn cmdAdd(specs, opts):
-  import { execSync } from "child_process"
   val isDev = opts?.dev ?? false
   val cwd   = process.cwd()
+  val pkg   = ensureFluxJson(cwd)
 
   for spec in specs:
     val { name, version } = parsePackageSpec(spec)
-    val spinner = startSpinner("Adding " + clr(C.bold, name) + clr(C.gray, "@" + version) + " ...")
+    val spinner = startSpinner("Fetching " + clr(C.bold, name) + clr(C.gray, "@" + version) + " ...")
 
     try:
-      val saveFlag = isDev ? "--save-dev" : "--save"
-      val pkgSpec  = version == "latest" ? name : name + "@" + version
+      val info_ = await fetchJson(REGISTRY_URL + "/" + name)
+      val resolvedVersion = version == "latest" ? (info_["dist-tags"]?.latest ?? "1.0.0") : version
+
+      val versionInfo = info_.versions?.[resolvedVersion]
       stopSpinner(spinner)
-      console.log(clr(C.cyan, "  Adding ") + clr(C.bold, pkgSpec) + clr(C.gray, " to node_modules/ and package.json..."))
-      execSync("npm install " + pkgSpec + " " + saveFlag, { cwd, stdio: "inherit" })
-      ok("Added " + clr(C.bold, name) + " to node_modules/ and package.json")
+      if not versionInfo:
+        err("Version " + resolvedVersion + " not found for " + name)
+        continue
+
+      val depKey = isDev ? "devDependencies" : "dependencies"
+      if not pkg[depKey]: pkg[depKey] = {}
+      pkg[depKey][name] = "^" + resolvedVersion
+
+      saveFluxJson(pkg, cwd)
+
+      val desc = versionInfo.description ? clr(C.gray, " — " + versionInfo.description) : ""
+      ok(name + clr(C.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(clr(C.gray, "  Run ") + clr(C.yellow, "flux install") + clr(C.gray, " to install packages"))
+  console.log()
 
 // ── flux remove <pkg> ─────────────────────────────────────────
-// Equivalent to: npm uninstall <pkg>
 export fn cmdRemove(names, opts):
-  import { execSync } from "child_process"
   val cwd = process.cwd()
+  val pkg = ensureFluxJson(cwd)
+  var removed = 0
 
   for name in names:
-    try:
-      console.log(clr(C.cyan, "  Removing ") + clr(C.bold, name) + " ...")
-      execSync("npm uninstall " + name, { cwd, stdio: "inherit" })
+    var found = false
+    if pkg.dependencies and pkg.dependencies[name]:
+      delete pkg.dependencies[name]
+      found = true
+    if pkg.devDependencies and pkg.devDependencies[name]:
+      delete pkg.devDependencies[name]
+      found = true
+
+    if found:
       ok("Removed " + clr(C.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)
 
 // ── flux install ──────────────────────────────────────────────
-// Equivalent to: npm install (reads package.json)
 export async fn cmdInstall(opts):
   import { execSync } from "child_process"
-  val cwd = process.cwd()
 
-  val pkgJsonPath = Path.join(cwd, "package.json")
-  if not Fs.existsSync(pkgJsonPath):
-    err("No package.json found. Run: flux init")
+  val cwd        = process.cwd()
+  val pkg        = ensureFluxJson(cwd)
+  val fluxModDir = Path.join(cwd, "flux_modules")
+
+  val deps    = pkg.dependencies ?? {}
+  val devDeps = pkg.devDependencies ?? {}
+  val all     = { ...deps, ...devDeps }
+  val names   = Object.keys(all)
+
+  if names.length == 0:
+    info("No dependencies found in flux.json")
     return
 
-  console.log(clr(C.cyan, "\n  Installing dependencies from package.json...\n"))
+  console.log(clr(C.cyan, "\n  Installing ") + names.length + " package(s) into flux_modules/...\n")
+
+  for name in names:
+    val spec = all[name]
+    console.log(clr(C.gray, "  ○ ") + name + clr(C.gray, "@" + spec))
+
+  console.log()
+
+  // Ensure flux_modules/ exists with a minimal package.json
+  if not Fs.existsSync(fluxModDir):
+    Fs.mkdirSync(fluxModDir, { recursive: true })
+
+  val fluxPkgFile = Path.join(fluxModDir, "package.json")
+  if not Fs.existsSync(fluxPkgFile):
+    val fluxPkg = { name: pkg.name + "-flux-modules", version: "1.0.0", private: true }
+    Fs.writeFileSync(fluxPkgFile, JSON.stringify(fluxPkg, null, 2) + "\n", "utf8")
+
+  val prodNames = Object.keys(deps)
+  val devNames  = Object.keys(devDeps)
+
   try:
-    execSync("npm install", { cwd, stdio: "inherit" })
+    if prodNames.length > 0:
+      val prodPkgs   = prodNames.map(n -> n + "@" + (deps[n] ?? "latest")).join(" ")
+      val installCmd = "npm install --prefix " + fluxModDir + " " + prodPkgs
+      info("Running: " + installCmd)
+      execSync(installCmd, { cwd: cwd, stdio: "inherit" })
+
+    if devNames.length > 0:
+      val devPkgs = devNames.map(n -> n + "@" + (devDeps[n] ?? "latest")).join(" ")
+      val devCmd  = "npm install --prefix " + fluxModDir + " --save-dev " + devPkgs
+      info("Running: " + devCmd)
+      execSync(devCmd, { cwd: 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()
 
@@ -149,7 +242,7 @@ export fn cmdList(opts):
   val pkg = readPackage(cwd)
 
   if not pkg:
-    err("No package.json found. Run: flux init")
+    err("No flux.json found. Run: flux init")
     return
 
   console.log()
@@ -232,13 +325,12 @@ export async fn cmdInfo(name, opts):
 
 // ── flux upgrade [--check] ────────────────────────────────────
 export async fn cmdUpgrade(opts):
-  import { execSync } from "child_process"
   val isCheck = opts?.check ?? false
   val cwd     = process.cwd()
   val pkg     = readPackage(cwd)
 
   if not pkg:
-    err("No package.json found. Run: flux init")
+    err("No flux.json found. Run: flux init")
     return
 
   val deps    = pkg.dependencies ?? {}
@@ -279,9 +371,11 @@ export async fn cmdUpgrade(opts):
         if isCheck:
           console.log("  " + clr(C.yellow, "↑ ") + clr(C.bold, name) + clr(C.gray, "  " + current + " → ") + clr(C.green, "^" + latest))
         else:
+          val isDev = devDeps[name] != null
+          val depKey = isDev ? "devDependencies" : "dependencies"
+          pkg[depKey][name] = "^" + latest
           updated = updated + 1
           console.log("  " + clr(C.green, "✓ ") + clr(C.bold, name) + clr(C.gray, "  " + current + " → ") + clr(C.green, "^" + latest))
-          execSync("npm install " + name + "@" + latest + " --save", { cwd, stdio: "pipe" })
 
     catch(e):
       stopSpinner(spinner)
@@ -299,7 +393,9 @@ export async fn cmdUpgrade(opts):
     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(clr(C.gray, "  Run ") + clr(C.yellow, "flux install") + clr(C.gray, " to install updated versions"))
 
   console.log()
 
@@ -309,20 +405,21 @@ export fn cmdPublish(opts):
   val pkg = readPackage(cwd)
 
   if not pkg:
-    err("No package.json found. Run: flux init")
+    err("No flux.json found. Run: flux init")
     return
 
   console.log()
   console.log(clr(C.cyan, "  Publishing ") + clr(C.bold, pkg.name + "@" + pkg.version) + " ...")
   console.log()
-  info("Checking package.json...")
+  info("Building package...")
+  info("Checking flux.json...")
 
   if not pkg.name:
-    err("package.json must have a name field")
+    err("flux.json must have a name field")
     return
 
   if not pkg.version:
-    err("package.json must have a version field")
+    err("flux.json must have a version field")
     return
 
   console.log()

package/src/self/pkg.js

@@ -1,6 +1,17 @@
-/* compiled from src/self/pkg.flux */
+/* compiled from src/self/pkg.flux by Flux Lang */
 'use strict';
-// Generated by Flux Transpiler v3.5.3 (self-hosted)
+// ── Flux stdlib ──
+
+function map(arr, fn) { return arr.map(fn); }
+
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+
+function keys(obj) { return Object.keys(obj); }
+
+function startsWith(s, prefix) { return String(s).startsWith(prefix); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.2.0
 "use strict";
 
 const Fs = require("fs");
@@ -8,9 +19,11 @@ const Path = require("path");
 const Https = require("https");
 const Http = require("http");
 const Os = require("os");
-const { readPackage } = require("./config");
+const { readPackage, writeConfig, loadConfig } = require("./config");
 const REGISTRY_URL = "https://registry.npmjs.org";
-const ESC = "\\u001b";
+const FLUX_PKG_DIR = "flux_modules";
+const PKG_FILE = "flux.json";
+const ESC = "\u001b";
 const C = { 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 clr(c, s) {
   return ((c + s) + C.reset);
@@ -32,7 +45,7 @@ function startSpinner(label) {
   }
   let frame = 0;
   function tick() {
-    stdout.write((((("\\r" + clr(C.cyan, SPIN_FRAMES[(frame % SPIN_FRAMES.length)])) + " ") + label) + "   "));
+    stdout.write((((("\r" + clr(C.cyan, SPIN_FRAMES[(frame % SPIN_FRAMES.length)])) + " ") + label) + "   "));
     frame = (frame + 1);
   }
   const timer = setInterval(tick, 80);
@@ -43,7 +56,7 @@ function stopSpinner(timer) {
     return;
   }
   clearInterval(timer);
-  stdout.write((("\\r" + ESC) + "[2K"));
+  stdout.write((("\r" + ESC) + "[2K"));
 }
 async function fetchJson(url) {
   const mod = (url.startsWith("https") ? Https : Http);
@@ -68,6 +81,21 @@ async function fetchJson(url) {
   }
   return new Promise(doRequest);
 }
+function ensureFluxJson(cwd_) {
+  const cwd = (cwd_ ?? process.cwd());
+  const file = Path.join(cwd, PKG_FILE);
+  if (!Fs.existsSync(file)) {
+    const pkg = { name: Path.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: {  } };
+    Fs.writeFileSync(file, (JSON.stringify(pkg, null, 2) + "\n"), "utf8");
+    ok("Created flux.json");
+  }
+  return JSON.parse(Fs.readFileSync(file, "utf8"));
+}
+function saveFluxJson(pkg, cwd_) {
+  const cwd = (cwd_ ?? process.cwd());
+  const file = Path.join(cwd, PKG_FILE);
+  Fs.writeFileSync(file, (JSON.stringify(pkg, null, 2) + "\n"), "utf8");
+}
 function parsePackageSpec(spec) {
   const atIdx = spec.lastIndexOf("@");
   if ((atIdx > 0)) {
@@ -76,61 +104,118 @@ function parsePackageSpec(spec) {
   return { name: spec, version: "latest" };
 }
 async function cmdAdd(specs, opts) {
-  const { execSync } = require("child_process");
   const isDev = (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 " + clr(C.bold, name)) + clr(C.gray, ("@" + version))) + " ..."));
+    const spinner = startSpinner(((("Fetching " + clr(C.bold, name)) + clr(C.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") ? (info_["dist-tags"]?.latest ?? "1.0.0") : version);
+      const versionInfo = info_.versions?.[resolvedVersion];
       stopSpinner(spinner);
-      console.log(((clr(C.cyan, "  Adding ") + clr(C.bold, pkgSpec)) + clr(C.gray, " to node_modules/ and package.json...")));
-      execSync(((("npm install " + pkgSpec) + " ") + saveFlag), { cwd, stdio: "inherit" });
-      ok((("Added " + clr(C.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 ? clr(C.gray, (" — " + versionInfo.description)) : "");
+      ok(((name + clr(C.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(((clr(C.gray, "  Run ") + clr(C.yellow, "flux install")) + clr(C.gray, " to install packages")));
+  console.log();
 }
 module.exports.cmdAdd = cmdAdd;
 function cmdRemove(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(((clr(C.cyan, "  Removing ") + clr(C.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 " + clr(C.bold, name)));
+      removed = (removed + 1);
     }
-    catch (e) {
-      err(((("Failed to remove " + name) + ": ") + e.message));
+    else {
+      err((name + " not found in flux.json"));
     }
   }
+  if ((removed > 0)) {
+    saveFluxJson(pkg, cwd);
+  }
 }
 module.exports.cmdRemove = cmdRemove;
 async function cmdInstall(opts) {
   const { execSync } = require("child_process");
   const cwd = process.cwd();
-  const pkgJsonPath = Path.join(cwd, "package.json");
-  if (!Fs.existsSync(pkgJsonPath)) {
-    err("No package.json found. Run: flux init");
+  const pkg = ensureFluxJson(cwd);
+  const fluxModDir = Path.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(clr(C.cyan, "\n  Installing dependencies from package.json...\n"));
+  console.log(((clr(C.cyan, "\n  Installing ") + names.length) + " package(s) into flux_modules/...\n"));
+  for (const name of names) {
+    const spec = all[name];
+    console.log(((clr(C.gray, "  ○ ") + name) + clr(C.gray, ("@" + spec))));
+  }
+  console.log();
+  if (!Fs.existsSync(fluxModDir)) {
+    Fs.mkdirSync(fluxModDir, { recursive: true });
+  }
+  const fluxPkgFile = Path.join(fluxModDir, "package.json");
+  if (!Fs.existsSync(fluxPkgFile)) {
+    const fluxPkg = { name: (pkg.name + "-flux-modules"), version: "1.0.0", private: true };
+    Fs.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();
 }
@@ -139,7 +224,7 @@ function cmdList(opts) {
   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();
@@ -228,12 +313,11 @@ async function cmdInfo(name, opts) {
 }
 module.exports.cmdInfo = cmdInfo;
 async function cmdUpgrade(opts) {
-  const { execSync } = require("child_process");
   const isCheck = (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 ?? {  });
@@ -274,9 +358,11 @@ async function cmdUpgrade(opts) {
           console.log((((("  " + clr(C.yellow, "↑ ")) + clr(C.bold, name)) + clr(C.gray, (("  " + current) + " → "))) + clr(C.green, ("^" + latest))));
         }
         else {
+          const isDev = (devDeps[name] != null);
+          const depKey = (isDev ? "devDependencies" : "dependencies");
+          pkg[depKey][name] = ("^" + latest);
           updated = (updated + 1);
           console.log((((("  " + clr(C.green, "✓ ")) + clr(C.bold, name)) + clr(C.gray, (("  " + current) + " → "))) + clr(C.green, ("^" + latest))));
-          execSync((((("npm install " + name) + "@") + latest) + " --save"), { cwd, stdio: "pipe" });
         }
       }
     }
@@ -300,7 +386,9 @@ async function cmdUpgrade(opts) {
       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(((clr(C.gray, "  Run ") + clr(C.yellow, "flux install")) + clr(C.gray, " to install updated versions")));
     }
   }
   console.log();
@@ -310,19 +398,20 @@ function cmdPublish(opts) {
   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(((clr(C.cyan, "  Publishing ") + clr(C.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();

package/src/self/sourcemap.js

@@ -1,3 +1,5 @@
+/* compiled from src/self/sourcemap.flux by Flux Lang */
+'use strict';
 // ── Flux stdlib ──
 
 function join(arr, sep) { return arr.join(sep != null ? sep : ','); }

package/src/self/stdlib.js

@@ -1,3 +1,5 @@
+/* compiled from src/self/stdlib.flux by Flux Lang */
+'use strict';
 // ── Flux stdlib ──
 
 function map(arr, fn) { return arr.map(fn); }

package/src/self/test-runner.js

@@ -1,3 +1,5 @@
+/* compiled from src/self/test-runner.flux by Flux Lang */
+'use strict';
 // ── Flux stdlib ──
 
 function map(arr, fn) { return arr.map(fn); }

package/src/self/transpiler.flux

@@ -24,7 +24,7 @@ fn _readFluxVersion():
     val pkgPath = Path.resolve(__dirname, "../../package.json")
     return JSON.parse(Fs.readFileSync(pkgPath, "utf8")).version
   catch(e):
-    return "4.0.7"
+    return "4.0.1"
 
 export val FLUX_VERSION = _readFluxVersion()
 export val FLUX_STAGE   = "self-hosted"

package/src/self/transpiler.js

@@ -1,4 +1,4 @@
-/* compiled from src/self/transpiler.flux */
+/* compiled from src/self/transpiler.flux by Flux Lang */
 'use strict';
 // Generated by Flux Transpiler v3.2.0
 "use strict";
@@ -18,7 +18,7 @@ function _readFluxVersion() {
     return JSON.parse(Fs.readFileSync(pkgPath, "utf8")).version;
   }
   catch (e) {
-    return "4.0.7";
+    return "4.0.1";
   }
 }
 const FLUX_VERSION = _readFluxVersion();

package/src/self/type-checker.js

@@ -1,3 +1,5 @@
+/* compiled from src/self/type-checker.flux by Flux Lang */
+'use strict';
 // ── Flux stdlib ──
 
 function map(arr, fn) { return arr.map(fn); }