milkio 0.7.0-alpha.9 → 0.8.0

package/.publish/publish.json

@@ -0,0 +1,7 @@
+{
+  "enableReleases": true,
+  "githubOwner": "akirarika",
+  "githubRepo": "milkio",
+  "giteeOwner": "akirarika",
+  "giteeRepo": "milkio"
+}

package/.publish/releases/0.1.0.md

@@ -0,0 +1,13 @@
+# 0.1.0 - 序幕
+
+> 世界终末之时，黑川想起了第一次见到爱丽丝时的样子。那时，黑川正走在东京都最繁华的街道旁，一个少女脏兮兮地坐在那里。抱着膝盖，眼神充满了迷茫和无助，仿佛是一只孤独的小猫，被世界给遗弃。
+
+## 生日快乐
+
+这是 Milkio 的第一个版本！
+
+实际上，在发布之前，我已经花了接近一年的时间来打磨它。所以，尽管刚刚发布，Milkio 的完成度却很高，有好看的文档和完善的工具。希望大家能够喜欢它！
+
+你可能在疑惑，开头的这段话是什么，许多开源的项目都喜欢为每个版本都起一些比较中二病的名字，我觉得这种传统非常有趣！我想拿小说的章节，作为版本的名称，并把其中的段落作为发行说明的开篇。小说本身是虚构的，段落也是我自己编纂出来的，但如果有机会，我可能会把它写成一部真正的小说并发行（只是想想而已啦）。
+
+总之！希望你喜欢 Milkio！

package/.publish/releases/0.2.0.md

@@ -0,0 +1,33 @@
+# 0.2.0 - 初遇
+
+> 电视机正报道着新闻，爱丽丝就是从实验室中失控逃出的超能力者。黑川暗自腹诽，自己究竟给自己找了多大的麻烦，竟然因为可怜，把她带回了家。她好像失忆了，对自己的之前的经历毫不知情，只会缠在黑川身边，踮着脚尖拉着黑川的衣袖说，我饿了。
+
+## 命令
+
+现在，Milkio 还可以用来开发一些使用终端运行的小工具！[文档](https://milkio.fun/essentials/command)
+
+位于 `/apps/$/` 目录下的任何 API 都会被当做是命令。对于命令，使用起来就像是普通的 API，不同的是参数的格式。
+
+你现在拥有 `commands` 和 `options` 两个参数。这两个参数由 Milkio 帮你从 argv 中自动解析而来。看一下下面的例子，分别是执行的命令，和获取到的 params。
+
+```bash
+./app say hello world --foo=bar --enable
+```
+
+```ts
+params: {
+  commands: ["hello", "world"],
+  options: {
+    foo: "bar",
+    enable: true,
+  },
+}
+```
+
+想要了解更多的用法，请阅读 [文档](https://milkio.fun/essentials/command)！
+
+## 升级
+
+```
+bun i milkio@0.2.0
+```

package/.publish/releases/0.3.0.md

@@ -0,0 +1,85 @@
+# 0.3.0 - 游乐园
+
+> “很简单呀，只要我想象着冰淇凌在我手里就好了呀。”爱丽丝边舔冰淇凌边说，“不过…… 之后就会逐渐变得很累，会困得直接睡着。而且只有清楚记得细节的东西才可以，逃出来的时候，我想要变出一顶帽子遮住自己的脸，却变出了一只吞掉大象的蛇，可怕。”
+
+## 全新的创建工具
+
+现在，Milkio 提供了一个工具，来帮助你方便地创建新工程。
+
+```bash
+bun create milkio
+```
+
+只要运行命令并回答一系列问题，你就可以得到一个全新的 Milkio 工程。
+
+## Windows 支持
+
+Bun 已经完成了对 Windows 平台的正式支持，经过一系列的调整，现在 Milkio 也支持在 Windows 平台上使用了。
+
+## 对 Stream API (Server-Sent Events) 的支持
+
+文档：[Stream](https://milkio.fun/essentials/stream)
+
+现在 Milkio 支持了以流的方式发送 API 响应。当你的应用包括和大语言模型聊天，或者当他人评论你的博客时需要实时提醒时，这将很有用。
+
+```ts
+export const api = defineApi({
+	meta: {},
+	action: async function* (params: undefined, context) {
+		yield "hello";
+		yield "world";
+	},
+});
+```
+
+## 客户端包现在基于 Fetch
+
+客户端包现在会默认使用 Fetch。以前，你需要手动通过 `handler` 告诉客户端包如何发送请求，如何存储数据：
+
+```ts
+import { createClient } from "client";
+
+export const client = createClient({
+  baseUrl: "http://localhost:9000/",
+  storage: localStorage,
+  async handler(url, body, headers) {
+    return await (await fetch(url, { method: "POST", body, headers })).text();
+  },
+});
+```
+
+现在，默认情况下，客户端包会使用 Fetch 来发送请求，并使用 `localStorage` 来存储数据。
+
+```ts
+import { createClient } from "client";
+
+export const client = createClient({
+  baseUrl: "http://localhost:9000/",
+});
+```
+
+某些环境下，或许缺少一些所需的对象，你可以在选项中提供 `storage`、`fetch`、`abort` 这些的 polyfill。其中对于 `storage`，甚至支持异步的。
+
+## 静态服务器
+
+文档：[Static](https://milkio.fun/extensions/static)
+
+Milkio 现在支持静态服务器，这意味着你可以将前端打包出的静态资产与 Milkio 一起部署。
+
+## VS Code 菜单栏
+
+文档：[VS Code Menubar](https://milkio.fun/extensions/menubar)
+
+现在，你可以自由配置 Milkio 的 VS Code 菜单栏。你可以将自己常用的脚本放在菜单栏中，这样不用手动输入命令，也可以快速调用。
+
+## Drizzle
+
+文档：[Drizzle](https://milkio.fun/drizzle/getting-started)
+
+现在，Drizzle 是 Milkio 首选的 ORM，它是唯一同时具有关系型查询 API 和类似 SQL 查询 API 的 ORM，在访问关系数据时为您提供两全其美的服务。
+
+尽管 Drizzle 在使用上或许有些繁琐，但 Milkio 提供了一系列功能，来帮助你简化 Drizzle 的使用。Milkio 的 Drizzle 相关文档是从零 SQL 基础的角度去编写的，在此前没有 SQL 经验的使用者，也能够快速通过文档来入门。
+
+## 优化生成阶段性能
+
+在过去，生成阶段通过加载一遍 TypeScript 文件的方式来获取 API 的信息，现在，改为了直接以字符串的形式分析 TypeScript 文件本身。

package/.publish/releases/0.4.0.md

@@ -0,0 +1,35 @@
+# 0.4.0 - 匿名通话
+
+> “七十五万円，对于你一个大学生来说，已经够多了吧。”电话那端传来冰冷的机械音，显然是为了避免泄露讲话者的身份，“虽然我不知道为什么她在你身边就会安静下来，但这也免得我们大费周章了。把她带到整个东京最高的地方，天空树的顶层。高空是天然的屏障，那里就是她的鸟笼。把她带到这里，等待到夜间 10 点整，找个理由悄悄离开就好了，我们会处理剩下的事。”
+
+## 🚨 破坏性的用法更改：execute 相关方法
+
+> 我们会努力保持用法的兼容性，但在 Milkio 的 1.0 版本发布之前，可能会有一些破坏性的用法更改。
+
+此前，execute 相关方法的用法是这样的：
+
+```ts
+app.execute('foo/bar/baz', 'some-params', { 'Content-Type': 'application/json' }, { ... })
+```
+
+现在，参数改为了类似 fetch 的用法：
+
+```ts
+app.execute('foo/bar/baz', {
+  params: 'some-params',
+  headers: { 'Content-Type': 'application/json' },
+  ...
+})
+```
+
+## 更好的失败类型
+
+现在，Milkio Client 在 `TYPE_SAFE_ERROR` 失败的返回值的类型更加准确，我们甚至可以利用编辑器自动补全诸如 `foo.fail.data.path === "$input.password"` 这样的代码，是的，`"$input.password"` 这种字符串，也能够被补全和检查出错误。
+
+更新命令：`cd ./packages/client && bun i milkio-client@0.4.0`
+
+## 升级
+
+```
+bun i milkio@0.4.0
+```

package/.publish/releases/0.5.0.md

@@ -0,0 +1,19 @@
+# 0.5.0 - 天空树
+
+> 金色的夕阳逐渐从城市中褪去，街灯和招牌陆陆续续地亮起，在天空树上俯瞰，整个东京就像逐渐亮起的星空一样，繁华而璀璨，“只有你会给我买冰淇淋，”爱丽丝紧紧扯着黑川的衣袖，好像下一秒就会失去他似的，“会陪着我，很温柔，而且…从不把我当作怪物看，我…也许喜欢上你了！”
+
+## 测试
+
+在这个版本中，Milkio 主要进行了测试相关功能的改进
+
+- 现在测试拥有颜色的漂亮输出
+
+- 以前，遇到失败时测试将终止，现在不会终止，而是进行完所有的测试
+
+- 对于 Stream 来说，测试失败时，不会卡住而是会被正常认为是失败的
+
+## 升级
+
+```
+bun i milkio@0.5.0
+```

package/.publish/releases/0.6.0.md

@@ -0,0 +1,41 @@
+# 0.6.0 - 正常的世界
+
+> 爱丽丝的求救声回响在黑川的耳畔，黑川装作什么也听不见，步入电梯，如同一尊麻木的雕像。电梯缓缓下降，楼层一个接一个地掠过，爱丽丝的呼声逐渐被电梯播放的旋律所淹没，如同雨滴融入大海，尽管最初泛起细微的波纹，最终却归于沉寂。“欢迎回到现实世界，”黑川对自己说，声音中带着不易察觉的颤抖，“一个超能力只存在于幻想小说中的世界。”
+
+## Electron
+
+现在，Milkio 可以用来创建桌面应用了，并且可以打包成 macOS、Windows、Linux 三个平台下的应用
+
+这是使用 Electron 完成的，Electron 的主进程和渲染进程之间的通信很麻烦，通过引入 Milkio，很好地解决了这个问题
+
+对于前端而言，我们默认为你安装了 [Astro](https://astro.build/)，它一个支持主流的前端框架（如 Vue3、React、Svelte 等），并且默认会进行 SSG，这可以让你的应用运行速度更快
+
+你可以通过运行 `bun create milkio` 后，选择 `electron (alpha)` 模板进行体验
+
+不过你需要注意，这仍然处于 alpha 阶段，可能会有许多问题，未来也可能进行不兼容的改动
+
+## Node
+
+对于一些担忧 Bun 稳定性的用户，现在你可以使用 Node.js 来创建 Milkio 应用了
+
+无论是在本机上开发，还是运行测试，都是使用 Node.js 完成的，不过，你在开发时，仍然需要 Bun，因为 Milkio 依赖 Bun，在你开发时完成自动生成以及许多辅助操作
+
+你可以通过运行 `bun create milkio` 后，选择 `node (beta)` 模板进行体验
+
+## VS Code 模板
+
+修复了在 Windows 下的兼容性问题，现在 Windows 下也可以正常工作了
+
+## 客户端
+
+修复了在 Windows 下，客户端类型不会自动更新的问题，现在 Windows 下也可以正常工作了
+
+## 性能改进
+
+现在在 Windows 下，Milkio 的启动速度变得非常快
+
+## 升级
+
+```
+bun i milkio@0.6.0
+```

package/.publish/releases/0.8.0.md

@@ -0,0 +1,128 @@
+# 0.7.0 - 某章节名
+
+> 黑川讨厌自己，讨厌那个因为害怕而当胆小鬼的自己。
+> 爱丽丝把自己当做了唯一，是他，带她见到了这个色彩斑斓的世界，却又在短短数天后把她给抛弃。
+> 黑川只要一闭上眼睛，脑海中就浮现出爱丽丝依偎在自己手臂的画面，笑的那么开心，嘴角还残留着冰淇淋的痕迹。
+> 终于，黑川颤抖着手臂，按下了通往顶层的电梯按钮。
+> “不管怎样…我不会抛弃你的…” 黑川深呼吸，随着电梯门缓缓打开，他的眼神逐渐坚定如钢铁。
+
+## 功能：Milkio Steps
+
+Milkio 中，新增了一种编写 API 的心智模型：Steps。它可以让你将很长的 API 代码拆分为若干个小的步骤，这对于复杂的 API 代码编写，可以提升代码的可读性。
+
+```ts
+async action(
+	params: {
+		by: string & typia.tags.MinLength<2> & typia.tags.MaxLength<16>;
+	},
+	context,
+) {
+	const result = await context
+		/**
+		 * Step 1
+		 */
+		.step(async (stages) => {
+			const message1 = `Step 1`;
+
+			return { message1 };
+		})
+		/**
+		 * Step 2
+		 */
+		.step(async (stage) => {
+			const $message2 = `Step 2`;
+
+			return { $message2 };
+		})
+		/**
+		 * Step 3
+		 */
+		.step(async (stage) => {
+			if (!stage.message1) throw reject("INTERNAL_SERVER_ERROR", undefined);
+			if (!stage.$message2) throw reject("INTERNAL_SERVER_ERROR", undefined);
+			return {};
+		})
+		.run();
+
+	return result;
+}
+```
+
+其中，每个 `step` 都是一个函数，返回一个对象，这个对象会被合并到下一步的 `stage` 中。
+
+如果对象中的属性是以 `$` 开头的，那么 Milkio 会将其视为一个私有属性，尽管在 `stage` 中它始终可访问，但在 `result` 中，它会被移除。
+
+为了避免对 `stage` 中的属性进行修改，从而导致难以知晓某些值在哪一步被更改，被属性设计为是不可变的。
+
+## VS Code：Milkio Structure
+
+> 注意：需要将 Milkio 的 VS Code Extension 更新到最新
+
+现在，你的 VS Code 资源管理器底部会显示你 Milkio  API 的结构。你可以通过它定位较长的 API 代码。
+
+```ts
+⬇️ Meta
+⬇️ Action
+    step: Step 1
+		step: Step 2
+		step: Step 3
+⬇️ Tests
+    test: Basic
+```
+
+## VS Code：同时启动前端工程
+
+> 注意：需要将 Milkio 的 VS Code Extension 更新到最新
+
+现在，Milkio 支持关联你的前端工程了，并且在启动 Milkio 时，同步启动它们。在 `milkio.toml` 中像下面这样配置即可。
+
+```toml
+[link]
+projects = [
+  { name = 'YourViteProject', cwd = '../your-project-path', script = 'bun run dev' },
+]
+```
+
+## VS Code：工作区优化
+
+> 注意：需要将 Milkio 的 VS Code Extension 更新到最新
+
+以前，当使用工作区时，只有当前在屏幕上所打开的文件，位于一个 Milkio 工程中时，Milkio 的菜单栏才会出现。
+
+这是因为，我们通过当前屏幕上所打开的文件，来判断这个工程是否是一个 Milkio 工程，以及你想要操作哪个 Milkio 工程。
+
+现在，当工作区中，只有一个是 Milkio 工程时，Milkio 的菜单栏会始终出现，我们假定你要操作的，就是这个 Milkio 工程。
+
+## 配置：根据环境自动切换
+
+现在，配置支持根据不同的环境来自动读取不同的配置了。
+
+https://milkio.fun/essentials/config
+
+## 测试：支持使用真实请求测试
+
+现在，测试新增了 `client` 对象，你可以利用它，使用真实的客户端包，发送真实的请求。
+
+https://milkio.fun/essentials/api-test
+
+## 模板：支持 Cloudflare Workers
+
+现在，Milkio 完成了对 Cloudflare Workers 的支持，你可以通过 `bun create milkio` 时间选择 `cloudflare` 选项，来创建一个 Cloudflare Workers 项目。
+
+## 文档：运行时文档改进
+
+现在，我为每个运行时都编写了文档，在其中讲述了注意事项和如何部署。
+
+Bun: https://milkio.fun/runtime/bun/
+Node.js: https://milkio.fun/runtime/node/
+Cloudflare: https://milkio.fun/runtime/cloudflare/
+Electron: https://milkio.fun/runtime/electron/
+
+## 升级
+
+使用新版本时，请务必也一同升级你的客户端包的版本。
+
+```
+bun i milkio@0.7.0
+cd packages/client && bun i milkio-client
+```

package/.publish/releases-github/0.1.0.md

@@ -0,0 +1,13 @@
+# 0.1.0 - Prologue
+
+> At the end of the world, Kurokawa remembered the first time he saw Alice. At that time, Kurokawa was walking along the busiest street in Tokyo, where a girl was sitting there, dirty and disheveled. Hugging her knees, her eyes were filled with confusion and helplessness, as if she were a lonely kitten, abandoned by the world.
+
+## Happy Birthday
+
+This is the first version of Milkio!
+
+In fact, before the release, I have spent nearly a year polishing it. So, despite being just released, Milkio is quite complete, with beautiful documentation and comprehensive tools. I hope you like it!
+
+You might be wondering what the opening paragraph is about. Many open-source projects like to give each version a somewhat melodramatic name, and I find this tradition quite interesting! I wanted to use chapters of a novel as version names, and use paragraphs from the novel as the opening of the release notes. The novel itself is fictional, and the paragraphs are also fabricated by me, but if given the chance, I might turn it into a real novel and publish it (just a thought).
+
+Anyway! I hope you like Milkio!

package/.publish/releases-github/0.2.0.md

@@ -0,0 +1,33 @@
+# 0.2.0 - First Encounter
+
+> The television was reporting the news, and Alice was the superpowered individual who had escaped from the lab. Kurokawa muttered to himself, wondering what kind of trouble he had gotten himself into by taking pity on her and bringing her home. She may have lost her memory, having no knowledge of her past experiences, and would only cling to Kurokawa, tugging at his sleeve and saying, "I'm hungry."
+
+## Commands
+
+Now, Milkio can also be used to develop small tools that run in the terminal! [Documentation](https://milkio.fun/essentials/command)
+
+At `/apps/$/` directory will be treated as a command. For commands, usage is similar to regular APIs, with the exception of the parameter format.
+
+You now have two parameters: `commands` and `options`. These parameters are automatically parsed by Milkio from `argv`. Take a look at the examples below, which show the executed command and the obtained `params`.
+
+```bash
+./app say hello world --foo=bar --enable
+```
+
+```ts
+params: {
+  commands: ["hello", "world"],
+  options: {
+    foo: "bar",
+    enable: true,
+  },
+}
+```
+
+To learn more about usage, please read the [documentation](https://milkio.fun/essentials/command)
+
+## Upgrade
+
+```
+bun i milkio@0.2.0
+```

package/.publish/releases-github/0.3.0.md

@@ -0,0 +1,85 @@
+# 0.3.0 - Amusement Park
+
+> "It's simple, just imagine the ice cream in my hand," Alice said while licking her ice cream, "but... it gets very tiring after a while, and I'll fall asleep right away. And it only works for things I remember in detail. When I tried to escape, I wanted to create a hat to cover my face, but instead, I created a snake that swallowed an elephant. Scary."
+
+## Brand New Creation Tool
+
+Now, Milkio offers a tool to help you create new projects easily.
+
+```bash
+bun create milkio
+```
+
+By running the command and answering a series of questions, you can get a brand new Milkio project.
+
+## Windows Support
+
+Bun has officially completed support for the Windows platform. After a series of adjustments, Milkio now supports the Windows platform as well.
+
+## Support for Stream API (Server-Sent Events)
+
+Documentation: [Stream](https://milkio.fun/essentials/stream)
+
+Now Milkio supports sending API responses in a streaming manner. This will be useful when your application includes chatting with a large language model or when you need real-time notifications when someone comments on your blog.
+
+```ts
+export const api = defineApi({
+	meta: {},
+	action: async function* (params: undefined, context) {
+		yield "hello";
+		yield "world";
+	},
+});
+```
+
+## Client Package Now Based on Fetch
+
+The client package now defaults to using Fetch. Previously, you had to manually tell the client package how to send requests and how to store data through the `handler`:
+
+```ts
+import { createClient } from "client";
+
+export const client = createClient({
+  baseUrl: "http://localhost:9000/",
+  storage: localStorage,
+  async handler(url, body, headers) {
+    return await (await fetch(url, { method: "POST", body, headers })).text();
+  },
+});
+```
+
+Now, by default, the client package will use Fetch to send requests and `localStorage` to store data.
+
+```ts
+import { createClient } from "client";
+
+export const client = createClient({
+  baseUrl: "http://localhost:9000/",
+});
+```
+
+In some environments, you might be missing some required objects. You can provide polyfills for `storage`, `fetch`, and `abort` in the options. For `storage`, it even supports asynchronous operations.
+
+## Static Server
+
+Documentation: [Static](https://milkio.fun/extensions/static)
+
+Milkio now supports a static server, which means you can deploy the static assets packaged by the frontend with Milkio.
+
+## VS Code Menubar
+
+Documentation: [VS Code Menubar](https://milkio.fun/extensions/menubar)
+
+Now, you can freely configure the VS Code menubar for Milkio. You can place your frequently used scripts in the menubar, so you don't have to manually enter commands and can call them quickly.
+
+## Drizzle
+
+Documentation: [Drizzle](https://milkio.fun/drizzle/getting-started)
+
+Now, Drizzle is Milkio's preferred ORM. It is the only ORM that has both a relational query API and a SQL-like query API, providing a comprehensive service when accessing relational data.
+
+Although Drizzle might be a bit cumbersome to use, Milkio provides a series of features to simplify the use of Drizzle. The documentation for Milkio's Drizzle is written from the perspective of someone with zero SQL knowledge, allowing even those without SQL experience to quickly get started through the documentation.
+
+## Optimizing Generate Phase Performance
+
+In the past, the generate phase would load TypeScript files to obtain information about the API. Now, it has been changed to directly analyze the TypeScript files as strings.

package/.publish/releases-github/0.4.0.md

@@ -0,0 +1,35 @@
+# 0.4.0 - Anonymous Call
+
+> "Seventy-five thousand yen, for a university student like you, should be enough." A cold mechanical voice came from the phone, apparently to avoid revealing the speaker's identity. "Although I don't know why she calms down when she's with you, it saves us a lot of trouble. Take her to the top of Tokyo Skytree, the highest place in the whole of Tokyo. The high altitude is a natural barrier, that's her cage. Bring her here, wait until exactly 10 o'clock at night, find a reason to quietly leave, and we will take care of the rest."
+
+## 🚨 Destructive Usage Changes: execute Related Methods
+
+> We will strive to maintain compatibility, but there may be some destructive usage changes before the 1.0 version of Milkio is released.
+
+Previously, the usage of execute-related methods was as follows:
+
+```ts
+app.execute('foo/bar/baz', 'some-params', { 'Content-Type': 'application/json' }, { ... })
+```
+
+Now, the parameters have been changed to a fetch-like usage:
+
+```ts
+app.execute('foo/bar/baz', {
+   params: 'some-params',
+   headers: { 'Content-Type': 'application/json' },
+   ...
+})
+```
+
+## Improved Failure Types
+
+Now, the `TYPE_SAFE_ERROR` failure return value type in Milkio Client is more accurate, and we can even use editor auto-completion for code like `foo.fail.data.path === "$input.password"`. Yes, strings like `"$input.password"` can also be auto-completed and errors can be detected.
+
+Update command: `cd ./packages/client && bun i milkio-client@0.4.0`
+
+## Upgrade
+
+```
+bun i milkio@0.4.0
+```

package/.publish/releases-github/0.5.0.md

@@ -0,0 +1,19 @@
+# 0.5.0 - Sky Tree
+
+> The golden sunset gradually fades from the city, street lights and signs are lit up one after another. Gazing down from the Sky Tree, the entire Tokyo looks like a gradually brightening starry sky, bustling and dazzling. "Only you would buy me ice cream," Alice clings tightly to Kurokawa's sleeve, as if she might lose him at any moment, "you would stay with me, be gentle, and... never treat me like a monster. I... might have fallen for you!"
+
+## Testing
+
+Milkio has primarily improved its testing procedures:
+
+- Tests now have colorful, attractive output
+
+- Previously, tests would terminate upon encountering a failure; now they will not, and will instead complete all tests
+
+- For streams, when a test fails, it will not hang but will be correctly identified as a failure
+
+## Upgrade
+
+```
+bun i milkio@0.5.0
+```

package/.publish/releases-github/0.6.0.md

@@ -0,0 +1,41 @@
+# 0.6.0 - A Normal World
+
+> Alice's cries for help echoed in Kurokawa's ears, but he pretended not to hear, stepping into the elevator like a numb statue. The elevator descended slowly, floors passing one by one, and Alice's voice was gradually drowned out by the melody playing inside the elevator, like raindrops merging into the ocean, creating faint ripples at first, but ultimately falling silent. "Welcome back to the real world," Kurokawa said to himself, his voice trembling slightly, "a world where superpowers only exist in fantasy novels."
+
+## Electron
+
+Now, Milkio can be used to create desktop applications and can be packaged into applications for macOS, Windows, and Linux platforms.
+
+This has been achieved using Electron, and the communication between the main process and the rendering process in Electron can be quite troublesome. By introducing Milkio, this issue has been effectively resolved.
+
+For front-end developers, we assume that you have installed [Astro](https://astro.build/), which supports mainstream front-end frameworks (such as Vue3, React, Svelte, etc.), and defaults to SSG, which can make your application run faster.
+
+You can experience this by running `bun create milkio` and choosing the `electron (alpha)` template.
+
+However, please note that this is still in the alpha stage, and there may be many issues. Future updates may also include incompatible changes.
+
+## Node
+
+For users concerned about the stability of Bun, you can now use Node.js to create Milkio applications.
+
+Whether you are developing locally or running tests, it is all done using Node.js. However, during development, you still need Bun because Milkio relies on Bun to perform automatic generation and many auxiliary operations.
+
+You can experience this by running `bun create milkio` and choosing the `node (beta)` template.
+
+## VS Code Template
+
+The compatibility issue on Windows has been fixed, and now it works properly on Windows as well.
+
+## Client
+
+The issue where the client type did not automatically update on Windows has been resolved, and now it works properly on Windows as well.
+
+## Performance Improvements
+
+Now, the startup speed of Milkio on Windows has become very fast.
+
+## Upgrade
+
+```
+bun i milkio@0.6.0
+```

package/api-test/index.ts

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import schema from "../../../generated/api-schema";
-import { ExecuteResultFail, type MilkioApp } from "..";
+import { ExecuteResultFail, reject, type MilkioApp } from "..";
 import { handleCatchError } from "../utils/handle-catch-error.ts";
 
 export const executeApiTests = async <Path extends Array<keyof (typeof schema)["apiTestsSchema"]>>(app: MilkioApp, path: Path | string | true | 1 | undefined) => {
@@ -16,8 +16,8 @@ export const executeApiTests = async <Path extends Array<keyof (typeof schema)["
 	const startedAt = new Date().getTime();
 	const apiTestHooks = await import("../../../src/api-test.ts");
 	await apiTestHooks.default.onBootstrap();
-	const clientPackage = apiTestHooks.default?.client ? (await apiTestHooks.default?.client()) : undefined;
-	const results: Array<{ path: string, case: number, fail: boolean, failMessage?: string }> = [];
+	const clientPackage = apiTestHooks.default?.client ? await apiTestHooks.default?.client() : undefined;
+	const results: Array<{ path: string; case: number; fail: boolean; failMessage?: string }> = [];
 
 	if (!clientPackage) {
 		console.log(`🚨 For testing purposes, if the client package does not exist, subsequent operations might result in errors.`);
@@ -51,12 +51,14 @@ export const executeApiTests = async <Path extends Array<keyof (typeof schema)["
 		}
 	}
 
-	const client = clientPackage ? {
-		execute: async (options?: any) => clientPackage!.execute((path as any), options),
-		executeOther: async (path: any, options?: any) => clientPackage!.execute((path as any), options),
-		executeStream: async (options?: any) => clientPackage!.executeStream((path as any), options),
-		executeStreamOther: async (path: any, options?: any) => clientPackage!.executeStream((path as any), options),
-	} : undefined;
+	const client = clientPackage
+		? {
+				execute: async (options?: any) => clientPackage!.execute(path as any, options),
+				executeOther: async (path: any, options?: any) => clientPackage!.execute(path as any, options),
+				executeStream: async (options?: any) => clientPackage!.executeStream(path as any, options),
+				executeStreamOther: async (path: any, options?: any) => clientPackage!.executeStream(path as any, options),
+			}
+		: undefined;
 
 	console.log(chalk.hex("#0B346E")(`₋₋₋₋₋₋₋₋`));
 
@@ -77,20 +79,21 @@ export const executeApiTests = async <Path extends Array<keyof (typeof schema)["
 				await cs.handler({
 					...((await apiTestHooks.default.onBefore()) ?? {}),
 					log: (...args: Array<unknown>) => console.log(...args),
-					execute: async (options?: any) => app.execute((path as any), options),
-					executeOther: async (path: any, options?: any) => app.execute((path as any), options),
-					executeStream: async (options?: any) => app.executeStream((path as any), options),
-					executeStreamOther: async (path: any, options?: any) => app.executeStream((path as any), options),
+					execute: async (options?: any) => app.execute(path as any, options),
+					executeOther: async (path: any, options?: any) => app.execute(path as any, options),
+					executeStream: async (options?: any) => app.executeStream(path as any, options),
+					executeStreamOther: async (path: any, options?: any) => app.executeStream(path as any, options),
 					client,
 					randParams: () => app.randParams(path as any),
 					randOtherParams: (path: any) => app.randParams(path),
 					reject: (message?: string) => {
 						fail = true;
 						failMessage = message;
+						return reject("BUSINESS_FAIL", message ?? "test failed");
 					},
 				});
 			} catch (e: any) {
-				const response = handleCatchError(e, 'no-execute-id') as ExecuteResultFail;
+				const response = handleCatchError(e, "no-execute-id") as ExecuteResultFail;
 				fail = true;
 				failMessage = response.fail.message;
 			}
@@ -102,16 +105,16 @@ export const executeApiTests = async <Path extends Array<keyof (typeof schema)["
 			}
 			results.push({ path, case: i, fail, failMessage });
 			console.log(chalk.hex("#0B346E")(`₋₋₋₋₋₋₋₋`));
-			await new Promise(resolve => setTimeout(resolve, 64));
+			await new Promise((resolve) => setTimeout(resolve, 64));
 		}
 	}
 
 	const endedAt = new Date().getTime();
 
-	const failTotal = results.filter(r => r.fail).length;
+	const failTotal = results.filter((r) => r.fail).length;
 	const passTotal = results.length - failTotal;
 
 	console.log("");
 	if (failTotal === 0) console.log(chalk.hex("#1B813E")(`🥳 all tests ${chalk.hex("#1B813E")(`passed`)} ${chalk.hex("#999A9E")(`🌟 milkio testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s\n`)}`));
-	else console.log(chalk.hex("#999A9E")(`🤗️️ ${failTotal} test${failTotal > 1 ? "s" : ""} ${chalk.hex("#D75455")(`failed`)}${passTotal > 0 ? `, and ${results.length - failTotal} ${chalk.hex("#1B813E")(`passed`)}` : ''} ${chalk.hex("#999A9E")(`🌟 milkio testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s`)}`));
+	else console.log(chalk.hex("#999A9E")(`🤗️️ ${failTotal} test${failTotal > 1 ? "s" : ""} ${chalk.hex("#D75455")(`failed`)}${passTotal > 0 ? `, and ${results.length - failTotal} ${chalk.hex("#1B813E")(`passed`)}` : ""} ${chalk.hex("#999A9E")(`🌟 milkio testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s`)}`));
 };

package/defines/define-api-test.ts

@@ -13,43 +13,55 @@ export type ApiTestCases<ApiT extends Api> = {
 	handler: (
 		test: {
 			log: (...params: Array<unknown>) => void;
-			execute: (options: { params: Parameters<ApiT["action"]>[0], headers?: Record<string, string> } & ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
+			execute: (options: { params: Parameters<ApiT["action"]>[0]; headers?: Record<string, string> } & ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
 			executeOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
 				path: Path,
 				options: {
-					params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
-					headers?: Record<string, string>
+					params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
+					headers?: Record<string, string>;
 				} & ExecuteOptions,
 			) => Promise<ExecuteResult<Result>>;
-			executeStream: (options: { params: Parameters<ApiT["action"]>[0], headers?: Record<string, string> } & ExecuteOptions) => Promise<{
-				getResult: () => ExecuteResult<undefined>,
-				stream: AsyncGenerator<Awaited<ReturnType<ApiT["action"]>>>
+			executeStream: (options: { params: Parameters<ApiT["action"]>[0]; headers?: Record<string, string> } & ExecuteOptions) => Promise<{
+				getResult: () => ExecuteResult<undefined>;
+				stream: AsyncGenerator<Awaited<ReturnType<ApiT["action"]>>>;
 			}>;
-			executeStreamOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(path: Path, options: { params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headers?: Record<string, string> } & ExecuteOptions) => Promise<{
-				getResult: () => ExecuteResult<undefined>,
-				stream: AsyncGenerator<Result>
+			executeStreamOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
+				path: Path,
+				options: { params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string; headers?: Record<string, string> } & ExecuteOptions,
+			) => Promise<{
+				getResult: () => ExecuteResult<undefined>;
+				stream: AsyncGenerator<Result>;
 			}>;
 			client: {
-				execute: (options: { params: Parameters<ApiT["action"]>[0], headers?: Record<string, string> } & ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
+				execute: (options: { params: Parameters<ApiT["action"]>[0]; headers?: Record<string, string> } & ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
 				executeOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
 					path: Path,
 					options: {
-						params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
-						headers?: Record<string, string>
+						params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
+						headers?: Record<string, string>;
 					} & ExecuteOptions,
 				) => Promise<ExecuteResult<Result>>;
-				executeStream: (options: { params: Parameters<ApiT["action"]>[0], headers?: Record<string, string> } & ExecuteOptions) => Promise<{
-					getResult: () => ExecuteResult<undefined>,
-					stream: AsyncGenerator<Awaited<ReturnType<ApiT["action"]>>>
+				executeStream: (options: { params: Parameters<ApiT["action"]>[0]; headers?: Record<string, string> } & ExecuteOptions) => Promise<{
+					getResult: () => ExecuteResult<undefined>;
+					stream: AsyncGenerator<Awaited<ReturnType<ApiT["action"]>>>;
 				}>;
-				executeStreamOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(path: Path, options: { params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headers?: Record<string, string> } & ExecuteOptions) => Promise<{
-					getResult: () => ExecuteResult<undefined>,
-					stream: AsyncGenerator<Result>
+				executeStreamOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
+					path: Path,
+					options: { params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string; headers?: Record<string, string> } & ExecuteOptions,
+				) => Promise<{
+					getResult: () => ExecuteResult<undefined>;
+					stream: AsyncGenerator<Result>;
 				}>;
-			}
+			};
 			randParams: () => Promise<Parameters<ApiT["action"]>[0]>;
 			randOtherParams: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path) => Promise<Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0]>;
-			reject: (message?: string) => void;
+			reject: (message?: string) => {
+				name: string;
+				code: "BUSINESS_FAIL";
+				message: string;
+				data: string;
+				stack: string;
+			};
 		} & Awaited<ReturnType<(typeof apiTestHooks)["onBefore"]>>,
 	) => Promise<void> | void;
 	name: string;

package/defines/define-http-handler.ts

@@ -29,12 +29,11 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 		runtime.execute.executeIds.add(executeId);
 		const logger = useLogger(executeId);
 		const ip = options.getRealIp ? options.getRealIp(request.request) : (request.request.headers.get("X-Forwarded-For") as string | undefined)?.split(",")[0] ?? "0.0.0.0";
-		const headers = request.request.headers;
+		const headers = request.request.headers as Headers;
 
 		loggerPushTags(executeId, {
 			from: "http-server",
 			url: fullurl.pathname,
-			fullurl: fullurl.pathname,
 			ip,
 			method: request.request.method,
 			// @ts-ignore
@@ -77,11 +76,11 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 			let pathstr = path.join("/") as keyof (typeof schema)["apiMethodsSchema"];
 
 			const detail = {
-				...options.mixin ?? {},
+				...(options.mixin ?? {}),
 				path: pathstr,
 				ip,
 				executeId,
-				fullurl,
+				fullurl: fullurl as URL,
 				request: request.request,
 				response,
 			};
@@ -99,7 +98,7 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 					if (!detail.response.body) {
 						if (!detail.response.headers["Content-Type"]) detail.response.headers["Content-Type"] = "application/json";
 						if (!detail.response.headers["Cache-Control"]) detail.response.headers["Cache-Control"] = "no-cache";
-						detail.response.body = `{"executeId":"${executeId}","success":false,"fail":{"code":"NOT_FOUND","message":"${failCode.NOT_FOUND()}"}}`;
+						detail.response.body = `{"executeId":"${executeId}","success":false,"fail":{"code":"NOT_FOUND","message":"${failCode.NOT_FOUND(undefined)}"}}`;
 					}
 					await MiddlewareEvent.handle("httpNotFound", [detail]);
 
@@ -125,7 +124,7 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 			// execute api
 			// after request middleware
 			await MiddlewareEvent.handle("afterHttpRequest", [headers, detail]);
-			const mode = (headers.get("Accept")) === "text/event-stream" ? "stream" : "execute";
+			const mode = headers.get("Accept") === "text/event-stream" ? "stream" : "execute";
 
 			const rawbody = await request.request.text();
 			loggerPushTags(executeId, {
@@ -159,7 +158,7 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 			}
 
 			if (mode === "execute") {
-				const result: string = await fn.validateResults(TSON.encode(resultsRaw.$result));
+				const result: string = JSON.stringify(TSON.encode(resultsRaw.$result));
 				if (!detail.response.body) detail.response.body = result;
 
 				// before response middleware
@@ -221,7 +220,7 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 							cancel() {
 								control.close();
 							},
-						} as unknown as UnderlyingByteSource);
+						});
 					} else {
 						// node.js or others
 						stream = new ReadableStream({
@@ -285,7 +284,7 @@ export type MilkioHttpRequest = {
 export type MilkioHttpResponse = Mixin<
 	ResponseInit,
 	{
-		body: string | BodyInit;
+		body: string | Blob | FormData | URLSearchParams | ReadableStream<Uint8Array>;
 		status: number;
 		headers: Record<string, string>;
 	}

package/kernel/context.ts

@@ -11,7 +11,7 @@ export type MilkioContext = {
 	 * During testing or when calling between microservices, some or all of the values may be undefined
 	 */
 	detail: FrameworkHttpDetail;
-	step: Steps<{}>['step'];
+	step: Steps<{}>["step"];
 };
 
 export type FrameworkHttpDetail = {
@@ -24,12 +24,12 @@ export type FrameworkHttpDetail = {
 };
 
 export type Steps<StageT extends Record<any, any>> = {
-	step: StepFunction<StageT>,
+	step: StepFunction<StageT>;
 	// run: <HandlerT extends (stage: StageT) => Record<any, any> | Promise<Record<any, any>>>(handler: HandlerT) => Promise<Awaited<ReturnType<HandlerT>>>,
-	run: () => Promise<Remove$<StageT>>
-}
+	run: () => Promise<Remove$<StageT>>;
+};
 
-type StepFunction<StageT extends Record<any, any>> = <HandlerT extends ((stage: Readonly<StageT>) => Record<any, any> | Promise<Record<any, any>>) >(handler: HandlerT) => Steps<Mixin<StageT, ToEmptyObject<Awaited<ReturnType<HandlerT>>>>>
+type StepFunction<StageT extends Record<any, any>> = <HandlerT extends (stage: Readonly<StageT>) => Record<any, any> | Promise<Record<any, any>>>(handler: HandlerT) => Steps<Awaited<StageT> & ToEmptyObject<Awaited<ReturnType<HandlerT>>>>;
 
 export const createStep = () => {
 	const stepController = {
@@ -41,15 +41,15 @@ export const createStep = () => {
 		async run() {
 			let stage = {};
 			for (const step of stepController._steps) {
-				stage = { ...stage, ...(await step(stage)) }
+				stage = { ...stage, ...(await step(stage)) };
 			}
 			let result: Record<any, any> = {};
 			for (const key in stage) {
 				const value = (stage as any)[key];
-				if (!key.startsWith('$')) result[key] = value;
+				if (!key.startsWith("$")) result[key] = value;
 			}
 			return result;
-		}
-	}
-	return stepController.step as any as Steps<{}>['step'];
-};
+		},
+	};
+	return stepController.step as any as Steps<{}>["step"];
+};

package/kernel/execute.ts

@@ -1,7 +1,7 @@
 import type { Context } from "../../../src/context";
 import { failCode } from "../../../src/fail-code";
 import schema from "../../../generated/api-schema";
-import { type ExecuteId, type ExecuteOptions, type ExecuteResult, createUlid, useLogger, runtime, loggerPushTags, headerToPlainObject, loggerSubmit, type ExecuteCoreOptions, TSON, MiddlewareEvent, reject, _validate, ExecuteStreamResult, createStep } from "..";
+import { type ExecuteId, type ExecuteOptions, type ExecuteResult, createUlid, useLogger, runtime, loggerPushTags, headerToPlainObject, loggerSubmit, type ExecuteCoreOptions, TSON, MiddlewareEvent, reject, _validate, ExecuteStreamResult, createStep, Steps } from "..";
 import { handleCatchError } from "../utils/handle-catch-error";
 
 const apis = new Map<string, any>();
@@ -28,7 +28,7 @@ export async function _call(
 			success: false,
 			fail: {
 				code: "NOT_FOUND",
-				message: failCode.NOT_FOUND(),
+				message: failCode.NOT_FOUND(undefined),
 				data: undefined,
 			},
 		} as ExecuteResult<unknown>;
@@ -55,8 +55,8 @@ export async function _call(
 		path: path as string,
 		headers,
 		logger: options.logger,
-		detail: options?.detail ?? {} as any,
-		step: createStep(),
+		detail: options?.detail ?? ({} as any),
+		step: createStep() as any,
 	};
 
 	let result: { value: unknown };
@@ -104,8 +104,8 @@ export async function _call(
 export async function _execute<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
 	path: Path,
 	options: {
-		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
-		headers?: Record<string, string> | Headers,
+		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
+		headers?: Record<string, string> | Headers;
 	} & ExecuteOptions,
 ): Promise<ExecuteResult<Result>> {
 	if (!options.headers) options.headers = {};
@@ -126,7 +126,7 @@ export async function _execute<Path extends keyof (typeof schema)["apiMethodsTyp
 		logger,
 		onAfterHeaders: (headers) => {
 			loggerPushTags(executeId, {
-				headers: headerToPlainObject(headers),
+				requestHeaders: headerToPlainObject(headers),
 			});
 		},
 	});
@@ -141,8 +141,8 @@ export async function _execute<Path extends keyof (typeof schema)["apiMethodsTyp
 export async function _executeToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(
 	path: Path,
 	options: {
-		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
-		headers?: Record<string, string> | Headers,
+		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
+		headers?: Record<string, string> | Headers;
 	} & ExecuteOptions,
 ): Promise<string> {
 	const resultsRaw = await _execute(path, options);
@@ -152,17 +152,15 @@ export async function _executeToJson<Path extends keyof (typeof schema)["apiMeth
 	} catch (error) {
 		throw reject("BUSINESS_FAIL", "This is the new API, which takes effect after restarting the server or saving any changes. It will be fixed in the future.");
 	}
-	const results = await fn.validateResults(TSON.encode(resultsRaw));
+	const results = JSON.stringify(TSON.encode(resultsRaw));
 	return results;
 }
 
-
-
 export async function _executeStream<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
 	path: Path,
 	options: {
-		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
-		headers?: Record<string, string> | Headers,
+		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
+		headers?: Record<string, string> | Headers;
 	} & ExecuteOptions,
 ): Promise<ExecuteStreamResult<Path, Result>> {
 	if (!options.headers) options.headers = {};
@@ -183,7 +181,7 @@ export async function _executeStream<Path extends keyof (typeof schema)["apiMeth
 		logger,
 		onAfterHeaders: (headers) => {
 			loggerPushTags(executeId, {
-				headers: headerToPlainObject(headers),
+				requestHeaders: headerToPlainObject(headers),
 			});
 		},
 	});
@@ -193,4 +191,4 @@ export async function _executeStream<Path extends keyof (typeof schema)["apiMeth
 	runtime.execute.executeIds.delete(executeId);
 
 	return { getResult: () => result.$result, stream: (result as any).$generator } as ExecuteStreamResult<Path, Result>;
-}
+}

package/kernel/logger.ts

@@ -21,6 +21,7 @@ export type MilkioLoggerTags = {
 	fail?: ExecuteResultFail;
 	timein?: number;
 	timeout?: number;
+	result?: unknown;
 	requestHeaders?: Record<string, string>;
 	responseHeaders?: Record<string, string>;
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "0.7.0-alpha.9",
+  "version": "0.8.0",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },
@@ -25,4 +25,4 @@
     "ts-patch": "^3.1.2",
     "typescript": "^5.3.3"
   }
-}
+}

package/scripts/gen-significant.ts

@@ -106,7 +106,6 @@ import type * as <%= utils.camel(path.slice(0, -3).replaceAll('/', '$')) %> from
 type ParamsT = Parameters<typeof <%= utils.camel(path.replaceAll('/', '$').slice(0, -${3})) %>['api']['action']>[0];
 export const validateParams = async (params: any) => typia.misc.validatePrune<ParamsT>(params);
 type ResultsT = Awaited<ReturnType<typeof <%= utils.camel(path.replaceAll('/', '$').slice(0, -${3})) %>['api']['action']>>;
-export const validateResults = async (results: any) => { _validate(typia.validate<TSONEncode<ExecuteResultSuccess<ResultsT> | ExecuteResultFail>>(results)); return typia.json.stringify<TSONEncode<ExecuteResultSuccess<ResultsT> | ExecuteResultFail>>(results); };
 export const randParams = async () => typia.random<ParamsT>();
 `.trim();
 					// export const paramsSchema = typia.json.application<[{ data: ParamsT }], "swagger">();

package/tsconfig.json

@@ -27,7 +27,4 @@
       ]
     }
   },
-  "include": [
-    "../../../**/*"
-  ]
 }

package/utils/header-to-plain-object.ts

@@ -1,8 +1,8 @@
-export const headerToPlainObject = (headers: Headers) => {
+export const headerToPlainObject = (headers: Headers): Record<string, string> => {
 	if (headers.toJSON) return headers.toJSON();
 	const plainHeaders: Record<string, string> = {};
 	headers.forEach((value, key) => {
 		plainHeaders[key] = value;
 	});
-	return headers;
+	return plainHeaders;
 };