@milkio/astra 1.0.0-alpha.1 → 1.0.0-alpha.100

package/index.ts

@@ -9,7 +9,7 @@ import { format } from "date-fns";
 import type { CookbookOptions } from "./utils/cookbook-dto-types";
 
 export type AstraOptionsInit = {
-  stargate: { $types: any; execute: any; ping: any; cookbook: any };
+  stargate: { $types: any; execute: any; ping: any; __cookbook: any };
   bootstrap: () => Promise<Record<string, any>>;
 };
 
@@ -41,9 +41,9 @@ type Log = [string /* executeId */, "[DEBUG]" | "[INFO]" | "[WARN]" | "[ERROR]"
 
 type Reject = (description: string, ...params: Array<unknown>) => Error;
 
-export const createAstra = async <AstraOptions extends AstraOptionsInit, Generated extends AstraOptions["stargate"]["$types"]["generated"]>(astraOptions: AstraOptions) => {
+export async function createAstra<AstraOptions extends AstraOptionsInit, Generated extends AstraOptions["stargate"]["$types"]["generated"]>(astraOptions: AstraOptions) {
   if (!existsSync(join(cwd(), "cookbook.toml"))) throw new Error(`The "cookbook.toml" file does not exist in the current directory. If you are running the test with the VS Code extension, make sure it exists in the root directory of the folder you are opening with VS Code.`);
-  let cookbookOptions = load((await readFile(join(cwd(), "cookbook.toml"))).toString()) as CookbookOptions;
+  const cookbookOptions = load((await readFile(join(cwd(), "cookbook.toml"))).toString()) as CookbookOptions;
   // wait for all milkio projects to start and can be accessed
   // the reason why stargate's ping method is not used directly is that even if only one project is tested, it is necessary to wait for all milkio projects to start
   await Promise.all([
@@ -53,7 +53,7 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
         const project = cookbookOptions.projects[projectName];
         if (project.type !== "milkio") continue;
         projectStatus.set(projectName, withResolvers());
-        let counter = 256;
+        let counter = 65;
         let timer: Timer | null = setInterval(async () => {
           if (--counter <= 0) {
             clearInterval(timer!);
@@ -63,6 +63,7 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
             return;
           }
           try {
+            console.log("\n[ASTRA]", `connecting.. ${counter >= 64 ? "" : `(${counter})`}`);
             const response = await fetchWithTimeout(`http://localhost:${project.port}/generate_204`, { method: "HEAD", timeout: 1024 });
             if (response.status === 204) {
               if (timer) clearTimeout(timer);
@@ -70,30 +71,30 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
               return projectStatus.get(projectName)!.resolve(undefined);
             }
           } catch (error) {}
-        }, 42);
+        }, 100);
       }
       return Array.from(projectStatus.values()).map((v) => v.promise);
     })(),
   ]);
 
-  type Execute = <Path extends keyof Generated["routeSchema"]["$types"]>(
+  type Execute = <Path extends keyof Generated["routeSchema"]>(
     path: Path,
     options?: Mixin<
       ExecuteOptions,
       | {
-          params?: Generated["routeSchema"]["$types"][Path]["params"];
+          params?: Generated["routeSchema"][Path]["types"]["params"];
         }
       | {
-          params?: Partial<Generated["routeSchema"]["$types"][Path]["params"]>;
+          params?: Partial<Generated["routeSchema"][Path]["types"]["params"]>;
           generateParams: true;
         }
     >,
   ) => Promise<
-    Generated["routeSchema"]["$types"][Path]["🐣"] extends boolean
+    Generated["routeSchema"][Path]["types"]["🐣"] extends boolean
       ? // action
-        [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, Generated["routeSchema"]["$types"][Path]["result"], ExecuteResultsOption]
+        [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, Generated["routeSchema"][Path]["types"]["result"], ExecuteResultsOption]
       : // stream
-        [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated["rejectCode"]>, null] | [null, GeneratorGeneric<Generated["routeSchema"]["$types"][Path]["result"]>], ExecuteResultsOption>]
+        [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated["rejectCode"]>, null] | [null, GeneratorGeneric<Generated["routeSchema"][Path]["types"]["result"]>], ExecuteResultsOption>]
   >;
 
   type MirrorWorld = Mixin<
@@ -110,7 +111,7 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
       const thisFilePath = join(fileURLToPath(importMetaUrl));
       const thisFileDirPath = join(dirname(thisFilePath)).replaceAll("\\", "/");
       const thisFileDirPathArr = thisFileDirPath.split("/");
-      let projectName: string = "";
+      let projectName = "";
 
       await (async () => {
         let isProjectsDirectory = false;
@@ -137,17 +138,17 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
       const paths = {
         cwd: join(cwd(), "projects", projectName),
         milkio: join(cwd(), "projects", projectName, ".milkio"),
-        generated: join(cwd(), "projects", projectName, ".milkio", "generated"),
+        generated: join(cwd(), "projects", projectName, ".milkio"),
       };
 
       const execute = async (path: Parameters<MirrorWorld["execute"]>[0], optionsInit?: Parameters<MirrorWorld["execute"]>[1]) => {
-        let options = (optionsInit as any) ?? {};
+        const options = (optionsInit as any) ?? {};
         if (options?.generateParams === true) {
           if (!options?.params) options.params = {};
           options.params.$milkioGenerateParams = "enable";
         }
 
-        const results = await this.options.stargate.cookbook.subscribe(`http://localhost:${cookbookOptions.general.cookbookPort}`);
+        const results = await this.options.stargate.__cookbook.subscribe(`http://localhost:${cookbookOptions.general.cookbookPort}`);
         void (async () => {
           for await (const result of results) {
             if (result.type !== "milkio@logger") continue;
@@ -165,6 +166,7 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
 
       const getNow = () => format(new Date(), "(yyyy-MM-dd hh:mm:ss)");
       const onLoggerInserting = (log: Log) => {
+        // biome-ignore lint/style/noParameterAssign: <explanation>
         log = [...log];
         log[0] = `\n${log[0]}` as any;
         console.log(...log);
@@ -208,15 +210,21 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
       } as any;
 
       const reject = (...params: Array<unknown>): Error => {
-        const output: Array<any> = ["[REJECT]", ...params];
+        const output: Array<any> = [
+          "[REJECT]",
+          ...params.map((param) => {
+            try {
+              const result = TSON.stringify(param);
+              return result;
+            } catch (error) {
+              return error?.toString?.() ?? typeof error;
+            }
+          }),
+        ];
         console.log(...output);
         for (let index = 1; index < output.length; index++) {
-          if (output[index] !== null && typeof output[index] === "object") {
-            if (output[index] instanceof Error || (output[index].message && output[index].stack)) {
-              output[index] = output[index].toString();
-            } else {
-              output[index] = TSON.stringify(output[index]);
-            }
+          if (typeof output[index] === "object") {
+            output[index] = output[index].toString();
           }
         }
         const message = output.join(" ");
@@ -226,7 +234,7 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
       return [context, reject, world];
     },
   };
-};
+}
 
 export async function fetchWithTimeout(url: string, options: FetchRequestInit & { timeout?: number } = {}) {
   const { timeout = 8000 } = options;

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "@milkio/astra",
-  "module": "index.ts",
-  "version": "1.0.0-alpha.1",
   "type": "module",
-  "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "5.6.0"
-  },
+  "version": "1.0.0-alpha.100",
+  "module": "index.ts",
   "dependencies": {
-    "@southern-aurora/tson": "^2.0.2",
+    "@southern-aurora/tson": "*",
     "date-fns": "^4.1.0",
     "js-toml": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
   }
 }

package/tsconfig.json

@@ -1,27 +1,28 @@
 {
   "compilerOptions": {
+    "target": "ESNext",
+    "jsx": "react-jsx",
+    "erasableSyntaxOnly":true,
     // Enable latest features
     "lib": ["ESNext", "DOM"],
-    "target": "ESNext",
-    "module": "ESNext",
     "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
+    "module": "ESNext",
 
     // Bundler mode
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
+    "allowJs": true,
 
     // Best practices
     "strict": true,
-    "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
 
+    "noPropertyAccessFromIndexSignature": false,
     // Some stricter flags (disabled by default)
     "noUnusedLocals": false,
     "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
+    "noEmit": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
   }
 }

package/utils/cookbook-dto-checks.ts

@@ -1,11 +1,14 @@
 /**
-* The content of this file is automatically generated by Typia.
-* It can be edited in the /packages/cookbook-dto/src/* file, and each time you run bun run dev, the generated file will be synced to another location based on the content of the /develop.ts.
-*/
+  * The content of this file is automatically generated by Typia.
+  * It can be edited in the /packages/cookbook-dto/src/* file, and each time you run bun run dev, the generated file will be synced to another location based on the content of the /develop.ts.
+  */
 
-import typia from "typia";
-import type { CookbookActionParams, CookbookOptions, CookbookSubscribeEmits } from "./cookbook-dto-types";
-export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
+import * as __typia_transform__throwTypeGuardError from "typia/lib/internal/_throwTypeGuardError.js";
+import typia from 'typia';
+import type { CookbookActionParams, CookbookOptions, CookbookSubscribeEmits } from './cookbook-dto-types';
+export async function checkCookbookOptions(cookbookTomlParsed: any): Promise<[
     Record<any, any> & {
         message: string;
         stack: string;
@@ -14,46 +17,47 @@ export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
 ] | [
     null,
     CookbookOptions
-]> => {
-    const checkResult = (() => { const $join = (typia.validateEquals as any).join; const $io0 = (input: any, _exceptionable: boolean = true): boolean => "object" === typeof input.projects && null !== input.projects && false === Array.isArray(input.projects) && $io1(input.projects, true && _exceptionable) && ("object" === typeof input.general && null !== input.general && $io3(input.general, true && _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key: any) => {
+]> {
+    const cookbookToml = { ...cookbookTomlParsed };
+    const checkResult = (() => { const _io0 = (input: any, _exceptionable: boolean = true): boolean => "object" === typeof input.projects && null !== input.projects && false === Array.isArray(input.projects) && _io1(input.projects, true && _exceptionable) && ("object" === typeof input.general && null !== input.general && _io3(input.general, true && _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key: any) => {
         if (["projects", "general"].some((prop: any) => key === prop))
             return true;
         const value = input[key];
         if (undefined === value)
             return true;
         return false;
-    })); const $io1 = (input: any, _exceptionable: boolean = true): boolean => Object.keys(input).every((key: any) => {
+    })); const _io1 = (input: any, _exceptionable: boolean = true): boolean => Object.keys(input).every((key: any) => {
         const value = input[key];
         if (undefined === value)
             return true;
-        return "object" === typeof value && null !== value && $io2(value, true && _exceptionable);
-    }); const $io2 = (input: any, _exceptionable: boolean = true): boolean => ("milkio" === input.type || "other" === input.type) && "number" === typeof input.port && (Array.isArray(input.start) && input.start.every((elem: any, _index1: number) => "string" === typeof elem)) && (Array.isArray(input.build) && input.build.every((elem: any, _index2: number) => "string" === typeof elem)) && (undefined === input.lazyRoutes || "boolean" === typeof input.lazyRoutes) && (undefined === input.typiaMode || "generation" === input.typiaMode || "bundler" === input.typiaMode) && (undefined === input.significant || Array.isArray(input.significant) && input.significant.every((elem: any, _index3: number) => "string" === typeof elem)) && (undefined === input.insignificant || Array.isArray(input.insignificant) && input.insignificant.every((elem: any, _index4: number) => "string" === typeof elem)) && (4 === Object.keys(input).length || Object.keys(input).every((key: any) => {
-        if (["type", "port", "start", "build", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
+        return "object" === typeof value && null !== value && _io2(value, true && _exceptionable);
+    }); const _io2 = (input: any, _exceptionable: boolean = true): boolean => ("milkio" === input.type || "custom" === input.type) && "number" === typeof input.port && (Array.isArray(input.start) && input.start.every((elem: any, _index1: number) => "string" === typeof elem)) && (Array.isArray(input.build) && input.build.every((elem: any, _index2: number) => "string" === typeof elem)) && (undefined === input.watch || "boolean" === typeof input.watch) && (undefined === input.lazyRoutes || "boolean" === typeof input.lazyRoutes) && (undefined === input.typiaMode || "generation" === input.typiaMode || "bundler" === input.typiaMode) && (undefined === input.significant || Array.isArray(input.significant) && input.significant.every((elem: any, _index3: number) => "string" === typeof elem)) && (undefined === input.insignificant || Array.isArray(input.insignificant) && input.insignificant.every((elem: any, _index4: number) => "string" === typeof elem)) && (4 === Object.keys(input).length || Object.keys(input).every((key: any) => {
+        if (["type", "port", "start", "build", "watch", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
             return true;
         const value = input[key];
         if (undefined === value)
             return true;
         return false;
-    })); const $io3 = (input: any, _exceptionable: boolean = true): boolean => "number" === typeof input.cookbookPort && (1 === Object.keys(input).length || Object.keys(input).every((key: any) => {
-        if (["cookbookPort"].some((prop: any) => key === prop))
+    })); const _io3 = (input: any, _exceptionable: boolean = true): boolean => "string" === typeof input.start && "number" === typeof input.cookbookPort && (2 === Object.keys(input).length || Object.keys(input).every((key: any) => {
+        if (["start", "cookbookPort"].some((prop: any) => key === prop))
             return true;
         const value = input[key];
         if (undefined === value)
             return true;
         return false;
-    })); const $vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => [("object" === typeof input.projects && null !== input.projects && false === Array.isArray(input.projects) || $report(_exceptionable, {
+    })); const _vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => [("object" === typeof input.projects && null !== input.projects && false === Array.isArray(input.projects) || _report(_exceptionable, {
             path: _path + ".projects",
             expected: "Record<string, __type>",
             value: input.projects
-        })) && $vo1(input.projects, _path + ".projects", true && _exceptionable) || $report(_exceptionable, {
+        })) && _vo1(input.projects, _path + ".projects", true && _exceptionable) || _report(_exceptionable, {
             path: _path + ".projects",
             expected: "Record<string, __type>",
             value: input.projects
-        }), ("object" === typeof input.general && null !== input.general || $report(_exceptionable, {
+        }), ("object" === typeof input.general && null !== input.general || _report(_exceptionable, {
             path: _path + ".general",
             expected: "__type.o1",
             value: input.general
-        })) && $vo3(input.general, _path + ".general", true && _exceptionable) || $report(_exceptionable, {
+        })) && _vo3(input.general, _path + ".general", true && _exceptionable) || _report(_exceptionable, {
             path: _path + ".general",
             expected: "__type.o1",
             value: input.general
@@ -63,150 +67,160 @@ export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
             const value = input[key];
             if (undefined === value)
                 return true;
-            return $report(_exceptionable, {
-                path: _path + $join(key),
+            return _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
                 expected: "undefined",
                 value: value
             });
-        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const $vo1 = (input: any, _path: string, _exceptionable: boolean = true): boolean => [false === _exceptionable || Object.keys(input).map((key: any) => {
+        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const _vo1 = (input: any, _path: string, _exceptionable: boolean = true): boolean => [false === _exceptionable || Object.keys(input).map((key: any) => {
             const value = input[key];
             if (undefined === value)
                 return true;
-            return ("object" === typeof value && null !== value || $report(_exceptionable, {
-                path: _path + $join(key),
+            return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
                 expected: "__type",
                 value: value
-            })) && $vo2(value, _path + $join(key), true && _exceptionable) || $report(_exceptionable, {
-                path: _path + $join(key),
+            })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
                 expected: "__type",
                 value: value
             });
-        }).every((flag: boolean) => flag)].every((flag: boolean) => flag); const $vo2 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio" === input.type || "other" === input.type || $report(_exceptionable, {
+        }).every((flag: boolean) => flag)].every((flag: boolean) => flag); const _vo2 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio" === input.type || "custom" === input.type || _report(_exceptionable, {
             path: _path + ".type",
-            expected: "(\"milkio\" | \"other\")",
+            expected: "(\"milkio\" | \"custom\")",
             value: input.type
-        }), "number" === typeof input.port || $report(_exceptionable, {
+        }), "number" === typeof input.port || _report(_exceptionable, {
             path: _path + ".port",
             expected: "number",
             value: input.port
-        }), (Array.isArray(input.start) || $report(_exceptionable, {
+        }), (Array.isArray(input.start) || _report(_exceptionable, {
             path: _path + ".start",
             expected: "Array<string>",
             value: input.start
-        })) && input.start.map((elem: any, _index5: number) => "string" === typeof elem || $report(_exceptionable, {
+        })) && input.start.map((elem: any, _index5: number) => "string" === typeof elem || _report(_exceptionable, {
             path: _path + ".start[" + _index5 + "]",
             expected: "string",
             value: elem
-        })).every((flag: boolean) => flag) || $report(_exceptionable, {
+        })).every((flag: boolean) => flag) || _report(_exceptionable, {
             path: _path + ".start",
             expected: "Array<string>",
             value: input.start
-        }), (Array.isArray(input.build) || $report(_exceptionable, {
+        }), (Array.isArray(input.build) || _report(_exceptionable, {
             path: _path + ".build",
             expected: "Array<string>",
             value: input.build
-        })) && input.build.map((elem: any, _index6: number) => "string" === typeof elem || $report(_exceptionable, {
+        })) && input.build.map((elem: any, _index6: number) => "string" === typeof elem || _report(_exceptionable, {
             path: _path + ".build[" + _index6 + "]",
             expected: "string",
             value: elem
-        })).every((flag: boolean) => flag) || $report(_exceptionable, {
+        })).every((flag: boolean) => flag) || _report(_exceptionable, {
             path: _path + ".build",
             expected: "Array<string>",
             value: input.build
-        }), undefined === input.lazyRoutes || "boolean" === typeof input.lazyRoutes || $report(_exceptionable, {
+        }), undefined === input.watch || "boolean" === typeof input.watch || _report(_exceptionable, {
+            path: _path + ".watch",
+            expected: "(boolean | undefined)",
+            value: input.watch
+        }), undefined === input.lazyRoutes || "boolean" === typeof input.lazyRoutes || _report(_exceptionable, {
             path: _path + ".lazyRoutes",
             expected: "(boolean | undefined)",
             value: input.lazyRoutes
-        }), undefined === input.typiaMode || "generation" === input.typiaMode || "bundler" === input.typiaMode || $report(_exceptionable, {
+        }), undefined === input.typiaMode || "generation" === input.typiaMode || "bundler" === input.typiaMode || _report(_exceptionable, {
             path: _path + ".typiaMode",
             expected: "(\"bundler\" | \"generation\" | undefined)",
             value: input.typiaMode
-        }), undefined === input.significant || (Array.isArray(input.significant) || $report(_exceptionable, {
+        }), undefined === input.significant || (Array.isArray(input.significant) || _report(_exceptionable, {
             path: _path + ".significant",
             expected: "(Array<string> | undefined)",
             value: input.significant
-        })) && input.significant.map((elem: any, _index7: number) => "string" === typeof elem || $report(_exceptionable, {
+        })) && input.significant.map((elem: any, _index7: number) => "string" === typeof elem || _report(_exceptionable, {
             path: _path + ".significant[" + _index7 + "]",
             expected: "string",
             value: elem
-        })).every((flag: boolean) => flag) || $report(_exceptionable, {
+        })).every((flag: boolean) => flag) || _report(_exceptionable, {
             path: _path + ".significant",
             expected: "(Array<string> | undefined)",
             value: input.significant
-        }), undefined === input.insignificant || (Array.isArray(input.insignificant) || $report(_exceptionable, {
+        }), undefined === input.insignificant || (Array.isArray(input.insignificant) || _report(_exceptionable, {
             path: _path + ".insignificant",
             expected: "(Array<string> | undefined)",
             value: input.insignificant
-        })) && input.insignificant.map((elem: any, _index8: number) => "string" === typeof elem || $report(_exceptionable, {
+        })) && input.insignificant.map((elem: any, _index8: number) => "string" === typeof elem || _report(_exceptionable, {
             path: _path + ".insignificant[" + _index8 + "]",
             expected: "string",
             value: elem
-        })).every((flag: boolean) => flag) || $report(_exceptionable, {
+        })).every((flag: boolean) => flag) || _report(_exceptionable, {
             path: _path + ".insignificant",
             expected: "(Array<string> | undefined)",
             value: input.insignificant
         }), 4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key: any) => {
-            if (["type", "port", "start", "build", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
+            if (["type", "port", "start", "build", "watch", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
                 return true;
             const value = input[key];
             if (undefined === value)
                 return true;
-            return $report(_exceptionable, {
-                path: _path + $join(key),
+            return _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
                 expected: "undefined",
                 value: value
             });
-        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const $vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["number" === typeof input.cookbookPort || $report(_exceptionable, {
+        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const _vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["string" === typeof input.start || _report(_exceptionable, {
+            path: _path + ".start",
+            expected: "string",
+            value: input.start
+        }), "number" === typeof input.cookbookPort || _report(_exceptionable, {
             path: _path + ".cookbookPort",
             expected: "number",
             value: input.cookbookPort
-        }), 1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key: any) => {
-            if (["cookbookPort"].some((prop: any) => key === prop))
+        }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key: any) => {
+            if (["start", "cookbookPort"].some((prop: any) => key === prop))
                 return true;
             const value = input[key];
             if (undefined === value)
                 return true;
-            return $report(_exceptionable, {
-                path: _path + $join(key),
+            return _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
                 expected: "undefined",
                 value: value
             });
-        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const __is = (input: any, _exceptionable: boolean = true): input is CookbookOptions => "object" === typeof input && null !== input && $io0(input, true); let errors: any; let $report: any; return (input: any): typia.IValidation<CookbookOptions> => {
+        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const __is = (input: any, _exceptionable: boolean = true): input is CookbookOptions => "object" === typeof input && null !== input && _io0(input, true); let errors: any; let _report: any; return (input: any): import("typia").IValidation<CookbookOptions> => {
         if (false === __is(input)) {
             errors = [];
-            $report = (typia.validateEquals as any).report(errors);
-            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || $report(true, {
+            _report = (__typia_transform__validateReport._validateReport as any)(errors);
+            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || _report(true, {
                 path: _path + "",
                 expected: "CookbookOptions",
                 value: input
-            })) && $vo0(input, _path + "", true) || $report(true, {
+            })) && _vo0(input, _path + "", true) || _report(true, {
                 path: _path + "",
                 expected: "CookbookOptions",
                 value: input
             }))(input, "$input", true);
             const success = 0 === errors.length;
-            return {
+            return success ? {
+                success,
+                data: input
+            } : {
                 success,
                 errors,
-                data: success ? input : undefined
+                data: input
             } as any;
         }
         return {
             success: true,
-            errors: [],
             data: input
         } as any;
     }; })()(cookbookTomlParsed);
-    let error = null;
+    const error = null;
     if (!checkResult.success) {
         const error: any = checkResult.errors.at(0)!;
         error.message = `The "cookbook.toml" format is incorrect, [${error.path.slice(7)}] should be ${error.expected}, but it is actually ${error.value}. You may be missing some properties in the configuration item, or adding some properties that will not be used. If you have extra properties, these properties are likely due to a misspelling.`;
         Error.captureStackTrace(error);
         cookbookTomlParsed = null;
     }
-    return [error, cookbookTomlParsed];
-};
-export const checkCookbookActionParams = async (results: any): Promise<[
+    return [error, cookbookToml];
+}
+export async function checkCookbookActionParams(resultsRaw: any): Promise<[
     Record<any, any> & {
         message: string;
         stack: string;
@@ -215,58 +229,168 @@ export const checkCookbookActionParams = async (results: any): Promise<[
 ] | [
     null,
     CookbookActionParams
-]> => {
-    if (typeof Bun === "undefined")
-        throw new Error("Bun is not defined");
-    const checkResult = (() => { const $io0 = (input: any): boolean => "milkio@logger" === input.type && Array.isArray(input.log); const $vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@logger" === input.type || $report(_exceptionable, {
+]> {
+    let results = { ...resultsRaw };
+    if (typeof Bun === 'undefined')
+        throw new Error('Bun is not defined');
+    const checkResult = (() => { const _io0 = (input: any): boolean => "milkio@ping" === input.type; const _io1 = (input: any): boolean => "milkio@logger" === input.type && Array.isArray(input.log); const _io2 = (input: any): boolean => "milkio@template" === input.type && "string" === typeof input.name && "string" === typeof input.fsPath && "string" === typeof input.template; const _io3 = (input: any): boolean => "workers@list" === input.type; const _io4 = (input: any): boolean => "workers@get" === input.type && "string" === typeof input.key && "number" === typeof input.index; const _iu0 = (input: any): any => (() => {
+        if ("milkio@ping" === input.type)
+            return _io0(input);
+        else if ("milkio@logger" === input.type)
+            return _io1(input);
+        else if ("milkio@template" === input.type)
+            return _io2(input);
+        else if ("workers@list" === input.type)
+            return _io3(input);
+        else if ("workers@get" === input.type)
+            return _io4(input);
+        else
+            return false;
+    })(); const _vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@ping" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"milkio@ping\"",
+            value: input.type
+        })].every((flag: boolean) => flag); const _vo1 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@logger" === input.type || _report(_exceptionable, {
             path: _path + ".type",
             expected: "\"milkio@logger\"",
             value: input.type
-        }), Array.isArray(input.log) || $report(_exceptionable, {
+        }), Array.isArray(input.log) || _report(_exceptionable, {
             path: _path + ".log",
             expected: "Array<any>",
             value: input.log
-        })].every((flag: boolean) => flag); const $po0 = (input: any): any => {
+        })].every((flag: boolean) => flag); const _vo2 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@template" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"milkio@template\"",
+            value: input.type
+        }), "string" === typeof input.name || _report(_exceptionable, {
+            path: _path + ".name",
+            expected: "string",
+            value: input.name
+        }), "string" === typeof input.fsPath || _report(_exceptionable, {
+            path: _path + ".fsPath",
+            expected: "string",
+            value: input.fsPath
+        }), "string" === typeof input.template || _report(_exceptionable, {
+            path: _path + ".template",
+            expected: "string",
+            value: input.template
+        })].every((flag: boolean) => flag); const _vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@list" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"workers@list\"",
+            value: input.type
+        })].every((flag: boolean) => flag); const _vo4 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@get" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"workers@get\"",
+            value: input.type
+        }), "string" === typeof input.key || _report(_exceptionable, {
+            path: _path + ".key",
+            expected: "string",
+            value: input.key
+        }), "number" === typeof input.index || _report(_exceptionable, {
+            path: _path + ".index",
+            expected: "number",
+            value: input.index
+        })].every((flag: boolean) => flag); const _vu0 = (input: any, _path: string, _exceptionable: boolean = true): any => (() => {
+        if ("milkio@ping" === input.type)
+            return _vo0(input, _path, true && _exceptionable);
+        else if ("milkio@logger" === input.type)
+            return _vo1(input, _path, true && _exceptionable);
+        else if ("milkio@template" === input.type)
+            return _vo2(input, _path, true && _exceptionable);
+        else if ("workers@list" === input.type)
+            return _vo3(input, _path, true && _exceptionable);
+        else if ("workers@get" === input.type)
+            return _vo4(input, _path, true && _exceptionable);
+        else
+            return _report(_exceptionable, {
+                path: _path,
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4)",
+                value: input
+            });
+    })(); const _po0 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po1 = (input: any): any => {
         for (const key of Object.keys(input)) {
             if ("type" === key || "log" === key)
                 continue;
             delete input[key];
         }
-    }; const __is = (input: any): input is CookbookActionParams => "object" === typeof input && null !== input && $io0(input); let errors: any; let $report: any; const __validate = (input: any): typia.IValidation<CookbookActionParams> => {
+    }; const _po2 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "name" === key || "fsPath" === key || "template" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po3 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po4 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "key" === key || "index" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _pu0 = (input: any): any => (() => {
+        if ("milkio@ping" === input.type)
+            return _po0(input);
+        else if ("milkio@logger" === input.type)
+            return _po1(input);
+        else if ("milkio@template" === input.type)
+            return _po2(input);
+        else if ("workers@list" === input.type)
+            return _po3(input);
+        else if ("workers@get" === input.type)
+            return _po4(input);
+        else
+            __typia_transform__throwTypeGuardError._throwTypeGuardError({
+                method: "typia.misc.validatePrune",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4)",
+                value: input
+            });
+    })(); const __is = (input: any): input is CookbookActionParams => "object" === typeof input && null !== input && _iu0(input); let errors: any; let _report: any; const __validate = (input: any): import("typia").IValidation<CookbookActionParams> => {
         if (false === __is(input)) {
             errors = [];
-            $report = (typia.misc.validatePrune as any).report(errors);
-            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || $report(true, {
+            _report = (__typia_transform__validateReport._validateReport as any)(errors);
+            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || _report(true, {
                 path: _path + "",
-                expected: "CookbookActionParams",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4)",
                 value: input
-            })) && $vo0(input, _path + "", true) || $report(true, {
+            })) && _vu0(input, _path + "", true) || _report(true, {
                 path: _path + "",
-                expected: "CookbookActionParams",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4)",
                 value: input
             }))(input, "$input", true);
             const success = 0 === errors.length;
-            return {
+            return success ? {
+                success,
+                data: input
+            } : {
                 success,
                 errors,
-                data: success ? input : undefined
+                data: input
             } as any;
         }
         return {
             success: true,
-            errors: [],
             data: input
         } as any;
     }; const __prune = (input: CookbookActionParams): void => {
         if ("object" === typeof input && null !== input)
-            $po0(input);
-    }; return (input: any): typia.IValidation<CookbookActionParams> => {
+            _pu0(input);
+    }; return (input: any): import("typia").IValidation<CookbookActionParams> => {
         const result = __validate(input);
         if (result.success)
             __prune(input);
         return result;
-    }; })()(results);
-    let error = null;
+    }; })()(resultsRaw);
+    const error = null;
     if (!checkResult.success) {
         const error: any = checkResult.errors.at(0)!;
         error.message = `The "cookbook.toml" format is incorrect, [${error.path.slice(7)}] should be ${error.expected}, but it is actually ${error.value}. You may be missing some properties in the configuration item, or adding some properties that will not be used. If you have extra properties, these properties are likely due to a misspelling.`;
@@ -274,8 +398,8 @@ export const checkCookbookActionParams = async (results: any): Promise<[
         results = null;
     }
     return [error, results];
-};
-export const checkCookbookSubscribeEmits = async (results: any): Promise<[
+}
+export async function checkCookbookSubscribeEmits(results: any): Promise<[
     Record<any, any> & {
         message: string;
         stack: string;
@@ -284,155 +408,158 @@ export const checkCookbookSubscribeEmits = async (results: any): Promise<[
 ] | [
     null,
     CookbookSubscribeEmits
-]> => {
-    const typia = await import("typia");
-    const checkResult = (() => { const $throws = (typia.misc.validatePrune as any).throws; const $io0 = (input: any): boolean => "workers@stdout" === input.type && "string" === typeof input.key && "string" === typeof input.chunk; const $io1 = (input: any): boolean => "workers@state" === input.type && "string" === typeof input.key && ("running" === input.state || "stopped" === input.state) && (null === input.code || "running" === input.code || "kill" === input.code || "number" === typeof input.code); const $io2 = (input: any): boolean => "watcher@change" === input.type && ("rename" === input.event || "change" === input.event) && "string" === typeof input.path; const $io3 = (input: any): boolean => "milkio@logger" === input.type && Array.isArray(input.log); const $iu0 = (input: any): any => (() => {
+]> {
+    const typia = await import('typia');
+    const checkResult = (() => { const _io0 = (input: any): boolean => "workers@stdout" === input.type && "string" === typeof input.key && "string" === typeof input.chunk; const _io1 = (input: any): boolean => "workers@state" === input.type && "string" === typeof input.key && ("running" === input.state || "stopped" === input.state) && (null === input.code || "running" === input.code || "kill" === input.code || "number" === typeof input.code); const _io2 = (input: any): boolean => "watcher@change" === input.type && ("rename" === input.event || "change" === input.event) && "string" === typeof input.path; const _io3 = (input: any): boolean => "milkio@logger" === input.type && Array.isArray(input.log); const _iu0 = (input: any): any => (() => {
         if ("workers@stdout" === input.type)
-            return $io0(input);
+            return _io0(input);
         else if ("workers@state" === input.type)
-            return $io1(input);
+            return _io1(input);
         else if ("watcher@change" === input.type)
-            return $io2(input);
+            return _io2(input);
         else if ("milkio@logger" === input.type)
-            return $io3(input);
+            return _io3(input);
         else
             return false;
-    })(); const $vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@stdout" === input.type || $report(_exceptionable, {
+    })(); const _vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@stdout" === input.type || _report(_exceptionable, {
             path: _path + ".type",
             expected: "\"workers@stdout\"",
             value: input.type
-        }), "string" === typeof input.key || $report(_exceptionable, {
+        }), "string" === typeof input.key || _report(_exceptionable, {
             path: _path + ".key",
             expected: "string",
             value: input.key
-        }), "string" === typeof input.chunk || $report(_exceptionable, {
+        }), "string" === typeof input.chunk || _report(_exceptionable, {
             path: _path + ".chunk",
             expected: "string",
             value: input.chunk
-        })].every((flag: boolean) => flag); const $vo1 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@state" === input.type || $report(_exceptionable, {
+        })].every((flag: boolean) => flag); const _vo1 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@state" === input.type || _report(_exceptionable, {
             path: _path + ".type",
             expected: "\"workers@state\"",
             value: input.type
-        }), "string" === typeof input.key || $report(_exceptionable, {
+        }), "string" === typeof input.key || _report(_exceptionable, {
             path: _path + ".key",
             expected: "string",
             value: input.key
-        }), "running" === input.state || "stopped" === input.state || $report(_exceptionable, {
+        }), "running" === input.state || "stopped" === input.state || _report(_exceptionable, {
             path: _path + ".state",
             expected: "(\"running\" | \"stopped\")",
             value: input.state
-        }), null === input.code || "running" === input.code || "kill" === input.code || "number" === typeof input.code || $report(_exceptionable, {
+        }), null === input.code || "running" === input.code || "kill" === input.code || "number" === typeof input.code || _report(_exceptionable, {
             path: _path + ".code",
             expected: "(\"kill\" | \"running\" | null | number)",
             value: input.code
-        })].every((flag: boolean) => flag); const $vo2 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["watcher@change" === input.type || $report(_exceptionable, {
+        })].every((flag: boolean) => flag); const _vo2 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["watcher@change" === input.type || _report(_exceptionable, {
             path: _path + ".type",
             expected: "\"watcher@change\"",
             value: input.type
-        }), "rename" === input.event || "change" === input.event || $report(_exceptionable, {
+        }), "rename" === input.event || "change" === input.event || _report(_exceptionable, {
             path: _path + ".event",
             expected: "(\"change\" | \"rename\")",
             value: input.event
-        }), "string" === typeof input.path || $report(_exceptionable, {
+        }), "string" === typeof input.path || _report(_exceptionable, {
             path: _path + ".path",
             expected: "string",
             value: input.path
-        })].every((flag: boolean) => flag); const $vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@logger" === input.type || $report(_exceptionable, {
+        })].every((flag: boolean) => flag); const _vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@logger" === input.type || _report(_exceptionable, {
             path: _path + ".type",
             expected: "\"milkio@logger\"",
             value: input.type
-        }), Array.isArray(input.log) || $report(_exceptionable, {
+        }), Array.isArray(input.log) || _report(_exceptionable, {
             path: _path + ".log",
             expected: "Array<any>",
             value: input.log
-        })].every((flag: boolean) => flag); const $vu0 = (input: any, _path: string, _exceptionable: boolean = true): any => (() => {
+        })].every((flag: boolean) => flag); const _vu0 = (input: any, _path: string, _exceptionable: boolean = true): any => (() => {
         if ("workers@stdout" === input.type)
-            return $vo0(input, _path, true && _exceptionable);
+            return _vo0(input, _path, true && _exceptionable);
         else if ("workers@state" === input.type)
-            return $vo1(input, _path, true && _exceptionable);
+            return _vo1(input, _path, true && _exceptionable);
         else if ("watcher@change" === input.type)
-            return $vo2(input, _path, true && _exceptionable);
+            return _vo2(input, _path, true && _exceptionable);
         else if ("milkio@logger" === input.type)
-            return $vo3(input, _path, true && _exceptionable);
+            return _vo3(input, _path, true && _exceptionable);
         else
-            return $report(_exceptionable, {
+            return _report(_exceptionable, {
                 path: _path,
                 expected: "(__type | __type.o1 | __type.o2 | __type.o3)",
                 value: input
             });
-    })(); const $po0 = (input: any): any => {
+    })(); const _po0 = (input: any): any => {
         for (const key of Object.keys(input)) {
             if ("type" === key || "key" === key || "chunk" === key)
                 continue;
             delete input[key];
         }
-    }; const $po1 = (input: any): any => {
+    }; const _po1 = (input: any): any => {
         for (const key of Object.keys(input)) {
             if ("type" === key || "key" === key || "state" === key || "code" === key)
                 continue;
             delete input[key];
         }
-    }; const $po2 = (input: any): any => {
+    }; const _po2 = (input: any): any => {
         for (const key of Object.keys(input)) {
             if ("type" === key || "event" === key || "path" === key)
                 continue;
             delete input[key];
         }
-    }; const $po3 = (input: any): any => {
+    }; const _po3 = (input: any): any => {
         for (const key of Object.keys(input)) {
             if ("type" === key || "log" === key)
                 continue;
             delete input[key];
         }
-    }; const $pu0 = (input: any): any => (() => {
+    }; const _pu0 = (input: any): any => (() => {
         if ("workers@stdout" === input.type)
-            return $po0(input);
+            return _po0(input);
         else if ("workers@state" === input.type)
-            return $po1(input);
+            return _po1(input);
         else if ("watcher@change" === input.type)
-            return $po2(input);
+            return _po2(input);
         else if ("milkio@logger" === input.type)
-            return $po3(input);
+            return _po3(input);
         else
-            $throws({
+            __typia_transform__throwTypeGuardError._throwTypeGuardError({
+                method: "typia.misc.validatePrune",
                 expected: "(__type | __type.o1 | __type.o2 | __type.o3)",
                 value: input
             });
-    })(); const __is = (input: any): input is CookbookSubscribeEmits => "object" === typeof input && null !== input && $iu0(input); let errors: any; let $report: any; const __validate = (input: any): typia.IValidation<CookbookSubscribeEmits> => {
+    })(); const __is = (input: any): input is CookbookSubscribeEmits => "object" === typeof input && null !== input && _iu0(input); let errors: any; let _report: any; const __validate = (input: any): import("typia").IValidation<CookbookSubscribeEmits> => {
         if (false === __is(input)) {
             errors = [];
-            $report = (typia.misc.validatePrune as any).report(errors);
-            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || $report(true, {
+            _report = (__typia_transform__validateReport._validateReport as any)(errors);
+            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || _report(true, {
                 path: _path + "",
                 expected: "(__type | __type.o1 | __type.o2 | __type.o3)",
                 value: input
-            })) && $vu0(input, _path + "", true) || $report(true, {
+            })) && _vu0(input, _path + "", true) || _report(true, {
                 path: _path + "",
                 expected: "(__type | __type.o1 | __type.o2 | __type.o3)",
                 value: input
             }))(input, "$input", true);
             const success = 0 === errors.length;
-            return {
+            return success ? {
+                success,
+                data: input
+            } : {
                 success,
                 errors,
-                data: success ? input : undefined
+                data: input
             } as any;
         }
         return {
             success: true,
-            errors: [],
             data: input
         } as any;
     }; const __prune = (input: CookbookSubscribeEmits): void => {
         if ("object" === typeof input && null !== input)
-            $pu0(input);
-    }; return (input: any): typia.IValidation<CookbookSubscribeEmits> => {
+            _pu0(input);
+    }; return (input: any): import("typia").IValidation<CookbookSubscribeEmits> => {
         const result = __validate(input);
         if (result.success)
             __prune(input);
         return result;
     }; })()(results);
-    let error = null;
+    const error = null;
     if (!checkResult.success) {
         const error: any = checkResult.errors.at(0)!;
         error.message = `The "cookbook.toml" format is incorrect, [${error.path.slice(7)}] should be ${error.expected}, but it is actually ${error.value}. You may be missing some properties in the configuration item, or adding some properties that will not be used. If you have extra properties, these properties are likely due to a misspelling.`;
@@ -440,4 +567,4 @@ export const checkCookbookSubscribeEmits = async (results: any): Promise<[
         results = null;
     }
     return [error, results];
-};
+}

package/utils/cookbook-dto-types.ts

@@ -1,41 +1,56 @@
 /**
-* The content of this file is automatically generated by Typia.
-* It can be edited in the /packages/cookbook-dto/src/* file, and each time you run bun run dev, the generated file will be synced to another location based on the content of the /develop.ts.
-*/
+  * The content of this file is automatically generated by Typia.
+  * It can be edited in the /packages/cookbook-dto/src/* file, and each time you run bun run dev, the generated file will be synced to another location based on the content of the /develop.ts.
+  */
 
-export type CookbookOptions = {
+export interface CookbookOptions {
     projects: Record<string, {
-        type: "milkio" | "other";
+        type: 'milkio' | 'custom';
         port: number;
         start: Array<string>;
         build: Array<string>;
+        watch?: boolean;
         lazyRoutes?: boolean;
-        typiaMode?: "generation" | "bundler";
+        typiaMode?: 'generation' | 'bundler';
         significant?: Array<string>;
         insignificant?: Array<string>;
     }>;
     general: {
+        start: string;
         cookbookPort: number;
     };
-};
+}
 export type CookbookActionParams = {
-    type: "milkio@logger";
+    type: 'milkio@ping';
+} | {
+    type: 'milkio@logger';
     log: Array<any>;
+} | {
+    type: 'milkio@template';
+    name: string;
+    fsPath: string;
+    template: string;
+} | {
+    type: 'workers@list';
+} | {
+    type: 'workers@get';
+    key: string;
+    index: number;
 };
 export type CookbookSubscribeEmits = {
-    type: "workers@stdout";
+    type: 'workers@stdout';
     key: string;
     chunk: string;
 } | {
-    type: "workers@state";
+    type: 'workers@state';
     key: string;
-    state: "running" | "stopped";
-    code: number | null | "kill" | "running";
+    state: 'running' | 'stopped';
+    code: number | null | 'kill' | 'running';
 } | {
-    type: "watcher@change";
-    event: "rename" | "change";
+    type: 'watcher@change';
+    event: 'rename' | 'change';
     path: string;
 } | {
-    type: "milkio@logger";
+    type: 'milkio@logger';
     log: Array<any>;
 };