@nanoforge-dev/cli 1.3.0 → 1.4.0

package/dist/nf.js

@@ -40,7 +40,7 @@ var require_package = __commonJS({
     module.exports = {
       $schema: "https://json.schemastore.org/package.json",
       name: "@nanoforge-dev/cli",
-      version: "1.3.0",
+      version: "1.4.0",
       description: "NanoForge CLI",
       keywords: [
         "nanoforge",
@@ -149,6 +149,110 @@ var require_package = __commonJS({
 import { program } from "commander";
 import "reflect-metadata";
 
+// src/lib/tree-kill/tree-kill.ts
+import { execSync, spawn } from "child_process";
+var treeKill = /* @__PURE__ */ __name((pid, signal) => {
+  function extracted(resolve4) {
+    const tree = {};
+    const pidsToProcess = {};
+    tree[pid] = [];
+    pidsToProcess[pid] = 1;
+    switch (process.platform) {
+      case "win32":
+        execSync("taskkill /pid " + pid + " /T /F");
+        resolve4();
+        break;
+      case "darwin":
+        buildProcessTree(
+          pid,
+          tree,
+          pidsToProcess,
+          function(parentPid) {
+            return spawn("pgrep", ["-P", parentPid]);
+          },
+          function() {
+            killAll(tree, signal);
+            resolve4();
+          }
+        );
+        break;
+      default:
+        buildProcessTree(
+          pid,
+          tree,
+          pidsToProcess,
+          function(parentPid) {
+            return spawn("ps", ["-o", "pid", "--no-headers", "--ppid", parentPid]);
+          },
+          function() {
+            killAll(tree, signal);
+            resolve4();
+          }
+        );
+        break;
+    }
+  }
+  __name(extracted, "extracted");
+  return new Promise((resolve4) => {
+    extracted(resolve4);
+  });
+}, "treeKill");
+function killAll(tree, signal) {
+  const killed = {};
+  Object.keys(tree).reverse().forEach(function(pidStr) {
+    const pid = Number(pidStr);
+    tree[pid]?.forEach(function(pidpid) {
+      if (!killed[pidpid]) {
+        killPid(pidpid, signal);
+        killed[pidpid] = true;
+      }
+    });
+    if (!killed[pid]) {
+      killPid(pid, signal);
+      killed[pid] = true;
+    }
+  });
+}
+__name(killAll, "killAll");
+function killPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (err) {
+    const e = err;
+    if (e.code !== "ESRCH") throw err;
+  }
+}
+__name(killPid, "killPid");
+function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+  const ps = spawnChildProcessesList(parentPid.toString());
+  let allData = "";
+  ps.stdout.on("data", function(data) {
+    allData += data.toString("ascii");
+  });
+  const onClose = /* @__PURE__ */ __name(function(code) {
+    delete pidsToProcess[parentPid];
+    if (code != 0) {
+      if (Object.keys(pidsToProcess).length == 0) {
+        cb();
+      }
+      return;
+    }
+    if (allData)
+      allData.match(/\d+/g)?.forEach(function(pid) {
+        const intPid = Number(pid);
+        if (tree[parentPid] === void 0) {
+          tree[parentPid] = [];
+        }
+        tree[parentPid].push(intPid);
+        tree[intPid] = [];
+        pidsToProcess[intPid] = 1;
+        buildProcessTree(intPid, tree, pidsToProcess, spawnChildProcessesList, cb);
+      });
+  }, "onClose");
+  ps.on("close", onClose);
+}
+__name(buildProcessTree, "buildProcessTree");
+
 // src/lib/utils/local-binaries.ts
 import { existsSync } from "fs";
 import { join, posix } from "path";
@@ -228,6 +332,11 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   NEW_SERVER_QUESTION: "Do you want to generate a server for multiplayer?",
   NEW_SKIP_INSTALL_QUESTION: "Do you want to skip dependency installation?",
   NEW_DOCKER_QUESTION: "Do you want to add a Dockerfile for containerization?",
+  // --- Create ---
+  CREATE_START: "NanoForge Component/System Creation",
+  CREATE_SUCCESS: success("Element successfully created!"),
+  CREATE_FAILED: failure("Creation failed!"),
+  CREATE_NAME_QUESTION: "What is the name of your component/system?",
   // --- Generate ---
   GENERATE_START: "NanoForge Generate",
   GENERATE_SUCCESS: success("Generation succeeded!"),
@@ -284,7 +393,7 @@ var getSpinner = /* @__PURE__ */ __name((message) => ora({ text: message }), "ge
 
 // src/action/actions/build.action.ts
 import { watch } from "chokidar";
-import { dirname, join as join4 } from "path";
+import { dirname, join as join5 } from "path";
 
 // src/lib/input/base-inputs.ts
 var getStringInput = /* @__PURE__ */ __name((input2, field) => {
@@ -333,21 +442,10 @@ var getConfigInput = /* @__PURE__ */ __name((inputs) => {
   return getStringInputWithDefault(inputs, "config", ".");
 }, "getConfigInput");
 
-// src/lib/input/inputs/watch.input.ts
-var getWatchInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInputWithDefault(inputs, "watch", false);
-}, "getWatchInput");
-
-// src/lib/input/inputs/dev/generate.input.ts
-var getDevGenerateInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInputWithDefault(inputs, "generate", false);
-}, "getDevGenerateInput");
-
-// src/lib/input/inputs/install/lib.input.ts
-function getInstallLibInput(inputs) {
-  return getBooleanInputWithDefault(inputs, "lib", false);
-}
-__name(getInstallLibInput, "getInstallLibInput");
+// src/lib/input/inputs/editor.input.ts
+var getEditorInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "editor", false);
+}, "getEditorInput");
 
 // src/lib/question/questions/confirm.question.ts
 import { confirm } from "@inquirer/prompts";
@@ -437,6 +535,66 @@ var askSelect = /* @__PURE__ */ __name(async (question, choices, baseOptions) =>
   }).catch(promptError);
 }, "askSelect");
 
+// src/lib/input/inputs/name.input.ts
+var getNameInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "name");
+}, "getNameInput");
+var getNewNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNameInput(inputs),
+    () => askInput(Messages.NEW_NAME_QUESTION, {
+      required: true,
+      default: "nanoforge-app"
+    })
+  );
+}, "getNewNameInputOrAsk");
+var getCreateNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNameInput(inputs),
+    () => askInput(Messages.CREATE_NAME_QUESTION, {
+      required: true,
+      default: "example"
+    })
+  );
+}, "getCreateNameInputOrAsk");
+
+// src/lib/input/inputs/path.input.ts
+var getPathInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "path");
+}, "getPathInput");
+var getPathInputWithDefault = /* @__PURE__ */ __name((inputs, defaultValue) => {
+  return getStringInputWithDefault(inputs, "path", defaultValue);
+}, "getPathInputWithDefault");
+
+// src/lib/input/inputs/server.input.ts
+function getServerInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "server", false);
+}
+__name(getServerInput, "getServerInput");
+
+// src/lib/input/inputs/watch.input.ts
+var getWatchInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "watch", false);
+}, "getWatchInput");
+
+// src/lib/input/inputs/create/type.input.ts
+var getCreateTypeInput = /* @__PURE__ */ __name((inputs) => {
+  const res = getStringInput(inputs, "type");
+  if (res && ["component", "system"].includes(res)) return res;
+  throw new Error("Invalid type. Please enter 'component' or 'system'.");
+}, "getCreateTypeInput");
+
+// src/lib/input/inputs/dev/generate.input.ts
+var getDevGenerateInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "generate", false);
+}, "getDevGenerateInput");
+
+// src/lib/input/inputs/install/lib.input.ts
+function getInstallLibInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "lib", false);
+}
+__name(getInstallLibInput, "getInstallLibInput");
+
 // src/lib/input/inputs/install/names.input.ts
 var getNamesInput = /* @__PURE__ */ __name((inputs) => {
   return getArrayInput(inputs, "names");
@@ -448,12 +606,6 @@ var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getInstallNamesInputOrAsk");
 
-// src/lib/input/inputs/install/server.input.ts
-function getInstallServerInput(inputs) {
-  return getBooleanInputWithDefault(inputs, "server", false);
-}
-__name(getInstallServerInput, "getInstallServerInput");
-
 // src/lib/input/inputs/login-out/api-key.input.ts
 var getApiKeyInput = /* @__PURE__ */ __name((inputs) => {
   return getStringInput(inputs, "apiKey");
@@ -507,20 +659,6 @@ var getNewLintInput = /* @__PURE__ */ __name((inputs) => {
   return getBooleanInputWithDefault(inputs, "lint", true);
 }, "getNewLintInput");
 
-// src/lib/input/inputs/new/name.input.ts
-var getNameInput = /* @__PURE__ */ __name((inputs) => {
-  return getStringInput(inputs, "name");
-}, "getNameInput");
-var getNewNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getNameInput(inputs),
-    () => askInput(Messages.NEW_NAME_QUESTION, {
-      required: true,
-      default: "nanoforge-app"
-    })
-  );
-}, "getNewNameInputOrAsk");
-
 // src/lib/input/inputs/new/package-manager.input.ts
 var getPackageManagerInput = /* @__PURE__ */ __name((inputs) => {
   return getStringInput(inputs, "packageManager");
@@ -538,11 +676,6 @@ var getNewPackageManagerInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getNewPackageManagerInputOrAsk");
 
-// src/lib/input/inputs/new/path.input.ts
-var getNewPathInput = /* @__PURE__ */ __name((inputs) => {
-  return getStringInput(inputs, "path");
-}, "getNewPathInput");
-
 // src/lib/input/inputs/new/server.input.ts
 var getNewServerInput = /* @__PURE__ */ __name((inputs) => {
   return getBooleanInput(inputs, "server");
@@ -645,6 +778,9 @@ var PackageManager = class {
     this.commands = commands;
     this.runner = runner;
   }
+  name;
+  commands;
+  runner;
   static {
     __name(this, "PackageManager");
   }
@@ -781,13 +917,15 @@ import { resolve as resolve2 } from "path";
 
 // src/lib/runner/runner.ts
 import { red as red4 } from "ansis";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import * as process2 from "process";
 var Runner = class {
   constructor(binary, baseArgs = []) {
     this.binary = binary;
     this.baseArgs = baseArgs;
   }
+  binary;
+  baseArgs;
   static {
     __name(this, "Runner");
   }
@@ -796,7 +934,7 @@ var Runner = class {
     const spawnOpts = this.buildSpawnOptions(collect, cwd2, env2);
     const fullArgs = [...this.baseArgs, ...args];
     return new Promise((resolve4, reject) => {
-      const child = spawn(`${this.binary} ${fullArgs.join(" ")}`, spawnOpts);
+      const child = spawn2(`${this.binary} ${fullArgs.join(" ")}`, spawnOpts);
       const output = this.attachOutputHandlers(child, listeners);
       child.on("close", (code) => {
         if (code === 0) {
@@ -992,6 +1130,21 @@ var PackageManagerFactory = class {
   }
 };
 
+// src/lib/utils/files.ts
+import fs3 from "fs";
+import { join as join3 } from "path";
+var copyFiles = /* @__PURE__ */ __name((from, to) => {
+  if (!fs3.existsSync(from)) return;
+  if (!fs3.existsSync(to)) throw new Error(`Directory ${to} does not exist`);
+  fs3.readdirSync(from, { recursive: true }).forEach((file) => {
+    fs3.copyFileSync(join3(from, file.toString()), join3(to, file.toString()));
+  });
+}, "copyFiles");
+var resetFolder = /* @__PURE__ */ __name((folder) => {
+  if (fs3.existsSync(folder)) fs3.rmSync(folder, { recursive: true, force: true });
+  fs3.mkdirSync(folder);
+}, "resetFolder");
+
 // src/lib/utils/run-safe.ts
 import { red as red5 } from "ansis";
 var runSafe = /* @__PURE__ */ __name(async (fn, fallback) => {
@@ -1011,42 +1164,77 @@ var BuildConfig = class {
   static {
     __name(this, "BuildConfig");
   }
-  entryFile;
-  outDir;
+  entry;
+  staticDir;
+};
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], BuildConfig.prototype, "entry", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], BuildConfig.prototype, "staticDir", 2);
+var EditorConfig = class {
+  static {
+    __name(this, "EditorConfig");
+  }
+  entry;
+  save;
 };
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], BuildConfig.prototype, "entryFile", 2);
+], EditorConfig.prototype, "entry", 2);
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], BuildConfig.prototype, "outDir", 2);
-var RunConfig = class {
+], EditorConfig.prototype, "save", 2);
+var DirsConfig = class {
   static {
-    __name(this, "RunConfig");
+    __name(this, "DirsConfig");
   }
-  dir;
+  components;
+  systems;
 };
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], RunConfig.prototype, "dir", 2);
+], DirsConfig.prototype, "components", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], DirsConfig.prototype, "systems", 2);
 var ClientConfig = class {
   static {
     __name(this, "ClientConfig");
   }
+  enable;
   port;
+  outDir;
   build;
-  runtime;
+  editor;
+  dirs;
 };
+__decorateClass([
+  Expose(),
+  IsBoolean()
+], ClientConfig.prototype, "enable", 2);
 __decorateClass([
   Expose(),
   IsPort()
 ], ClientConfig.prototype, "port", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], ClientConfig.prototype, "outDir", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -1054,21 +1242,33 @@ __decorateClass([
 ], ClientConfig.prototype, "build", 2);
 __decorateClass([
   Expose(),
-  Type(() => RunConfig),
+  Type(() => EditorConfig),
+  ValidateNested()
+], ClientConfig.prototype, "editor", 2);
+__decorateClass([
+  Expose(),
+  Type(() => DirsConfig),
   ValidateNested()
-], ClientConfig.prototype, "runtime", 2);
+], ClientConfig.prototype, "dirs", 2);
 var ServerConfig = class {
   static {
     __name(this, "ServerConfig");
   }
   enable;
+  outDir;
   build;
-  runtime;
+  editor;
+  dirs;
 };
 __decorateClass([
   Expose(),
   IsBoolean()
 ], ServerConfig.prototype, "enable", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], ServerConfig.prototype, "outDir", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -1076,9 +1276,14 @@ __decorateClass([
 ], ServerConfig.prototype, "build", 2);
 __decorateClass([
   Expose(),
-  Type(() => RunConfig),
+  Type(() => EditorConfig),
   ValidateNested()
-], ServerConfig.prototype, "runtime", 2);
+], ServerConfig.prototype, "editor", 2);
+__decorateClass([
+  Expose(),
+  Type(() => DirsConfig),
+  ValidateNested()
+], ServerConfig.prototype, "dirs", 2);
 var Config = class {
   static {
     __name(this, "Config");
@@ -1117,13 +1322,12 @@ __decorateClass([
 import { plainToInstance } from "class-transformer";
 import { validate } from "class-validator";
 import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/lib/constants.ts
 var CONFIG_FILE_NAME = "nanoforge.config.json";
 var MANIFEST_FILE_NAME = "nanoforge.manifest.json";
 var GLOBAL_CONFIG_FILE_NAME = ".nanoforgerc";
-var NANOFORGE_DIR = ".nanoforge";
 var REGISTRY_URL = "https://api.nanoforge.dev";
 
 // src/lib/utils/object.ts
@@ -1153,23 +1357,36 @@ var CONFIG_DEFAULTS = {
   language: "ts",
   initFunctions: true,
   client: {
+    enable: true,
     port: "3000",
+    outDir: ".nanoforge/client",
     build: {
-      entryFile: "client/main.ts",
-      outDir: ".nanoforge/client"
+      entry: "client/main.ts",
+      staticDir: "client/static"
     },
-    runtime: {
-      dir: ".nanoforge/client"
+    editor: {
+      entry: ".nanoforge/editor/client/main.ts",
+      save: ".nanoforge/client.save.json"
+    },
+    dirs: {
+      components: "client/components",
+      systems: "client/systems"
     }
   },
   server: {
     enable: false,
+    outDir: ".nanoforge/server",
     build: {
-      entryFile: "server/main.ts",
-      outDir: ".nanoforge/server"
+      entry: "server/main.ts",
+      staticDir: "server/static"
+    },
+    editor: {
+      entry: ".nanoforge/editor/server/main.ts",
+      save: ".nanoforge/server.save.json"
     },
-    runtime: {
-      dir: ".nanoforge/server"
+    dirs: {
+      components: "server/components",
+      systems: "server/systems"
     }
   }
 };
@@ -1178,23 +1395,23 @@ var CONFIG_DEFAULTS = {
 var config;
 var getConfigPath = /* @__PURE__ */ __name((directory, name) => {
   if (name) {
-    return join3(directory, name);
+    return join4(directory, name);
   } else {
     for (const n of [CONFIG_FILE_NAME]) {
-      const path = join3(directory, n);
+      const path = join4(directory, n);
       if (existsSync2(path)) return path;
     }
     throw new Error(`No config file found in directory: ${directory}`);
   }
 }, "getConfigPath");
-var loadConfig = /* @__PURE__ */ __name(async (directory, name) => {
+var loadConfig = /* @__PURE__ */ __name(async (directory, name, noThrow = false) => {
   if (config) return config;
   let rawData;
   const path = getConfigPath(directory, name);
   try {
     rawData = deepMerge(CONFIG_DEFAULTS, JSON.parse(readFileSync(path, "utf-8")));
   } catch {
-    rawData = null;
+    rawData = noThrow ? CONFIG_DEFAULTS : null;
   }
   if (!rawData) throw new Error(`Not able to read config file : ${path}`);
   const data = plainToInstance(Config, rawData, {
@@ -1209,8 +1426,8 @@ ${errors.toString().replace(/,/g, "\n")}`);
 }, "loadConfig");
 
 // src/action/common/config.ts
-var getConfig = /* @__PURE__ */ __name((inputs, dir) => {
-  return loadConfig(dir, getConfigInput(inputs));
+var getConfig = /* @__PURE__ */ __name((inputs, dir, noThrow) => {
+  return loadConfig(dir, getConfigInput(inputs), noThrow);
 }, "getConfig");
 
 // src/action/abstract.action.ts
@@ -1257,40 +1474,53 @@ var BuildAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
+    const isEditor = getEditorInput(options);
     const isWatch = getWatchInput(options);
-    const targets = this.resolveTargets(config2, options);
+    const targets = this.resolveTargets(config2, options, isEditor);
     const results = await this.buildAll(targets, directory, isWatch);
     if (isWatch) {
       return this.enterWatchMode();
     }
     return { success: results.every(Boolean) };
   }
-  resolveTargets(config2, options) {
-    const targets = [
-      this.createTarget(
-        "Client",
-        config2.client.build,
-        "browser",
-        getStringInput(options, "clientDirectory")
-      )
-    ];
-    if (config2.server.enable) {
+  resolveTargets(config2, options, isEditor) {
+    const targets = [];
+    if (config2.client.enable)
+      targets.push(
+        this.createTarget(
+          "Client",
+          "browser",
+          getStringInputWithDefault(
+            options,
+            "clientEntry",
+            !isEditor ? config2.client.build.entry : config2.client.editor.entry
+          ),
+          getStringInputWithDefault(options, "clientStaticDir", config2.client.build.staticDir),
+          getStringInputWithDefault(options, "clientOutDir", config2.client.outDir)
+        )
+      );
+    if (config2.server.enable)
       targets.push(
         this.createTarget(
           "Server",
-          config2.server.build,
           "node",
-          getStringInput(options, "serverDirectory")
+          getStringInputWithDefault(
+            options,
+            "serverEntry",
+            !isEditor ? config2.server.build.entry : config2.server.editor.entry
+          ),
+          getStringInputWithDefault(options, "serverStaticDir", config2.server.build.staticDir),
+          getStringInputWithDefault(options, "serverOutDir", config2.server.outDir)
         )
       );
-    }
     return targets;
   }
-  createTarget(name, config2, platform, outDirOverride) {
+  createTarget(name, platform, entryFile, staticDir, outDir) {
     return {
       name,
-      entry: config2.entryFile,
-      output: outDirOverride || config2.outDir,
+      entry: entryFile,
+      static: staticDir,
+      output: outDir,
       platform
     };
   }
@@ -1304,17 +1534,18 @@ var BuildAction = class extends AbstractAction {
   }
   async buildTarget(target, directory, isWatch) {
     const packageManager = PackageManagerFactory.create("local_bun" /* LOCAL_BUN */);
-    const executeBuild = /* @__PURE__ */ __name((rebuild = false) => runSafe(
-      () => packageManager.build(
+    const executeBuild = /* @__PURE__ */ __name((rebuild = false) => runSafe(() => {
+      this.resetOut(target.output, directory);
+      this.copyFiles(target, directory);
+      return packageManager.build(
         target.name,
         directory,
         target.entry,
         target.output,
         ["--asset-naming", "[name].[ext]", "--target", target.platform],
         rebuild
-      ),
-      false
-    ), "executeBuild");
+      );
+    }, false), "executeBuild");
     if (isWatch) {
       this.watchDirectory(directory, target.entry, () => executeBuild(true));
     }
@@ -1322,7 +1553,7 @@ var BuildAction = class extends AbstractAction {
     return result !== false;
   }
   watchDirectory(directory, entry, onChange) {
-    const watchPath = dirname(join4(getCwd(directory), entry));
+    const watchPath = dirname(join5(getCwd(directory), entry));
     watch(watchPath).on("change", onChange);
   }
   enterWatchMode() {
@@ -1331,43 +1562,16 @@ var BuildAction = class extends AbstractAction {
     console.info();
     return { keepAlive: true };
   }
-};
-
-// src/action/actions/dev.action.ts
-var DevAction = class extends AbstractAction {
-  static {
-    __name(this, "DevAction");
+  resetOut(outDir, directory) {
+    resetFolder(getCwd(join5(directory, outDir)));
   }
-  startMessage = Messages.DEV_START;
-  successMessage = Messages.DEV_SUCCESS;
-  failureMessage = Messages.DEV_FAILED;
-  async handle(_args, options) {
-    const directory = getDirectoryInput(options);
-    const generate = getDevGenerateInput(options);
-    const tasks = this.buildTaskList(directory, generate);
-    await Promise.all(tasks);
-    return { keepAlive: true };
-  }
-  buildTaskList(directory, generate) {
-    const tasks = [];
-    if (generate) {
-      tasks.push(this.runSubCommand("generate", directory, { silent: true }));
-    }
-    tasks.push(this.runSubCommand("build", directory, { silent: true }));
-    tasks.push(this.runSubCommand("start", directory, { silent: false }));
-    return tasks;
-  }
-  async runSubCommand(command, directory, options) {
-    await runSafe(async () => {
-      const packageManager = await PackageManagerFactory.find(directory);
-      await packageManager.runDev(directory, "nf", {}, [command, "--watch"], options.silent);
-    });
+  copyFiles(target, directory) {
+    const from = getCwd(join5(directory, target.static));
+    const to = getCwd(join5(directory, target.output));
+    copyFiles(from, to);
   }
 };
 
-// src/action/actions/generate.action.ts
-import { join as join5 } from "path";
-
 // src/lib/schematics/abstract.collection.ts
 var AbstractCollection = class {
   constructor(collection, runner, cwd2) {
@@ -1375,6 +1579,9 @@ var AbstractCollection = class {
     this.runner = runner;
     this.cwd = cwd2;
   }
+  collection;
+  runner;
+  cwd;
   static {
     __name(this, "AbstractCollection");
   }
@@ -1424,6 +1631,16 @@ var NanoforgeCollection = class _NanoforgeCollection extends AbstractCollection
       name: "docker",
       alias: "docker",
       description: "Generate a Dockerfile for the application"
+    },
+    {
+      name: "component",
+      alias: "component",
+      description: "Generate a Component for an application"
+    },
+    {
+      name: "system",
+      alias: "system",
+      description: "Generate a System for an application"
     }
   ];
   constructor(runner, cwd2) {
@@ -1467,6 +1684,7 @@ var CollectionFactory = class {
 var toKebabCase = /* @__PURE__ */ __name((str) => {
   return str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
 }, "toKebabCase");
+var capitalize = /* @__PURE__ */ __name((str) => str.charAt(0).toUpperCase() + str.slice(1), "capitalize");
 
 // src/lib/schematics/schematic.option.ts
 var SchematicOption = class {
@@ -1474,6 +1692,8 @@ var SchematicOption = class {
     this.name = name;
     this.value = value;
   }
+  name;
+  value;
   static {
     __name(this, "SchematicOption");
   }
@@ -1544,7 +1764,72 @@ var mapSchematicOptions = /* @__PURE__ */ __name((inputs) => {
   }, []);
 }, "mapSchematicOptions");
 
+// src/action/actions/create.action.ts
+var CreateAction = class extends AbstractAction {
+  static {
+    __name(this, "CreateAction");
+  }
+  startMessage = Messages.CREATE_START;
+  successMessage = Messages.CREATE_SUCCESS;
+  failureMessage = Messages.CREATE_FAILED;
+  async handle(args, options) {
+    const directory = getDirectoryInput(options);
+    const config2 = await getConfig(options, directory, true);
+    const type = getCreateTypeInput(args);
+    const name = await getCreateNameInputOrAsk(options);
+    const isServer = getServerInput(options);
+    const path = getPathInputWithDefault(
+      options,
+      config2[isServer ? "server" : "client"].dirs[type === "component" ? "components" : "systems"]
+    );
+    await this.generateElement(directory, type, {
+      name,
+      directory: path,
+      part: isServer ? "server" : "client",
+      language: config2.language
+    });
+    return {};
+  }
+  async generateElement(directory, type, values) {
+    const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
+    await executeSchematic(capitalize(type), collection, type, values);
+  }
+};
+
+// src/action/actions/dev.action.ts
+var DevAction = class extends AbstractAction {
+  static {
+    __name(this, "DevAction");
+  }
+  startMessage = Messages.DEV_START;
+  successMessage = Messages.DEV_SUCCESS;
+  failureMessage = Messages.DEV_FAILED;
+  async handle(_args, options) {
+    const directory = getDirectoryInput(options);
+    const generate = getDevGenerateInput(options);
+    const tasks = this.buildTaskList(directory, generate);
+    await Promise.all(tasks);
+    return { keepAlive: true };
+  }
+  buildTaskList(directory, generate) {
+    const tasks = [];
+    if (generate) {
+      tasks.push(this.runSubCommand("generate", directory, { silent: true }));
+    }
+    tasks.push(this.runSubCommand("build", directory, { silent: true }));
+    tasks.push(this.runSubCommand("start", directory, { silent: false }));
+    return tasks;
+  }
+  async runSubCommand(command, directory, options) {
+    await runSafe(async () => {
+      const packageManager = await PackageManagerFactory.find(directory);
+      await packageManager.runDev(directory, "nf", {}, [command, "--watch"], options.silent);
+    });
+  }
+};
+
 // src/action/actions/generate.action.ts
+import { join as join6 } from "path";
 var GenerateAction = class extends AbstractAction {
   static {
     __name(this, "GenerateAction");
@@ -1555,9 +1840,9 @@ var GenerateAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
+    const isEditor = getEditorInput(options);
     const isWatch = getWatchInput(options);
-    const values = this.extractValues(config2);
-    await this.generateParts(values, directory, isWatch);
+    await this.generateParts(config2, directory, isEditor, isWatch);
     if (isWatch) {
       return this.enterWatchMode();
     }
@@ -1565,43 +1850,45 @@ var GenerateAction = class extends AbstractAction {
   }
   extractValues(config2) {
     return {
-      name: config2.name,
       directory: ".",
       language: config2.language,
-      server: config2.server.enable,
       initFunctions: config2.initFunctions
     };
   }
-  async generateParts(values, directory, watch3) {
+  async generateParts(config2, directory, isEditor, watch3) {
     const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
-    const baseOptions = this.baseSchematicOptions(values);
-    await executeSchematic(
-      "Client main file",
-      collection,
-      "part-main",
-      { ...baseOptions, part: "client" },
-      watch3 ? this.watchPath(directory, values.directory, "client") : void 0
-    );
-    if (values.server) {
+    const values = this.extractValues(config2);
+    if (config2.client.enable)
+      await executeSchematic(
+        "Client main file",
+        collection,
+        "part-main",
+        {
+          ...values,
+          part: "client",
+          outFile: !isEditor ? config2.client.build.entry : config2.client.editor.entry,
+          saveFile: config2.client.editor.save,
+          editor: isEditor
+        },
+        watch3 ? this.watchPath(directory, values.directory, config2.client.editor.save) : void 0
+      );
+    if (config2.server.enable)
       await executeSchematic(
         "Server main file",
         collection,
         "part-main",
-        { ...baseOptions, part: "server" },
-        this.watchPath(directory, values.directory, "server")
+        {
+          ...values,
+          part: "server",
+          outFile: !isEditor ? config2.server.build.entry : config2.server.editor.entry,
+          saveFile: config2.server.editor.save,
+          editor: isEditor
+        },
+        this.watchPath(directory, values.directory, config2.server.editor.save)
       );
-    }
   }
-  baseSchematicOptions(values) {
-    return {
-      name: values.name,
-      directory: values.directory,
-      language: values.language,
-      initFunctions: values.initFunctions
-    };
-  }
-  watchPath(directory, subDir, part) {
-    return join5(getCwd(directory), subDir, NANOFORGE_DIR, `${part}.save.json`);
+  watchPath(directory, subDir, saveFile) {
+    return join6(getCwd(directory), subDir, saveFile);
   }
   enterWatchMode() {
     console.info();
@@ -1612,7 +1899,7 @@ var GenerateAction = class extends AbstractAction {
 };
 
 // src/action/actions/install.action.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/lib/global-config/global-config-handler.ts
 import { read, readUser, write, writeUser } from "rc9";
@@ -1855,8 +2142,8 @@ var concatDeps = /* @__PURE__ */ __name((deps) => {
 }, "concatDeps");
 
 // src/lib/registry/registry.ts
-import fs3 from "fs";
-import { join as join6 } from "path";
+import fs4 from "fs";
+import { join as join7 } from "path";
 var Registry = class {
   static {
     __name(this, "Registry");
@@ -1887,9 +2174,9 @@ var Registry = class {
   }
   static async installPackage(client2, manifest, dir) {
     const file = await client2.getFile(`/registry/${manifest.name}/-/${manifest._file}`);
-    const path = join6(dir, this.getTypeSubFolder(manifest.type));
-    fs3.mkdirSync(path, { recursive: true });
-    fs3.writeFileSync(join6(path, manifest._file), await file.bytes());
+    const path = join7(dir, this.getTypeSubFolder(manifest.type));
+    fs4.mkdirSync(path, { recursive: true });
+    fs4.writeFileSync(join7(path, manifest._file), await file.bytes());
   }
   static getTypeSubFolder(type) {
     if (type === "component") return "components";
@@ -1901,14 +2188,14 @@ var Registry = class {
     return withAuth(config2.apiKey, force, !headers ? {} : void 0);
   }
   static _getPackageFile(filename, dir) {
-    const path = join6(getCwd(dir ?? "."), filename);
-    if (!fs3.existsSync(path))
+    const path = join7(getCwd(dir ?? "."), filename);
+    if (!fs4.existsSync(path))
       throw new Error(
-        "Package not found, please specify path in the nanoforge.manifest.json : `publish.paths.components`!"
+        "Package not found, please specify path in the nanoforge.manifest.json : `publish.paths.package`!"
       );
     try {
-      fs3.accessSync(path, fs3.constants.R_OK);
-      return fs3.openAsBlob(path);
+      fs4.accessSync(path, fs4.constants.R_OK);
+      return fs4.openAsBlob(path);
     } catch {
       throw new Error("Cannot read package file, please verify your file permissions!");
     }
@@ -1927,7 +2214,7 @@ var InstallAction = class extends AbstractAction {
     const names = await getInstallNamesInputOrAsk(args);
     const directory = getDirectoryInput(options);
     const isLib = getInstallLibInput(options);
-    const isServer = getInstallServerInput(options);
+    const isServer = getServerInput(options);
     return isLib ? this._installLibs(directory, names) : this._installNfPackages(directory, names, isServer);
   }
   async _installLibs(directory, names) {
@@ -1944,7 +2231,7 @@ var InstallAction = class extends AbstractAction {
     return withSpinner(Messages.INSTALL_PACKAGES_IN_PROGRESS, async () => {
       await Registry.install(
         Object.values(deps.nf),
-        join7(directory, isServer ? "server" : "client")
+        join8(directory, isServer ? "server" : "client")
       );
     });
   }
@@ -1997,7 +2284,7 @@ var LogoutAction = class extends AbstractAction {
 };
 
 // src/action/actions/new.action.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var NewAction = class extends AbstractAction {
   static {
     __name(this, "NewAction");
@@ -2013,7 +2300,7 @@ var NewAction = class extends AbstractAction {
     if (!values.skipInstall) {
       res = await this.installDependencies(
         values.packageManager,
-        join8(cwdDirectory, values.directory ?? values.name)
+        join9(cwdDirectory, values.directory ?? values.name)
       );
     }
     return { success: res };
@@ -2021,7 +2308,7 @@ var NewAction = class extends AbstractAction {
   async collectValues(inputs) {
     return {
       name: await getNewNameInputOrAsk(inputs),
-      directory: getNewPathInput(inputs),
+      directory: getPathInput(inputs),
       packageManager: await getNewPackageManagerInputOrAsk(inputs),
       language: await getNewLanguageInputOrAsk(inputs),
       strict: await getNewStrictOrAsk(inputs),
@@ -2029,7 +2316,8 @@ var NewAction = class extends AbstractAction {
       initFunctions: getNewInitFunctionsWithDefault(inputs),
       skipInstall: await getNewSkipInstallOrAsk(inputs),
       docker: await getNewDockerOrAsk(inputs),
-      lint: getNewLintInput(inputs)
+      lint: getNewLintInput(inputs),
+      editor: getEditorInput(inputs)
     };
   }
   async scaffold(values, directory) {
@@ -2052,14 +2340,17 @@ var NewAction = class extends AbstractAction {
       language: values.language,
       strict: values.strict,
       server: values.server,
-      lint: values.lint
+      lint: values.lint,
+      editor: values.editor
     });
   }
   generateConfiguration(collection, values) {
     return executeSchematic("Configuration", collection, "configuration", {
       name: values.name,
-      directory: values.directory,
-      server: values.server
+      directory: values.directory ?? values.name,
+      server: values.server,
+      language: values.language,
+      initFunctions: values.initFunctions
     });
   }
   async generateClientParts(collection, values) {
@@ -2068,7 +2359,9 @@ var NewAction = class extends AbstractAction {
       ...partOptions,
       server: values.server
     });
-    await executeSchematic("Client main file", collection, "part-main", partOptions);
+    await executeSchematic("Client main file", collection, "part-main", {
+      ...partOptions
+    });
   }
   async generateServerParts(collection, values) {
     const partOptions = this.partOptions(values, "server");
@@ -2076,20 +2369,20 @@ var NewAction = class extends AbstractAction {
       ...partOptions,
       server: values.server
     });
-    await executeSchematic("Server main file", collection, "part-main", partOptions);
+    await executeSchematic("Server main file", collection, "part-main", {
+      ...partOptions
+    });
   }
   async generateDocker(collection, values) {
     await executeSchematic("Docker", collection, "docker", {
-      name: values.name,
-      directory: values.directory,
+      directory: values.directory ?? values.name,
       packageManager: values.packageManager
     });
   }
   partOptions(values, part) {
     return {
-      name: values.name,
       part,
-      directory: values.directory,
+      directory: values.directory ?? values.name,
       language: values.language,
       initFunctions: values.initFunctions
     };
@@ -2147,6 +2440,7 @@ var Manifest = class {
   name;
   type;
   description;
+  tags;
   dependencies;
   publish;
   npmDependencies;
@@ -2168,6 +2462,11 @@ __decorateClass([
   IsString2(),
   IsOptional()
 ], Manifest.prototype, "description", 2);
+__decorateClass([
+  Expose2(),
+  IsString2({ each: true }),
+  IsOptional()
+], Manifest.prototype, "tags", 2);
 __decorateClass([
   Expose2(),
   IsString2({ each: true }),
@@ -2190,10 +2489,10 @@ __decorateClass([
 import { plainToInstance as plainToInstance2 } from "class-transformer";
 import { validate as validate2 } from "class-validator";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var getManifestPath = /* @__PURE__ */ __name((directory) => {
   for (const n of [MANIFEST_FILE_NAME]) {
-    const path = join9(directory, n);
+    const path = join10(directory, n);
     if (existsSync3(path)) return path;
   }
   throw new Error(`No manifest file found in directory: ${directory}`);
@@ -2236,7 +2535,7 @@ var PublishAction = class extends AbstractAction {
 
 // src/action/actions/start.action.ts
 import dotenv from "dotenv";
-import { join as join10, resolve as resolve3 } from "path";
+import { join as join11, resolve as resolve3 } from "path";
 var StartAction = class extends AbstractAction {
   static {
     __name(this, "StartAction");
@@ -2247,10 +2546,18 @@ var StartAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
+    const clientDir = getStringInputWithDefault(options, "clientDir", config2.client.outDir);
+    const serverDir = getStringInputWithDefault(options, "serverDir", config2.server.outDir);
     const watch3 = getWatchInput(options);
     const port = getStringInputWithDefault(options, "port", config2.client.port);
     const ssl = this.resolveSSL(options);
-    const tasks = this.buildStartTasks(config2, directory, watch3, port, ssl);
+    const tasks = this.buildStartTasks(config2, directory, {
+      clientDir,
+      serverDir,
+      watch: watch3,
+      port,
+      ssl
+    });
     await Promise.all(tasks);
     return { keepAlive: true };
   }
@@ -2265,13 +2572,16 @@ var StartAction = class extends AbstractAction {
       key
     };
   }
-  buildStartTasks(config2, directory, watch3, port, ssl) {
+  buildStartTasks(config2, directory, options) {
     const env2 = this.parseEnv(directory);
     const tasks = [];
-    if (config2.server.enable) {
-      tasks.push(this.startServer(directory, config2, { watch: watch3 }, env2));
-    }
-    tasks.push(this.startClient(directory, config2, { watch: watch3, port, ssl }, env2));
+    const { clientDir, serverDir, watch: watch3, port, ssl } = options;
+    if (config2.server.enable)
+      tasks.push(this.startServer(directory, config2, { serverDir, watch: watch3 }, env2));
+    if (config2.client.enable)
+      tasks.push(
+        this.startClient(directory, config2, { clientDir, serverDir, watch: watch3, port, ssl }, env2)
+      );
     return tasks;
   }
   async startClient(directory, config2, options, env2) {
@@ -2286,14 +2596,14 @@ var StartAction = class extends AbstractAction {
   }
   buildClientParams(directory, config2, options) {
     const params = {
-      "-d": getCwd(join10(directory, config2.client.runtime.dir)),
+      "-d": getCwd(join11(directory, options.clientDir)),
       "-p": options.port
     };
     if (options.watch) params["--watch"] = true;
     if (options.watch) {
       params["--watch"] = true;
       if (config2.server.enable) {
-        params["--watch-server-dir"] = getCwd(join10(directory, config2.server.runtime.dir));
+        params["--watch-server-dir"] = getCwd(join11(directory, options.serverDir));
       }
     }
     if (options.ssl) {
@@ -2302,9 +2612,9 @@ var StartAction = class extends AbstractAction {
     }
     return this.buildParams(params);
   }
-  buildServerParams(directory, config2, options) {
+  buildServerParams(directory, _config, options) {
     const params = {
-      "-d": getCwd(join10(directory, config2.server.runtime.dir))
+      "-d": getCwd(join11(directory, options.serverDir))
     };
     if (options.watch) params["--watch"] = true;
     return this.buildParams(params);
@@ -2320,7 +2630,7 @@ var StartAction = class extends AbstractAction {
       ...process.env
     };
     dotenv.config({
-      path: resolve3(getCwd(join10(dir, ".env"))),
+      path: resolve3(getCwd(join11(dir, ".env"))),
       processEnv: rawEnv
     });
     const baseEnv = Object.entries(rawEnv).filter(
@@ -2365,6 +2675,7 @@ var AbstractCommand = class {
   constructor(action) {
     this.action = action;
   }
+  action;
   static {
     __name(this, "AbstractCommand");
   }
@@ -2383,12 +2694,17 @@ var BuildCommand = class extends AbstractCommand {
     __name(this, "BuildCommand");
   }
   load(program2) {
-    program2.command("build").description("build your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--client-outDir [clientDirectory]", "specify the output directory of the client").option("--server-outDir [serverDirectory]", "specify the output directory of the server").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
+    program2.command("build").description("build your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--client-entry [clientEntry]", "specify the entry file of the client").option("--server-entry [serverEntry]", "specify the entry file of the server").option("--client-static-dir [clientStaticDir]", "specify the static directory of the client").option("--server-static-dir [serverStaticDir]", "specify the static directory of the server").option("--client-out-dir [clientOutDir]", "specify the output directory of the client").option("--server-out-dir [serverOutDir]", "specify the output directory of the server").option("--editor", "specify if the project must build with editor config").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
-        clientDirectory: rawOptions.clientOutDir,
-        serverDirectory: rawOptions.serverOutDir,
+        clientEntry: rawOptions.clientEntry,
+        serverEntry: rawOptions.serverEntry,
+        clientStaticDir: rawOptions.clientStaticDir,
+        serverStaticDir: rawOptions.serverStaticDir,
+        clientOutDir: rawOptions.clientOutDir,
+        serverOutDir: rawOptions.serverOutDir,
+        editor: rawOptions.editor,
         watch: rawOptions.watch
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
@@ -2396,6 +2712,35 @@ var BuildCommand = class extends AbstractCommand {
   }
 };
 
+// src/command/commands/create.command.ts
+var CreateCommand = class extends AbstractCommand {
+  static {
+    __name(this, "CreateCommand");
+  }
+  load(program2) {
+    program2.command("create [type]").description("create nanoforge components or systems").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-n, --name [name]", "name of the component/system").option(
+      "-s, --server",
+      "install components/systems on server (default install on client)",
+      false
+    ).option(
+      "-p, --path [path]",
+      "path to the component/system folder (default: [part]/<components|systems>)"
+    ).action(async (type, rawOptions) => {
+      const args = AbstractCommand.mapToInput({
+        type
+      });
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        config: rawOptions.config,
+        name: rawOptions.name,
+        server: rawOptions.server,
+        path: rawOptions.path
+      });
+      await this.action.run(args, options);
+    });
+  }
+};
+
 // src/command/commands/dev.command.ts
 var DevCommand = class extends AbstractCommand {
   static {
@@ -2419,10 +2764,11 @@ var GenerateCommand = class extends AbstractCommand {
     __name(this, "GenerateCommand");
   }
   load(program2) {
-    program2.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
+    program2.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--editor", "specify if the project must generate editor main file").option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
+        editor: rawOptions.editor,
         watch: rawOptions.watch
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
@@ -2496,7 +2842,7 @@ var NewCommand = class extends AbstractCommand {
     program2.command("new").description("create a new nanoforge project").option("-d, --directory [directory]", "specify the working directory of the command").option("--name [name]", "specify the name of your project").option(
       "--path [path]",
       "specify the relative path where your project will be created (default: name of the project)"
-    ).option("--package-manager [packageManager]", "specify the package manager of your project").option("--language [language]", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").option("--no-lint", "do not generate lint files").action(async (rawOptions) => {
+    ).option("--package-manager [packageManager]", "specify the package manager of your project").option("--language [language]", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").option("--no-lint", "do not generate lint files").option("--editor", "do add editor dependencies").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         name: rawOptions.name,
@@ -2508,7 +2854,8 @@ var NewCommand = class extends AbstractCommand {
         initFunctions: rawOptions.initFunctions,
         skipInstall: rawOptions.skipInstall,
         docker: rawOptions.docker,
-        lint: rawOptions.lint
+        lint: rawOptions.lint,
+        editor: rawOptions.editor
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
     });
@@ -2536,11 +2883,13 @@ var StartCommand = class extends AbstractCommand {
     __name(this, "StartCommand");
   }
   load(program2) {
-    program2.command("start").description("start your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-p, --port [port]", "specify the port of the loader (the website to load the game)").option("--watch", "run app in watching mode", false).option("--cert [cert]", "path to the SSL certificate for HTTPS").option("--key [key]", "path to the SSL key for HTTPS").action(async (rawOptions) => {
+    program2.command("start").description("start your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-p, --port [port]", "specify the port of the loader (the website to load the game)").option("--client-dir [clientDirectory]", "specify the directory of the client").option("--server-dir [serverDirectory]", "specify the directory of the server").option("--watch", "run app in watching mode", false).option("--cert [cert]", "path to the SSL certificate for HTTPS").option("--key [key]", "path to the SSL key for HTTPS").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
         port: rawOptions.port,
+        clientDir: rawOptions.clientDir,
+        serverDir: rawOptions.serverDir,
         watch: rawOptions.watch,
         cert: rawOptions.cert,
         key: rawOptions.key
@@ -2577,6 +2926,7 @@ var CommandLoader = class {
     new StartCommand(new StartAction()).load(program2);
     new DevCommand(new DevAction()).load(program2);
     new GenerateCommand(new GenerateAction()).load(program2);
+    new CreateCommand(new CreateAction()).load(program2);
     new LoginCommand(new LoginAction()).load(program2);
     new LogoutCommand(new LogoutAction()).load(program2);
     new PublishCommand(new PublishAction()).load(program2);
@@ -2596,6 +2946,14 @@ ${Prefixes.ERROR} Invalid command: ${red6`%s`}`, program2.args.join(" "));
 
 // src/bin/nf.ts
 var bootstrap = /* @__PURE__ */ __name(async () => {
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT", "SIGBREAK"];
+  signals.forEach((signal) => {
+    const listener = /* @__PURE__ */ __name(async () => {
+      process.off(signal, listener);
+      await treeKill(process.pid, signal);
+    }, "listener");
+    process.on(signal, listener);
+  });
   program.version(
     (await Promise.resolve().then(() => __toESM(require_package(), 1))).version ?? "unknown",
     "-v, --version",