milkio 1.3.74 → 1.3.75

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.js CHANGED
@@ -38,6 +38,311 @@ function headersToJSON(headers) {
38
38
  return json;
39
39
  }
40
40
 
41
+ // packages/milkio/cache/index.ts
42
+ /**
43
+ * milkio 进程内缓存:KV、Memo、Bloom 三种模型。
44
+ *
45
+ * 设计要点:
46
+ *
47
+ * 1. 没有序列化。值原样存放在 Map 里,可以存对象、Date、类实例。
48
+ *
49
+ * 2. 过期有两条路径:
50
+ * - 惰性过期:读命中后发现已过期,立即删除并当作未命中(保证正确性);
51
+ * - 主动清理:请求末尾触发,按表级 intervalMs 节流,每批只取 16 条,
52
+ * 本批过期比例达到 25% 才继续下一批,单次总耗时不超过 16ms。
53
+ * 没有定时器:serverless 在请求之间会冻结 CPU,定时器不可靠。
54
+ *
55
+ * 3. 容量由 maxEntries 硬约束,写入时立即淘汰最旧的一条(LRU),
56
+ * 所以主动清理只负责回收内存,不负责防止无限增长。
57
+ *
58
+ * 4. 内存水位来自 createWorld 的 memoryLimitBytes。只有运行时能读到可信的
59
+ * heapUsed(Node 进程 / Node worker)才参与判断;浏览器 Worker 与
60
+ * EdgeOne/Cloudflare 等 isolate 环境自动跳过,其余能力不受影响。
61
+ */
62
+ /** 每批清理的条目数 */
63
+ const SAMPLE_SIZE = 16;
64
+ /** 本批过期比例达到该值才继续清理下一批(Redis activeExpireCycle 的阈值策略) */
65
+ const EXPIRED_RATIO_THRESHOLD = .25;
66
+ /** 单次清理的总耗时上限(毫秒),避免请求停顿 */
67
+ const SWEEP_BUDGET_MS = 16;
68
+ /** 表级清理间隔下限(毫秒):短时大量请求同时结束时不至于反复争抢清理 */
69
+ const MIN_INTERVAL_MS = 128;
70
+ /** 单调时钟:优先 performance.now,浏览器 Worker 与 Node 都有;极端环境回退 Date.now */
71
+ const clock = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
72
+ function validateCacheOptions(options) {
73
+ if (options === null || typeof options !== "object") throw new Error("milkio cache: options is required");
74
+ if (options.expireMs !== null && (typeof options.expireMs !== "number" || !Number.isFinite(options.expireMs) || options.expireMs <= 0)) throw new Error("milkio cache: expireMs must be a positive number or null");
75
+ if (typeof options.maxEntries !== "number" || !Number.isInteger(options.maxEntries) || options.maxEntries <= 0) throw new Error("milkio cache: maxEntries must be a positive integer");
76
+ if (typeof options.intervalMs !== "number" || !Number.isInteger(options.intervalMs) || options.intervalMs < MIN_INTERVAL_MS) throw new Error(`milkio cache: intervalMs must be an integer >= ${MIN_INTERVAL_MS}`);
77
+ }
78
+ /**
79
+ * 读取当前 isolate 的堆占用。
80
+ * Node 进程、node:worker_threads、Node 实验性 Web Worker 都能读;
81
+ * Bun 的 process.memoryUsage().heapUsed 返回 0,浏览器 Worker 没有 process,
82
+ * 因此以“有限正数”作为可信判据,其余情况返回 null 让调用方降级。
83
+ */
84
+ function readHeapUsedBytes() {
85
+ const processLike = globalThis.process;
86
+ if (processLike === void 0 || typeof processLike.memoryUsage !== "function") return null;
87
+ try {
88
+ const used = processLike.memoryUsage()?.heapUsed;
89
+ if (typeof used !== "number" || !Number.isFinite(used) || used <= 0) return null;
90
+ return used;
91
+ } catch {
92
+ return null;
93
+ }
94
+ }
95
+ /**
96
+ * KV / Memo 共用的存储核心。
97
+ * 每个实例独立一张 Map,插入顺序就是 LRU 顺序:读命中时 delete + set 挪到队尾。
98
+ */
99
+ var CacheStore = class {
100
+ map = /* @__PURE__ */ new Map();
101
+ expireMs;
102
+ maxEntries;
103
+ intervalMs;
104
+ lastSweepAt = 0;
105
+ sweepIterator = null;
106
+ constructor(options) {
107
+ validateCacheOptions(options);
108
+ this.expireMs = options.expireMs;
109
+ this.maxEntries = options.maxEntries;
110
+ this.intervalMs = options.intervalMs;
111
+ }
112
+ /** 读:命中且未过期时把条目挪到队尾;已过期则删除并当作未命中 */
113
+ read(key) {
114
+ const entry = this.map.get(key);
115
+ if (entry === void 0) return { found: false };
116
+ if (entry.expireAt !== null && entry.expireAt <= clock()) {
117
+ this.map.delete(key);
118
+ return { found: false };
119
+ }
120
+ this.map.delete(key);
121
+ this.map.set(key, entry);
122
+ return {
123
+ found: true,
124
+ value: entry.value
125
+ };
126
+ }
127
+ /** 写:覆盖或新增都挪到队尾,超过 maxEntries 立即淘汰队首(最久未使用) */
128
+ write(key, value) {
129
+ const expireAt = this.expireMs === null ? null : clock() + this.expireMs;
130
+ if (this.map.has(key)) this.map.delete(key);
131
+ this.map.set(key, {
132
+ value,
133
+ expireAt
134
+ });
135
+ if (this.map.size > this.maxEntries) {
136
+ const oldest = this.map.keys().next();
137
+ if (oldest.done === false) this.map.delete(oldest.value);
138
+ }
139
+ }
140
+ has(key) {
141
+ return this.read(key).found;
142
+ }
143
+ delete(key) {
144
+ this.map.delete(key);
145
+ }
146
+ clear() {
147
+ this.map.clear();
148
+ this.sweepIterator = null;
149
+ }
150
+ /**
151
+ * 主动清理一批过期条目。
152
+ * 返回 true 表示迭代器已经走完表尾(下个 tick 从表头重新开始)。
153
+ * 迭代器跨 tick 继续,不重建、不回到表头,因此常态只检查尚未检查过的区间。
154
+ */
155
+ sweep(now, deadline) {
156
+ if (this.map.size === 0) {
157
+ this.sweepIterator = null;
158
+ return;
159
+ }
160
+ if (this.sweepIterator === null) this.sweepIterator = this.map.entries();
161
+ for (;;) {
162
+ let removedInBatch = 0;
163
+ for (let index = 0; index < SAMPLE_SIZE; index++) {
164
+ const next = this.sweepIterator.next();
165
+ if (next.done) {
166
+ this.sweepIterator = null;
167
+ return;
168
+ }
169
+ const [key, entry] = next.value;
170
+ if (entry.expireAt !== null && entry.expireAt <= now) {
171
+ this.map.delete(key);
172
+ removedInBatch += 1;
173
+ }
174
+ }
175
+ if (removedInBatch / SAMPLE_SIZE < EXPIRED_RATIO_THRESHOLD) return;
176
+ if (clock() > deadline) return;
177
+ }
178
+ }
179
+ };
180
+ const stores = [];
181
+ let cursor = 0;
182
+ let memoryLimitBytes;
183
+ /** createWorld 初始化时调用,设置全局内存水位 */
184
+ function __configureMilkioCache(options) {
185
+ memoryLimitBytes = options.memoryLimitBytes;
186
+ }
187
+ /**
188
+ * 请求末尾的缓存维护入口(由 execute 的 finales 最后一项调用)。
189
+ *
190
+ * 热路径成本:遍历所有缓存表做一次时间戳比较。表数量按“一个复杂工程最多 100 张”
191
+ * 设计,实测 100 个表约 87ns/请求。
192
+ */
193
+ function __cacheTick() {
194
+ if (stores.length === 0) return;
195
+ const now = clock();
196
+ const tickStartedAt = now;
197
+ let maintained = false;
198
+ for (let index = 0; index < stores.length; index++) {
199
+ const store = stores[(cursor + index) % stores.length];
200
+ if (now - store.lastSweepAt < store.intervalMs) continue;
201
+ if (maintained && clock() - tickStartedAt > SWEEP_BUDGET_MS) break;
202
+ store.lastSweepAt = now;
203
+ store.sweep(now, tickStartedAt + SWEEP_BUDGET_MS);
204
+ maintained = true;
205
+ }
206
+ cursor = (cursor + 1) % stores.length;
207
+ if (!maintained) return;
208
+ if (memoryLimitBytes === void 0) return;
209
+ const used = readHeapUsedBytes();
210
+ if (used === null || used <= memoryLimitBytes) return;
211
+ for (let index = 0; index < stores.length; index++) {
212
+ if (clock() - tickStartedAt > SWEEP_BUDGET_MS) break;
213
+ const store = stores[(cursor + index) % stores.length];
214
+ const quota = Math.max(1, Math.ceil(store.map.size / 16));
215
+ for (let count = 0; count < quota; count++) {
216
+ const oldest = store.map.keys().next();
217
+ if (oldest.done) break;
218
+ store.map.delete(oldest.value);
219
+ }
220
+ }
221
+ }
222
+ /** 定义 KV 缓存 */
223
+ function defineMilkioKVCache(options) {
224
+ const store = new CacheStore(options);
225
+ stores.push(store);
226
+ return {
227
+ get: (key) => {
228
+ const result = store.read(key);
229
+ return result.found ? result.value : void 0;
230
+ },
231
+ set: (key, value) => {
232
+ store.write(key, value);
233
+ return value;
234
+ },
235
+ setIfAbsent: (key, value) => {
236
+ if (store.read(key).found) return false;
237
+ store.write(key, value);
238
+ return true;
239
+ },
240
+ has: (key) => store.has(key),
241
+ delete: (key) => store.delete(key),
242
+ pull: (key) => {
243
+ const result = store.read(key);
244
+ if (result.found === false) return void 0;
245
+ store.delete(key);
246
+ return result.value;
247
+ },
248
+ clear: () => store.clear(),
249
+ size: () => store.map.size
250
+ };
251
+ }
252
+ /** 定义 Memo 缓存(闭包结果缓存,loader 必须是 async) */
253
+ function defineMilkioMemoCache(options) {
254
+ const store = new CacheStore(options);
255
+ stores.push(store);
256
+ /** 同一 key 的并发调用共用同一个 Promise,避免同时回源 */
257
+ const inflight = /* @__PURE__ */ new Map();
258
+ const run = (key, loader) => {
259
+ const cached = store.read(key);
260
+ if (cached.found) return Promise.resolve(cached.value);
261
+ const existing = inflight.get(key);
262
+ if (existing !== void 0) return existing;
263
+ const promise = Promise.resolve().then(loader).then((value) => {
264
+ inflight.delete(key);
265
+ store.write(key, value);
266
+ return value;
267
+ }, (error) => {
268
+ inflight.delete(key);
269
+ throw error;
270
+ });
271
+ inflight.set(key, promise);
272
+ return promise;
273
+ };
274
+ return {
275
+ run: ((keyOrLoader, maybeLoader) => {
276
+ if (typeof keyOrLoader === "string") return run(keyOrLoader, maybeLoader);
277
+ return run("$", keyOrLoader);
278
+ }),
279
+ delete: (key) => {
280
+ if (key === void 0) store.clear();
281
+ else store.delete(key);
282
+ },
283
+ clear: () => {
284
+ store.clear();
285
+ inflight.clear();
286
+ },
287
+ size: () => store.map.size
288
+ };
289
+ }
290
+ /** 定义布隆过滤器(无 TTL、无逐出,位图整体固定大小) */
291
+ function defineMilkioBloomFilter(options) {
292
+ if (typeof options?.expectedEntries !== "number" || !Number.isInteger(options.expectedEntries) || options.expectedEntries <= 0) throw new Error("milkio bloom filter: expectedEntries must be a positive integer");
293
+ if (typeof options?.falsePositiveRate !== "number" || !Number.isFinite(options.falsePositiveRate) || options.falsePositiveRate <= 0 || options.falsePositiveRate >= 1) throw new Error("milkio bloom filter: falsePositiveRate must be in (0, 1)");
294
+ const expectedEntries = options.expectedEntries;
295
+ const falsePositiveRate = options.falsePositiveRate;
296
+ const ln2 = Math.LN2;
297
+ const bitCount = Math.max(1, Math.ceil(-expectedEntries * Math.log(falsePositiveRate) / (ln2 * ln2)));
298
+ const hashCount = Math.max(1, Math.round(bitCount / expectedEntries * ln2));
299
+ const byteCount = Math.ceil(bitCount / 8);
300
+ let bits = new Uint8Array(byteCount);
301
+ let added = 0;
302
+ const hash1 = (value) => {
303
+ let hash = 2166136261;
304
+ for (let index = 0; index < value.length; index++) {
305
+ hash ^= value.charCodeAt(index);
306
+ hash = Math.imul(hash, 16777619);
307
+ }
308
+ return hash >>> 0;
309
+ };
310
+ const hash2 = (value) => {
311
+ let hash = 0;
312
+ for (let index = 0; index < value.length; index++) {
313
+ hash = Math.imul(hash ^ value.charCodeAt(index), 1540483477);
314
+ hash ^= hash >>> 13;
315
+ }
316
+ return hash >>> 0;
317
+ };
318
+ const testAndSet = (value, onlyTest) => {
319
+ const first = hash1(value);
320
+ const second = hash2(value) | 1;
321
+ let present = true;
322
+ for (let index = 0; index < hashCount; index++) {
323
+ const bitIndex = (first + Math.imul(index, second) >>> 0) % bitCount;
324
+ const byteIndex = bitIndex >>> 3;
325
+ const mask = 1 << (bitIndex & 7);
326
+ if (onlyTest) {
327
+ if ((bits[byteIndex] & mask) === 0) present = false;
328
+ } else bits[byteIndex] = bits[byteIndex] | mask;
329
+ }
330
+ return present;
331
+ };
332
+ return {
333
+ add: (value) => {
334
+ testAndSet(value, false);
335
+ added += 1;
336
+ },
337
+ mightContain: (value) => testAndSet(value, true),
338
+ clear: () => {
339
+ bits = new Uint8Array(byteCount);
340
+ added = 0;
341
+ },
342
+ estimatedCount: () => added
343
+ };
344
+ }
345
+
41
346
  // packages/milkio/utils/merge-deep.ts
42
347
  function isPlainObject(value) {
43
348
  return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -125,6 +430,7 @@ function __initExecuter(generated, runtime) {
125
430
  }
126
431
  const finales = [];
127
432
  const onFinally = (handler) => finales.unshift(handler);
433
+ finales.push(() => __cacheTick());
128
434
  let params;
129
435
  if (options.paramsType === "raw") {
130
436
  params = options.params;
@@ -463,6 +769,7 @@ function defineDefaultExecuteIdGenerator() {
463
769
  async function createWorld(generated, configSchema, options) {
464
770
  const executeId = options.executeId ?? defineDefaultExecuteIdGenerator();
465
771
  const config = await configSchema.get();
772
+ __configureMilkioCache({ memoryLimitBytes: options.memoryLimitBytes });
466
773
  const runtime = {
467
774
  request: /* @__PURE__ */ new Map(),
468
775
  config
@@ -492,7 +799,16 @@ async function createWorld(generated, configSchema, options) {
492
799
  emitAllApproved: eventManager.emitAllApproved,
493
800
  listener,
494
801
  config,
495
- isTestMode: config?.mode === "test"
802
+ isTestMode: config?.mode === "test",
803
+ memory: {
804
+ limitBytes: options.memoryLimitBytes,
805
+ usedBytes: () => readHeapUsedBytes(),
806
+ exceeded: () => {
807
+ if (options.memoryLimitBytes === void 0) return false;
808
+ const used = readHeapUsedBytes();
809
+ return used !== null && used > options.memoryLimitBytes;
810
+ }
811
+ }
496
812
  };
497
813
  runtime.app = world;
498
814
  if (Array.isArray(options.bootstraps)) for (const bootstrap of options.bootstraps) await bootstrap(world);
@@ -1921,5 +2237,5 @@ function failureHandler(executeId, logger, error, options = {}) {
1921
2237
  };
1922
2238
  }
1923
2239
 
1924
- export { DEFAULT_BODY_LIMIT, MilkioFaultError, __initEventManager, __initExecuter, __initListener, classifyFailure, config, createFlow, createLogger, createStep, createWorld, envToBoolean, envToNumber, envToString, fail, failureHandler, fault, isMilkioFailure, part, serializeCause, typeSafety, typia };
1925
- //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../utils/part.ts","../type-safety/index.ts","../config/index.ts","../utils/headers-to-json.ts","../utils/merge-deep.ts","../utils/revive-json-parse.ts","../execute/index.ts","../event/index.ts","../flow/index.ts","../utils/create-id.ts","../execute/execute-id-generator.ts","../world/index.ts","../typia/index.ts","../utils/send-cookbook-event.ts","../logger/index.ts","../step/index.ts","../utils/trie.ts","../utils/build-cors-headers.ts","../utils/sanitize-execute-id.ts","../listener/index.ts","../failure/index.ts"],"sourcesContent":["export function part<T extends () => unknown>(handler: T): ReturnType<T> {\n  return handler() as unknown as ReturnType<T>;\n}\n","export type TypeSafety<Value extends Record<any, any>> = (value: Value) => TypeSafetyValue;\n\nexport interface TypeSafetyValue {\n  type: <Type extends Record<any, any>>() => Type;\n}\n\nexport interface TypeSafetyType<Type extends Record<any, any>> {\n  $milkioType: \"type-safety\";\n  value: Type;\n}\n\nexport function typeSafety<Value extends Record<any, any>>(value: Value): TypeSafetyValue {\n  return {\n    type: () => ({ $milkioType: \"type-safety\", value }),\n  } as any;\n}\n","export function config<ConfigT extends Config>(config: ConfigT): ConfigT {\n  return config;\n}\n\nexport type Config = (mode: string) => Promise<Record<string, unknown>> | Record<string, unknown>;\n\nexport interface ConfigEnvironments<T extends Config> {\n  [key: string]: (env: Record<string, string>) => Partial<Awaited<ReturnType<T>>> | Promise<Partial<Awaited<ReturnType<T>>>>;\n}\n\nexport function envToString(value: string | number | undefined, defaultValue: string) {\n  if (value === undefined) return defaultValue;\n\n  return `${value}`;\n}\n\nexport function envToNumber(value: string | undefined, defaultValue: number) {\n  if (value === undefined) return defaultValue;\n\n  return Number.parseInt(value, 10);\n}\n\nexport function envToBoolean(value: string | number | undefined, defaultValue: boolean) {\n  if (value === \"true\") return true;\n\n  if (value === \"false\") return false;\n\n  if (value === \"\") return false;\n\n  if (undefined === value) return defaultValue;\n\n  return Boolean(value);\n}\n","export function headersToJSON(headers: Headers) {\n  const json: Record<string, string> = {};\n  for (const [key, value] of (headers as any).entries()) {\n    json[key] = value;\n  }\n  return json;\n}\n","function isPlainObject(value: any): value is Record<string, any> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nexport function mergeDeep<T extends Record<string, any>, U extends Record<string, any>>(target: T, source: U): T {\n  const merged = { ...target };\n\n  for (const key in source) {\n    if (!Object.prototype.hasOwnProperty.call(source, key)) continue;\n\n    const sourceValue = source[key];\n    const targetValue = target[key as keyof T];\n\n    if (Object.prototype.hasOwnProperty.call(target, key)) {\n      if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {\n        merged[key as keyof T & keyof U] = mergeDeep(targetValue, sourceValue) as any;\n      }\n    } else {\n      (merged as any)[key] = sourceValue;\n    }\n  }\n\n  return merged as T & U;\n}\n","const isoDatePattern = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?)(Z|[+-]\\d{2}:?\\d{2})?$/;\n\nfunction tryParseDate(str: string): Date | null {\n    const len = str.length;\n    if (len >= 20 && len <= 32 && str.charCodeAt(0) >= 0x30 && str.charCodeAt(0) <= 0x39 && str.indexOf('T') !== -1) {\n        const match = isoDatePattern.exec(str);\n        if (match !== null) {\n            const datePart = match[1];\n            const tzPart = match[2];\n            if (datePart === undefined) return null;\n            if (tzPart !== undefined) {\n                const normalizedTz = tzPart.length === 5 && tzPart.charAt(3) !== \":\" ? `${tzPart.slice(0, 3)}:${tzPart.slice(3)}` : tzPart;\n                return new Date(datePart + normalizedTz);\n            }\n            return new Date(datePart + 'Z');\n        }\n    }\n    return null;\n}\n\nexport function reviveJSONParse<T>(json: T): T {\n    if (json === null || json === undefined) return json;\n    if (typeof json === 'object') {\n        if (json instanceof Date) return json;\n        if (Array.isArray(json)) {\n            const len = json.length;\n            for (let i = 0; i < len; i++) {\n                const v = json[i];\n                if (typeof v === 'string') {\n                    const d = tryParseDate(v);\n                    if (d !== null) json[i] = d;\n                } else if (typeof v === 'object' && v !== null) {\n                    reviveJSONParse(v);\n                }\n            }\n            return json;\n        }\n        const obj = json as Record<string, unknown>;\n        for (const key in obj) {\n            if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n            const v = obj[key];\n            if (typeof v === 'string') {\n                const d = tryParseDate(v);\n                if (d !== null) obj[key] = d;\n            } else if (typeof v === 'object' && v !== null) {\n                reviveJSONParse(v);\n            }\n        }\n        return json;\n    }\n    if (typeof json === 'string') {\n        const d = tryParseDate(json);\n        if (d !== null) return d as any;\n    }\n    return json;\n}","import type { IValidation } from \"typia\";\nimport { fail, fault } from \"../index.ts\";\nimport type { $context, $meta, Logger, Results, GeneratedInit } from \"../index.ts\";\nimport { headersToJSON } from \"../utils/headers-to-json.ts\";\nimport { mergeDeep } from \"../utils/merge-deep.ts\";\nimport { reviveJSONParse } from \"../utils/revive-json-parse.ts\";\n\nexport function __initExecuter(generated: GeneratedInit, runtime: any) {\n    const __execute = async (\n        routeSchema: any,\n        options: {\n            createdExecuteId: string;\n            createdLogger: Logger;\n            path: string;\n            headers: Record<string, string> | Headers;\n            context: any | undefined;\n            paramsContentType?: string;\n        } & (\n                | {\n                    params: Record<any, any>;\n                    paramsType: \"raw\";\n                }\n                | {\n                    params: string;\n                    paramsType: \"string\";\n                }\n            ),\n    ): Promise<{ executeId: string; headers: Headers; params: Record<any, unknown>; results: Results<any>; context: $context; meta: Readonly<$meta>; type: \"action\" | \"stream\"; emptyResult: boolean; finales: Array<() => void | Promise<void>> }> => {\n        const type = options.path.endsWith(\"~\") ? \"stream\" : \"action\";\n        const executeId: string = options.createdExecuteId;\n        let headers: Headers;\n        if (!(options.headers instanceof Headers)) {\n            // Support lightweight headers proxy with get() method\n            if (typeof (options.headers as any)?.get === \"function\" && !(options.headers instanceof Headers)) {\n                headers = options.headers as unknown as Headers;\n                // Skip toJSON for lightweight proxy - not needed in HTTP request path\n            } else {\n                // @ts-ignore\n                headers = new Headers({\n                    ...options.headers,\n                });\n                if (!(\"toJSON\" in headers)) (headers as any).toJSON = () => headersToJSON(headers);\n            }\n        } else {\n            headers = options.headers;\n            if (!(\"toJSON\" in headers)) (headers as any).toJSON = () => headersToJSON(headers);\n        }\n\n        const finales: Array<any> = [];\n        const onFinally = (handler: any) => finales.unshift(handler);\n\n        let params: Record<any, unknown>;\n        if (options.paramsType === \"raw\") {\n            params = options.params;\n            if (typeof params === \"undefined\") params = {};\n        } else {\n            if (!options.params || options.params === \"\" || options.params === \"{}\") {\n                params = {};\n            } else if (headers.get(\"content-type\")?.startsWith(\"application/json\")) {\n                try {\n                    params = reviveJSONParse(JSON.parse(options.params));\n                } catch {\n                    throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\", contentType: headers.get(\"content-type\") ?? null, params: options.params.slice(0, 4096) });\n                }\n                if (typeof params === \"undefined\") params = {};\n            } else if (headers.get(\"content-type\")?.startsWith(\"application/x-www-form-urlencoded\")) {\n                try {\n                    const formData = new URLSearchParams(options.params);\n                    params = {};\n                    formData.forEach((value, key) => params[key] = value);\n                } catch {\n                    throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"form-urlencoded\", contentType: headers.get(\"content-type\") ?? null, params: options.params.slice(0, 4096) });\n                }\n            } else if (options.params.startsWith(\"{\")) {\n                try {\n                    params = reviveJSONParse(JSON.parse(options.params));\n                } catch {\n                    throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\", contentType: headers.get(\"content-type\") ?? null, params: options.params.slice(0, 4096) });\n                }\n            }\n            else {\n                throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\", contentType: headers.get(\"content-type\") ?? null, params: options.params.slice(0, 4096) });\n            }\n        }\n        if (typeof params !== \"object\" || Array.isArray(params)) throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\", contentType: headers.get(\"content-type\") ?? null, params: (typeof options.params === \"string\" ? options.params : JSON.stringify(options.params)).slice(0, 4096) });\n        if (\"$milkioGenerateParams\" in params && params.$milkioGenerateParams === \"enable\") {\n            if (!runtime.develop) throw fail(\"NOT_DEVELOP_MODE\", \"This feature must be in cookbook to use.\");\n            delete params.$milkioGenerateParams;\n            let paramsRand = routeSchema.randomParams();\n            if (paramsRand === undefined || paramsRand === null) paramsRand = {};\n            params = mergeDeep(params, paramsRand);\n            options.createdLogger.debug(\"✨ the generated params:\", JSON.stringify(params));\n        }\n        if (!options.context?.http?.notFound && options.context?.http?.params?.string) options.context.http.params.parsed = params;\n\n        if (!options.context) options.context = {};\n        const ctx = options.context;\n        ctx.develop = runtime.develop;\n        ctx.path = options.path;\n        ctx.routeType = type;\n        ctx.logger = options.createdLogger;\n        ctx.emit = runtime.emit;\n        ctx.emitAnyApproved = runtime.emitAnyApproved;\n        ctx.emitAllApproved = runtime.emitAllApproved;\n        ctx.executeId = options.createdExecuteId;\n        ctx.config = runtime.runtime.config;\n        ctx.typia = generated.typiaSchema;\n        ctx.call = (module: any, params: any) => __call(ctx, module, params);\n        ctx.onFinally = onFinally;\n        ctx._ = runtime;\n        ctx.fail = fail;\n        ctx.fault = fault;\n\n        const results: Results<any> = { value: undefined };\n\n        const module = routeSchema.module;\n        const meta = (module?.meta ? module?.meta : {}) as unknown as Readonly<$meta>;\n\n        if (options.context.http?.request?.method !== undefined) {\n            const allowMethods = meta?.methods ?? [\"POST\"];\n            if (!allowMethods.includes(options.context.http.request.method)) throw fail(\"METHOD_NOT_ALLOWED\", undefined);\n        }\n\n        if (meta?.typeSafety === undefined || meta.typeSafety === true || (Array.isArray(meta.typeSafety) && meta.typeSafety.includes(\"params\"))) {\n            const validation = routeSchema.validateParams(params) as IValidation<any>;\n            if (!validation.success) throw fail(\"PARAMS_TYPE_INCORRECT\", { ...(validation as any).errors[0], message: `The value '${(validation as any).errors[0].path}' is '${(validation as any).errors[0].value}', which does not meet '${(validation as any).errors[0].expected}' requirements.` });\n        }\n\n        if (runtime._hasEmitHandlers?.(\"milkio:executeBefore\") ?? true) {\n            await runtime.emit(\"milkio:executeBefore\", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context: options.context, fail, fault });\n        }\n\n        results.value = await module.handler(options.context, params);\n\n        let emptyResult = false;\n        if (results.value === undefined || results.value === null || results.value === \"\") {\n            emptyResult = true;\n            results.value = {};\n        } else if (Array.isArray(results.value) || typeof results.value !== \"object\") {\n            throw fault(\"FRAMEWORK_ERROR\", { message: `The return type of the handler must be an 'object', which is currently an '${typeof results.value}'.` });\n        }\n\n        if (runtime._hasEmitHandlers?.(\"milkio:executeAfter\") ?? true) {\n            await runtime.emit(\"milkio:executeAfter\", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context: options.context, results, fail, fault });\n        }\n\n        return { executeId, headers, params, results, context: options.context, meta, type, emptyResult, finales };\n    };\n\n    const __call = async (context: $context, module: { meta: any, handler: any }, params?: any): Promise<any> => {\n        const { handler } = await module;\n        return handler(context, params);\n    };\n\n    return {\n        __call,\n        __execute,\n    };\n}","import type { $context, ContextHttp, Results, Logger, $meta } from \"../index.ts\";\n\nexport interface $events {\n    \"*\": { key: keyof $events, value: any };\n    \"milkio:httpRequest\": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>> };\n    \"milkio:httpResponse\": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>>; context: $context; success: boolean };\n    \"milkio:httpNotFound\": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>> };\n    \"milkio:executeBefore\": { executeId: string; path: string; logger: Logger; meta: $meta; context: $context };\n    \"milkio:executeAfter\": { executeId: string; path: string; logger: Logger; meta: $meta; context: $context; results: Results<any> };\n}\n\nconst RESOLVED_PROMISE = Promise.resolve();\n\nexport function __initEventManager() {\n    const handlers = new Map<(event: any) => void, string>();\n    const indexed = new Map<string, Set<(event: any) => Promise<void | boolean> | void | boolean>>();\n    let _version = 0;\n\n    const eventManager = {\n        on: <Key extends keyof $events, Handler extends (event: $events[Key]) => Promise<void | boolean> | void | boolean>(key: Key, handler: Handler) => {\n            _version++;\n            handlers.set(handler, key as string);\n            if (key === '*') {\n                if (indexed.has('*') === false) {\n                    indexed.set('*', new Set());\n                }\n                const wildcardSet = indexed.get('*')!;\n                wildcardSet.add(handler);\n            } else {\n                if (indexed.has(key as string) === false) {\n                    indexed.set(key as string, new Set());\n                }\n                const set = indexed.get(key as string)!;\n                set.add(handler);\n            }\n\n            return () => {\n                handlers.delete(handler);\n                if (key === '*') {\n                    const wildcardSet = indexed.get('*');\n                    if (wildcardSet) {\n                        wildcardSet.delete(handler);\n                    }\n                } else {\n                    const set = indexed.get(key as string);\n                    if (set) {\n                        set.delete(handler);\n                    }\n                }\n            };\n        },\n        off: <Key extends keyof $events, Handler extends (event: $events[Key]) => void>(key: Key, handler: Handler) => {\n            _version++;\n            if (key === '*') {\n                const wildcardSet = indexed.get('*');\n                if (!wildcardSet) return;\n                handlers.delete(handler);\n                wildcardSet.delete(handler);\n            } else {\n                const set = indexed.get(key as string);\n                if (!set) return;\n                handlers.delete(handler);\n                set.delete(handler);\n            }\n        },\n        emit: <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<void> => {\n            const h = indexed.get(key as string);\n            const wildcardHandlers = indexed.get('*');\n            if (!wildcardHandlers && !h) return RESOLVED_PROMISE;\n\n            if (wildcardHandlers && h) {\n                return (async () => {\n                    for (const handler of wildcardHandlers) {\n                        await handler({ key, value });\n                    }\n                    for (const handler of h) {\n                        await handler(value);\n                    }\n                })();\n            }\n\n            if (wildcardHandlers) {\n                return (async () => {\n                    for (const handler of wildcardHandlers) {\n                        await handler({ key, value });\n                    }\n                })();\n            }\n\n            return (async () => {\n                for (const handler of h!) {\n                    await handler(value);\n                }\n            })();\n        },\n        _hasEmitHandlers: (key: string): boolean => {\n            return indexed.has(key) || indexed.has('*');\n        },\n        get _version() { return _version; },\n        emitAnyApproved: async <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<boolean> => {\n            const wildcardHandlers = indexed.get('*');\n            let accepted = false;\n            if (wildcardHandlers) {\n                for (const handler of wildcardHandlers) {\n                    if ((await handler({ key, value })) === true) {\n                        accepted = true;\n                    }\n                }\n            }\n\n            const h = indexed.get(key as string);\n            if (h) {\n                for (const handler of h) {\n                    if ((await handler(value)) === true) {\n                        accepted = true;\n                    }\n                }\n            }\n            return accepted;\n        },\n        emitAllApproved: async <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<boolean> => {\n            const wildcardHandlers = indexed.get('*');\n            let approved = true;\n            if (wildcardHandlers) {\n                for (const handler of wildcardHandlers) {\n                    if ((await handler({ key, value })) !== true) {\n                        approved = false;\n                    }\n                }\n            }\n\n            const h = indexed.get(key as string);\n            if (h) {\n                for (const handler of h) {\n                    if ((await handler(value)) !== true) {\n                        approved = false;\n                    }\n                }\n            }\n            return approved;\n        },\n    };\n\n    return eventManager;\n}\n","export type MilkioFlow<T, TReturn = any, TNext = any> = {\n  emit: (flow: T) => void;\n  [Symbol.asyncIterator]: () => MilkioFlow<T>;\n  next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;\n  return(): Promise<IteratorResult<T, TReturn>>;\n  throw(error: any): Promise<IteratorResult<T, TReturn>>;\n};\n\nexport function createFlow<T>(): MilkioFlow<T> {\n  let status: \"pending\" | \"resolved\" | \"rejected\" = \"pending\";\n  const flows: Array<{\n    blank: boolean;\n    promise: Promise<T>;\n    resolve: (value?: T | PromiseLike<T>) => void;\n    reject: (reason?: any) => void;\n  }> = [];\n\n  const iterator = {\n    emit: (flow: T) => {\n      if (flows.at(-1)?.blank === true) {\n        const item = flows.at(-1)!;\n        item.blank = false;\n        item.resolve(flow);\n        return;\n      } else {\n        const resolvers = Promise.withResolvers<T>();\n        resolvers.resolve(flow);\n        flows.push({ ...resolvers, blank: false } as any);\n      }\n    },\n    ...({\n      async next(): Promise<IteratorResult<T>> {\n        if (status !== \"pending\") return { done: true, value: null };\n        if (flows.length === 0) {\n          const resolvers = Promise.withResolvers<T>();\n          flows.push({ ...resolvers, blank: true } as any);\n        }\n        const flow = flows.at(0)!;\n        const result = await flow.promise;\n        flows.shift();\n        return { done: status !== \"pending\", value: result };\n      },\n      async return(): Promise<IteratorResult<void>> {\n        status = \"resolved\";\n        for (const flow of flows) {\n          flow.blank = false;\n          flow.resolve(undefined);\n        }\n        return { done: true, value: null };\n      },\n      async throw(err: any): Promise<IteratorResult<void>> {\n        status = \"rejected\";\n        if (flows.length === 0) {\n          const resolvers = Promise.withResolvers<T>();\n          flows.push({ ...resolvers, blank: true } as any);\n        }\n        for (const flow of flows) {\n          flow.blank = false;\n          flow.reject(err);\n        }\n        return { done: true, value: null };\n      },\n    } satisfies AsyncIterator<unknown>),\n    [Symbol.asyncIterator]() {\n      return this;\n    },\n  };\n\n  return iterator as MilkioFlow<T>;\n}\n","const ENCODING = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\nconst ENCODING_LEN = ENCODING.length;\n\nlet __fastIdPool = new Uint8Array(256);\nlet __fastIdPoolIndex = 256;\nlet __fastIdCounter = 0;\n\nexport function __createId(): string {\n    if (__fastIdPoolIndex + 16 > 256) {\n        crypto.getRandomValues(__fastIdPool);\n        __fastIdPoolIndex = 0;\n    }\n    // 前 8 字符: 时间戳 base36（Date.now().toString(36) 替代 BigInt，~100x 更快）\n    const ts = Date.now().toString(36).padStart(8, \"0\");\n    // 字符串拼接替代 Array.from + join，避免数组分配\n    let id = ts;\n    // 中间 6 字符: 纯随机\n    for (let i = 0; i < 6; i++) {\n        id += ENCODING.charAt(__fastIdPool[__fastIdPoolIndex++]! % ENCODING_LEN);\n    }\n    // 后 10 字符: 计数器 + 随机混合\n    const counter = __fastIdCounter++;\n    for (let i = 0; i < 10; i++) {\n        const mix = (counter + __fastIdPool[__fastIdPoolIndex++ % 256]!) & 0xFFFF;\n        id += ENCODING.charAt(mix % ENCODING_LEN);\n    }\n    return id;\n}\n","import { __createId } from \"../utils/create-id.ts\";\n\nexport type ExecuteIdGenerator = (headers?: Headers) => string | Promise<string>;\n\nexport function defineDefaultExecuteIdGenerator() {\n  return __createId;\n}\n","import { type $types, __initListener, __initExecuter, __initEventManager, type ExecuteId, type Logger, type Mixin, type GeneratedInit, type Ping, type LoggerSubmittingHandler, type LoggerInsertingHandler, type CorsConfig, type MilkioFaultReport } from \"../index.ts\";\nimport { defineDefaultExecuteIdGenerator } from \"../execute/execute-id-generator.ts\";\n\nexport interface MilkioInit {\n    port: number;\n    develop: boolean;\n    fetchEnv?: (key: string) => string | undefined;\n    accessKey?: string;\n    http?: {\n        cors?: CorsConfig;\n        /**\n         * HTTP request body size limit in bytes. Only applies to HTTP requests;\n         * the message/worker path has no raw body and is never limited.\n         * @default 10240 (10KB)\n         */\n        bodyLimit?: number;\n        /** Alias of `bodyLimit`. */\n        maxBodySize?: number;\n    };\n    ignorePathLevel?: number;\n    realIp?: (headers: Headers) => string;\n    executeId?: (headers: Headers) => string | Promise<string>;\n    onLoggerSubmitting?: LoggerSubmittingHandler;\n    onLoggerInserting?: LoggerInsertingHandler;\n    /** called only for fault-level failures (unexpected/internal); never for fail (business rejections) */\n    onError?: (report: MilkioFaultReport) => void;\n    bootstraps?: Array<(world: any) => Promise<void> | void>;\n}\n\nexport type MilkioRuntimeInit<T extends MilkioInit> = Mixin<\n    T,\n    {\n        executeId: (headers: Headers) => string | Promise<string>;\n        runtime: {\n            request: Map<ExecuteId, { logger: Logger }>;\n            config: Awaited<ReturnType<$types[\"generated\"][\"configSchema\"]>>;\n            app: any;\n        };\n        on: Awaited<ReturnType<typeof __initEventManager>>[\"on\"];\n        off: Awaited<ReturnType<typeof __initEventManager>>[\"off\"];\n        emit: Awaited<ReturnType<typeof __initEventManager>>[\"emit\"];\n        emitAnyApproved: Awaited<ReturnType<typeof __initEventManager>>[\"emitAnyApproved\"];\n        emitAllApproved: Awaited<ReturnType<typeof __initEventManager>>[\"emitAllApproved\"];\n        _hasEmitHandlers: Awaited<ReturnType<typeof __initEventManager>>[\"_hasEmitHandlers\"];\n        _emitHandlersVersion: number;\n    }\n>;\n\nexport async function createWorld<MilkioOptions extends MilkioInit>(generated: GeneratedInit, configSchema: { get: () => Promise<Record<any, any>> }, options: MilkioOptions): Promise<MilkioWorld<GeneratedInit, MilkioOptions>> {\n    const executeId = options.executeId ?? defineDefaultExecuteIdGenerator();\n    const config = await configSchema.get();\n\n    const runtime = {\n        request: new Map(),\n        config,\n    } as MilkioRuntimeInit<MilkioOptions>[\"runtime\"];\n\n    const eventManager = __initEventManager();\n\n    if (options.accessKey) options.ignorePathLevel = options.ignorePathLevel ? options.ignorePathLevel + 1 : 1;\n\n    const _: MilkioRuntimeInit<MilkioOptions> = {\n        ...options,\n        executeId,\n        runtime,\n        on: eventManager.on,\n        off: eventManager.off,\n        emit: eventManager.emit,\n        emitAnyApproved: eventManager.emitAnyApproved,\n        emitAllApproved: eventManager.emitAllApproved,\n        _hasEmitHandlers: eventManager._hasEmitHandlers,\n        _emitHandlersVersion: eventManager._version,\n    };\n\n    const executer = __initExecuter(generated, _);\n    const listener = __initListener(generated, _, executer);\n\n    // Initialize the app\n    const world = {\n        _,\n        // event manager\n        on: eventManager.on,\n        off: eventManager.off,\n        emit: eventManager.emit,\n        emitAnyApproved: eventManager.emitAnyApproved,\n        emitAllApproved: eventManager.emitAllApproved,\n        // listener\n        listener,\n        // function\n        config,\n        isTestMode: (config as Record<any, any>)?.mode === \"test\",\n    };\n\n    runtime.app = world;\n\n    if (Array.isArray(options.bootstraps)) {\n        for (const bootstrap of options.bootstraps) {\n            await bootstrap(world as MilkioWorld<GeneratedInit, MilkioOptions>);\n        }\n    }\n\n    await Promise.all(generated.handlerSchema.loadHandlers(world));\n\n    const routeKeys = Object.keys(generated.routeSchema as Record<string, any>);\n    const rawPaths: Array<string> = generated.rawSchema?.rawPaths ? Array.from(generated.rawSchema.rawPaths as Set<string>) : [];\n    const allRoutes = [...routeKeys, ...rawPaths];\n    console.log(`\\n△ Routes:\\n    ${allRoutes.join(\"\\n    \")}\\n  A total of ${allRoutes.length} routes.`);\n    console.log(`\\n△ Server: http://localhost:${options.port}`);\n\n    return world as MilkioWorld<GeneratedInit, MilkioOptions>;\n}\n\nexport interface MilkioWorld<Generated extends GeneratedInit, MilkioOptions extends MilkioInit = MilkioInit> {\n    _: MilkioRuntimeInit<MilkioOptions>;\n    // event manager\n    on: <Key extends keyof Generated[\"events\"], Handler extends (event: Generated[\"events\"][Key]) => void>(key: Key, handler: Handler) => (() => void);\n    off: <Key extends keyof Generated[\"events\"], Handler extends (event: Generated[\"events\"][Key]) => void>(key: Key, handler: Handler) => void;\n    emit: <Key extends keyof Generated[\"events\"], Value extends Generated[\"events\"][Key]>(key: Key, value: Value) => Promise<void>;\n    emitAnyApproved: <Key extends keyof Generated[\"events\"], Value extends Generated[\"events\"][Key]>(key: Key, value: Value) => Promise<boolean>;\n    emitAllApproved: <Key extends keyof Generated[\"events\"], Value extends Generated[\"events\"][Key]>(key: Key, value: Value) => Promise<boolean>;\n    ping: (options?: { timeout?: number }) => Promise<Ping>;\n    // listener\n    listener: Awaited<ReturnType<typeof __initListener>>;\n    config: Readonly<Awaited<ReturnType<$types[\"configSchema\"][\"get\"]>>>;\n    isTestMode: boolean;\n}\n","export function typia<TypiaInitT extends TypiaInit>(init: TypiaInitT): Typia<TypiaInitT> {\n  return init as unknown as Typia<TypiaInitT>;\n}\n\nexport type TypiaInit = () => Record<PropertyKey, unknown> | Promise<Record<PropertyKey, unknown>>;\n\nexport type Typia<TypiaInitT extends TypiaInit> = TypiaInitT;\n","import type { Log, MilkioInit, MilkioRuntimeInit } from \"../index.ts\";\n\ninterface CookbookEvent {\n  type: \"milkio@logger\";\n  log: Log;\n}\n\nexport async function sendCookbookEvent(runtime: MilkioRuntimeInit<MilkioInit>, event: CookbookEvent) {\n  // try {\n  //   const response = await fetch(`http://localhost:${runtime.cookbook.cookbookPort}/$action`, {\n  //     method: \"POST\",\n  //     headers: {\n  //       \"Content-Type\": \"application/json\",\n  //     },\n  //     body: JSON.stringify(event),\n  //   });\n  //   if (!response.ok) {\n  //     console.log(\"[COOKBOOK]\", await response.text());\n  //     console.log(\"[COOKBOOK]\", \"Is Cookbook closed? There is an abnormality in the communication with Cookbook.\");\n  //   }\n  // } catch (error) {\n  //   console.log(\"[COOKBOOK]\", error);\n  //   console.log(\"[COOKBOOK]\", \"Is Cookbook closed? There is an abnormality in the communication with Cookbook.\");\n  // }\n}\n","import type { $context, MilkioInit, MilkioRuntimeInit } from \"../index.ts\";\nimport { sendCookbookEvent } from \"../utils/send-cookbook-event.ts\";\n\nexport type Log = [\"(debug)\" | \"(info)\" | \"(warn)\" | \"(error)\" | \"(request)\" | \"(response)\", string /* executeId */, string, string, string, ...Array<unknown>];\n\nexport interface Logger {\n    _: {\n        logs: Array<Log>;\n        tags: Map<string, unknown>;\n        submit: (context: $context) => Promise<void> | void;\n    };\n    setTag: (key: string, value: unknown) => void;\n    setLog: (...log: Log) => void;\n    debug: (description: string, ...params: Array<unknown>) => Log;\n    info: (description: string, ...params: Array<unknown>) => Log;\n    warn: (description: string, ...params: Array<unknown>) => Log;\n    error: (description: string, ...params: Array<unknown>) => Log;\n    request: (description: string, ...params: Array<unknown>) => Log;\n    response: (description: string, ...params: Array<unknown>) => Log;\n}\n\nexport type LoggerInsertingHandler = (log: Log) => boolean;\n\nexport type LoggerSubmittingHandler = (context: $context, logs: Array<Log>, tags: Map<string, unknown>) => Promise<void> | void;\n\nfunction fastTimestamp(): string {\n    const d = new Date();\n    return `(${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, \"0\")}-${String(d.getDate()).padStart(2, \"0\")} ${String(d.getHours()).padStart(2, \"0\")}:${String(d.getMinutes()).padStart(2, \"0\")}:${String(d.getSeconds()).padStart(2, \"0\")})`;\n}\n\n// Pre-created default inserting handler - shared across all loggers\nconst defaultInserting = (log: Log): boolean => {\n    log[0] = `\\n${log[0]}` as any;\n    console.log(...log);\n    return true;\n};\n\nexport function createLogger<MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(runtime: MilkioRuntime, path: string, executeId: string): Logger {\n    const logger = {} as Logger;\n\n    const logs: Array<Log> = [];\n    const tags: Map<string, unknown> = new Map();\n\n    const inserting = runtime.onLoggerInserting || defaultInserting;\n    const hasSubmitting = !!runtime.onLoggerSubmitting;\n    const isDevelop = runtime.develop;\n\n    logger._ = {\n        logs,\n        tags,\n        submit: (context: $context) => {\n            if (!runtime.onLoggerSubmitting) return;\n            return runtime.onLoggerSubmitting(context, logs, tags);\n        },\n    };\n\n    const __tagPush = (key: string, value: unknown): void => {\n        tags.set(key, value);\n    };\n    const __logPush = (log: Log): Log => {\n        if (!inserting(log)) return log;\n        if (hasSubmitting) logs.push([...log]);\n        if (isDevelop) void sendCookbookEvent(runtime, { type: \"milkio@logger\", log });\n        return log;\n    };\n\n    logger.setTag = __tagPush;\n    logger.setLog = (...log: Log) => __logPush(log);\n\n    const getNow = fastTimestamp;\n\n    logger.debug = (description: string, ...params: Array<unknown>) => __logPush([\"(debug)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.info = (description: string, ...params: Array<unknown>) => __logPush([\"(info)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.warn = (description: string, ...params: Array<unknown>) => __logPush([\"(warn)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.error = (description: string, ...params: Array<unknown>) => __logPush([\"(error)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.request = (description: string, ...params: Array<unknown>) => __logPush([\"(request)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.response = (description: string, ...params: Array<unknown>) => __logPush([\"(response)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n\n    return logger;\n}\n","export interface Steps<StageT extends Record<any, any>> {\n  step: StepFunction<StageT>;\n  run: () => Promise<Remove_<StageT>>;\n}\n\ntype Remove_<T> = {\n  [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\n\ntype ToEmptyObject<T> = T extends undefined | null | never ? {} : T extends object ? T : {};\n\nexport 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>>>>;\n\nexport function createStep(): Steps<{}> {\n  const stepController = {\n    $milkioType: \"step\",\n    _steps: [] as Array<(stage: any) => Promise<any>>,\n    step(handler: (stage: any) => Promise<any>) {\n      stepController._steps.push(handler);\n      return stepController;\n    },\n    async run() {\n      let stage = {};\n      for (const step of stepController._steps) {\n        stage = { ...stage, ...(await step(stage)) };\n      }\n      const result: Record<any, any> = {};\n      for (const key in stage) {\n        const value = (stage as any)[key];\n        if (!key.startsWith(\"_\")) result[key] = value;\n      }\n      return result;\n    },\n  };\n  return stepController as any as Steps<{}>;\n}\n","export class Trie<T> {\n    private root: TrieNode<T>;\n    private cache: Map<string, T | null>;\n\n    constructor() {\n        this.root = new TrieNode();\n        this.cache = new Map();\n    }\n\n    add(path: string, value: T): void {\n        const parts = path\n            .replace(/^\\/+|\\/+$/g, \"\")\n            .split(\"/\")\n            .filter((p) => p !== \"\");\n        let currentNode = this.root;\n        if (parts.length === 0) {\n            currentNode.value = value;\n            this.cache.set(path, value);\n            return;\n        }\n        for (const part of parts) {\n            if (!currentNode.children.has(part)) {\n                currentNode.children.set(part, new TrieNode());\n            }\n            currentNode = currentNode.children.get(part)!;\n        }\n        currentNode.value = value;\n        this.cache.set(path, value);\n    }\n\n    get(path: string): T | null {\n        const cached = this.cache.get(path);\n        if (cached !== undefined) return cached;\n\n        const parts = path\n            .replace(/^\\/+|\\/+$/g, \"\")\n            .split(\"/\")\n            .filter((p) => p !== \"\");\n        let currentNode = this.root;\n        for (const part of parts) {\n            if (!currentNode.children.has(part)) {\n                return null;\n            }\n            currentNode = currentNode.children.get(part)!;\n        }\n        const result = currentNode.value;\n        if (result !== null) this.cache.set(path, result);\n        return result;\n    }\n\n    getByParts(parts: string[]): T | null {\n        let currentNode = this.root;\n        for (const part of parts) {\n            if (!currentNode.children.has(part)) return null;\n            currentNode = currentNode.children.get(part)!;\n        }\n        return currentNode.value;\n    }\n\n    has(path: string): boolean {\n        return this.get(path) !== null;\n    }\n}\n\nclass TrieNode<T> {\n    children: Map<string, TrieNode<T>>;\n    value: T | null;\n\n    constructor() {\n        this.children = new Map();\n        this.value = null;\n    }\n}\n","import type { CorsConfig } from \"../index.ts\";\n\nexport function buildCorsHeaders(cors: CorsConfig | undefined, origin?: string | null): Record<string, string> {\n    const result: Record<string, string> = {};\n    if (cors?.corsAllowMethods) result[\"Access-Control-Allow-Methods\"] = cors.corsAllowMethods.join(\", \");\n    if (cors?.corsAllowHeaders) result[\"Access-Control-Allow-Headers\"] = cors.corsAllowHeaders.join(\", \");\n    if (cors?.corsMaxAge !== undefined) result[\"Access-Control-Max-Age\"] = String(cors.corsMaxAge);\n    if (cors?.corsAllowOrigin && cors.corsAllowOrigin.length > 0) {\n        const isWildcard = cors.corsAllowOrigin.includes(\"*\");\n        if (cors.corsAllowCredentials) {\n            // When credentials: true, the spec forbids Access-Control-Allow-Origin: *.\n            // Echo the request origin instead (wildcard means \"allow any origin\").\n            if (origin && (isWildcard || cors.corsAllowOrigin.includes(origin))) {\n                result[\"Access-Control-Allow-Origin\"] = origin;\n                result[\"Vary\"] = \"Origin\";\n                result[\"Access-Control-Allow-Credentials\"] = \"true\";\n            }\n        } else {\n            if (isWildcard) {\n                result[\"Access-Control-Allow-Origin\"] = \"*\";\n            } else if (origin && cors.corsAllowOrigin.includes(origin)) {\n                result[\"Access-Control-Allow-Origin\"] = origin;\n                result[\"Vary\"] = \"Origin\";\n            }\n        }\n    }\n    if (cors?.corsExposeHeaders && cors.corsExposeHeaders.length > 0) result[\"Access-Control-Expose-Headers\"] = cors.corsExposeHeaders.join(\", \");\n    return result;\n}","export function sanitizeExecuteId(executeId: string | undefined): string {\n  const value = typeof executeId === \"string\" ? executeId : \"\";\n  return value.replace(/[^A-Za-z0-9_-]/g, \"\");\n}\n","import { createLogger, failureHandler, fail, fault } from \"../index.ts\";\nimport type { Mixin, GeneratedInit, $types, ContextHttp, MilkioResponseFailure, Results, MilkioResponseSuccess, CorsConfig, Logger, Log, MilkioFailureWire } from \"../index.ts\";\nimport type { __initExecuter } from \"../execute/index.ts\";\nimport { __createId } from \"../utils/create-id.ts\";\nimport { Trie } from \"../utils/trie.ts\";\nimport { buildCorsHeaders } from \"../utils/build-cors-headers.ts\";\nimport { reviveJSONParse } from \"../utils/revive-json-parse.ts\";\nimport { sanitizeExecuteId } from \"../utils/sanitize-execute-id.ts\";\n\nexport type MilkioHttpRequest = Request;\n\n/** HTTP request body size limit used when the runtime does not configure one: 10KB. */\nexport const DEFAULT_BODY_LIMIT = 10 * 1024;\n\nexport type MilkioHttpResponse = Mixin<\n    ResponseInit,\n    {\n        body: string | ReadableStream<Uint8Array> | Uint8Array | ArrayBuffer | Blob | null;\n        status: number;\n        headers: Record<string, string>;\n    }\n>;\n\nexport function __initListener(generated: GeneratedInit, runtime: any, executer: ReturnType<typeof __initExecuter>) {\n    const port = runtime.port;\n    const trie = new Trie<any>();\n    // Raw routes: exact keys hit in O(1); keys ending in \"/*\" are prefix routes,\n    // matched by longest prefix so nested prefixes stay deterministic.\n    const rawPaths: Set<string> = generated.rawSchema?.rawPaths ?? new Set<string>();\n    const rawPrefixes: Array<{ key: string; prefix: string }> = [];\n    for (const rawPath of rawPaths) {\n        if (rawPath.endsWith(\"/*\")) rawPrefixes.push({ key: rawPath, prefix: rawPath.slice(0, -1) });\n    }\n    rawPrefixes.sort((a, b) => b.prefix.length - a.prefix.length);\n    // HTTP only: the message/worker path never has a raw request body to limit.\n    const configuredBodyLimit = runtime.http?.bodyLimit ?? runtime.http?.maxBodySize;\n    const bodyLimit = Number.isFinite(configuredBodyLimit) && configuredBodyLimit > 0 ? configuredBodyLimit : DEFAULT_BODY_LIMIT;\n    const textEncoder = new TextEncoder();\n    // Pre-compute default CORS config and cache headers per origin\n    const cors: CorsConfig = { corsAllowMethods: [\"POST\", \"OPTIONS\"], corsAllowHeaders: [\"Content-Type\", \"Authorization\"], corsMaxAge: 0, ...runtime.http?.cors };\n    const corsHeadersCache = new Map<string, Record<string, string>>();\n    const MAX_CORS_HEADERS_CACHE_SIZE = 1024;\n    const getCorsHeaders = (origin: string | null): Record<string, string> => {\n        const key = origin ?? \"\";\n        let cached = corsHeadersCache.get(key);\n        if (cached !== undefined) return cached;\n        if (corsHeadersCache.size >= MAX_CORS_HEADERS_CACHE_SIZE) corsHeadersCache.clear();\n        cached = buildCorsHeaders(cors, origin);\n        corsHeadersCache.set(key, cached);\n        return cached;\n    };\n    // Pre-compute default response headers (without origin-specific CORS)\n    const defaultResponseHeaders: Record<string, string> = {\n        \"Cache-Control\": \"no-store\",\n        \"Content-Type\": \"application/json\",\n    };\n    // Pre-compute merged headers for null origin (most common case)\n    const defaultMergedHeaders: Record<string, string> = { ...getCorsHeaders(null), ...defaultResponseHeaders };\n\n    // Pre-allocate response template parts for Fast Path\n    const emptyResultPrefix = '{\"data\":{},\"executeId\":\"';\n    const resultPrefix = '{\"data\":';\n    const idSuffix = '\",\"success\":true}';\n    // Shared response object for Fast Path (handler returns result directly, never modifies response)\n    const fastPathResponse = { body: \"\", status: 200, headers: defaultMergedHeaders };\n\n    // Dynamic check for event handlers with version-based caching\n    let cachedNoEmitHandlers = true;\n    let lastEmitHandlersVersion = -1;\n    const checkNoEmitHandlers = (): boolean => {\n        const v = runtime._emitHandlersVersion;\n        if (v !== lastEmitHandlersVersion) {\n            lastEmitHandlersVersion = v;\n            cachedNoEmitHandlers =\n                !runtime._hasEmitHandlers?.(\"milkio:executeBefore\") &&\n                !runtime._hasEmitHandlers?.(\"milkio:executeAfter\") &&\n                !runtime._hasEmitHandlers?.(\"milkio:httpRequest\") &&\n                !runtime._hasEmitHandlers?.(\"milkio:httpResponse\") &&\n                !runtime._hasEmitHandlers?.(\"milkio:httpNotFound\");\n        }\n        return cachedNoEmitHandlers;\n    };\n    const hasOnLoggerSubmitting = !!runtime.onLoggerSubmitting;\n\n    // Shared no-op logger for fast path (used when no event handlers)\n    const noopLogger: Logger = {\n        _: { logs: [] as any, tags: new Map<string, unknown>(), submit: () => { } },\n        setTag: () => { },\n        setLog: (..._log: Log) => ({} as Log),\n        debug: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        info: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        warn: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        error: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        request: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        response: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n    };\n\n    // Pre-create base context prototype for Fast Path (shared immutable properties)\n    // `call` is defined on prototype to avoid creating a closure per request\n    const baseContextProto: any = {\n        fail,\n        fault,\n        develop: runtime.develop,\n        logger: noopLogger,\n        emit: runtime.emit,\n        emitAnyApproved: runtime.emitAnyApproved,\n        emitAllApproved: runtime.emitAllApproved,\n        config: runtime.runtime.config,\n        typia: generated.typiaSchema,\n        onFinally: () => { },\n        _: runtime,\n        call(module: any, p: any) { return executer.__call(this, module, p); },\n    };\n\n    // Hot path cache: pre-resolve the most common route\n    let cachedRouteSchema: any = null;\n    let cachedPathString: string | null = null;\n    // Cache validateParams and handler references to avoid property lookups\n    let cachedValidateParams: any = null;\n    let cachedHandler: any = null;\n    let cachedSkipValidation: boolean = false;\n\n    const fetch = async (options: {\n        request: MilkioHttpRequest;\n        envMode?: string;\n        env?: Record<any, any>;\n        routeSchema?: any;\n        rawResponse?: boolean;\n    }): Promise<Response> => {\n        // The fast path executes the handler before the full context/logger exists. When\n        // the handler throws (or returns a non-object), we must NOT fall through and run\n        // it again in the slow path: remember the failure and let the slow path only\n        // handle the error response (single execution, single log). Per request, so a\n        // concurrent request can never observe another request's failure.\n        let fastPathError: unknown;\n        const tooLarge = () => fail(\"REQUEST_TOO_LARGE\", { maxBodySize: bodyLimit });\n        const readBodyText = async (): Promise<string> => {\n            const contentLength = Number(options.request.headers.get(\"content-length\") ?? \"0\");\n            if (Number.isFinite(contentLength) && contentLength > bodyLimit) throw tooLarge();\n            const preRead = (options.request as any).__bodyText;\n            if (preRead !== undefined) {\n                // UTF-8 byte length is never smaller than the UTF-16 length, so this\n                // cheap check avoids encoding bodies a third-party adapter pre-read uncapped.\n                if (typeof preRead === \"string\" && (preRead.length > bodyLimit || textEncoder.encode(preRead).byteLength > bodyLimit)) throw tooLarge();\n                return preRead;\n            }\n            if (!options.request.body) return \"\";\n            const reader = options.request.body.getReader();\n            const decoder = new TextDecoder();\n            let byteLength = 0;\n            let text = \"\";\n            try {\n                while (true) {\n                    const { done, value } = await reader.read();\n                    if (done) break;\n                    byteLength += value.byteLength;\n                    if (byteLength > bodyLimit) {\n                        await reader.cancel().catch(() => {});\n                        throw tooLarge();\n                    }\n                    text += decoder.decode(value, { stream: true });\n                }\n                text += decoder.decode();\n            } finally {\n                reader.releaseLock();\n            }\n            return text;\n        };\n\n        // Use pre-passed origin from adapter to avoid headers.get() call\n        const origin = (options.request as any).__origin ?? options.request.headers.get(\"Origin\");\n\n        if (options.request.method === \"OPTIONS\") {\n            return new Response(undefined, {\n                headers: getCorsHeaders(origin),\n            });\n        }\n\n        // Use pre-parsed pathname and pathArray if available (from adapter), otherwise parse\n        const pathname = (options.request as any).__pathname ?? new URL(options.request.url).pathname;\n        if (pathname.endsWith(\"/generate_204\")) {\n            const corsHeaders = getCorsHeaders(origin);\n            return new Response(null, {\n                status: 204,\n                headers: {\n                    Server: \"milkio\",\n                    ...corsHeaders,\n                    \"Cache-Control\": \"no-store\",\n                    \"Content-Type\": `text/plain; time=${Date.now()}`,\n                },\n            });\n        }\n\n        const prePathArray = (options.request as any).__pathArray;\n        let pathString: string;\n        let pathArray: string[];\n        if (!runtime.accessKey && (!runtime.ignorePathLevel || runtime.ignorePathLevel === 0)) {\n            pathString = pathname;\n            pathArray = prePathArray ?? pathname.substring(1).split(\"/\");\n        } else {\n            pathArray = prePathArray ?? pathname.substring(1).split(\"/\");\n            if (runtime.accessKey && pathArray.at(0) !== runtime.accessKey) {\n                const corsHeaders = getCorsHeaders(origin);\n                if (options.rawResponse) return { __rawResponse: true, body: \"\", status: 403, headers: corsHeaders } as any;\n                return new Response(undefined, {\n                    status: 403,\n                    headers: corsHeaders,\n                });\n            }\n            if (runtime.ignorePathLevel !== undefined && runtime.ignorePathLevel !== 0) pathArray = pathArray.slice(runtime.ignorePathLevel);\n            pathString = `/${pathArray.join(\"/\")}`;\n        }\n\n        // Pre-read body text if available (from adapter), otherwise use async request.text()\n        const bodyText = (options.request as any).__bodyText;\n        const ip = runtime.realIp ? runtime.realIp(options.request.headers) : \"::1\";\n\n        // 测试环境下的 $event 端点：通过 base64 编码的事件名触发事件\n        if (options.envMode === \"test\" && pathString.startsWith(\"/$event/\")) {\n            const executeId = __createId();\n            const base64Name = decodeURIComponent(pathString.slice(8));\n            let eventName: string;\n            try {\n                // 兼容不同运行时：优先使用 atob，回退到 Buffer\n                if (typeof atob !== \"undefined\") {\n                    eventName = atob(base64Name);\n                } else if (typeof Buffer !== \"undefined\") {\n                    eventName = Buffer.from(base64Name, \"base64\").toString();\n                } else {\n                    throw new Error(\"No base64 decoder available\");\n                }\n            } catch {\n                const corsHeaders = getCorsHeaders(origin);\n                const body = JSON.stringify(failureHandler(executeId, noopLogger, fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"valid base64 event name\" }), { path: pathString, routeType: \"event\" }).response);\n                if (options.rawResponse) return { __rawResponse: true, body, status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } } as any;\n                return new Response(body, { status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } });\n            }\n\n            let eventData: any = undefined;\n            let rawBody: string;\n            try {\n                rawBody = await readBodyText();\n            } catch (error) {\n                const corsHeaders = getCorsHeaders(origin);\n                const body = JSON.stringify(failureHandler(executeId, noopLogger, error, { path: pathString, routeType: \"event\" }).response);\n                if (options.rawResponse) return { __rawResponse: true, body, status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } } as any;\n                return new Response(body, { status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } });\n            }\n            if (rawBody && rawBody !== \"\" && rawBody !== \"{}\") {\n                try {\n                    eventData = reviveJSONParse(JSON.parse(rawBody));\n                } catch {\n                    const corsHeaders = getCorsHeaders(origin);\n                    const body = JSON.stringify(failureHandler(executeId, noopLogger, fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\" }), { path: pathString, routeType: \"event\" }).response);\n                    if (options.rawResponse) return { __rawResponse: true, body, status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } } as any;\n                    return new Response(body, { status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } });\n                }\n            }\n\n            const corsHeaders = getCorsHeaders(origin);\n            const jsonHeaders = { ...corsHeaders, \"Content-Type\": \"application/json\", \"Cache-Control\": \"no-store\" };\n\n            // 自动注入 context — event 数据中约定俗成的 context 参数无法由外部传参，由服务端补全。\n            // 与 action 执行保持一致：构建完整的 context（logger/config/typia/call 等），并触发\n            // milkio:executeBefore / milkio:httpResponse 事件，使 bootstrap 可以注入 db/redis 等能力。\n            if (eventData && typeof eventData === \"object\" && !Array.isArray(eventData) && !(\"context\" in eventData)) {\n                const context: any = {};\n                context.fail = fail;\n                context.fault = fault;\n                context.develop = runtime.develop;\n                context.executeId = executeId;\n                context.path = pathString;\n                context.emit = runtime.emit;\n                context.emitAnyApproved = runtime.emitAnyApproved;\n                context.emitAllApproved = runtime.emitAllApproved;\n                context._ = runtime;\n                context.config = runtime.runtime.config;\n                context.typia = generated.typiaSchema;\n                context.call = (module: any, params: any) => executer.__call(context, module, params);\n                context.onFinally = () => {};\n                const logger = createLogger(runtime, pathString, executeId);\n                context.logger = logger;\n                context.http = {\n                    ip,\n                    params: { string: rawBody ?? \"\", parsed: eventData },\n                    request: options.request,\n                };\n                context.headers = options.request.headers;\n                eventData.context = context;\n\n                const emitHttpResponse = (success: boolean, failure?: MilkioFailureWire) => {\n                    if (runtime._hasEmitHandlers?.(\"milkio:httpResponse\") ?? true) {\n                        return runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: pathString, http: context.http, headers: options.request.headers, context, success, failure, fail, fault });\n                    }\n                };\n\n                try {\n                    // 先触发 executeBefore（bootstrap 注入 db/redis），事件处理完成后再触发\n                    // httpResponse（释放连接），与 action 的生命周期保持一致。\n                    if (runtime._hasEmitHandlers?.(\"milkio:executeBefore\") ?? true) {\n                        await runtime.emit(\"milkio:executeBefore\", { executeId, logger, path: pathString, meta: {}, context, fail, fault });\n                    }\n                    await runtime.emit(eventName, eventData);\n                } catch (emitError) {\n                    const errResult = failureHandler(executeId, logger, emitError, { path: pathString, routeType: \"event\", onError: runtime.onError });\n                    const errBody = JSON.stringify(errResult.response);\n                    try {\n                        await emitHttpResponse(false, errResult.response.error);\n                    } catch {}\n                    if (options.rawResponse) return { __rawResponse: true, body: errBody, status: 200, headers: jsonHeaders } as any;\n                    return new Response(errBody, { status: 200, headers: jsonHeaders });\n                }\n\n                try {\n                    await emitHttpResponse(true);\n                } catch {}\n            } else {\n                try {\n                    await runtime.emit(eventName, eventData);\n                } catch (emitError) {\n                    const errResult = failureHandler(executeId, noopLogger, emitError, { path: pathString, routeType: \"event\" });\n                    const errBody = JSON.stringify(errResult.response);\n                    if (options.rawResponse) return { __rawResponse: true, body: errBody, status: 200, headers: jsonHeaders } as any;\n                    return new Response(errBody, { status: 200, headers: jsonHeaders });\n                }\n            }\n\n            const body = `{\"data\":${JSON.stringify(eventData ?? {}, (key, value) => key === \"context\" ? undefined : value)},\"executeId\":\"${executeId}\",\"success\":true}`;\n            if (options.rawResponse) return { __rawResponse: true, body, status: 200, headers: jsonHeaders } as any;\n            return new Response(body, { status: 200, headers: jsonHeaders });\n        }\n\n        // ===== FAST PATH for common action requests =====\n        // Skip logger, request map, and most object creation when:\n        // - rawResponse mode (adapter)\n        // - No origin header (no CORS needed)\n        // - No event handlers registered (dynamic check)\n        // - Not a stream request\n        if (options.rawResponse && !origin && checkNoEmitHandlers()) {\n            const __isAction = (options.request as any).__isAction;\n            if (__isAction !== false) {\n                // Resolve route schema with hot cache\n                let routeSchema = options.routeSchema;\n                if (!routeSchema) {\n                    if (pathString === cachedPathString && cachedRouteSchema) {\n                        routeSchema = cachedRouteSchema;\n                    } else {\n                        routeSchema = trie.get(pathString);\n                        if (routeSchema !== null) {\n                            cachedRouteSchema = routeSchema;\n                            cachedPathString = pathString;\n                        } else {\n                            routeSchema = generated.routeSchema?.[pathString];\n                            if (routeSchema === undefined) {\n                                // 404 - fall through to slow path for proper error handling\n                            } else {\n                                if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n                                else routeSchema.module = await routeSchema.module();\n                                trie.add(pathString, routeSchema);\n                                cachedRouteSchema = routeSchema;\n                                cachedPathString = pathString;\n                            }\n                        }\n                    }\n                }\n\n                if (routeSchema && routeSchema.type === \"action\") {\n                    // Use cached function references when hitting the same route. The\n                    // route-schema cache is also filled by the slow path (and by the\n                    // hot-path assignment above), so re-initialize when the references\n                    // have never been captured.\n                    let validateParams = cachedValidateParams;\n                    let handler = cachedHandler;\n                    let skipValidation = cachedSkipValidation;\n                    if (routeSchema !== cachedRouteSchema || cachedHandler === null) {\n                        validateParams = routeSchema.validateParams;\n                        handler = routeSchema.module.handler;\n                        const meta = routeSchema.module?.meta;\n                        skipValidation = meta?.typeSafety === false || (Array.isArray(meta?.typeSafety) && !meta.typeSafety.includes(\"params\"));\n                        cachedValidateParams = validateParams;\n                        cachedHandler = handler;\n                        cachedSkipValidation = skipValidation;\n                    }\n\n                    const executeId = __createId();\n                    let body = \"\";\n                    // Parse params\n                    let params: any;\n                    let paramsOk = true;\n                    try {\n                        body = await readBodyText();\n                    } catch (error) {\n                        // Let the slow path turn the limit failure into a failure envelope.\n                        fastPathError = error;\n                        paramsOk = false;\n                    }\n                    if (paramsOk && (!body || body === \"\" || body === \"{}\")) {\n                        params = {};\n                    } else if (paramsOk) {\n                        try {\n                            params = reviveJSONParse(JSON.parse(body));\n                            if (typeof params === \"undefined\") params = {};\n                        } catch {\n                            paramsOk = false;\n                        }\n                    }\n\n                    if (paramsOk && params !== null && typeof params === \"object\" && !Array.isArray(params)) {\n                        // Skip $milkioGenerateParams in test mode\n                        if (options.envMode === \"test\" || !(\"$milkioGenerateParams\" in params)) {\n                            // Validate params when typeSafety is enabled\n                            if (!skipValidation) {\n                                const validation = validateParams(params);\n                                if (!validation.success) {\n                                    // Validation failed - fall through to slow path\n                                    paramsOk = false;\n                                }\n                            }\n\n                            if (paramsOk) {\n                                // Build minimal context using prototype for shared properties\n                                const context: any = Object.create(baseContextProto);\n                                context.path = pathString;\n                                context.routeType = \"action\";\n                                context.executeId = executeId;\n                                context.http = {\n                                    url: pathname,\n                                    ip,\n                                    path: { string: pathString, array: pathArray },\n                                    params: { string: body, parsed: params },\n                                    request: options.request,\n                                    response: fastPathResponse,\n                                    cors,\n                                };\n                                context.headers = options.request.headers;\n\n                                try {\n                                    const result = await handler(context, params);\n\n                                    if (result === undefined || result === null || result === \"\") {\n                                        return { __rawResponse: true, body: emptyResultPrefix + executeId + idSuffix, status: 200, headers: defaultMergedHeaders } as any;\n                                    } else if (!Array.isArray(result) && typeof result === \"object\") {\n                                        return { __rawResponse: true, body: resultPrefix + JSON.stringify(result) + ',\"executeId\":\"' + executeId + idSuffix, status: 200, headers: defaultMergedHeaders } as any;\n                                    }\n                                    // Invalid result type - slow path handles it as a fault, without re-running the handler\n                                    fastPathError = fault(\"FRAMEWORK_ERROR\", { message: \"The return type of the handler must be an 'object'.\" });\n                                } catch (error) {\n                                    // Handler threw - slow path handles the error response, without re-running the handler\n                                    fastPathError = error;\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        // ===== SLOW PATH =====\n        const corsHeaders = getCorsHeaders(origin);\n        const rawExecuteId = runtime?.executeId ? await runtime.executeId(options.request.headers) : __createId();\n        const executeId = sanitizeExecuteId(rawExecuteId) || __createId();\n        const anyEmitHandlers = !checkNoEmitHandlers();\n\n        const logger = createLogger(runtime, pathString, executeId);\n        if (anyEmitHandlers) runtime.runtime.request.set(executeId, { logger });\n        // Pre-compute base headers for this request (CORS + defaults)\n        const baseHeaders: Record<string, string> = origin ? { ...corsHeaders, ...defaultResponseHeaders } : defaultMergedHeaders;\n\n        let finales: Array<() => void | Promise<void>> = [];\n\n        const response: MilkioHttpResponse = {\n            body: \"\",\n            status: 200,\n            headers: { ...baseHeaders },\n        };\n\n        // Check if this is a raw route — raw routes bypass action/stream logic\n        // and let the handler own the full Request/Response lifecycle.\n        let rawRouteKey: string | undefined = rawPaths.has(pathString) ? pathString : undefined;\n        if (rawRouteKey === undefined) {\n            for (const item of rawPrefixes) {\n                if (pathString.startsWith(item.prefix)) {\n                    rawRouteKey = item.key;\n                    break;\n                }\n            }\n        }\n        const isRawPath = rawRouteKey !== undefined;\n\n        // Read the body before the try block, then rethrow the limit failure inside\n        // it so REQUEST_TOO_LARGE gets the regular failure envelope + httpResponse event.\n        let bodyString = \"\";\n        let bodyReadError: unknown;\n        if (!isRawPath && fastPathError === undefined) {\n            try {\n                bodyString = await readBodyText();\n            } catch (error) {\n                bodyReadError = error;\n            }\n        }\n\n        const http: ContextHttp = {\n            url: pathname as any,\n            ip,\n            path: { string: pathString as keyof $types[\"generated\"][\"routeSchema\"], array: pathArray },\n            params: {\n                // For raw routes, don't consume the request body — the handler\n                // needs it intact. The body will be passed via the Request object.\n                // On a fast-path error the body was already consumed by the fast path.\n                string: bodyString,\n                parsed: undefined,\n            },\n            request: options.request,\n            response,\n            cors,\n        };\n\n        const context: any = { fail, fault };\n        try {\n            // Fast path already executed the handler; only produce the error response here.\n            if (fastPathError !== undefined) throw fastPathError;\n            if (bodyReadError !== undefined) throw bodyReadError;\n\n            // Check if emit has handlers before awaiting\n            const hasHttpRequestHandlers = runtime._hasEmitHandlers?.(\"milkio:httpRequest\") ?? true;\n            if (hasHttpRequestHandlers) await runtime.emit(\"milkio:httpRequest\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n\n            // 非 test 环境下拦截 $exports 内部路径\n            if (options.envMode !== \"test\" && (http.path.string as string).includes(\"$\")) {\n                await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n            }\n\n            // ===== RAW PATH =====\n            // Raw routes receive a native Request and return a native Response.\n            // They bypass typia validation, JSON serialization, and stargate.\n            // Use case: SSE passthrough (e.g. OpenAI proxy), webhooks, binary.\n            if (isRawPath) {\n                const rawRoute = generated.rawSchema.routes[rawRouteKey as string];\n                if (!rawRoute) {\n                    await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                    throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n                }\n                // Lazy-load module on first access, then cache\n                let module: any = rawRoute.module;\n                if (typeof module === \"function\") {\n                    module = await module();\n                    rawRoute.module = module;\n                }\n                const meta = module?.meta ?? {};\n\n                // Construct full context (raw doesn't go through __execute,\n                // so we set all fields manually here)\n                context.http = http;\n                context.headers = http.request.headers;\n                context.develop = runtime.develop;\n                context.path = pathString;\n                context.routeType = \"raw\";\n                context.logger = logger;\n                context.emit = runtime.emit;\n                context.emitAnyApproved = runtime.emitAnyApproved;\n                context.emitAllApproved = runtime.emitAllApproved;\n                context.executeId = executeId;\n                context.config = runtime.runtime.config;\n                context.typia = generated.typiaSchema;\n                context.call = (mod: any, params: any) => executer.__call(context, mod, params);\n                context.onFinally = (handler: any) => finales.unshift(handler);\n                context._ = runtime;\n\n                // If adapter pre-read the body (bodyText set), reconstruct a\n                // Request with the body re-injected so the handler can read it.\n                // Otherwise, the original request body is still intact (we skipped\n                // reading it above for raw paths).\n                const handlerRequest: Request = bodyText !== undefined\n                    ? new Request(options.request.url, {\n                        method: options.request.method,\n                        headers: options.request.headers,\n                        body: bodyText || null,\n                        signal: options.request.signal,\n                    })\n                    : options.request;\n\n                const results: Results<any> = { value: undefined };\n\n                if (runtime._hasEmitHandlers?.(\"milkio:executeBefore\") ?? true) {\n                    await runtime.emit(\"milkio:executeBefore\", { executeId, logger, path: pathString, meta, context, fail, fault });\n                }\n\n                const rawResponse: Response = await module.handler(context, handlerRequest);\n                results.value = rawResponse;\n\n                if (runtime._hasEmitHandlers?.(\"milkio:executeAfter\") ?? true) {\n                    await runtime.emit(\"milkio:executeAfter\", { executeId, logger, path: pathString, meta, context, results, fail, fault });\n                }\n\n                // Apply CORS headers to the raw response\n                const finalHeaders = new Headers(rawResponse.headers);\n                for (const [k, v] of Object.entries(corsHeaders)) {\n                    if (!finalHeaders.has(k)) finalHeaders.set(k, v);\n                }\n\n                const hasHttpResponseHandlers = runtime._hasEmitHandlers?.(\"milkio:httpResponse\") ?? true;\n                if (hasHttpResponseHandlers) await runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: http.path.string as string, http, headers: http.request.headers, context, success: true, fail, fault });\n\n                // Run onFinally handlers (after httpResponse, matching action path ordering)\n                if (finales.length > 0) {\n                    for (const handler of finales) {\n                        try { await handler(); } catch (error) { logger.error(\"An error occurred inside onFinally.\", error); }\n                    }\n                }\n\n                if (hasOnLoggerSubmitting) await logger._.submit(context as any);\n                if (anyEmitHandlers) runtime.runtime.request.delete(executeId);\n\n                return new Response(rawResponse.body, {\n                    status: rawResponse.status,\n                    statusText: rawResponse.statusText,\n                    headers: finalHeaders,\n                });\n            }\n\n            if (!options.request.headers.get(\"Accept\")?.startsWith(\"text/event-stream\")) {\n                // action\n                let routeSchema = options.routeSchema;\n                if (!routeSchema) {\n                    // Hot path: check single-entry cache first\n                    if (pathString === cachedPathString && cachedRouteSchema) {\n                        routeSchema = cachedRouteSchema;\n                    } else if ((http.path.string as string).includes(\"$\")) {\n                        routeSchema = trie.get(http.path.string as string);\n                        if (routeSchema === null) {\n                            routeSchema = generated.routeSchema?.[http.path.string];\n                            if (routeSchema === undefined) {\n                                await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                                throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n                            }\n                            if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n                            else routeSchema.module = await routeSchema.module();\n                            trie.add(http.path.string as string, routeSchema);\n                        }\n                    } else {\n                        routeSchema = trie.get(http.path.string as string);\n                        if (routeSchema === null) {\n                            routeSchema = generated.routeSchema?.[http.path.string];\n                            if (routeSchema === undefined) {\n                                await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                                throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n                            }\n                            if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n                            else routeSchema.module = await routeSchema.module();\n                            trie.add(http.path.string as string, routeSchema);\n                        }\n                        // Update hot path cache\n                        cachedRouteSchema = routeSchema;\n                        cachedPathString = pathString;\n                    }\n\n                    if (routeSchema.type !== \"action\") throw fail(\"UNACCEPTABLE\", { expected: \"stream\", message: `Not acceptable, the Accept in the request header should be \"text/event-stream\". If you are using the \"@milkio/stargate\" package, please add \\`type: \"stream\"\\` to the execute options.` });\n                }\n\n                context.http = http;\n                context.headers = http.request.headers;\n                context.routeType = \"action\";\n\n                const executed = await executer.__execute(routeSchema, {\n                    createdExecuteId: executeId,\n                    createdLogger: logger,\n                    path: http.path.string as string,\n                    headers: options.request.headers as Headers,\n                    context,\n                    params: http.params.string,\n                    paramsType: \"string\",\n                    paramsContentType: \"json\",\n                });\n                finales = executed.finales;\n\n                if (response.body === \"\" && executed.results.value !== undefined) {\n                    if (executed.emptyResult) {\n                        response.body = `{\"data\":{},\"executeId\":\"${executeId}\",\"success\":true}`;\n                    } else {\n                        response.body = `{\"data\":${JSON.stringify(executed.results.value)},\"executeId\":\"${executeId}\",\"success\":true}`;\n                    }\n                }\n\n                const hasHttpResponseHandlers = runtime._hasEmitHandlers?.(\"milkio:httpResponse\") ?? true;\n                if (hasHttpResponseHandlers) await runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: http.path.string as string, http, headers: http.request.headers, context: executed.context, success: true, fail, fault });\n\n                if (finales.length > 0) {\n                    for (const handler of finales) {\n                        try {\n                            await handler();\n                        } catch (error) {\n                            logger.error(\"An error occurred inside onFinally.\", error);\n                        }\n                    }\n                }\n\n                if (hasOnLoggerSubmitting) await logger._.submit(context as any);\n                if (anyEmitHandlers) runtime.runtime.request.delete(executeId);\n                if (options.rawResponse) {\n                    return { __rawResponse: true, body: response.body, status: response.status, headers: response.headers } as any;\n                }\n                return new Response(response.body as BodyInit | null, response);\n            } else {\n                // stream\n                let routeSchema = options.routeSchema;\n                if (!routeSchema) {\n                    routeSchema = trie.get(http.path.string as string);\n                    if ((http.path.string as string).includes(\"$\") || !(http.path.string as string).endsWith(\"~\") || routeSchema === null) {\n                        routeSchema = generated.routeSchema?.[http.path.string];\n                        if (routeSchema === undefined) {\n                            await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                            throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n                        }\n                        if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n                        else routeSchema.module = await routeSchema.module();\n                        trie.add(http.path.string as string, routeSchema);\n                    }\n                    if (routeSchema.type !== \"stream\") throw fail(\"UNACCEPTABLE\", { expected: \"stream\", message: `Not acceptable, the Accept in the request header should be \"application/json\". If you are using the \"@milkio/stargate\" package, please remove \\`type: \"stream\"\\` to the execute options.` });\n                }\n\n                let streamClosed = false;\n                const handleClose = async () => {\n                    if (streamClosed) return;\n                    streamClosed = true;\n                    for (const handler of finales) {\n                        try {\n                            await handler();\n                        } catch (error) {\n                            logger.error(\"An error occurred inside onFinally.\", error);\n                        }\n                    }\n                    if (hasOnLoggerSubmitting) await logger._.submit(context as any);\n                    if (anyEmitHandlers) runtime.runtime.request.delete(executeId);\n                };\n\n                context.http = http;\n                context.headers = http.request.headers;\n                context.routeType = \"stream\";\n\n                const executed = await executer.__execute(routeSchema, {\n                    createdExecuteId: executeId,\n                    createdLogger: logger,\n                    path: http.path.string as string,\n                    headers: options.request.headers as Headers,\n                    context,\n                    params: http.params.string,\n                    paramsType: \"string\",\n                });\n                finales = executed.finales;\n                // Stream path: create new headers object to avoid polluting shared defaultMergedHeaders\n                response.headers = { ...response.headers, ...buildCorsHeaders(http.cors, origin) };\n                // @ts-ignore: bun\n                let stream: ReadableStream;\n                // @ts-ignore: bun\n                let control: ReadableStreamDirectController | ReadableStreamDefaultController;\n\n                // @ts-ignore: bun\n                if (typeof Bun !== \"undefined\") {\n                    // @ts-ignore: bun\n                    stream = new ReadableStream({\n                        type: \"direct\",\n                        // @ts-ignore: bun\n                        async pull(controller: ReadableStreamDirectController) {\n                            control = controller;\n                            try {\n                                controller.write(`data:@${JSON.stringify({ success: true, data: undefined, executeId } satisfies MilkioResponseSuccess<any>)}\\n\\n`);\n                                for await (const value of executed.results.value) {\n                                    if (!options.request.signal.aborted) {\n                                        const result: string = JSON.stringify([null, value]);\n                                        controller.write(`data:${result}\\n\\n`);\n                                    } else {\n                                        executed.results.value.return(undefined);\n                                        await handleClose();\n                                        controller.close();\n                                    }\n                                }\n                            } catch (error) {\n                                const result = failureHandler(executeId, logger, error, { path: http.path.string as string, routeType: \"stream\", onError: runtime.onError }).response;\n                                controller.write(`data:${JSON.stringify([result.error, null])}\\n\\n`);\n                            }\n                            await new Promise((resolve) => setTimeout(resolve, 0));\n                            await handleClose();\n                            controller.close();\n                        },\n                        async cancel() {\n                            await handleClose();\n                            control.close();\n                        },\n                    } as any);\n                } else {\n                    // node.js or others\n                    // @ts-ignore: bun\n                    stream = new ReadableStream({\n                        // @ts-ignore: bun\n                        async pull(controller) {\n                            control = controller;\n                            try {\n                                controller.enqueue(`data:@${JSON.stringify({ success: true, data: undefined, executeId } satisfies MilkioResponseSuccess<any>)}\\n\\n`);\n                                for await (const value of executed.results.value) {\n                                    if (!options.request.signal?.aborted) {\n                                        const result: string = JSON.stringify([null, value]);\n                                        controller.enqueue(`data:${result}\\n\\n`);\n                                    } else {\n                                        executed.results.value.return(undefined);\n                                        await handleClose();\n                                        controller.close();\n                                    }\n                                }\n                            } catch (error) {\n                                const result = failureHandler(executeId, logger, error, { path: http.path.string as string, routeType: \"stream\", onError: runtime.onError }).response;\n                                controller.enqueue(`data:${JSON.stringify([result.error, null])}\\n\\n`);\n                            }\n                            await handleClose();\n                            await new Promise((resolve) => setTimeout(resolve, 0));\n                            controller.close();\n                        },\n                        async cancel() {\n                            await handleClose();\n                            control.close();\n                        },\n                    } as any);\n                }\n\n                response.body = stream;\n                // Stream path: create new headers to avoid polluting shared object\n                response.headers = { ...response.headers, \"Content-Type\": \"text/event-stream\", \"Cache-Control\": \"no-cache\" };\n\n                await runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: http.path.string as string, http, headers: http.request.headers, context: executed.context, success: true, fail, fault });\n\n                return new Response(response.body, response);\n            }\n        } catch (error) {\n            const failureResult = failureHandler(executeId, logger, error, { path: http.path.string as string, routeType: (context as any)?.routeType, onError: runtime.onError });\n            const results: Results<MilkioResponseFailure> = { value: failureResult.response };\n            response.body = JSON.stringify(results.value);\n            // Error path: create new headers to avoid polluting shared object\n            response.headers = { ...response.headers, ...corsHeaders };\n            await runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: http.path.string as string, http, headers: http.request.headers, context, success: false, failure: failureResult.response.error, fail, fault });\n            // Run onFinally handlers even on error (important for raw routes where\n            // the handler may have registered cleanup via context.onFinally before throwing)\n            if (finales.length > 0) {\n                for (const handler of finales) {\n                    try { await handler(); } catch (e) { logger.error(\"An error occurred inside onFinally.\", e); }\n                }\n            }\n            if (hasOnLoggerSubmitting) await logger._.submit(context as any);\n            if (anyEmitHandlers) runtime.runtime.request.delete(executeId);\n            if (options.rawResponse) {\n                return { __rawResponse: true, body: response.body, status: response.status, headers: response.headers } as any;\n            }\n            return new Response(response.body as BodyInit | null, response);\n        }\n    };\n\n    const streamClosers: Map<string, { generator: AsyncGenerator; handleClose: any }> = new Map();\n    const handleMessage = async (\n        port: { postMessage(message: any): void },\n        options:\n            | {\n                executeId: string;\n                path: string;\n                params?: Record<any, any>;\n                headers?: Record<string, string>;\n            }\n            | string,\n    ) => {\n        if (typeof options === \"string\") {\n            if (options === \"PING\") {\n                port.postMessage(\"PONG\");\n            }\n            if (options.startsWith(\"CLOSE_STREAM:\")) {\n                const executeId = options.substring(\"CLOSE_STREAM:\".length);\n                const streamCloser = streamClosers.get(executeId);\n                if (streamCloser) {\n                    streamCloser.generator.return(undefined);\n                    streamCloser.handleClose(\"stream\");\n                }\n            }\n            return;\n        }\n        let routeSchema = trie.get(options.path);\n        if (routeSchema === null) {\n            routeSchema = generated.routeSchema?.[options.path];\n            if (routeSchema === undefined) {\n                throw fail(\"NOT_FOUND\", { path: options.path });\n            }\n            if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n            else routeSchema.module = await routeSchema.module();\n            trie.add(options.path, routeSchema);\n        }\n\n        const headers = new Headers(options.headers);\n        const params = options.params ?? {};\n        const logger = createLogger(runtime, options.path, options.executeId);\n        let finales: Array<() => void | Promise<void>> = [];\n\n        const http = new Proxy(\n            {},\n            {\n                get: (target, property) => {\n                    if (property === \"notFound\") return true;\n                    return undefined;\n                },\n                set: () => {\n                    throw fail(\"UNACCEPTABLE\", { expected: \"context.http\", message: \"This request was invoked through the execute method. Since no actual request was generated, the HTTP methods under the context cannot be accessed.\" });\n                },\n            },\n        );\n\n        const handleClose = async (type: \"action\" | \"stream\") => {\n            if (type === \"stream\") streamClosers.delete(options.executeId);\n            for (const handler of finales) {\n                try {\n                    await handler();\n                } catch (error) {\n                    logger.error(\"An error occurred inside onFinally.\", error);\n                }\n            }\n            await logger._.submit(context as any);\n            runtime.runtime.request.delete(options.executeId);\n        };\n\n        const context = { http: http, headers, routeType: routeSchema.type, fail, fault };\n\n        try {\n            if (routeSchema.type === \"action\") {\n                const executed = await executer.__execute(routeSchema, {\n                    createdExecuteId: options.executeId,\n                    createdLogger: logger,\n                    path: options.path,\n                    headers,\n                    context,\n                    params,\n                    paramsType: \"raw\",\n                });\n                finales = executed.finales;\n\n                await handleClose(\"action\");\n\n                if (executed.emptyResult) {\n                    port.postMessage({\n                        executeId: options.executeId,\n                        success: true,\n                        data: undefined,\n                    });\n                } else {\n                    port.postMessage({\n                        executeId: options.executeId,\n                        success: true,\n                        data: executed.results.value,\n                    });\n                }\n            }\n            if (routeSchema.type === \"stream\") {\n                const executed = await executer.__execute(routeSchema, {\n                    createdExecuteId: options.executeId,\n                    createdLogger: logger,\n                    path: options.path,\n                    headers,\n                    context,\n                    params,\n                    paramsType: \"raw\",\n                });\n                finales = executed.finales;\n\n                try {\n                    port.postMessage({ success: true, data: undefined, executeId: options.executeId, done: false });\n                    streamClosers.set(options.executeId, { generator: executed.results.value, handleClose });\n                    for await (const value of executed.results.value) {\n                        const data = { success: true, data: [null, value], executeId: options.executeId, done: false };\n                        port.postMessage(data);\n                    }\n                    port.postMessage({ success: true, data: undefined, executeId: options.executeId, done: true });\n                } catch (error) {\n                    const result = failureHandler(options.executeId, logger, error, { path: options.path, routeType: \"stream\", onError: runtime.onError }).response;\n                    port.postMessage({ success: true, data: [result.error, null], executeId: options.executeId, done: true });\n                }\n                await handleClose(\"stream\");\n            }\n        } catch (error) {\n            const result = failureHandler(options.executeId, logger, error, { path: options.path, routeType: routeSchema?.type, onError: runtime.onError }).response;\n            if (finales.length > 0) {\n                for (const handler of finales) {\n                    try { await handler(); } catch (finaleError) { logger.error(\"An error occurred inside onFinally.\", finaleError); }\n                }\n            }\n            await logger._.submit(context as any);\n            runtime.runtime.request.delete(options.executeId);\n            port.postMessage({ success: false, data: undefined, error: result.error, executeId: options.executeId, done: true });\n        }\n    };\n\n    return {\n        port,\n        bodyLimit,\n        fetch,\n        handleMessage,\n    };\n}\n","import type { MilkioResponseFailure } from \"../types/index.ts\";\nimport type { Logger } from \"../logger/index.ts\";\n\n// ---------------------------------------------------------------------------\n// fail-code: expected business rejection. warn level, no stack, cheap to build.\n// fault-code: unexpected/internal failure. error level, stack/cause, never exposed.\n// ---------------------------------------------------------------------------\n\nexport type MilkioFailureKind = \"fail\" | \"fault\";\n\n// ===== framework built-in codes =====\nexport interface $failCode {\n    NOT_FOUND: { path: string };\n    METHOD_NOT_ALLOWED: undefined;\n    PARAMS_TYPE_INCORRECT: { path: string; expected: string; value: any; message: string } | null;\n    PARAMS_TYPE_NOT_SUPPORTED: { expected: string; contentType: string | null; params: string };\n    NOT_DEVELOP_MODE: string;\n    UNACCEPTABLE: { expected: string; message: string };\n    REQUEST_TOO_LARGE: { maxBodySize: number };\n}\n\nexport interface $faultCode {\n    INTERNAL_SERVER_ERROR: undefined;\n    FRAMEWORK_ERROR: { message: string };\n    RESULTS_TYPE_INCORRECT: { path: string; expected: string; value: any; message: string } | null;\n}\n\n// ===== failure values =====\nexport interface MilkioFail<Code extends string = string, Data = unknown> {\n    readonly $milkioFailure: true;\n    readonly kind: \"fail\";\n    readonly code: Code;\n    readonly data: Data;\n}\n\nexport interface MilkioFaultShape<Code extends string = string, Data = unknown> {\n    readonly $milkioFailure: true;\n    readonly kind: \"fault\";\n    readonly code: Code;\n    readonly data: Data;\n    readonly stack?: string;\n}\n\nexport type MilkioFailure = MilkioFail | MilkioFaultShape;\n\n// ===== client-visible fault shape (real fault code/data stay server side) =====\nexport interface MilkioPublicFault {\n    readonly $milkioFailure: true;\n    readonly kind: \"fault\";\n    readonly code: \"INTERNAL_SERVER_ERROR\";\n    readonly data?: undefined;\n}\n\n// ===== wire types =====\nexport interface MilkioFailWire<Code extends string = string, Data = unknown> {\n    kind: \"fail\";\n    code: Code;\n    data: Data;\n}\n\nexport interface MilkioFaultWire {\n    kind: \"fault\";\n    code: \"INTERNAL_SERVER_ERROR\";\n}\n\nexport type MilkioFailureWire = MilkioFailWire | MilkioFaultWire;\n\n// ===== constructors =====\n/** fail: plain object only — no Error, no stack, no captureStackTrace (hot path). */\nexport function fail<Code extends string = string>(code: Code, data?: unknown): MilkioFail<Code, unknown> {\n    return { $milkioFailure: true, kind: \"fail\", code, data } as MilkioFail<Code, unknown>;\n}\n\n/** fault: Error subclass — captures stack/cause for server-side logs only. */\nexport class MilkioFaultError extends Error implements MilkioFaultShape {\n    readonly $milkioFailure = true as const;\n    readonly kind = \"fault\" as const;\n    readonly code: string;\n    readonly data: unknown;\n\n    constructor(code: string, data?: unknown, options?: { cause?: unknown; stack?: string }) {\n        super(code, options?.cause === undefined ? undefined : { cause: options.cause });\n        this.name = \"MilkioFault\";\n        this.code = code;\n        this.data = data;\n        if (options?.stack !== undefined) this.stack = options.stack;\n    }\n}\n\nexport function fault(code: string, data?: unknown, options?: { cause?: unknown }): MilkioFaultError {\n    return new MilkioFaultError(code, data, options);\n}\n\nexport function isMilkioFailure(value: unknown): value is MilkioFailure {\n    return typeof value === \"object\" && value !== null && (value as any).$milkioFailure === true;\n}\n\nexport interface MilkioFaultReport {\n    executeId: string;\n    path?: string;\n    routeType?: \"action\" | \"stream\" | \"raw\" | \"event\";\n    kind: \"fault\";\n    code: string;\n    data: unknown;\n    stack?: string;\n    cause?: unknown;\n    source: \"fault\" | \"unexpected\";\n}\n\n// cause chain is where the real reason usually lives (drizzle/fetch put it there)\nexport function serializeCause(error: unknown): string {\n    const seen = new Set<any>();\n    const causes: Array<Record<string, unknown>> = [];\n    let current = (error as any)?.cause;\n    while (current !== null && current !== undefined && typeof current === \"object\" && !seen.has(current)) {\n        seen.add(current);\n        const cause: Record<string, unknown> = {};\n        for (const key of [\"name\", \"message\", \"code\", \"errno\", \"sqlState\", \"sqlMessage\"]) {\n            if ((current as any)[key] !== undefined) cause[key] = (current as any)[key];\n        }\n        causes.push(cause);\n        current = (current as any).cause;\n    }\n    return causes.length > 0 ? JSON.stringify(causes) : \"\";\n}\n\nfunction safeStringify(value: unknown): string {\n    if (value === undefined) return \"undefined\";\n    try {\n        return JSON.stringify(value) ?? \"undefined\";\n    } catch {\n        try { return String(value); } catch { return \"[unserializable]\"; }\n    }\n}\n\ntype Classified =\n    | { kind: \"fail\"; code: string; data: unknown }\n    | { kind: \"fault\"; code: string; data: unknown; stack?: string; cause?: unknown; source: \"fault\" | \"unexpected\" };\n\nexport function classifyFailure(error: unknown): Classified {\n    if (isMilkioFailure(error)) {\n        if (error.kind === \"fail\") return { kind: \"fail\", code: error.code, data: error.data };\n        return { kind: \"fault\", code: error.code, data: error.data, stack: error.stack, source: \"fault\" };\n    }\n    return {\n        kind: \"fault\",\n        code: \"INTERNAL_SERVER_ERROR\",\n        data: undefined,\n        stack: error instanceof Error ? (error.stack ?? \"\") : \"\",\n        cause: error,\n        source: \"unexpected\",\n    };\n}\n\nexport function failureHandler(\n    executeId: string,\n    logger: Logger,\n    error: unknown,\n    options: {\n        path?: string;\n        routeType?: MilkioFaultReport[\"routeType\"];\n        onError?: (report: MilkioFaultReport) => void;\n    } = {},\n): { response: MilkioResponseFailure; report?: MilkioFaultReport } {\n    const classified = classifyFailure(error);\n\n    if (classified.kind === \"fail\") {\n        // fail: warn, no stack (never captured), data is part of the public contract\n        logger.warn(classified.code, safeStringify(classified.data));\n        return {\n            response: {\n                success: false,\n                executeId,\n                error: { kind: \"fail\", code: classified.code, data: classified.data },\n            },\n        };\n    }\n\n    // fault: log real code/data/stack/cause; client only learns \"fault + generic code\"\n    try {\n        const params: Array<unknown> = [safeStringify(classified.data)];\n        const causes = serializeCause(classified.cause ?? error);\n        if (causes !== \"\") params.push(`causes: ${causes}`);\n        if (classified.stack !== undefined && classified.stack !== \"\") params.push(`\\n${classified.stack}\\n`);\n        logger.error(classified.code, ...params);\n    } catch (_) {\n        logger.error(classified.code, safeStringify(classified.data));\n    }\n\n    const report: MilkioFaultReport = {\n        executeId,\n        path: options.path,\n        routeType: options.routeType,\n        kind: \"fault\",\n        code: classified.code,\n        data: classified.data,\n        stack: classified.stack,\n        cause: classified.cause,\n        source: classified.source,\n    };\n\n    if (options.onError !== undefined) {\n        try {\n            options.onError(report);\n        } catch (onErrorError) {\n            try {\n                logger.error(\"An error occurred inside onError.\", onErrorError);\n            } catch { /* never let alerting break error handling */ }\n        }\n    }\n\n    return {\n        response: {\n            success: false,\n            executeId,\n            error: { kind: \"fault\", code: \"INTERNAL_SERVER_ERROR\" },\n        },\n        report,\n    };\n}\n"],"mappings":"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"}
2240
+ export { DEFAULT_BODY_LIMIT, MilkioFaultError, __cacheTick, __configureMilkioCache, __initEventManager, __initExecuter, __initListener, classifyFailure, config, createFlow, createLogger, createStep, createWorld, defineMilkioBloomFilter, defineMilkioKVCache, defineMilkioMemoCache, envToBoolean, envToNumber, envToString, fail, failureHandler, fault, isMilkioFailure, part, readHeapUsedBytes, serializeCause, typeSafety, typia };
2241
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../utils/part.ts","../type-safety/index.ts","../config/index.ts","../utils/headers-to-json.ts","../cache/index.ts","../utils/merge-deep.ts","../utils/revive-json-parse.ts","../execute/index.ts","../event/index.ts","../flow/index.ts","../utils/create-id.ts","../execute/execute-id-generator.ts","../world/index.ts","../typia/index.ts","../utils/send-cookbook-event.ts","../logger/index.ts","../step/index.ts","../utils/trie.ts","../utils/build-cors-headers.ts","../utils/sanitize-execute-id.ts","../listener/index.ts","../failure/index.ts"],"sourcesContent":["export function part<T extends () => unknown>(handler: T): ReturnType<T> {\n  return handler() as unknown as ReturnType<T>;\n}\n","export type TypeSafety<Value extends Record<any, any>> = (value: Value) => TypeSafetyValue;\n\nexport interface TypeSafetyValue {\n  type: <Type extends Record<any, any>>() => Type;\n}\n\nexport interface TypeSafetyType<Type extends Record<any, any>> {\n  $milkioType: \"type-safety\";\n  value: Type;\n}\n\nexport function typeSafety<Value extends Record<any, any>>(value: Value): TypeSafetyValue {\n  return {\n    type: () => ({ $milkioType: \"type-safety\", value }),\n  } as any;\n}\n","export function config<ConfigT extends Config>(config: ConfigT): ConfigT {\n  return config;\n}\n\nexport type Config = (mode: string) => Promise<Record<string, unknown>> | Record<string, unknown>;\n\nexport interface ConfigEnvironments<T extends Config> {\n  [key: string]: (env: Record<string, string>) => Partial<Awaited<ReturnType<T>>> | Promise<Partial<Awaited<ReturnType<T>>>>;\n}\n\nexport function envToString(value: string | number | undefined, defaultValue: string) {\n  if (value === undefined) return defaultValue;\n\n  return `${value}`;\n}\n\nexport function envToNumber(value: string | undefined, defaultValue: number) {\n  if (value === undefined) return defaultValue;\n\n  return Number.parseInt(value, 10);\n}\n\nexport function envToBoolean(value: string | number | undefined, defaultValue: boolean) {\n  if (value === \"true\") return true;\n\n  if (value === \"false\") return false;\n\n  if (value === \"\") return false;\n\n  if (undefined === value) return defaultValue;\n\n  return Boolean(value);\n}\n","export function headersToJSON(headers: Headers) {\n  const json: Record<string, string> = {};\n  for (const [key, value] of (headers as any).entries()) {\n    json[key] = value;\n  }\n  return json;\n}\n","/**\n * milkio 进程内缓存：KV、Memo、Bloom 三种模型。\n *\n * 设计要点：\n *\n * 1. 没有序列化。值原样存放在 Map 里，可以存对象、Date、类实例。\n *\n * 2. 过期有两条路径：\n *    - 惰性过期：读命中后发现已过期，立即删除并当作未命中（保证正确性）；\n *    - 主动清理：请求末尾触发，按表级 intervalMs 节流，每批只取 16 条，\n *      本批过期比例达到 25% 才继续下一批，单次总耗时不超过 16ms。\n *      没有定时器：serverless 在请求之间会冻结 CPU，定时器不可靠。\n *\n * 3. 容量由 maxEntries 硬约束，写入时立即淘汰最旧的一条（LRU），\n *    所以主动清理只负责回收内存，不负责防止无限增长。\n *\n * 4. 内存水位来自 createWorld 的 memoryLimitBytes。只有运行时能读到可信的\n *    heapUsed（Node 进程 / Node worker）才参与判断；浏览器 Worker 与\n *    EdgeOne/Cloudflare 等 isolate 环境自动跳过，其余能力不受影响。\n */\n\n/** 每批清理的条目数 */\nconst SAMPLE_SIZE = 16;\n\n/** 本批过期比例达到该值才继续清理下一批（Redis activeExpireCycle 的阈值策略） */\nconst EXPIRED_RATIO_THRESHOLD = 0.25;\n\n/** 单次清理的总耗时上限（毫秒），避免请求停顿 */\nconst SWEEP_BUDGET_MS = 16;\n\n/** 表级清理间隔下限（毫秒）：短时大量请求同时结束时不至于反复争抢清理 */\nconst MIN_INTERVAL_MS = 128;\n\n/** 单调时钟：优先 performance.now，浏览器 Worker 与 Node 都有；极端环境回退 Date.now */\nconst clock: () => number = typeof performance !== \"undefined\" && typeof performance.now === \"function\" ? () => performance.now() : () => Date.now();\n\nexport type MilkioCacheOptions = {\n    /** 条目过期毫秒；永不过期必须显式传 null */\n    expireMs: number | null;\n    /** 本表条目数上限，超出时写入即淘汰最旧（LRU） */\n    maxEntries: number;\n    /** 本表主动清理间隔毫秒，最小 128 */\n    intervalMs: number;\n};\n\nexport type MilkioKVCache<T> = {\n    /** 未命中返回 undefined（与 drizzle relational query 的 findFirst 对齐） */\n    get(key: string): T | undefined;\n    set(key: string, value: T): T;\n    /** key 不存在或已过期时写入并返回 true；否则不写入返回 false */\n    setIfAbsent(key: string, value: T): boolean;\n    has(key: string): boolean;\n    delete(key: string): void;\n    /** 读取并删除 */\n    pull(key: string): T | undefined;\n    clear(): void;\n    size(): number;\n};\n\nexport type MilkioMemoCache<T> = {\n    /** 无 key 时内部固定使用 \"$\" */\n    run(loader: () => Promise<T>): Promise<T>;\n    run(key: string, loader: () => Promise<T>): Promise<T>;\n    delete(key?: string): void;\n    clear(): void;\n    size(): number;\n};\n\nexport type MilkioBloomFilter = {\n    add(value: string): void;\n    /** 有假阳性：返回 true 只代表“可能存在” */\n    mightContain(value: string): boolean;\n    clear(): void;\n    estimatedCount(): number;\n};\n\ntype CacheEntry<T> = {\n    value: T;\n    /** null 表示永不过期 */\n    expireAt: number | null;\n};\n\nfunction validateCacheOptions(options: MilkioCacheOptions): void {\n    if (options === null || typeof options !== \"object\") throw new Error(\"milkio cache: options is required\");\n    if (options.expireMs !== null && (typeof options.expireMs !== \"number\" || !Number.isFinite(options.expireMs) || options.expireMs <= 0)) {\n        throw new Error(\"milkio cache: expireMs must be a positive number or null\");\n    }\n    if (typeof options.maxEntries !== \"number\" || !Number.isInteger(options.maxEntries) || options.maxEntries <= 0) {\n        throw new Error(\"milkio cache: maxEntries must be a positive integer\");\n    }\n    if (typeof options.intervalMs !== \"number\" || !Number.isInteger(options.intervalMs) || options.intervalMs < MIN_INTERVAL_MS) {\n        throw new Error(`milkio cache: intervalMs must be an integer >= ${MIN_INTERVAL_MS}`);\n    }\n}\n\n/**\n * 读取当前 isolate 的堆占用。\n * Node 进程、node:worker_threads、Node 实验性 Web Worker 都能读；\n * Bun 的 process.memoryUsage().heapUsed 返回 0，浏览器 Worker 没有 process，\n * 因此以“有限正数”作为可信判据，其余情况返回 null 让调用方降级。\n */\nexport function readHeapUsedBytes(): number | null {\n    const processLike = (globalThis as any).process;\n    if (processLike === undefined || typeof processLike.memoryUsage !== \"function\") return null;\n    try {\n        const used = processLike.memoryUsage()?.heapUsed;\n        if (typeof used !== \"number\" || !Number.isFinite(used) || used <= 0) return null;\n        return used;\n    } catch {\n        return null;\n    }\n}\n\n/**\n * KV / Memo 共用的存储核心。\n * 每个实例独立一张 Map，插入顺序就是 LRU 顺序：读命中时 delete + set 挪到队尾。\n */\nclass CacheStore<T> {\n    readonly map = new Map<string, CacheEntry<T>>();\n    readonly expireMs: number | null;\n    readonly maxEntries: number;\n    readonly intervalMs: number;\n\n    lastSweepAt = 0;\n    private sweepIterator: Iterator<[string, CacheEntry<T>]> | null = null;\n\n    constructor(options: MilkioCacheOptions) {\n        validateCacheOptions(options);\n        this.expireMs = options.expireMs;\n        this.maxEntries = options.maxEntries;\n        this.intervalMs = options.intervalMs;\n    }\n\n    /** 读：命中且未过期时把条目挪到队尾；已过期则删除并当作未命中 */\n    read(key: string): { found: boolean; value?: T } {\n        const entry = this.map.get(key);\n        if (entry === undefined) return { found: false };\n\n        if (entry.expireAt !== null && entry.expireAt <= clock()) {\n            this.map.delete(key);\n            return { found: false };\n        }\n\n        this.map.delete(key);\n        this.map.set(key, entry);\n        return { found: true, value: entry.value };\n    }\n\n    /** 写：覆盖或新增都挪到队尾，超过 maxEntries 立即淘汰队首（最久未使用） */\n    write(key: string, value: T): void {\n        const expireAt = this.expireMs === null ? null : clock() + this.expireMs;\n\n        if (this.map.has(key)) this.map.delete(key);\n        this.map.set(key, { value, expireAt });\n\n        if (this.map.size > this.maxEntries) {\n            const oldest = this.map.keys().next();\n            if (oldest.done === false) this.map.delete(oldest.value);\n        }\n    }\n\n    has(key: string): boolean {\n        return this.read(key).found;\n    }\n\n    delete(key: string): void {\n        this.map.delete(key);\n    }\n\n    clear(): void {\n        this.map.clear();\n        this.sweepIterator = null;\n    }\n\n    /**\n     * 主动清理一批过期条目。\n     * 返回 true 表示迭代器已经走完表尾（下个 tick 从表头重新开始）。\n     * 迭代器跨 tick 继续，不重建、不回到表头，因此常态只检查尚未检查过的区间。\n     */\n    sweep(now: number, deadline: number): void {\n        if (this.map.size === 0) {\n            this.sweepIterator = null;\n            return;\n        }\n\n        if (this.sweepIterator === null) this.sweepIterator = this.map.entries();\n\n        for (;;) {\n            let removedInBatch = 0;\n\n            for (let index = 0; index < SAMPLE_SIZE; index++) {\n                const next = this.sweepIterator.next();\n                if (next.done) {\n                    this.sweepIterator = null;\n                    return;\n                }\n                const [key, entry] = next.value;\n                if (entry.expireAt !== null && entry.expireAt <= now) {\n                    this.map.delete(key);\n                    removedInBatch += 1;\n                }\n            }\n\n            // 本批过期比例低说明表内过期数据已经清理得差不多，本轮到此为止；\n            // 比例高则继续下一批，直到时间预算用尽（大量条目同时过期时快速回收）\n            if (removedInBatch / SAMPLE_SIZE < EXPIRED_RATIO_THRESHOLD) return;\n            if (clock() > deadline) return;\n        }\n    }\n}\n\nconst stores: Array<CacheStore<any>> = [];\n\nlet cursor = 0;\nlet memoryLimitBytes: number | undefined;\n\n/** createWorld 初始化时调用，设置全局内存水位 */\nexport function __configureMilkioCache(options: { memoryLimitBytes?: number }): void {\n    memoryLimitBytes = options.memoryLimitBytes;\n}\n\n/**\n * 请求末尾的缓存维护入口（由 execute 的 finales 最后一项调用）。\n *\n * 热路径成本：遍历所有缓存表做一次时间戳比较。表数量按“一个复杂工程最多 100 张”\n * 设计，实测 100 个表约 87ns/请求。\n */\nexport function __cacheTick(): void {\n    if (stores.length === 0) return;\n\n    const now = clock();\n    const tickStartedAt = now;\n    let maintained = false;\n\n    for (let index = 0; index < stores.length; index++) {\n        const store = stores[(cursor + index) % stores.length]!;\n        if (now - store.lastSweepAt < store.intervalMs) continue;\n\n        // 单次 tick 的总预算：前面的表清理耗时过多就让后面的表等下一轮，\n        // 避免一个请求里停顿太久\n        if (maintained && clock() - tickStartedAt > SWEEP_BUDGET_MS) break;\n\n        store.lastSweepAt = now;\n        store.sweep(now, tickStartedAt + SWEEP_BUDGET_MS);\n        maintained = true;\n    }\n\n    cursor = (cursor + 1) % stores.length;\n\n    if (!maintained) return;\n    if (memoryLimitBytes === undefined) return;\n\n    const used = readHeapUsedBytes();\n    if (used === null || used <= memoryLimitBytes) return;\n\n    // 超过水位：跨表按 LRU 逐出，每表约 1/16，受同一时间预算约束。\n    // 逐出是渐进的，一次不会清空缓存（重建缓存本身也要花 CPU）。\n    for (let index = 0; index < stores.length; index++) {\n        if (clock() - tickStartedAt > SWEEP_BUDGET_MS) break;\n        const store = stores[(cursor + index) % stores.length]!;\n        const quota = Math.max(1, Math.ceil(store.map.size / 16));\n        for (let count = 0; count < quota; count++) {\n            const oldest = store.map.keys().next();\n            if (oldest.done) break;\n            store.map.delete(oldest.value);\n        }\n    }\n}\n\n/** 定义 KV 缓存 */\nexport function defineMilkioKVCache<T>(options: MilkioCacheOptions): MilkioKVCache<T> {\n    const store = new CacheStore<T>(options);\n    stores.push(store);\n\n    return {\n        get: (key: string) => {\n            const result = store.read(key);\n            return result.found ? result.value : undefined;\n        },\n        set: (key: string, value: T) => {\n            store.write(key, value);\n            return value;\n        },\n        setIfAbsent: (key: string, value: T) => {\n            if (store.read(key).found) return false;\n            store.write(key, value);\n            return true;\n        },\n        has: (key: string) => store.has(key),\n        delete: (key: string) => store.delete(key),\n        pull: (key: string) => {\n            const result = store.read(key);\n            if (result.found === false) return undefined;\n            store.delete(key);\n            return result.value;\n        },\n        clear: () => store.clear(),\n        size: () => store.map.size,\n    };\n}\n\n/** 定义 Memo 缓存（闭包结果缓存，loader 必须是 async） */\nexport function defineMilkioMemoCache<T>(options: MilkioCacheOptions): MilkioMemoCache<T> {\n    const store = new CacheStore<T>(options);\n    stores.push(store);\n\n    /** 同一 key 的并发调用共用同一个 Promise，避免同时回源 */\n    const inflight = new Map<string, Promise<T>>();\n\n    const run = (key: string, loader: () => Promise<T>): Promise<T> => {\n        const cached = store.read(key);\n        if (cached.found) return Promise.resolve(cached.value as T);\n\n        const existing = inflight.get(key);\n        if (existing !== undefined) return existing;\n\n        const promise = Promise.resolve()\n            .then(loader)\n            .then(\n                (value) => {\n                    inflight.delete(key);\n                    store.write(key, value);\n                    return value;\n                },\n                (error) => {\n                    inflight.delete(key);\n                    throw error;\n                },\n            );\n\n        inflight.set(key, promise);\n        return promise;\n    };\n\n    return {\n        run: ((keyOrLoader: string | (() => Promise<T>), maybeLoader?: () => Promise<T>) => {\n            if (typeof keyOrLoader === \"string\") return run(keyOrLoader, maybeLoader!);\n            return run(\"$\", keyOrLoader as () => Promise<T>);\n        }) as MilkioMemoCache<T>[\"run\"],\n        delete: (key?: string) => {\n            if (key === undefined) store.clear();\n            else store.delete(key);\n        },\n        clear: () => {\n            store.clear();\n            inflight.clear();\n        },\n        size: () => store.map.size,\n    };\n}\n\n/** 定义布隆过滤器（无 TTL、无逐出，位图整体固定大小） */\nexport function defineMilkioBloomFilter(options: { expectedEntries: number; falsePositiveRate: number }): MilkioBloomFilter {\n    if (typeof options?.expectedEntries !== \"number\" || !Number.isInteger(options.expectedEntries) || options.expectedEntries <= 0) {\n        throw new Error(\"milkio bloom filter: expectedEntries must be a positive integer\");\n    }\n    if (typeof options?.falsePositiveRate !== \"number\" || !Number.isFinite(options.falsePositiveRate) || options.falsePositiveRate <= 0 || options.falsePositiveRate >= 1) {\n        throw new Error(\"milkio bloom filter: falsePositiveRate must be in (0, 1)\");\n    }\n\n    const expectedEntries = options.expectedEntries;\n    const falsePositiveRate = options.falsePositiveRate;\n    const ln2 = Math.LN2;\n    // m = -n·ln(p) / (ln2)²，k = (m/n)·ln2\n    const bitCount = Math.max(1, Math.ceil((-expectedEntries * Math.log(falsePositiveRate)) / (ln2 * ln2)));\n    const hashCount = Math.max(1, Math.round((bitCount / expectedEntries) * ln2));\n    const byteCount = Math.ceil(bitCount / 8);\n\n    let bits = new Uint8Array(byteCount);\n    let added = 0;\n\n    const hash1 = (value: string): number => {\n        let hash = 0x811c9dc5;\n        for (let index = 0; index < value.length; index++) {\n            hash ^= value.charCodeAt(index);\n            hash = Math.imul(hash, 0x01000193);\n        }\n        return hash >>> 0;\n    };\n\n    const hash2 = (value: string): number => {\n        let hash = 0;\n        for (let index = 0; index < value.length; index++) {\n            hash = Math.imul(hash ^ value.charCodeAt(index), 0x5bd1e995);\n            hash ^= hash >>> 13;\n        }\n        return hash >>> 0;\n    };\n\n    const testAndSet = (value: string, onlyTest: boolean): boolean => {\n        const first = hash1(value);\n        const second = hash2(value) | 1;\n        let present = true;\n        for (let index = 0; index < hashCount; index++) {\n            // Math.imul 的结果是有符号 32 位，先转无符号再取模，避免负下标绕过位图\n            const position = (first + Math.imul(index, second)) >>> 0;\n            const bitIndex = position % bitCount;\n            const byteIndex = bitIndex >>> 3;\n            const mask = 1 << (bitIndex & 7);\n            if (onlyTest) {\n                if ((bits[byteIndex]! & mask) === 0) present = false;\n            } else {\n                bits[byteIndex] = bits[byteIndex]! | mask;\n            }\n        }\n        return present;\n    };\n\n    return {\n        add: (value: string) => {\n            testAndSet(value, false);\n            added += 1;\n        },\n        mightContain: (value: string) => testAndSet(value, true),\n        clear: () => {\n            bits = new Uint8Array(byteCount);\n            added = 0;\n        },\n        estimatedCount: () => added,\n    };\n}\n","function isPlainObject(value: any): value is Record<string, any> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nexport function mergeDeep<T extends Record<string, any>, U extends Record<string, any>>(target: T, source: U): T {\n  const merged = { ...target };\n\n  for (const key in source) {\n    if (!Object.prototype.hasOwnProperty.call(source, key)) continue;\n\n    const sourceValue = source[key];\n    const targetValue = target[key as keyof T];\n\n    if (Object.prototype.hasOwnProperty.call(target, key)) {\n      if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {\n        merged[key as keyof T & keyof U] = mergeDeep(targetValue, sourceValue) as any;\n      }\n    } else {\n      (merged as any)[key] = sourceValue;\n    }\n  }\n\n  return merged as T & U;\n}\n","const isoDatePattern = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?)(Z|[+-]\\d{2}:?\\d{2})?$/;\n\nfunction tryParseDate(str: string): Date | null {\n    const len = str.length;\n    if (len >= 20 && len <= 32 && str.charCodeAt(0) >= 0x30 && str.charCodeAt(0) <= 0x39 && str.indexOf('T') !== -1) {\n        const match = isoDatePattern.exec(str);\n        if (match !== null) {\n            const datePart = match[1];\n            const tzPart = match[2];\n            if (datePart === undefined) return null;\n            if (tzPart !== undefined) {\n                const normalizedTz = tzPart.length === 5 && tzPart.charAt(3) !== \":\" ? `${tzPart.slice(0, 3)}:${tzPart.slice(3)}` : tzPart;\n                return new Date(datePart + normalizedTz);\n            }\n            return new Date(datePart + 'Z');\n        }\n    }\n    return null;\n}\n\nexport function reviveJSONParse<T>(json: T): T {\n    if (json === null || json === undefined) return json;\n    if (typeof json === 'object') {\n        if (json instanceof Date) return json;\n        if (Array.isArray(json)) {\n            const len = json.length;\n            for (let i = 0; i < len; i++) {\n                const v = json[i];\n                if (typeof v === 'string') {\n                    const d = tryParseDate(v);\n                    if (d !== null) json[i] = d;\n                } else if (typeof v === 'object' && v !== null) {\n                    reviveJSONParse(v);\n                }\n            }\n            return json;\n        }\n        const obj = json as Record<string, unknown>;\n        for (const key in obj) {\n            if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n            const v = obj[key];\n            if (typeof v === 'string') {\n                const d = tryParseDate(v);\n                if (d !== null) obj[key] = d;\n            } else if (typeof v === 'object' && v !== null) {\n                reviveJSONParse(v);\n            }\n        }\n        return json;\n    }\n    if (typeof json === 'string') {\n        const d = tryParseDate(json);\n        if (d !== null) return d as any;\n    }\n    return json;\n}","import type { IValidation } from \"typia\";\nimport { fail, fault } from \"../index.ts\";\nimport type { $context, $meta, Logger, Results, GeneratedInit } from \"../index.ts\";\nimport { headersToJSON } from \"../utils/headers-to-json.ts\";\nimport { __cacheTick } from \"../cache/index.ts\";\nimport { mergeDeep } from \"../utils/merge-deep.ts\";\nimport { reviveJSONParse } from \"../utils/revive-json-parse.ts\";\n\nexport function __initExecuter(generated: GeneratedInit, runtime: any) {\n    const __execute = async (\n        routeSchema: any,\n        options: {\n            createdExecuteId: string;\n            createdLogger: Logger;\n            path: string;\n            headers: Record<string, string> | Headers;\n            context: any | undefined;\n            paramsContentType?: string;\n        } & (\n                | {\n                    params: Record<any, any>;\n                    paramsType: \"raw\";\n                }\n                | {\n                    params: string;\n                    paramsType: \"string\";\n                }\n            ),\n    ): Promise<{ executeId: string; headers: Headers; params: Record<any, unknown>; results: Results<any>; context: $context; meta: Readonly<$meta>; type: \"action\" | \"stream\"; emptyResult: boolean; finales: Array<() => void | Promise<void>> }> => {\n        const type = options.path.endsWith(\"~\") ? \"stream\" : \"action\";\n        const executeId: string = options.createdExecuteId;\n        let headers: Headers;\n        if (!(options.headers instanceof Headers)) {\n            // Support lightweight headers proxy with get() method\n            if (typeof (options.headers as any)?.get === \"function\" && !(options.headers instanceof Headers)) {\n                headers = options.headers as unknown as Headers;\n                // Skip toJSON for lightweight proxy - not needed in HTTP request path\n            } else {\n                // @ts-ignore\n                headers = new Headers({\n                    ...options.headers,\n                });\n                if (!(\"toJSON\" in headers)) (headers as any).toJSON = () => headersToJSON(headers);\n            }\n        } else {\n            headers = options.headers;\n            if (!(\"toJSON\" in headers)) (headers as any).toJSON = () => headersToJSON(headers);\n        }\n\n        const finales: Array<any> = [];\n        const onFinally = (handler: any) => finales.unshift(handler);\n        // 缓存维护排在 finales 末尾：onFinally 是 unshift，用户钩子都会先执行，\n        // 因此它正好落在“所有钩子结束、正式响应之前”的位置\n        finales.push(() => __cacheTick());\n\n        let params: Record<any, unknown>;\n        if (options.paramsType === \"raw\") {\n            params = options.params;\n            if (typeof params === \"undefined\") params = {};\n        } else {\n            if (!options.params || options.params === \"\" || options.params === \"{}\") {\n                params = {};\n            } else if (headers.get(\"content-type\")?.startsWith(\"application/json\")) {\n                try {\n                    params = reviveJSONParse(JSON.parse(options.params));\n                } catch {\n                    throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\", contentType: headers.get(\"content-type\") ?? null, params: options.params.slice(0, 4096) });\n                }\n                if (typeof params === \"undefined\") params = {};\n            } else if (headers.get(\"content-type\")?.startsWith(\"application/x-www-form-urlencoded\")) {\n                try {\n                    const formData = new URLSearchParams(options.params);\n                    params = {};\n                    formData.forEach((value, key) => params[key] = value);\n                } catch {\n                    throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"form-urlencoded\", contentType: headers.get(\"content-type\") ?? null, params: options.params.slice(0, 4096) });\n                }\n            } else if (options.params.startsWith(\"{\")) {\n                try {\n                    params = reviveJSONParse(JSON.parse(options.params));\n                } catch {\n                    throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\", contentType: headers.get(\"content-type\") ?? null, params: options.params.slice(0, 4096) });\n                }\n            }\n            else {\n                throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\", contentType: headers.get(\"content-type\") ?? null, params: options.params.slice(0, 4096) });\n            }\n        }\n        if (typeof params !== \"object\" || Array.isArray(params)) throw fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\", contentType: headers.get(\"content-type\") ?? null, params: (typeof options.params === \"string\" ? options.params : JSON.stringify(options.params)).slice(0, 4096) });\n        if (\"$milkioGenerateParams\" in params && params.$milkioGenerateParams === \"enable\") {\n            if (!runtime.develop) throw fail(\"NOT_DEVELOP_MODE\", \"This feature must be in cookbook to use.\");\n            delete params.$milkioGenerateParams;\n            let paramsRand = routeSchema.randomParams();\n            if (paramsRand === undefined || paramsRand === null) paramsRand = {};\n            params = mergeDeep(params, paramsRand);\n            options.createdLogger.debug(\"✨ the generated params:\", JSON.stringify(params));\n        }\n        if (!options.context?.http?.notFound && options.context?.http?.params?.string) options.context.http.params.parsed = params;\n\n        if (!options.context) options.context = {};\n        const ctx = options.context;\n        ctx.develop = runtime.develop;\n        ctx.path = options.path;\n        ctx.routeType = type;\n        ctx.logger = options.createdLogger;\n        ctx.emit = runtime.emit;\n        ctx.emitAnyApproved = runtime.emitAnyApproved;\n        ctx.emitAllApproved = runtime.emitAllApproved;\n        ctx.executeId = options.createdExecuteId;\n        ctx.config = runtime.runtime.config;\n        ctx.typia = generated.typiaSchema;\n        ctx.call = (module: any, params: any) => __call(ctx, module, params);\n        ctx.onFinally = onFinally;\n        ctx._ = runtime;\n        ctx.fail = fail;\n        ctx.fault = fault;\n\n        const results: Results<any> = { value: undefined };\n\n        const module = routeSchema.module;\n        const meta = (module?.meta ? module?.meta : {}) as unknown as Readonly<$meta>;\n\n        if (options.context.http?.request?.method !== undefined) {\n            const allowMethods = meta?.methods ?? [\"POST\"];\n            if (!allowMethods.includes(options.context.http.request.method)) throw fail(\"METHOD_NOT_ALLOWED\", undefined);\n        }\n\n        if (meta?.typeSafety === undefined || meta.typeSafety === true || (Array.isArray(meta.typeSafety) && meta.typeSafety.includes(\"params\"))) {\n            const validation = routeSchema.validateParams(params) as IValidation<any>;\n            if (!validation.success) throw fail(\"PARAMS_TYPE_INCORRECT\", { ...(validation as any).errors[0], message: `The value '${(validation as any).errors[0].path}' is '${(validation as any).errors[0].value}', which does not meet '${(validation as any).errors[0].expected}' requirements.` });\n        }\n\n        if (runtime._hasEmitHandlers?.(\"milkio:executeBefore\") ?? true) {\n            await runtime.emit(\"milkio:executeBefore\", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context: options.context, fail, fault });\n        }\n\n        results.value = await module.handler(options.context, params);\n\n        let emptyResult = false;\n        if (results.value === undefined || results.value === null || results.value === \"\") {\n            emptyResult = true;\n            results.value = {};\n        } else if (Array.isArray(results.value) || typeof results.value !== \"object\") {\n            throw fault(\"FRAMEWORK_ERROR\", { message: `The return type of the handler must be an 'object', which is currently an '${typeof results.value}'.` });\n        }\n\n        if (runtime._hasEmitHandlers?.(\"milkio:executeAfter\") ?? true) {\n            await runtime.emit(\"milkio:executeAfter\", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context: options.context, results, fail, fault });\n        }\n\n        return { executeId, headers, params, results, context: options.context, meta, type, emptyResult, finales };\n    };\n\n    const __call = async (context: $context, module: { meta: any, handler: any }, params?: any): Promise<any> => {\n        const { handler } = await module;\n        return handler(context, params);\n    };\n\n    return {\n        __call,\n        __execute,\n    };\n}","import type { $context, ContextHttp, Results, Logger, $meta } from \"../index.ts\";\n\nexport interface $events {\n    \"*\": { key: keyof $events, value: any };\n    \"milkio:httpRequest\": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>> };\n    \"milkio:httpResponse\": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>>; context: $context; success: boolean };\n    \"milkio:httpNotFound\": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>> };\n    \"milkio:executeBefore\": { executeId: string; path: string; logger: Logger; meta: $meta; context: $context };\n    \"milkio:executeAfter\": { executeId: string; path: string; logger: Logger; meta: $meta; context: $context; results: Results<any> };\n}\n\nconst RESOLVED_PROMISE = Promise.resolve();\n\nexport function __initEventManager() {\n    const handlers = new Map<(event: any) => void, string>();\n    const indexed = new Map<string, Set<(event: any) => Promise<void | boolean> | void | boolean>>();\n    let _version = 0;\n\n    const eventManager = {\n        on: <Key extends keyof $events, Handler extends (event: $events[Key]) => Promise<void | boolean> | void | boolean>(key: Key, handler: Handler) => {\n            _version++;\n            handlers.set(handler, key as string);\n            if (key === '*') {\n                if (indexed.has('*') === false) {\n                    indexed.set('*', new Set());\n                }\n                const wildcardSet = indexed.get('*')!;\n                wildcardSet.add(handler);\n            } else {\n                if (indexed.has(key as string) === false) {\n                    indexed.set(key as string, new Set());\n                }\n                const set = indexed.get(key as string)!;\n                set.add(handler);\n            }\n\n            return () => {\n                handlers.delete(handler);\n                if (key === '*') {\n                    const wildcardSet = indexed.get('*');\n                    if (wildcardSet) {\n                        wildcardSet.delete(handler);\n                    }\n                } else {\n                    const set = indexed.get(key as string);\n                    if (set) {\n                        set.delete(handler);\n                    }\n                }\n            };\n        },\n        off: <Key extends keyof $events, Handler extends (event: $events[Key]) => void>(key: Key, handler: Handler) => {\n            _version++;\n            if (key === '*') {\n                const wildcardSet = indexed.get('*');\n                if (!wildcardSet) return;\n                handlers.delete(handler);\n                wildcardSet.delete(handler);\n            } else {\n                const set = indexed.get(key as string);\n                if (!set) return;\n                handlers.delete(handler);\n                set.delete(handler);\n            }\n        },\n        emit: <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<void> => {\n            const h = indexed.get(key as string);\n            const wildcardHandlers = indexed.get('*');\n            if (!wildcardHandlers && !h) return RESOLVED_PROMISE;\n\n            if (wildcardHandlers && h) {\n                return (async () => {\n                    for (const handler of wildcardHandlers) {\n                        await handler({ key, value });\n                    }\n                    for (const handler of h) {\n                        await handler(value);\n                    }\n                })();\n            }\n\n            if (wildcardHandlers) {\n                return (async () => {\n                    for (const handler of wildcardHandlers) {\n                        await handler({ key, value });\n                    }\n                })();\n            }\n\n            return (async () => {\n                for (const handler of h!) {\n                    await handler(value);\n                }\n            })();\n        },\n        _hasEmitHandlers: (key: string): boolean => {\n            return indexed.has(key) || indexed.has('*');\n        },\n        get _version() { return _version; },\n        emitAnyApproved: async <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<boolean> => {\n            const wildcardHandlers = indexed.get('*');\n            let accepted = false;\n            if (wildcardHandlers) {\n                for (const handler of wildcardHandlers) {\n                    if ((await handler({ key, value })) === true) {\n                        accepted = true;\n                    }\n                }\n            }\n\n            const h = indexed.get(key as string);\n            if (h) {\n                for (const handler of h) {\n                    if ((await handler(value)) === true) {\n                        accepted = true;\n                    }\n                }\n            }\n            return accepted;\n        },\n        emitAllApproved: async <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<boolean> => {\n            const wildcardHandlers = indexed.get('*');\n            let approved = true;\n            if (wildcardHandlers) {\n                for (const handler of wildcardHandlers) {\n                    if ((await handler({ key, value })) !== true) {\n                        approved = false;\n                    }\n                }\n            }\n\n            const h = indexed.get(key as string);\n            if (h) {\n                for (const handler of h) {\n                    if ((await handler(value)) !== true) {\n                        approved = false;\n                    }\n                }\n            }\n            return approved;\n        },\n    };\n\n    return eventManager;\n}\n","export type MilkioFlow<T, TReturn = any, TNext = any> = {\n  emit: (flow: T) => void;\n  [Symbol.asyncIterator]: () => MilkioFlow<T>;\n  next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;\n  return(): Promise<IteratorResult<T, TReturn>>;\n  throw(error: any): Promise<IteratorResult<T, TReturn>>;\n};\n\nexport function createFlow<T>(): MilkioFlow<T> {\n  let status: \"pending\" | \"resolved\" | \"rejected\" = \"pending\";\n  const flows: Array<{\n    blank: boolean;\n    promise: Promise<T>;\n    resolve: (value?: T | PromiseLike<T>) => void;\n    reject: (reason?: any) => void;\n  }> = [];\n\n  const iterator = {\n    emit: (flow: T) => {\n      if (flows.at(-1)?.blank === true) {\n        const item = flows.at(-1)!;\n        item.blank = false;\n        item.resolve(flow);\n        return;\n      } else {\n        const resolvers = Promise.withResolvers<T>();\n        resolvers.resolve(flow);\n        flows.push({ ...resolvers, blank: false } as any);\n      }\n    },\n    ...({\n      async next(): Promise<IteratorResult<T>> {\n        if (status !== \"pending\") return { done: true, value: null };\n        if (flows.length === 0) {\n          const resolvers = Promise.withResolvers<T>();\n          flows.push({ ...resolvers, blank: true } as any);\n        }\n        const flow = flows.at(0)!;\n        const result = await flow.promise;\n        flows.shift();\n        return { done: status !== \"pending\", value: result };\n      },\n      async return(): Promise<IteratorResult<void>> {\n        status = \"resolved\";\n        for (const flow of flows) {\n          flow.blank = false;\n          flow.resolve(undefined);\n        }\n        return { done: true, value: null };\n      },\n      async throw(err: any): Promise<IteratorResult<void>> {\n        status = \"rejected\";\n        if (flows.length === 0) {\n          const resolvers = Promise.withResolvers<T>();\n          flows.push({ ...resolvers, blank: true } as any);\n        }\n        for (const flow of flows) {\n          flow.blank = false;\n          flow.reject(err);\n        }\n        return { done: true, value: null };\n      },\n    } satisfies AsyncIterator<unknown>),\n    [Symbol.asyncIterator]() {\n      return this;\n    },\n  };\n\n  return iterator as MilkioFlow<T>;\n}\n","const ENCODING = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\nconst ENCODING_LEN = ENCODING.length;\n\nlet __fastIdPool = new Uint8Array(256);\nlet __fastIdPoolIndex = 256;\nlet __fastIdCounter = 0;\n\nexport function __createId(): string {\n    if (__fastIdPoolIndex + 16 > 256) {\n        crypto.getRandomValues(__fastIdPool);\n        __fastIdPoolIndex = 0;\n    }\n    // 前 8 字符: 时间戳 base36（Date.now().toString(36) 替代 BigInt，~100x 更快）\n    const ts = Date.now().toString(36).padStart(8, \"0\");\n    // 字符串拼接替代 Array.from + join，避免数组分配\n    let id = ts;\n    // 中间 6 字符: 纯随机\n    for (let i = 0; i < 6; i++) {\n        id += ENCODING.charAt(__fastIdPool[__fastIdPoolIndex++]! % ENCODING_LEN);\n    }\n    // 后 10 字符: 计数器 + 随机混合\n    const counter = __fastIdCounter++;\n    for (let i = 0; i < 10; i++) {\n        const mix = (counter + __fastIdPool[__fastIdPoolIndex++ % 256]!) & 0xFFFF;\n        id += ENCODING.charAt(mix % ENCODING_LEN);\n    }\n    return id;\n}\n","import { __createId } from \"../utils/create-id.ts\";\n\nexport type ExecuteIdGenerator = (headers?: Headers) => string | Promise<string>;\n\nexport function defineDefaultExecuteIdGenerator() {\n  return __createId;\n}\n","import { type $types, __initListener, __initExecuter, __initEventManager, type ExecuteId, type Logger, type Mixin, type GeneratedInit, type Ping, type LoggerSubmittingHandler, type LoggerInsertingHandler, type CorsConfig, type MilkioFaultReport } from \"../index.ts\";\nimport { defineDefaultExecuteIdGenerator } from \"../execute/execute-id-generator.ts\";\nimport { __configureMilkioCache, readHeapUsedBytes } from \"../cache/index.ts\";\n\nexport interface MilkioInit {\n    port: number;\n    develop: boolean;\n    fetchEnv?: (key: string) => string | undefined;\n    accessKey?: string;\n    http?: {\n        cors?: CorsConfig;\n        /**\n         * HTTP request body size limit in bytes. Only applies to HTTP requests;\n         * the message/worker path has no raw body and is never limited.\n         * @default 10240 (10KB)\n         */\n        bodyLimit?: number;\n        /** Alias of `bodyLimit`. */\n        maxBodySize?: number;\n    };\n    ignorePathLevel?: number;\n    realIp?: (headers: Headers) => string;\n    executeId?: (headers: Headers) => string | Promise<string>;\n    onLoggerSubmitting?: LoggerSubmittingHandler;\n    onLoggerInserting?: LoggerInsertingHandler;\n    /** called only for fault-level failures (unexpected/internal); never for fail (business rejections) */\n    onError?: (report: MilkioFaultReport) => void;\n    /**\n     * 全局内存水位（字节）。运行时能读到可信的堆占用（Node 进程 / Node worker）时，\n     * 缓存在超过该水位后渐进逐出；不传则不检查水位。\n     */\n    memoryLimitBytes?: number;\n    bootstraps?: Array<(world: any) => Promise<void> | void>;\n}\n\nexport type MilkioRuntimeInit<T extends MilkioInit> = Mixin<\n    T,\n    {\n        executeId: (headers: Headers) => string | Promise<string>;\n        runtime: {\n            request: Map<ExecuteId, { logger: Logger }>;\n            config: Awaited<ReturnType<$types[\"generated\"][\"configSchema\"]>>;\n            app: any;\n        };\n        on: Awaited<ReturnType<typeof __initEventManager>>[\"on\"];\n        off: Awaited<ReturnType<typeof __initEventManager>>[\"off\"];\n        emit: Awaited<ReturnType<typeof __initEventManager>>[\"emit\"];\n        emitAnyApproved: Awaited<ReturnType<typeof __initEventManager>>[\"emitAnyApproved\"];\n        emitAllApproved: Awaited<ReturnType<typeof __initEventManager>>[\"emitAllApproved\"];\n        _hasEmitHandlers: Awaited<ReturnType<typeof __initEventManager>>[\"_hasEmitHandlers\"];\n        _emitHandlersVersion: number;\n    }\n>;\n\nexport async function createWorld<MilkioOptions extends MilkioInit>(generated: GeneratedInit, configSchema: { get: () => Promise<Record<any, any>> }, options: MilkioOptions): Promise<MilkioWorld<GeneratedInit, MilkioOptions>> {\n    const executeId = options.executeId ?? defineDefaultExecuteIdGenerator();\n    const config = await configSchema.get();\n    __configureMilkioCache({ memoryLimitBytes: options.memoryLimitBytes });\n\n    const runtime = {\n        request: new Map(),\n        config,\n    } as MilkioRuntimeInit<MilkioOptions>[\"runtime\"];\n\n    const eventManager = __initEventManager();\n\n    if (options.accessKey) options.ignorePathLevel = options.ignorePathLevel ? options.ignorePathLevel + 1 : 1;\n\n    const _: MilkioRuntimeInit<MilkioOptions> = {\n        ...options,\n        executeId,\n        runtime,\n        on: eventManager.on,\n        off: eventManager.off,\n        emit: eventManager.emit,\n        emitAnyApproved: eventManager.emitAnyApproved,\n        emitAllApproved: eventManager.emitAllApproved,\n        _hasEmitHandlers: eventManager._hasEmitHandlers,\n        _emitHandlersVersion: eventManager._version,\n    };\n\n    const executer = __initExecuter(generated, _);\n    const listener = __initListener(generated, _, executer);\n\n    // Initialize the app\n    const world = {\n        _,\n        // event manager\n        on: eventManager.on,\n        off: eventManager.off,\n        emit: eventManager.emit,\n        emitAnyApproved: eventManager.emitAnyApproved,\n        emitAllApproved: eventManager.emitAllApproved,\n        // listener\n        listener,\n        // function\n        config,\n        isTestMode: (config as Record<any, any>)?.mode === \"test\",\n        // 内存水位：供缓存与未来其他需要判断内存压力的功能复用\n        memory: {\n            limitBytes: options.memoryLimitBytes,\n            usedBytes: () => readHeapUsedBytes(),\n            exceeded: () => {\n                if (options.memoryLimitBytes === undefined) return false;\n                const used = readHeapUsedBytes();\n                return used !== null && used > options.memoryLimitBytes;\n            },\n        },\n    };\n\n    runtime.app = world;\n\n    if (Array.isArray(options.bootstraps)) {\n        for (const bootstrap of options.bootstraps) {\n            await bootstrap(world as MilkioWorld<GeneratedInit, MilkioOptions>);\n        }\n    }\n\n    await Promise.all(generated.handlerSchema.loadHandlers(world));\n\n    const routeKeys = Object.keys(generated.routeSchema as Record<string, any>);\n    const rawPaths: Array<string> = generated.rawSchema?.rawPaths ? Array.from(generated.rawSchema.rawPaths as Set<string>) : [];\n    const allRoutes = [...routeKeys, ...rawPaths];\n    console.log(`\\n△ Routes:\\n    ${allRoutes.join(\"\\n    \")}\\n  A total of ${allRoutes.length} routes.`);\n    console.log(`\\n△ Server: http://localhost:${options.port}`);\n\n    return world as MilkioWorld<GeneratedInit, MilkioOptions>;\n}\n\nexport interface MilkioWorld<Generated extends GeneratedInit, MilkioOptions extends MilkioInit = MilkioInit> {\n    _: MilkioRuntimeInit<MilkioOptions>;\n    // event manager\n    on: <Key extends keyof Generated[\"events\"], Handler extends (event: Generated[\"events\"][Key]) => void>(key: Key, handler: Handler) => (() => void);\n    off: <Key extends keyof Generated[\"events\"], Handler extends (event: Generated[\"events\"][Key]) => void>(key: Key, handler: Handler) => void;\n    emit: <Key extends keyof Generated[\"events\"], Value extends Generated[\"events\"][Key]>(key: Key, value: Value) => Promise<void>;\n    emitAnyApproved: <Key extends keyof Generated[\"events\"], Value extends Generated[\"events\"][Key]>(key: Key, value: Value) => Promise<boolean>;\n    emitAllApproved: <Key extends keyof Generated[\"events\"], Value extends Generated[\"events\"][Key]>(key: Key, value: Value) => Promise<boolean>;\n    ping: (options?: { timeout?: number }) => Promise<Ping>;\n    // listener\n    listener: Awaited<ReturnType<typeof __initListener>>;\n    config: Readonly<Awaited<ReturnType<$types[\"configSchema\"][\"get\"]>>>;\n    isTestMode: boolean;\n    memory: {\n        /** 全局内存水位（字节）；未配置为 undefined */\n        limitBytes: number | undefined;\n        /** 当前 isolate 的堆占用；运行时不可读时为 null */\n        usedBytes: () => number | null;\n        /** 是否超过水位；未配置或运行时不可读时恒为 false */\n        exceeded: () => boolean;\n    };\n}\n","export function typia<TypiaInitT extends TypiaInit>(init: TypiaInitT): Typia<TypiaInitT> {\n  return init as unknown as Typia<TypiaInitT>;\n}\n\nexport type TypiaInit = () => Record<PropertyKey, unknown> | Promise<Record<PropertyKey, unknown>>;\n\nexport type Typia<TypiaInitT extends TypiaInit> = TypiaInitT;\n","import type { Log, MilkioInit, MilkioRuntimeInit } from \"../index.ts\";\n\ninterface CookbookEvent {\n  type: \"milkio@logger\";\n  log: Log;\n}\n\nexport async function sendCookbookEvent(runtime: MilkioRuntimeInit<MilkioInit>, event: CookbookEvent) {\n  // try {\n  //   const response = await fetch(`http://localhost:${runtime.cookbook.cookbookPort}/$action`, {\n  //     method: \"POST\",\n  //     headers: {\n  //       \"Content-Type\": \"application/json\",\n  //     },\n  //     body: JSON.stringify(event),\n  //   });\n  //   if (!response.ok) {\n  //     console.log(\"[COOKBOOK]\", await response.text());\n  //     console.log(\"[COOKBOOK]\", \"Is Cookbook closed? There is an abnormality in the communication with Cookbook.\");\n  //   }\n  // } catch (error) {\n  //   console.log(\"[COOKBOOK]\", error);\n  //   console.log(\"[COOKBOOK]\", \"Is Cookbook closed? There is an abnormality in the communication with Cookbook.\");\n  // }\n}\n","import type { $context, MilkioInit, MilkioRuntimeInit } from \"../index.ts\";\nimport { sendCookbookEvent } from \"../utils/send-cookbook-event.ts\";\n\nexport type Log = [\"(debug)\" | \"(info)\" | \"(warn)\" | \"(error)\" | \"(request)\" | \"(response)\", string /* executeId */, string, string, string, ...Array<unknown>];\n\nexport interface Logger {\n    _: {\n        logs: Array<Log>;\n        tags: Map<string, unknown>;\n        submit: (context: $context) => Promise<void> | void;\n    };\n    setTag: (key: string, value: unknown) => void;\n    setLog: (...log: Log) => void;\n    debug: (description: string, ...params: Array<unknown>) => Log;\n    info: (description: string, ...params: Array<unknown>) => Log;\n    warn: (description: string, ...params: Array<unknown>) => Log;\n    error: (description: string, ...params: Array<unknown>) => Log;\n    request: (description: string, ...params: Array<unknown>) => Log;\n    response: (description: string, ...params: Array<unknown>) => Log;\n}\n\nexport type LoggerInsertingHandler = (log: Log) => boolean;\n\nexport type LoggerSubmittingHandler = (context: $context, logs: Array<Log>, tags: Map<string, unknown>) => Promise<void> | void;\n\nfunction fastTimestamp(): string {\n    const d = new Date();\n    return `(${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, \"0\")}-${String(d.getDate()).padStart(2, \"0\")} ${String(d.getHours()).padStart(2, \"0\")}:${String(d.getMinutes()).padStart(2, \"0\")}:${String(d.getSeconds()).padStart(2, \"0\")})`;\n}\n\n// Pre-created default inserting handler - shared across all loggers\nconst defaultInserting = (log: Log): boolean => {\n    log[0] = `\\n${log[0]}` as any;\n    console.log(...log);\n    return true;\n};\n\nexport function createLogger<MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(runtime: MilkioRuntime, path: string, executeId: string): Logger {\n    const logger = {} as Logger;\n\n    const logs: Array<Log> = [];\n    const tags: Map<string, unknown> = new Map();\n\n    const inserting = runtime.onLoggerInserting || defaultInserting;\n    const hasSubmitting = !!runtime.onLoggerSubmitting;\n    const isDevelop = runtime.develop;\n\n    logger._ = {\n        logs,\n        tags,\n        submit: (context: $context) => {\n            if (!runtime.onLoggerSubmitting) return;\n            return runtime.onLoggerSubmitting(context, logs, tags);\n        },\n    };\n\n    const __tagPush = (key: string, value: unknown): void => {\n        tags.set(key, value);\n    };\n    const __logPush = (log: Log): Log => {\n        if (!inserting(log)) return log;\n        if (hasSubmitting) logs.push([...log]);\n        if (isDevelop) void sendCookbookEvent(runtime, { type: \"milkio@logger\", log });\n        return log;\n    };\n\n    logger.setTag = __tagPush;\n    logger.setLog = (...log: Log) => __logPush(log);\n\n    const getNow = fastTimestamp;\n\n    logger.debug = (description: string, ...params: Array<unknown>) => __logPush([\"(debug)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.info = (description: string, ...params: Array<unknown>) => __logPush([\"(info)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.warn = (description: string, ...params: Array<unknown>) => __logPush([\"(warn)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.error = (description: string, ...params: Array<unknown>) => __logPush([\"(error)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.request = (description: string, ...params: Array<unknown>) => __logPush([\"(request)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n    logger.response = (description: string, ...params: Array<unknown>) => __logPush([\"(response)\", path, executeId, getNow(), `\\n${description}`, ...params]);\n\n    return logger;\n}\n","export interface Steps<StageT extends Record<any, any>> {\n  step: StepFunction<StageT>;\n  run: () => Promise<Remove_<StageT>>;\n}\n\ntype Remove_<T> = {\n  [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\n\ntype ToEmptyObject<T> = T extends undefined | null | never ? {} : T extends object ? T : {};\n\nexport 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>>>>;\n\nexport function createStep(): Steps<{}> {\n  const stepController = {\n    $milkioType: \"step\",\n    _steps: [] as Array<(stage: any) => Promise<any>>,\n    step(handler: (stage: any) => Promise<any>) {\n      stepController._steps.push(handler);\n      return stepController;\n    },\n    async run() {\n      let stage = {};\n      for (const step of stepController._steps) {\n        stage = { ...stage, ...(await step(stage)) };\n      }\n      const result: Record<any, any> = {};\n      for (const key in stage) {\n        const value = (stage as any)[key];\n        if (!key.startsWith(\"_\")) result[key] = value;\n      }\n      return result;\n    },\n  };\n  return stepController as any as Steps<{}>;\n}\n","export class Trie<T> {\n    private root: TrieNode<T>;\n    private cache: Map<string, T | null>;\n\n    constructor() {\n        this.root = new TrieNode();\n        this.cache = new Map();\n    }\n\n    add(path: string, value: T): void {\n        const parts = path\n            .replace(/^\\/+|\\/+$/g, \"\")\n            .split(\"/\")\n            .filter((p) => p !== \"\");\n        let currentNode = this.root;\n        if (parts.length === 0) {\n            currentNode.value = value;\n            this.cache.set(path, value);\n            return;\n        }\n        for (const part of parts) {\n            if (!currentNode.children.has(part)) {\n                currentNode.children.set(part, new TrieNode());\n            }\n            currentNode = currentNode.children.get(part)!;\n        }\n        currentNode.value = value;\n        this.cache.set(path, value);\n    }\n\n    get(path: string): T | null {\n        const cached = this.cache.get(path);\n        if (cached !== undefined) return cached;\n\n        const parts = path\n            .replace(/^\\/+|\\/+$/g, \"\")\n            .split(\"/\")\n            .filter((p) => p !== \"\");\n        let currentNode = this.root;\n        for (const part of parts) {\n            if (!currentNode.children.has(part)) {\n                return null;\n            }\n            currentNode = currentNode.children.get(part)!;\n        }\n        const result = currentNode.value;\n        if (result !== null) this.cache.set(path, result);\n        return result;\n    }\n\n    getByParts(parts: string[]): T | null {\n        let currentNode = this.root;\n        for (const part of parts) {\n            if (!currentNode.children.has(part)) return null;\n            currentNode = currentNode.children.get(part)!;\n        }\n        return currentNode.value;\n    }\n\n    has(path: string): boolean {\n        return this.get(path) !== null;\n    }\n}\n\nclass TrieNode<T> {\n    children: Map<string, TrieNode<T>>;\n    value: T | null;\n\n    constructor() {\n        this.children = new Map();\n        this.value = null;\n    }\n}\n","import type { CorsConfig } from \"../index.ts\";\n\nexport function buildCorsHeaders(cors: CorsConfig | undefined, origin?: string | null): Record<string, string> {\n    const result: Record<string, string> = {};\n    if (cors?.corsAllowMethods) result[\"Access-Control-Allow-Methods\"] = cors.corsAllowMethods.join(\", \");\n    if (cors?.corsAllowHeaders) result[\"Access-Control-Allow-Headers\"] = cors.corsAllowHeaders.join(\", \");\n    if (cors?.corsMaxAge !== undefined) result[\"Access-Control-Max-Age\"] = String(cors.corsMaxAge);\n    if (cors?.corsAllowOrigin && cors.corsAllowOrigin.length > 0) {\n        const isWildcard = cors.corsAllowOrigin.includes(\"*\");\n        if (cors.corsAllowCredentials) {\n            // When credentials: true, the spec forbids Access-Control-Allow-Origin: *.\n            // Echo the request origin instead (wildcard means \"allow any origin\").\n            if (origin && (isWildcard || cors.corsAllowOrigin.includes(origin))) {\n                result[\"Access-Control-Allow-Origin\"] = origin;\n                result[\"Vary\"] = \"Origin\";\n                result[\"Access-Control-Allow-Credentials\"] = \"true\";\n            }\n        } else {\n            if (isWildcard) {\n                result[\"Access-Control-Allow-Origin\"] = \"*\";\n            } else if (origin && cors.corsAllowOrigin.includes(origin)) {\n                result[\"Access-Control-Allow-Origin\"] = origin;\n                result[\"Vary\"] = \"Origin\";\n            }\n        }\n    }\n    if (cors?.corsExposeHeaders && cors.corsExposeHeaders.length > 0) result[\"Access-Control-Expose-Headers\"] = cors.corsExposeHeaders.join(\", \");\n    return result;\n}","export function sanitizeExecuteId(executeId: string | undefined): string {\n  const value = typeof executeId === \"string\" ? executeId : \"\";\n  return value.replace(/[^A-Za-z0-9_-]/g, \"\");\n}\n","import { createLogger, failureHandler, fail, fault } from \"../index.ts\";\nimport type { Mixin, GeneratedInit, $types, ContextHttp, MilkioResponseFailure, Results, MilkioResponseSuccess, CorsConfig, Logger, Log, MilkioFailureWire } from \"../index.ts\";\nimport type { __initExecuter } from \"../execute/index.ts\";\nimport { __createId } from \"../utils/create-id.ts\";\nimport { Trie } from \"../utils/trie.ts\";\nimport { buildCorsHeaders } from \"../utils/build-cors-headers.ts\";\nimport { reviveJSONParse } from \"../utils/revive-json-parse.ts\";\nimport { sanitizeExecuteId } from \"../utils/sanitize-execute-id.ts\";\n\nexport type MilkioHttpRequest = Request;\n\n/** HTTP request body size limit used when the runtime does not configure one: 10KB. */\nexport const DEFAULT_BODY_LIMIT = 10 * 1024;\n\nexport type MilkioHttpResponse = Mixin<\n    ResponseInit,\n    {\n        body: string | ReadableStream<Uint8Array> | Uint8Array | ArrayBuffer | Blob | null;\n        status: number;\n        headers: Record<string, string>;\n    }\n>;\n\nexport function __initListener(generated: GeneratedInit, runtime: any, executer: ReturnType<typeof __initExecuter>) {\n    const port = runtime.port;\n    const trie = new Trie<any>();\n    // Raw routes: exact keys hit in O(1); keys ending in \"/*\" are prefix routes,\n    // matched by longest prefix so nested prefixes stay deterministic.\n    const rawPaths: Set<string> = generated.rawSchema?.rawPaths ?? new Set<string>();\n    const rawPrefixes: Array<{ key: string; prefix: string }> = [];\n    for (const rawPath of rawPaths) {\n        if (rawPath.endsWith(\"/*\")) rawPrefixes.push({ key: rawPath, prefix: rawPath.slice(0, -1) });\n    }\n    rawPrefixes.sort((a, b) => b.prefix.length - a.prefix.length);\n    // HTTP only: the message/worker path never has a raw request body to limit.\n    const configuredBodyLimit = runtime.http?.bodyLimit ?? runtime.http?.maxBodySize;\n    const bodyLimit = Number.isFinite(configuredBodyLimit) && configuredBodyLimit > 0 ? configuredBodyLimit : DEFAULT_BODY_LIMIT;\n    const textEncoder = new TextEncoder();\n    // Pre-compute default CORS config and cache headers per origin\n    const cors: CorsConfig = { corsAllowMethods: [\"POST\", \"OPTIONS\"], corsAllowHeaders: [\"Content-Type\", \"Authorization\"], corsMaxAge: 0, ...runtime.http?.cors };\n    const corsHeadersCache = new Map<string, Record<string, string>>();\n    const MAX_CORS_HEADERS_CACHE_SIZE = 1024;\n    const getCorsHeaders = (origin: string | null): Record<string, string> => {\n        const key = origin ?? \"\";\n        let cached = corsHeadersCache.get(key);\n        if (cached !== undefined) return cached;\n        if (corsHeadersCache.size >= MAX_CORS_HEADERS_CACHE_SIZE) corsHeadersCache.clear();\n        cached = buildCorsHeaders(cors, origin);\n        corsHeadersCache.set(key, cached);\n        return cached;\n    };\n    // Pre-compute default response headers (without origin-specific CORS)\n    const defaultResponseHeaders: Record<string, string> = {\n        \"Cache-Control\": \"no-store\",\n        \"Content-Type\": \"application/json\",\n    };\n    // Pre-compute merged headers for null origin (most common case)\n    const defaultMergedHeaders: Record<string, string> = { ...getCorsHeaders(null), ...defaultResponseHeaders };\n\n    // Pre-allocate response template parts for Fast Path\n    const emptyResultPrefix = '{\"data\":{},\"executeId\":\"';\n    const resultPrefix = '{\"data\":';\n    const idSuffix = '\",\"success\":true}';\n    // Shared response object for Fast Path (handler returns result directly, never modifies response)\n    const fastPathResponse = { body: \"\", status: 200, headers: defaultMergedHeaders };\n\n    // Dynamic check for event handlers with version-based caching\n    let cachedNoEmitHandlers = true;\n    let lastEmitHandlersVersion = -1;\n    const checkNoEmitHandlers = (): boolean => {\n        const v = runtime._emitHandlersVersion;\n        if (v !== lastEmitHandlersVersion) {\n            lastEmitHandlersVersion = v;\n            cachedNoEmitHandlers =\n                !runtime._hasEmitHandlers?.(\"milkio:executeBefore\") &&\n                !runtime._hasEmitHandlers?.(\"milkio:executeAfter\") &&\n                !runtime._hasEmitHandlers?.(\"milkio:httpRequest\") &&\n                !runtime._hasEmitHandlers?.(\"milkio:httpResponse\") &&\n                !runtime._hasEmitHandlers?.(\"milkio:httpNotFound\");\n        }\n        return cachedNoEmitHandlers;\n    };\n    const hasOnLoggerSubmitting = !!runtime.onLoggerSubmitting;\n\n    // Shared no-op logger for fast path (used when no event handlers)\n    const noopLogger: Logger = {\n        _: { logs: [] as any, tags: new Map<string, unknown>(), submit: () => { } },\n        setTag: () => { },\n        setLog: (..._log: Log) => ({} as Log),\n        debug: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        info: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        warn: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        error: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        request: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n        response: (_description: string, ..._params: Array<unknown>) => ({} as Log),\n    };\n\n    // Pre-create base context prototype for Fast Path (shared immutable properties)\n    // `call` is defined on prototype to avoid creating a closure per request\n    const baseContextProto: any = {\n        fail,\n        fault,\n        develop: runtime.develop,\n        logger: noopLogger,\n        emit: runtime.emit,\n        emitAnyApproved: runtime.emitAnyApproved,\n        emitAllApproved: runtime.emitAllApproved,\n        config: runtime.runtime.config,\n        typia: generated.typiaSchema,\n        onFinally: () => { },\n        _: runtime,\n        call(module: any, p: any) { return executer.__call(this, module, p); },\n    };\n\n    // Hot path cache: pre-resolve the most common route\n    let cachedRouteSchema: any = null;\n    let cachedPathString: string | null = null;\n    // Cache validateParams and handler references to avoid property lookups\n    let cachedValidateParams: any = null;\n    let cachedHandler: any = null;\n    let cachedSkipValidation: boolean = false;\n\n    const fetch = async (options: {\n        request: MilkioHttpRequest;\n        envMode?: string;\n        env?: Record<any, any>;\n        routeSchema?: any;\n        rawResponse?: boolean;\n    }): Promise<Response> => {\n        // The fast path executes the handler before the full context/logger exists. When\n        // the handler throws (or returns a non-object), we must NOT fall through and run\n        // it again in the slow path: remember the failure and let the slow path only\n        // handle the error response (single execution, single log). Per request, so a\n        // concurrent request can never observe another request's failure.\n        let fastPathError: unknown;\n        const tooLarge = () => fail(\"REQUEST_TOO_LARGE\", { maxBodySize: bodyLimit });\n        const readBodyText = async (): Promise<string> => {\n            const contentLength = Number(options.request.headers.get(\"content-length\") ?? \"0\");\n            if (Number.isFinite(contentLength) && contentLength > bodyLimit) throw tooLarge();\n            const preRead = (options.request as any).__bodyText;\n            if (preRead !== undefined) {\n                // UTF-8 byte length is never smaller than the UTF-16 length, so this\n                // cheap check avoids encoding bodies a third-party adapter pre-read uncapped.\n                if (typeof preRead === \"string\" && (preRead.length > bodyLimit || textEncoder.encode(preRead).byteLength > bodyLimit)) throw tooLarge();\n                return preRead;\n            }\n            if (!options.request.body) return \"\";\n            const reader = options.request.body.getReader();\n            const decoder = new TextDecoder();\n            let byteLength = 0;\n            let text = \"\";\n            try {\n                while (true) {\n                    const { done, value } = await reader.read();\n                    if (done) break;\n                    byteLength += value.byteLength;\n                    if (byteLength > bodyLimit) {\n                        await reader.cancel().catch(() => {});\n                        throw tooLarge();\n                    }\n                    text += decoder.decode(value, { stream: true });\n                }\n                text += decoder.decode();\n            } finally {\n                reader.releaseLock();\n            }\n            return text;\n        };\n\n        // Use pre-passed origin from adapter to avoid headers.get() call\n        const origin = (options.request as any).__origin ?? options.request.headers.get(\"Origin\");\n\n        if (options.request.method === \"OPTIONS\") {\n            return new Response(undefined, {\n                headers: getCorsHeaders(origin),\n            });\n        }\n\n        // Use pre-parsed pathname and pathArray if available (from adapter), otherwise parse\n        const pathname = (options.request as any).__pathname ?? new URL(options.request.url).pathname;\n        if (pathname.endsWith(\"/generate_204\")) {\n            const corsHeaders = getCorsHeaders(origin);\n            return new Response(null, {\n                status: 204,\n                headers: {\n                    Server: \"milkio\",\n                    ...corsHeaders,\n                    \"Cache-Control\": \"no-store\",\n                    \"Content-Type\": `text/plain; time=${Date.now()}`,\n                },\n            });\n        }\n\n        const prePathArray = (options.request as any).__pathArray;\n        let pathString: string;\n        let pathArray: string[];\n        if (!runtime.accessKey && (!runtime.ignorePathLevel || runtime.ignorePathLevel === 0)) {\n            pathString = pathname;\n            pathArray = prePathArray ?? pathname.substring(1).split(\"/\");\n        } else {\n            pathArray = prePathArray ?? pathname.substring(1).split(\"/\");\n            if (runtime.accessKey && pathArray.at(0) !== runtime.accessKey) {\n                const corsHeaders = getCorsHeaders(origin);\n                if (options.rawResponse) return { __rawResponse: true, body: \"\", status: 403, headers: corsHeaders } as any;\n                return new Response(undefined, {\n                    status: 403,\n                    headers: corsHeaders,\n                });\n            }\n            if (runtime.ignorePathLevel !== undefined && runtime.ignorePathLevel !== 0) pathArray = pathArray.slice(runtime.ignorePathLevel);\n            pathString = `/${pathArray.join(\"/\")}`;\n        }\n\n        // Pre-read body text if available (from adapter), otherwise use async request.text()\n        const bodyText = (options.request as any).__bodyText;\n        const ip = runtime.realIp ? runtime.realIp(options.request.headers) : \"::1\";\n\n        // 测试环境下的 $event 端点：通过 base64 编码的事件名触发事件\n        if (options.envMode === \"test\" && pathString.startsWith(\"/$event/\")) {\n            const executeId = __createId();\n            const base64Name = decodeURIComponent(pathString.slice(8));\n            let eventName: string;\n            try {\n                // 兼容不同运行时：优先使用 atob，回退到 Buffer\n                if (typeof atob !== \"undefined\") {\n                    eventName = atob(base64Name);\n                } else if (typeof Buffer !== \"undefined\") {\n                    eventName = Buffer.from(base64Name, \"base64\").toString();\n                } else {\n                    throw new Error(\"No base64 decoder available\");\n                }\n            } catch {\n                const corsHeaders = getCorsHeaders(origin);\n                const body = JSON.stringify(failureHandler(executeId, noopLogger, fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"valid base64 event name\" }), { path: pathString, routeType: \"event\" }).response);\n                if (options.rawResponse) return { __rawResponse: true, body, status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } } as any;\n                return new Response(body, { status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } });\n            }\n\n            let eventData: any = undefined;\n            let rawBody: string;\n            try {\n                rawBody = await readBodyText();\n            } catch (error) {\n                const corsHeaders = getCorsHeaders(origin);\n                const body = JSON.stringify(failureHandler(executeId, noopLogger, error, { path: pathString, routeType: \"event\" }).response);\n                if (options.rawResponse) return { __rawResponse: true, body, status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } } as any;\n                return new Response(body, { status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } });\n            }\n            if (rawBody && rawBody !== \"\" && rawBody !== \"{}\") {\n                try {\n                    eventData = reviveJSONParse(JSON.parse(rawBody));\n                } catch {\n                    const corsHeaders = getCorsHeaders(origin);\n                    const body = JSON.stringify(failureHandler(executeId, noopLogger, fail(\"PARAMS_TYPE_NOT_SUPPORTED\", { expected: \"json\" }), { path: pathString, routeType: \"event\" }).response);\n                    if (options.rawResponse) return { __rawResponse: true, body, status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } } as any;\n                    return new Response(body, { status: 200, headers: { ...corsHeaders, \"Content-Type\": \"application/json\" } });\n                }\n            }\n\n            const corsHeaders = getCorsHeaders(origin);\n            const jsonHeaders = { ...corsHeaders, \"Content-Type\": \"application/json\", \"Cache-Control\": \"no-store\" };\n\n            // 自动注入 context — event 数据中约定俗成的 context 参数无法由外部传参，由服务端补全。\n            // 与 action 执行保持一致：构建完整的 context（logger/config/typia/call 等），并触发\n            // milkio:executeBefore / milkio:httpResponse 事件，使 bootstrap 可以注入 db/redis 等能力。\n            if (eventData && typeof eventData === \"object\" && !Array.isArray(eventData) && !(\"context\" in eventData)) {\n                const context: any = {};\n                context.fail = fail;\n                context.fault = fault;\n                context.develop = runtime.develop;\n                context.executeId = executeId;\n                context.path = pathString;\n                context.emit = runtime.emit;\n                context.emitAnyApproved = runtime.emitAnyApproved;\n                context.emitAllApproved = runtime.emitAllApproved;\n                context._ = runtime;\n                context.config = runtime.runtime.config;\n                context.typia = generated.typiaSchema;\n                context.call = (module: any, params: any) => executer.__call(context, module, params);\n                context.onFinally = () => {};\n                const logger = createLogger(runtime, pathString, executeId);\n                context.logger = logger;\n                context.http = {\n                    ip,\n                    params: { string: rawBody ?? \"\", parsed: eventData },\n                    request: options.request,\n                };\n                context.headers = options.request.headers;\n                eventData.context = context;\n\n                const emitHttpResponse = (success: boolean, failure?: MilkioFailureWire) => {\n                    if (runtime._hasEmitHandlers?.(\"milkio:httpResponse\") ?? true) {\n                        return runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: pathString, http: context.http, headers: options.request.headers, context, success, failure, fail, fault });\n                    }\n                };\n\n                try {\n                    // 先触发 executeBefore（bootstrap 注入 db/redis），事件处理完成后再触发\n                    // httpResponse（释放连接），与 action 的生命周期保持一致。\n                    if (runtime._hasEmitHandlers?.(\"milkio:executeBefore\") ?? true) {\n                        await runtime.emit(\"milkio:executeBefore\", { executeId, logger, path: pathString, meta: {}, context, fail, fault });\n                    }\n                    await runtime.emit(eventName, eventData);\n                } catch (emitError) {\n                    const errResult = failureHandler(executeId, logger, emitError, { path: pathString, routeType: \"event\", onError: runtime.onError });\n                    const errBody = JSON.stringify(errResult.response);\n                    try {\n                        await emitHttpResponse(false, errResult.response.error);\n                    } catch {}\n                    if (options.rawResponse) return { __rawResponse: true, body: errBody, status: 200, headers: jsonHeaders } as any;\n                    return new Response(errBody, { status: 200, headers: jsonHeaders });\n                }\n\n                try {\n                    await emitHttpResponse(true);\n                } catch {}\n            } else {\n                try {\n                    await runtime.emit(eventName, eventData);\n                } catch (emitError) {\n                    const errResult = failureHandler(executeId, noopLogger, emitError, { path: pathString, routeType: \"event\" });\n                    const errBody = JSON.stringify(errResult.response);\n                    if (options.rawResponse) return { __rawResponse: true, body: errBody, status: 200, headers: jsonHeaders } as any;\n                    return new Response(errBody, { status: 200, headers: jsonHeaders });\n                }\n            }\n\n            const body = `{\"data\":${JSON.stringify(eventData ?? {}, (key, value) => key === \"context\" ? undefined : value)},\"executeId\":\"${executeId}\",\"success\":true}`;\n            if (options.rawResponse) return { __rawResponse: true, body, status: 200, headers: jsonHeaders } as any;\n            return new Response(body, { status: 200, headers: jsonHeaders });\n        }\n\n        // ===== FAST PATH for common action requests =====\n        // Skip logger, request map, and most object creation when:\n        // - rawResponse mode (adapter)\n        // - No origin header (no CORS needed)\n        // - No event handlers registered (dynamic check)\n        // - Not a stream request\n        if (options.rawResponse && !origin && checkNoEmitHandlers()) {\n            const __isAction = (options.request as any).__isAction;\n            if (__isAction !== false) {\n                // Resolve route schema with hot cache\n                let routeSchema = options.routeSchema;\n                if (!routeSchema) {\n                    if (pathString === cachedPathString && cachedRouteSchema) {\n                        routeSchema = cachedRouteSchema;\n                    } else {\n                        routeSchema = trie.get(pathString);\n                        if (routeSchema !== null) {\n                            cachedRouteSchema = routeSchema;\n                            cachedPathString = pathString;\n                        } else {\n                            routeSchema = generated.routeSchema?.[pathString];\n                            if (routeSchema === undefined) {\n                                // 404 - fall through to slow path for proper error handling\n                            } else {\n                                if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n                                else routeSchema.module = await routeSchema.module();\n                                trie.add(pathString, routeSchema);\n                                cachedRouteSchema = routeSchema;\n                                cachedPathString = pathString;\n                            }\n                        }\n                    }\n                }\n\n                if (routeSchema && routeSchema.type === \"action\") {\n                    // Use cached function references when hitting the same route. The\n                    // route-schema cache is also filled by the slow path (and by the\n                    // hot-path assignment above), so re-initialize when the references\n                    // have never been captured.\n                    let validateParams = cachedValidateParams;\n                    let handler = cachedHandler;\n                    let skipValidation = cachedSkipValidation;\n                    if (routeSchema !== cachedRouteSchema || cachedHandler === null) {\n                        validateParams = routeSchema.validateParams;\n                        handler = routeSchema.module.handler;\n                        const meta = routeSchema.module?.meta;\n                        skipValidation = meta?.typeSafety === false || (Array.isArray(meta?.typeSafety) && !meta.typeSafety.includes(\"params\"));\n                        cachedValidateParams = validateParams;\n                        cachedHandler = handler;\n                        cachedSkipValidation = skipValidation;\n                    }\n\n                    const executeId = __createId();\n                    let body = \"\";\n                    // Parse params\n                    let params: any;\n                    let paramsOk = true;\n                    try {\n                        body = await readBodyText();\n                    } catch (error) {\n                        // Let the slow path turn the limit failure into a failure envelope.\n                        fastPathError = error;\n                        paramsOk = false;\n                    }\n                    if (paramsOk && (!body || body === \"\" || body === \"{}\")) {\n                        params = {};\n                    } else if (paramsOk) {\n                        try {\n                            params = reviveJSONParse(JSON.parse(body));\n                            if (typeof params === \"undefined\") params = {};\n                        } catch {\n                            paramsOk = false;\n                        }\n                    }\n\n                    if (paramsOk && params !== null && typeof params === \"object\" && !Array.isArray(params)) {\n                        // Skip $milkioGenerateParams in test mode\n                        if (options.envMode === \"test\" || !(\"$milkioGenerateParams\" in params)) {\n                            // Validate params when typeSafety is enabled\n                            if (!skipValidation) {\n                                const validation = validateParams(params);\n                                if (!validation.success) {\n                                    // Validation failed - fall through to slow path\n                                    paramsOk = false;\n                                }\n                            }\n\n                            if (paramsOk) {\n                                // Build minimal context using prototype for shared properties\n                                const context: any = Object.create(baseContextProto);\n                                context.path = pathString;\n                                context.routeType = \"action\";\n                                context.executeId = executeId;\n                                context.http = {\n                                    url: pathname,\n                                    ip,\n                                    path: { string: pathString, array: pathArray },\n                                    params: { string: body, parsed: params },\n                                    request: options.request,\n                                    response: fastPathResponse,\n                                    cors,\n                                };\n                                context.headers = options.request.headers;\n\n                                try {\n                                    const result = await handler(context, params);\n\n                                    if (result === undefined || result === null || result === \"\") {\n                                        return { __rawResponse: true, body: emptyResultPrefix + executeId + idSuffix, status: 200, headers: defaultMergedHeaders } as any;\n                                    } else if (!Array.isArray(result) && typeof result === \"object\") {\n                                        return { __rawResponse: true, body: resultPrefix + JSON.stringify(result) + ',\"executeId\":\"' + executeId + idSuffix, status: 200, headers: defaultMergedHeaders } as any;\n                                    }\n                                    // Invalid result type - slow path handles it as a fault, without re-running the handler\n                                    fastPathError = fault(\"FRAMEWORK_ERROR\", { message: \"The return type of the handler must be an 'object'.\" });\n                                } catch (error) {\n                                    // Handler threw - slow path handles the error response, without re-running the handler\n                                    fastPathError = error;\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        // ===== SLOW PATH =====\n        const corsHeaders = getCorsHeaders(origin);\n        const rawExecuteId = runtime?.executeId ? await runtime.executeId(options.request.headers) : __createId();\n        const executeId = sanitizeExecuteId(rawExecuteId) || __createId();\n        const anyEmitHandlers = !checkNoEmitHandlers();\n\n        const logger = createLogger(runtime, pathString, executeId);\n        if (anyEmitHandlers) runtime.runtime.request.set(executeId, { logger });\n        // Pre-compute base headers for this request (CORS + defaults)\n        const baseHeaders: Record<string, string> = origin ? { ...corsHeaders, ...defaultResponseHeaders } : defaultMergedHeaders;\n\n        let finales: Array<() => void | Promise<void>> = [];\n\n        const response: MilkioHttpResponse = {\n            body: \"\",\n            status: 200,\n            headers: { ...baseHeaders },\n        };\n\n        // Check if this is a raw route — raw routes bypass action/stream logic\n        // and let the handler own the full Request/Response lifecycle.\n        let rawRouteKey: string | undefined = rawPaths.has(pathString) ? pathString : undefined;\n        if (rawRouteKey === undefined) {\n            for (const item of rawPrefixes) {\n                if (pathString.startsWith(item.prefix)) {\n                    rawRouteKey = item.key;\n                    break;\n                }\n            }\n        }\n        const isRawPath = rawRouteKey !== undefined;\n\n        // Read the body before the try block, then rethrow the limit failure inside\n        // it so REQUEST_TOO_LARGE gets the regular failure envelope + httpResponse event.\n        let bodyString = \"\";\n        let bodyReadError: unknown;\n        if (!isRawPath && fastPathError === undefined) {\n            try {\n                bodyString = await readBodyText();\n            } catch (error) {\n                bodyReadError = error;\n            }\n        }\n\n        const http: ContextHttp = {\n            url: pathname as any,\n            ip,\n            path: { string: pathString as keyof $types[\"generated\"][\"routeSchema\"], array: pathArray },\n            params: {\n                // For raw routes, don't consume the request body — the handler\n                // needs it intact. The body will be passed via the Request object.\n                // On a fast-path error the body was already consumed by the fast path.\n                string: bodyString,\n                parsed: undefined,\n            },\n            request: options.request,\n            response,\n            cors,\n        };\n\n        const context: any = { fail, fault };\n        try {\n            // Fast path already executed the handler; only produce the error response here.\n            if (fastPathError !== undefined) throw fastPathError;\n            if (bodyReadError !== undefined) throw bodyReadError;\n\n            // Check if emit has handlers before awaiting\n            const hasHttpRequestHandlers = runtime._hasEmitHandlers?.(\"milkio:httpRequest\") ?? true;\n            if (hasHttpRequestHandlers) await runtime.emit(\"milkio:httpRequest\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n\n            // 非 test 环境下拦截 $exports 内部路径\n            if (options.envMode !== \"test\" && (http.path.string as string).includes(\"$\")) {\n                await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n            }\n\n            // ===== RAW PATH =====\n            // Raw routes receive a native Request and return a native Response.\n            // They bypass typia validation, JSON serialization, and stargate.\n            // Use case: SSE passthrough (e.g. OpenAI proxy), webhooks, binary.\n            if (isRawPath) {\n                const rawRoute = generated.rawSchema.routes[rawRouteKey as string];\n                if (!rawRoute) {\n                    await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                    throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n                }\n                // Lazy-load module on first access, then cache\n                let module: any = rawRoute.module;\n                if (typeof module === \"function\") {\n                    module = await module();\n                    rawRoute.module = module;\n                }\n                const meta = module?.meta ?? {};\n\n                // Construct full context (raw doesn't go through __execute,\n                // so we set all fields manually here)\n                context.http = http;\n                context.headers = http.request.headers;\n                context.develop = runtime.develop;\n                context.path = pathString;\n                context.routeType = \"raw\";\n                context.logger = logger;\n                context.emit = runtime.emit;\n                context.emitAnyApproved = runtime.emitAnyApproved;\n                context.emitAllApproved = runtime.emitAllApproved;\n                context.executeId = executeId;\n                context.config = runtime.runtime.config;\n                context.typia = generated.typiaSchema;\n                context.call = (mod: any, params: any) => executer.__call(context, mod, params);\n                context.onFinally = (handler: any) => finales.unshift(handler);\n                context._ = runtime;\n\n                // If adapter pre-read the body (bodyText set), reconstruct a\n                // Request with the body re-injected so the handler can read it.\n                // Otherwise, the original request body is still intact (we skipped\n                // reading it above for raw paths).\n                const handlerRequest: Request = bodyText !== undefined\n                    ? new Request(options.request.url, {\n                        method: options.request.method,\n                        headers: options.request.headers,\n                        body: bodyText || null,\n                        signal: options.request.signal,\n                    })\n                    : options.request;\n\n                const results: Results<any> = { value: undefined };\n\n                if (runtime._hasEmitHandlers?.(\"milkio:executeBefore\") ?? true) {\n                    await runtime.emit(\"milkio:executeBefore\", { executeId, logger, path: pathString, meta, context, fail, fault });\n                }\n\n                const rawResponse: Response = await module.handler(context, handlerRequest);\n                results.value = rawResponse;\n\n                if (runtime._hasEmitHandlers?.(\"milkio:executeAfter\") ?? true) {\n                    await runtime.emit(\"milkio:executeAfter\", { executeId, logger, path: pathString, meta, context, results, fail, fault });\n                }\n\n                // Apply CORS headers to the raw response\n                const finalHeaders = new Headers(rawResponse.headers);\n                for (const [k, v] of Object.entries(corsHeaders)) {\n                    if (!finalHeaders.has(k)) finalHeaders.set(k, v);\n                }\n\n                const hasHttpResponseHandlers = runtime._hasEmitHandlers?.(\"milkio:httpResponse\") ?? true;\n                if (hasHttpResponseHandlers) await runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: http.path.string as string, http, headers: http.request.headers, context, success: true, fail, fault });\n\n                // Run onFinally handlers (after httpResponse, matching action path ordering)\n                if (finales.length > 0) {\n                    for (const handler of finales) {\n                        try { await handler(); } catch (error) { logger.error(\"An error occurred inside onFinally.\", error); }\n                    }\n                }\n\n                if (hasOnLoggerSubmitting) await logger._.submit(context as any);\n                if (anyEmitHandlers) runtime.runtime.request.delete(executeId);\n\n                return new Response(rawResponse.body, {\n                    status: rawResponse.status,\n                    statusText: rawResponse.statusText,\n                    headers: finalHeaders,\n                });\n            }\n\n            if (!options.request.headers.get(\"Accept\")?.startsWith(\"text/event-stream\")) {\n                // action\n                let routeSchema = options.routeSchema;\n                if (!routeSchema) {\n                    // Hot path: check single-entry cache first\n                    if (pathString === cachedPathString && cachedRouteSchema) {\n                        routeSchema = cachedRouteSchema;\n                    } else if ((http.path.string as string).includes(\"$\")) {\n                        routeSchema = trie.get(http.path.string as string);\n                        if (routeSchema === null) {\n                            routeSchema = generated.routeSchema?.[http.path.string];\n                            if (routeSchema === undefined) {\n                                await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                                throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n                            }\n                            if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n                            else routeSchema.module = await routeSchema.module();\n                            trie.add(http.path.string as string, routeSchema);\n                        }\n                    } else {\n                        routeSchema = trie.get(http.path.string as string);\n                        if (routeSchema === null) {\n                            routeSchema = generated.routeSchema?.[http.path.string];\n                            if (routeSchema === undefined) {\n                                await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                                throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n                            }\n                            if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n                            else routeSchema.module = await routeSchema.module();\n                            trie.add(http.path.string as string, routeSchema);\n                        }\n                        // Update hot path cache\n                        cachedRouteSchema = routeSchema;\n                        cachedPathString = pathString;\n                    }\n\n                    if (routeSchema.type !== \"action\") throw fail(\"UNACCEPTABLE\", { expected: \"stream\", message: `Not acceptable, the Accept in the request header should be \"text/event-stream\". If you are using the \"@milkio/stargate\" package, please add \\`type: \"stream\"\\` to the execute options.` });\n                }\n\n                context.http = http;\n                context.headers = http.request.headers;\n                context.routeType = \"action\";\n\n                const executed = await executer.__execute(routeSchema, {\n                    createdExecuteId: executeId,\n                    createdLogger: logger,\n                    path: http.path.string as string,\n                    headers: options.request.headers as Headers,\n                    context,\n                    params: http.params.string,\n                    paramsType: \"string\",\n                    paramsContentType: \"json\",\n                });\n                finales = executed.finales;\n\n                if (response.body === \"\" && executed.results.value !== undefined) {\n                    if (executed.emptyResult) {\n                        response.body = `{\"data\":{},\"executeId\":\"${executeId}\",\"success\":true}`;\n                    } else {\n                        response.body = `{\"data\":${JSON.stringify(executed.results.value)},\"executeId\":\"${executeId}\",\"success\":true}`;\n                    }\n                }\n\n                const hasHttpResponseHandlers = runtime._hasEmitHandlers?.(\"milkio:httpResponse\") ?? true;\n                if (hasHttpResponseHandlers) await runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: http.path.string as string, http, headers: http.request.headers, context: executed.context, success: true, fail, fault });\n\n                if (finales.length > 0) {\n                    for (const handler of finales) {\n                        try {\n                            await handler();\n                        } catch (error) {\n                            logger.error(\"An error occurred inside onFinally.\", error);\n                        }\n                    }\n                }\n\n                if (hasOnLoggerSubmitting) await logger._.submit(context as any);\n                if (anyEmitHandlers) runtime.runtime.request.delete(executeId);\n                if (options.rawResponse) {\n                    return { __rawResponse: true, body: response.body, status: response.status, headers: response.headers } as any;\n                }\n                return new Response(response.body as BodyInit | null, response);\n            } else {\n                // stream\n                let routeSchema = options.routeSchema;\n                if (!routeSchema) {\n                    routeSchema = trie.get(http.path.string as string);\n                    if ((http.path.string as string).includes(\"$\") || !(http.path.string as string).endsWith(\"~\") || routeSchema === null) {\n                        routeSchema = generated.routeSchema?.[http.path.string];\n                        if (routeSchema === undefined) {\n                            await runtime.emit(\"milkio:httpNotFound\", { executeId, logger, path: http.path.string as string, http, fail, fault });\n                            throw fail(\"NOT_FOUND\", { path: http.path.string as string });\n                        }\n                        if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n                        else routeSchema.module = await routeSchema.module();\n                        trie.add(http.path.string as string, routeSchema);\n                    }\n                    if (routeSchema.type !== \"stream\") throw fail(\"UNACCEPTABLE\", { expected: \"stream\", message: `Not acceptable, the Accept in the request header should be \"application/json\". If you are using the \"@milkio/stargate\" package, please remove \\`type: \"stream\"\\` to the execute options.` });\n                }\n\n                let streamClosed = false;\n                const handleClose = async () => {\n                    if (streamClosed) return;\n                    streamClosed = true;\n                    for (const handler of finales) {\n                        try {\n                            await handler();\n                        } catch (error) {\n                            logger.error(\"An error occurred inside onFinally.\", error);\n                        }\n                    }\n                    if (hasOnLoggerSubmitting) await logger._.submit(context as any);\n                    if (anyEmitHandlers) runtime.runtime.request.delete(executeId);\n                };\n\n                context.http = http;\n                context.headers = http.request.headers;\n                context.routeType = \"stream\";\n\n                const executed = await executer.__execute(routeSchema, {\n                    createdExecuteId: executeId,\n                    createdLogger: logger,\n                    path: http.path.string as string,\n                    headers: options.request.headers as Headers,\n                    context,\n                    params: http.params.string,\n                    paramsType: \"string\",\n                });\n                finales = executed.finales;\n                // Stream path: create new headers object to avoid polluting shared defaultMergedHeaders\n                response.headers = { ...response.headers, ...buildCorsHeaders(http.cors, origin) };\n                // @ts-ignore: bun\n                let stream: ReadableStream;\n                // @ts-ignore: bun\n                let control: ReadableStreamDirectController | ReadableStreamDefaultController;\n\n                // @ts-ignore: bun\n                if (typeof Bun !== \"undefined\") {\n                    // @ts-ignore: bun\n                    stream = new ReadableStream({\n                        type: \"direct\",\n                        // @ts-ignore: bun\n                        async pull(controller: ReadableStreamDirectController) {\n                            control = controller;\n                            try {\n                                controller.write(`data:@${JSON.stringify({ success: true, data: undefined, executeId } satisfies MilkioResponseSuccess<any>)}\\n\\n`);\n                                for await (const value of executed.results.value) {\n                                    if (!options.request.signal.aborted) {\n                                        const result: string = JSON.stringify([null, value]);\n                                        controller.write(`data:${result}\\n\\n`);\n                                    } else {\n                                        executed.results.value.return(undefined);\n                                        await handleClose();\n                                        controller.close();\n                                    }\n                                }\n                            } catch (error) {\n                                const result = failureHandler(executeId, logger, error, { path: http.path.string as string, routeType: \"stream\", onError: runtime.onError }).response;\n                                controller.write(`data:${JSON.stringify([result.error, null])}\\n\\n`);\n                            }\n                            await new Promise((resolve) => setTimeout(resolve, 0));\n                            await handleClose();\n                            controller.close();\n                        },\n                        async cancel() {\n                            await handleClose();\n                            control.close();\n                        },\n                    } as any);\n                } else {\n                    // node.js or others\n                    // @ts-ignore: bun\n                    stream = new ReadableStream({\n                        // @ts-ignore: bun\n                        async pull(controller) {\n                            control = controller;\n                            try {\n                                controller.enqueue(`data:@${JSON.stringify({ success: true, data: undefined, executeId } satisfies MilkioResponseSuccess<any>)}\\n\\n`);\n                                for await (const value of executed.results.value) {\n                                    if (!options.request.signal?.aborted) {\n                                        const result: string = JSON.stringify([null, value]);\n                                        controller.enqueue(`data:${result}\\n\\n`);\n                                    } else {\n                                        executed.results.value.return(undefined);\n                                        await handleClose();\n                                        controller.close();\n                                    }\n                                }\n                            } catch (error) {\n                                const result = failureHandler(executeId, logger, error, { path: http.path.string as string, routeType: \"stream\", onError: runtime.onError }).response;\n                                controller.enqueue(`data:${JSON.stringify([result.error, null])}\\n\\n`);\n                            }\n                            await handleClose();\n                            await new Promise((resolve) => setTimeout(resolve, 0));\n                            controller.close();\n                        },\n                        async cancel() {\n                            await handleClose();\n                            control.close();\n                        },\n                    } as any);\n                }\n\n                response.body = stream;\n                // Stream path: create new headers to avoid polluting shared object\n                response.headers = { ...response.headers, \"Content-Type\": \"text/event-stream\", \"Cache-Control\": \"no-cache\" };\n\n                await runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: http.path.string as string, http, headers: http.request.headers, context: executed.context, success: true, fail, fault });\n\n                return new Response(response.body, response);\n            }\n        } catch (error) {\n            const failureResult = failureHandler(executeId, logger, error, { path: http.path.string as string, routeType: (context as any)?.routeType, onError: runtime.onError });\n            const results: Results<MilkioResponseFailure> = { value: failureResult.response };\n            response.body = JSON.stringify(results.value);\n            // Error path: create new headers to avoid polluting shared object\n            response.headers = { ...response.headers, ...corsHeaders };\n            await runtime.emit(\"milkio:httpResponse\", { executeId, logger, path: http.path.string as string, http, headers: http.request.headers, context, success: false, failure: failureResult.response.error, fail, fault });\n            // Run onFinally handlers even on error (important for raw routes where\n            // the handler may have registered cleanup via context.onFinally before throwing)\n            if (finales.length > 0) {\n                for (const handler of finales) {\n                    try { await handler(); } catch (e) { logger.error(\"An error occurred inside onFinally.\", e); }\n                }\n            }\n            if (hasOnLoggerSubmitting) await logger._.submit(context as any);\n            if (anyEmitHandlers) runtime.runtime.request.delete(executeId);\n            if (options.rawResponse) {\n                return { __rawResponse: true, body: response.body, status: response.status, headers: response.headers } as any;\n            }\n            return new Response(response.body as BodyInit | null, response);\n        }\n    };\n\n    const streamClosers: Map<string, { generator: AsyncGenerator; handleClose: any }> = new Map();\n    const handleMessage = async (\n        port: { postMessage(message: any): void },\n        options:\n            | {\n                executeId: string;\n                path: string;\n                params?: Record<any, any>;\n                headers?: Record<string, string>;\n            }\n            | string,\n    ) => {\n        if (typeof options === \"string\") {\n            if (options === \"PING\") {\n                port.postMessage(\"PONG\");\n            }\n            if (options.startsWith(\"CLOSE_STREAM:\")) {\n                const executeId = options.substring(\"CLOSE_STREAM:\".length);\n                const streamCloser = streamClosers.get(executeId);\n                if (streamCloser) {\n                    streamCloser.generator.return(undefined);\n                    streamCloser.handleClose(\"stream\");\n                }\n            }\n            return;\n        }\n        let routeSchema = trie.get(options.path);\n        if (routeSchema === null) {\n            routeSchema = generated.routeSchema?.[options.path];\n            if (routeSchema === undefined) {\n                throw fail(\"NOT_FOUND\", { path: options.path });\n            }\n            if (typeof routeSchema.module !== \"function\") routeSchema.module = await routeSchema.module;\n            else routeSchema.module = await routeSchema.module();\n            trie.add(options.path, routeSchema);\n        }\n\n        const headers = new Headers(options.headers);\n        const params = options.params ?? {};\n        const logger = createLogger(runtime, options.path, options.executeId);\n        let finales: Array<() => void | Promise<void>> = [];\n\n        const http = new Proxy(\n            {},\n            {\n                get: (target, property) => {\n                    if (property === \"notFound\") return true;\n                    return undefined;\n                },\n                set: () => {\n                    throw fail(\"UNACCEPTABLE\", { expected: \"context.http\", message: \"This request was invoked through the execute method. Since no actual request was generated, the HTTP methods under the context cannot be accessed.\" });\n                },\n            },\n        );\n\n        const handleClose = async (type: \"action\" | \"stream\") => {\n            if (type === \"stream\") streamClosers.delete(options.executeId);\n            for (const handler of finales) {\n                try {\n                    await handler();\n                } catch (error) {\n                    logger.error(\"An error occurred inside onFinally.\", error);\n                }\n            }\n            await logger._.submit(context as any);\n            runtime.runtime.request.delete(options.executeId);\n        };\n\n        const context = { http: http, headers, routeType: routeSchema.type, fail, fault };\n\n        try {\n            if (routeSchema.type === \"action\") {\n                const executed = await executer.__execute(routeSchema, {\n                    createdExecuteId: options.executeId,\n                    createdLogger: logger,\n                    path: options.path,\n                    headers,\n                    context,\n                    params,\n                    paramsType: \"raw\",\n                });\n                finales = executed.finales;\n\n                await handleClose(\"action\");\n\n                if (executed.emptyResult) {\n                    port.postMessage({\n                        executeId: options.executeId,\n                        success: true,\n                        data: undefined,\n                    });\n                } else {\n                    port.postMessage({\n                        executeId: options.executeId,\n                        success: true,\n                        data: executed.results.value,\n                    });\n                }\n            }\n            if (routeSchema.type === \"stream\") {\n                const executed = await executer.__execute(routeSchema, {\n                    createdExecuteId: options.executeId,\n                    createdLogger: logger,\n                    path: options.path,\n                    headers,\n                    context,\n                    params,\n                    paramsType: \"raw\",\n                });\n                finales = executed.finales;\n\n                try {\n                    port.postMessage({ success: true, data: undefined, executeId: options.executeId, done: false });\n                    streamClosers.set(options.executeId, { generator: executed.results.value, handleClose });\n                    for await (const value of executed.results.value) {\n                        const data = { success: true, data: [null, value], executeId: options.executeId, done: false };\n                        port.postMessage(data);\n                    }\n                    port.postMessage({ success: true, data: undefined, executeId: options.executeId, done: true });\n                } catch (error) {\n                    const result = failureHandler(options.executeId, logger, error, { path: options.path, routeType: \"stream\", onError: runtime.onError }).response;\n                    port.postMessage({ success: true, data: [result.error, null], executeId: options.executeId, done: true });\n                }\n                await handleClose(\"stream\");\n            }\n        } catch (error) {\n            const result = failureHandler(options.executeId, logger, error, { path: options.path, routeType: routeSchema?.type, onError: runtime.onError }).response;\n            if (finales.length > 0) {\n                for (const handler of finales) {\n                    try { await handler(); } catch (finaleError) { logger.error(\"An error occurred inside onFinally.\", finaleError); }\n                }\n            }\n            await logger._.submit(context as any);\n            runtime.runtime.request.delete(options.executeId);\n            port.postMessage({ success: false, data: undefined, error: result.error, executeId: options.executeId, done: true });\n        }\n    };\n\n    return {\n        port,\n        bodyLimit,\n        fetch,\n        handleMessage,\n    };\n}\n","import type { MilkioResponseFailure } from \"../types/index.ts\";\nimport type { Logger } from \"../logger/index.ts\";\n\n// ---------------------------------------------------------------------------\n// fail-code: expected business rejection. warn level, no stack, cheap to build.\n// fault-code: unexpected/internal failure. error level, stack/cause, never exposed.\n// ---------------------------------------------------------------------------\n\nexport type MilkioFailureKind = \"fail\" | \"fault\";\n\n// ===== framework built-in codes =====\nexport interface $failCode {\n    NOT_FOUND: { path: string };\n    METHOD_NOT_ALLOWED: undefined;\n    PARAMS_TYPE_INCORRECT: { path: string; expected: string; value: any; message: string } | null;\n    PARAMS_TYPE_NOT_SUPPORTED: { expected: string; contentType: string | null; params: string };\n    NOT_DEVELOP_MODE: string;\n    UNACCEPTABLE: { expected: string; message: string };\n    REQUEST_TOO_LARGE: { maxBodySize: number };\n}\n\nexport interface $faultCode {\n    INTERNAL_SERVER_ERROR: undefined;\n    FRAMEWORK_ERROR: { message: string };\n    RESULTS_TYPE_INCORRECT: { path: string; expected: string; value: any; message: string } | null;\n}\n\n// ===== failure values =====\nexport interface MilkioFail<Code extends string = string, Data = unknown> {\n    readonly $milkioFailure: true;\n    readonly kind: \"fail\";\n    readonly code: Code;\n    readonly data: Data;\n}\n\nexport interface MilkioFaultShape<Code extends string = string, Data = unknown> {\n    readonly $milkioFailure: true;\n    readonly kind: \"fault\";\n    readonly code: Code;\n    readonly data: Data;\n    readonly stack?: string;\n}\n\nexport type MilkioFailure = MilkioFail | MilkioFaultShape;\n\n// ===== client-visible fault shape (real fault code/data stay server side) =====\nexport interface MilkioPublicFault {\n    readonly $milkioFailure: true;\n    readonly kind: \"fault\";\n    readonly code: \"INTERNAL_SERVER_ERROR\";\n    readonly data?: undefined;\n}\n\n// ===== wire types =====\nexport interface MilkioFailWire<Code extends string = string, Data = unknown> {\n    kind: \"fail\";\n    code: Code;\n    data: Data;\n}\n\nexport interface MilkioFaultWire {\n    kind: \"fault\";\n    code: \"INTERNAL_SERVER_ERROR\";\n}\n\nexport type MilkioFailureWire = MilkioFailWire | MilkioFaultWire;\n\n// ===== constructors =====\n/** fail: plain object only — no Error, no stack, no captureStackTrace (hot path). */\nexport function fail<Code extends string = string>(code: Code, data?: unknown): MilkioFail<Code, unknown> {\n    return { $milkioFailure: true, kind: \"fail\", code, data } as MilkioFail<Code, unknown>;\n}\n\n/** fault: Error subclass — captures stack/cause for server-side logs only. */\nexport class MilkioFaultError extends Error implements MilkioFaultShape {\n    readonly $milkioFailure = true as const;\n    readonly kind = \"fault\" as const;\n    readonly code: string;\n    readonly data: unknown;\n\n    constructor(code: string, data?: unknown, options?: { cause?: unknown; stack?: string }) {\n        super(code, options?.cause === undefined ? undefined : { cause: options.cause });\n        this.name = \"MilkioFault\";\n        this.code = code;\n        this.data = data;\n        if (options?.stack !== undefined) this.stack = options.stack;\n    }\n}\n\nexport function fault(code: string, data?: unknown, options?: { cause?: unknown }): MilkioFaultError {\n    return new MilkioFaultError(code, data, options);\n}\n\nexport function isMilkioFailure(value: unknown): value is MilkioFailure {\n    return typeof value === \"object\" && value !== null && (value as any).$milkioFailure === true;\n}\n\nexport interface MilkioFaultReport {\n    executeId: string;\n    path?: string;\n    routeType?: \"action\" | \"stream\" | \"raw\" | \"event\";\n    kind: \"fault\";\n    code: string;\n    data: unknown;\n    stack?: string;\n    cause?: unknown;\n    source: \"fault\" | \"unexpected\";\n}\n\n// cause chain is where the real reason usually lives (drizzle/fetch put it there)\nexport function serializeCause(error: unknown): string {\n    const seen = new Set<any>();\n    const causes: Array<Record<string, unknown>> = [];\n    let current = (error as any)?.cause;\n    while (current !== null && current !== undefined && typeof current === \"object\" && !seen.has(current)) {\n        seen.add(current);\n        const cause: Record<string, unknown> = {};\n        for (const key of [\"name\", \"message\", \"code\", \"errno\", \"sqlState\", \"sqlMessage\"]) {\n            if ((current as any)[key] !== undefined) cause[key] = (current as any)[key];\n        }\n        causes.push(cause);\n        current = (current as any).cause;\n    }\n    return causes.length > 0 ? JSON.stringify(causes) : \"\";\n}\n\nfunction safeStringify(value: unknown): string {\n    if (value === undefined) return \"undefined\";\n    try {\n        return JSON.stringify(value) ?? \"undefined\";\n    } catch {\n        try { return String(value); } catch { return \"[unserializable]\"; }\n    }\n}\n\ntype Classified =\n    | { kind: \"fail\"; code: string; data: unknown }\n    | { kind: \"fault\"; code: string; data: unknown; stack?: string; cause?: unknown; source: \"fault\" | \"unexpected\" };\n\nexport function classifyFailure(error: unknown): Classified {\n    if (isMilkioFailure(error)) {\n        if (error.kind === \"fail\") return { kind: \"fail\", code: error.code, data: error.data };\n        return { kind: \"fault\", code: error.code, data: error.data, stack: error.stack, source: \"fault\" };\n    }\n    return {\n        kind: \"fault\",\n        code: \"INTERNAL_SERVER_ERROR\",\n        data: undefined,\n        stack: error instanceof Error ? (error.stack ?? \"\") : \"\",\n        cause: error,\n        source: \"unexpected\",\n    };\n}\n\nexport function failureHandler(\n    executeId: string,\n    logger: Logger,\n    error: unknown,\n    options: {\n        path?: string;\n        routeType?: MilkioFaultReport[\"routeType\"];\n        onError?: (report: MilkioFaultReport) => void;\n    } = {},\n): { response: MilkioResponseFailure; report?: MilkioFaultReport } {\n    const classified = classifyFailure(error);\n\n    if (classified.kind === \"fail\") {\n        // fail: warn, no stack (never captured), data is part of the public contract\n        logger.warn(classified.code, safeStringify(classified.data));\n        return {\n            response: {\n                success: false,\n                executeId,\n                error: { kind: \"fail\", code: classified.code, data: classified.data },\n            },\n        };\n    }\n\n    // fault: log real code/data/stack/cause; client only learns \"fault + generic code\"\n    try {\n        const params: Array<unknown> = [safeStringify(classified.data)];\n        const causes = serializeCause(classified.cause ?? error);\n        if (causes !== \"\") params.push(`causes: ${causes}`);\n        if (classified.stack !== undefined && classified.stack !== \"\") params.push(`\\n${classified.stack}\\n`);\n        logger.error(classified.code, ...params);\n    } catch (_) {\n        logger.error(classified.code, safeStringify(classified.data));\n    }\n\n    const report: MilkioFaultReport = {\n        executeId,\n        path: options.path,\n        routeType: options.routeType,\n        kind: \"fault\",\n        code: classified.code,\n        data: classified.data,\n        stack: classified.stack,\n        cause: classified.cause,\n        source: classified.source,\n    };\n\n    if (options.onError !== undefined) {\n        try {\n            options.onError(report);\n        } catch (onErrorError) {\n            try {\n                logger.error(\"An error occurred inside onError.\", onErrorError);\n            } catch { /* never let alerting break error handling */ }\n        }\n    }\n\n    return {\n        response: {\n            success: false,\n            executeId,\n            error: { kind: \"fault\", code: \"INTERNAL_SERVER_ERROR\" },\n        },\n        report,\n    };\n}\n"],"mappings":"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"}