@milkio/stargate 1.3.71 → 1.3.73

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.
Files changed (3) hide show
  1. package/index.d.ts +102 -19
  2. package/index.js +891 -724
  3. package/package.json +1 -1
package/index.js CHANGED
@@ -1,748 +1,915 @@
1
1
  // packages/milkio-stargate/index.ts
2
+ function createFail(code, data) {
3
+ return {
4
+ $milkioFailure: true,
5
+ kind: "fail",
6
+ code,
7
+ data
8
+ };
9
+ }
10
+ function createFault(code, data) {
11
+ return {
12
+ $milkioFailure: true,
13
+ kind: "fault",
14
+ code,
15
+ data
16
+ };
17
+ }
18
+ function createNetworkFailure(error) {
19
+ const data = {};
20
+ if (error instanceof Error) {
21
+ data.name = error.name;
22
+ if (error.message) data.message = error.message;
23
+ } else if (typeof error === "string" && error !== "") data.message = error;
24
+ const code = error?.code;
25
+ if (typeof code === "string" && code !== "") data.code = code;
26
+ return {
27
+ $milkioFailure: true,
28
+ kind: "fault",
29
+ code: "NETWORK_ERROR",
30
+ data: Object.keys(data).length > 0 ? data : void 0
31
+ };
32
+ }
33
+ function createTimeoutFailure(timeout) {
34
+ return {
35
+ $milkioFailure: true,
36
+ kind: "fault",
37
+ code: "REQUEST_TIMEOUT",
38
+ data: {
39
+ timeout,
40
+ message: `Execute timeout after ${timeout}ms.`
41
+ }
42
+ };
43
+ }
44
+ /** only transport-level faults are retried; fail and server faults are never retried */
45
+ function isTransportFailure(failure) {
46
+ return failure.kind === "fault" && (failure.code === "NETWORK_ERROR" || failure.code === "REQUEST_TIMEOUT");
47
+ }
48
+ /** restore a wire failure: fail keeps code/data, fault is always reduced to the generic code by the server */
49
+ function reviveFailureWire(wire) {
50
+ if (typeof wire === "object" && wire !== null) {
51
+ const parsed = wire;
52
+ if (parsed.kind === "fail" && typeof parsed.code === "string") return createFail(parsed.code, parsed.data);
53
+ if (parsed.kind === "fault") return createFault("INTERNAL_SERVER_ERROR");
54
+ }
55
+ return createFault("INTERNAL_SERVER_ERROR");
56
+ }
2
57
  async function createStargate(stargateOptions) {
3
- const $fetch = stargateOptions.fetch ?? fetch;
4
- const $abort = stargateOptions.abort ?? AbortController;
5
- const handleError = async (error, key, handler) => {
6
- if (key in error) {
7
- const handled = await handler(error[key]);
8
- if (handled)
9
- delete error[key];
10
- }
11
- };
12
- const __initEventManager = () => {
13
- const handlers = new Map;
14
- const indexed = new Map;
15
- const eventManager = {
16
- on: (key, handler) => {
17
- handlers.set(handler, key);
18
- if (indexed.has(key) === false) {
19
- indexed.set(key, new Set);
20
- }
21
- const set = indexed.get(key);
22
- set.add(handler);
23
- handlers.set(handler, key);
24
- return () => {
25
- handlers.delete(handler);
26
- set.delete(handler);
27
- };
28
- },
29
- off: (key, handler) => {
30
- const set = indexed.get(key);
31
- if (!set)
32
- return;
33
- handlers.delete(handler);
34
- set.delete(handler);
35
- },
36
- emit: async (key, value) => {
37
- const h = indexed.get(key);
38
- if (h) {
39
- for (const handler of h) {
40
- await handler(value);
41
- }
42
- }
43
- }
44
- };
45
- return eventManager;
46
- };
47
- const eventManager = __initEventManager();
48
- const bootstrap = async () => {
49
- let baseUrl = stargateOptions.baseUrl;
50
- if (typeof baseUrl === "function")
51
- baseUrl = await baseUrl();
52
- if (baseUrl.endsWith("/"))
53
- baseUrl = baseUrl.slice(0, -1);
54
- return baseUrl;
55
- };
56
- const baseUrlPromise = bootstrap();
57
- let resolvedBaseUrl = null;
58
- let cachedUrlPath = null;
59
- let cachedUrl = null;
60
- const stargate = {
61
- ...eventManager,
62
- options: stargateOptions,
63
- async execute(path, options) {
64
- if (options.headers === undefined)
65
- options.headers = {};
66
- let url;
67
- if (options.baseUrl) {
68
- let baseUrl = options.baseUrl;
69
- if (typeof baseUrl === "function")
70
- baseUrl = await baseUrl();
71
- if (baseUrl.endsWith("/"))
72
- baseUrl = baseUrl.slice(0, -1);
73
- url = baseUrl + path;
74
- } else {
75
- if (!resolvedBaseUrl)
76
- resolvedBaseUrl = await baseUrlPromise;
77
- if (path === cachedUrlPath && cachedUrl !== null) {
78
- url = cachedUrl;
79
- } else {
80
- url = resolvedBaseUrl + path;
81
- cachedUrlPath = path;
82
- cachedUrl = url;
83
- }
84
- }
85
- if (!path.endsWith("~")) {
86
- const h = options.headers;
87
- if (h.Accept === undefined)
88
- h.Accept = "application/json";
89
- if (h["Content-Type"] === undefined)
90
- h["Content-Type"] = "application/json";
91
- const cacheStrategy = options.cacheStrategy ?? "off";
92
- let retryCount = 0;
93
- if (options.retryStrategy === true || options.retryStrategy === 2) {
94
- retryCount = 2;
95
- } else if (typeof options.retryStrategy === "number" && options.retryStrategy > 0) {
96
- retryCount = options.retryStrategy;
97
- }
98
- if (cacheStrategy === "off" && retryCount === 0) {
99
- try {
100
- await eventManager.emit("milkio:executeBefore", { path, options });
101
- const body = JSON.stringify(options.params) ?? "";
102
- await eventManager.emit("milkio:fetchBefore", { path, options, body });
103
- let text;
104
- const response = await $fetch(url, { method: "POST", body, headers: options.headers });
105
- text = await response.text();
106
- const parsed = reviveJSONParse(JSON.parse(text));
107
- if (parsed.success !== true) {
108
- const err = {};
109
- err[parsed.code] = parsed.reject ?? null;
110
- return [err, null, { executeId: parsed.executeId }];
111
- }
112
- return [null, parsed.data, { executeId: parsed.executeId }];
113
- } catch (error) {
114
- if (error?.[0]?.REQUEST_TIMEOUT) {
115
- return [error, null, { executeId: "" }];
116
- }
117
- const errorPined = { REQUEST_FAIL: error };
118
- return [errorPined, null, { executeId: "unknown" }];
119
- }
120
- }
121
- const cacheThrottleMs = options.cacheThrottleMs ?? 0;
122
- const cacheKey = generateCacheKey(path, options.params);
123
- let cacheStorage = stargateOptions.cacheStorage;
124
- if (cacheStrategy !== "off" && !cacheStorage) {
125
- cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });
126
- }
127
- if (cacheStrategy !== "off" && cacheStorage && options.onCacheHit) {
128
- const cached = await cacheStorage.get(cacheKey);
129
- if (cached) {
130
- try {
131
- await options.onCacheHit(cached.data);
132
- } catch {}
133
- }
134
- }
135
- if (cacheStrategy === "throttle" && cacheStorage) {
136
- const cached = await cacheStorage.get(cacheKey);
137
- if (cached && Date.now() - cached.timestamp < cacheThrottleMs) {
138
- return [null, cached.data, { executeId: "cached" }];
139
- }
140
- }
141
- await eventManager.emit("milkio:executeBefore", { path, options });
142
- const body = JSON.stringify(options.params) ?? "";
143
- await eventManager.emit("milkio:fetchBefore", { path, options, body });
144
- const executeRequest = async (isRetry) => {
145
- try {
146
- const response = await $fetch(url, { method: "POST", body, headers: options.headers });
147
- const text = await response.text();
148
- const parsed = JSON.parse(text);
149
- return { result: { value: parsed }, error: null, isNetworkError: false };
150
- } catch (error) {
151
- const isNetworkError = !error?.[0]?.REQUEST_TIMEOUT;
152
- return { result: null, error, isNetworkError };
153
- }
154
- };
155
- let { result, error, isNetworkError } = await executeRequest(false);
156
- for (let retryIndex = 0;retryIndex < retryCount && error && isNetworkError; retryIndex++) {
157
- if (retryIndex > 0) {
158
- await new Promise((resolve) => setTimeout(resolve, 500));
159
- }
160
- const retryResult = await executeRequest(true);
161
- result = retryResult.result;
162
- error = retryResult.error;
163
- isNetworkError = retryResult.isNetworkError;
164
- }
165
- if (error) {
166
- if (error?.[0]?.REQUEST_TIMEOUT) {
167
- await eventManager.emit("milkio:executeError", { handleError, path, options, error });
168
- return error;
169
- }
170
- if (cacheStrategy !== "off" && cacheStorage && isNetworkError) {
171
- const cached = await cacheStorage.get(cacheKey);
172
- if (cached) {
173
- return [null, cached.data, { executeId: "cached" }];
174
- }
175
- }
176
- const errorPined = { REQUEST_FAIL: error };
177
- await eventManager.emit("milkio:executeError", { handleError, path, options, error: errorPined });
178
- return [errorPined, null, { executeId: "unknown" }];
179
- }
180
- if (result.value.success !== true) {
181
- const err = {};
182
- err[result.value.code] = result.value.reject ?? null;
183
- await eventManager.emit("milkio:executeError", { handleError, path, options, error: err });
184
- return [err, null, { executeId: result.value.executeId }];
185
- }
186
- if (cacheStrategy !== "off" && cacheStorage) {
187
- await cacheStorage.set(cacheKey, result.value.data);
188
- }
189
- return [null, result.value.data, { executeId: result.value.executeId }];
190
- } else {
191
- options.cacheStrategy = "off";
192
- options.onCacheHit = undefined;
193
- options.cacheThrottleMs = undefined;
194
- if (options.headers.Accept === undefined)
195
- options.headers.Accept = "text/event-stream";
196
- if (options.headers["Content-Type"] === undefined)
197
- options.headers["Content-Type"] = "application/json";
198
- const stacks = new Map;
199
- let stacksIndex = 0;
200
- let iteratorIndex = 0;
201
- let streamResult;
202
- const streamResultFetched = withResolvers();
203
- const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;
204
- const timer = setTimeout(() => {
205
- streamResultFetched.reject([{ REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } }, null, { executeId: "unknown" }]);
206
- }, timeout);
207
- const onmessage = (event) => {
208
- if (event.data.startsWith("@")) {
209
- try {
210
- streamResult = reviveJSONParse(JSON.parse(event.data.slice(1)));
211
- streamResultFetched.resolve(undefined);
212
- clearTimeout(timer);
213
- } catch (error) {
214
- streamResultFetched.reject([{ REQUEST_FAIL: error }, null, { executeId: "unknown" }]);
215
- clearTimeout(timer);
216
- }
217
- } else {
218
- const index = ++stacksIndex;
219
- if (stacks.has(index)) {
220
- const stack = stacks.get(index);
221
- stack.done = true;
222
- stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });
223
- } else {
224
- const stack = withResolvers();
225
- stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });
226
- stacks.set(index, { ...stack, done: false });
227
- }
228
- }
229
- };
230
- let curRequestController;
231
- async function create() {
232
- curRequestController = new $abort;
233
- curRequestController.signal.addEventListener("abort", () => {
234
- iterator.return();
235
- });
236
- try {
237
- await eventManager.emit("milkio:executeBefore", { path, options });
238
- const body = JSON.stringify(options.params) ?? "";
239
- await eventManager.emit("milkio:fetchBefore", { path, options, body });
240
- const response = await $fetch(url, {
241
- method: "POST",
242
- headers: options.headers,
243
- body,
244
- signal: curRequestController.signal
245
- });
246
- const contentType = response.headers.get("Content-Type");
247
- if (!contentType?.startsWith("text/event-stream")) {
248
- throw new Error(`Expected content-type to be ${"text/event-stream"}, Actual: ${contentType}`);
249
- }
250
- await getBytes(response.body, getLines(getMessages(onmessage)));
251
- await iterator.return();
252
- } catch (err) {
253
- if (!curRequestController.signal.aborted)
254
- curRequestController.abort();
255
- const error = { REQUEST_FAIL: err };
256
- await eventManager.emit("milkio:executeError", { handleError, path, options, error });
257
- await iterator.throw(err);
258
- streamResultFetched.reject([error, null, { executeId: "unknown" }]);
259
- }
260
- }
261
- create();
262
- const iterator = {
263
- ...{
264
- next() {
265
- const index = ++iteratorIndex;
266
- if (stacks.has(index - 2))
267
- stacks.delete(index - 2);
268
- if (!stacks.has(index) && !curRequestController.signal.aborted) {
269
- const stack = withResolvers();
270
- stacks.set(index, { ...stack, done: false });
271
- return stack.promise;
272
- }
273
- if (!stacks.has(index) && curRequestController.signal.aborted) {
274
- const stack = withResolvers();
275
- stack.resolve({ done: true, value: undefined });
276
- return stack.promise;
277
- }
278
- return stacks.get(index).promise;
279
- },
280
- async return() {
281
- if (!curRequestController.signal.aborted)
282
- curRequestController.abort();
283
- for (const [_, iterator] of stacks)
284
- iterator.resolve({ done: true, value: undefined });
285
- return { done: true, value: undefined };
286
- },
287
- async throw(err) {
288
- streamResult = {
289
- success: false,
290
- executeId: streamResult?.executeId ?? "",
291
- fail: {
292
- code: "NETWORK_ERROR",
293
- message: "Network Error",
294
- fromClient: true,
295
- data: err
296
- }
297
- };
298
- for (const [_index, stack] of stacks) {
299
- if (stack.done)
300
- continue;
301
- stack.done = true;
302
- stack.resolve({ done: true, value: undefined });
303
- }
304
- if (!curRequestController.signal.aborted)
305
- curRequestController.abort();
306
- for (const [_, iterator] of stacks)
307
- iterator.resolve({ done: true, value: undefined });
308
- return { done: true, value: undefined };
309
- }
310
- },
311
- [Symbol.asyncIterator]() {
312
- return this;
313
- }
314
- };
315
- try {
316
- await streamResultFetched.promise;
317
- return [null, iterator, { executeId: streamResult.executeId }];
318
- } catch (error) {
319
- return error;
320
- }
321
- }
322
- },
323
- __cookbook: {
324
- subscribe: async (baseUrl) => {
325
- const headers = {
326
- "Content-Type": "application/json",
327
- Accept: "text/event-stream"
328
- };
329
- const params = {};
330
- const body = JSON.stringify(params) ?? "";
331
- const stacks = new Map;
332
- let stacksIndex = 0;
333
- let iteratorIndex = 0;
334
- const onmessage = (event) => {
335
- const index = ++stacksIndex;
336
- if (stacks.has(index)) {
337
- const stack = stacks.get(index);
338
- stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });
339
- } else {
340
- const stack = withResolvers();
341
- stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });
342
- stacks.set(index, { ...stack, done: false });
343
- }
344
- };
345
- let curRequestController;
346
- async function create() {
347
- curRequestController = new $abort;
348
- curRequestController.signal.addEventListener("abort", () => {
349
- iterator.return();
350
- });
351
- try {
352
- const response = await $fetch(`${baseUrl}/$subscribe`, {
353
- method: "POST",
354
- headers,
355
- body,
356
- signal: curRequestController.signal
357
- });
358
- const contentType = response.headers.get("Content-Type");
359
- if (!contentType?.startsWith("text/event-stream")) {
360
- throw new Error(`Expected content-type to be ${"text/event-stream"}, Actual: ${contentType}`);
361
- }
362
- await getBytes(response.body, getLines(getMessages(onmessage)));
363
- await iterator.return();
364
- } catch (err) {
365
- if (!curRequestController.signal.aborted)
366
- curRequestController.abort();
367
- await iterator.throw(err);
368
- }
369
- }
370
- create();
371
- const iterator = {
372
- ...{
373
- next() {
374
- const index = ++iteratorIndex;
375
- if (stacks.has(index - 2))
376
- stacks.delete(index - 2);
377
- if (!stacks.has(index) && !curRequestController.signal.aborted) {
378
- const stack = withResolvers();
379
- stacks.set(index, { ...stack, done: false });
380
- return stack.promise;
381
- }
382
- if (!stacks.has(index) && curRequestController.signal.aborted) {
383
- const stack = withResolvers();
384
- stack.resolve({ done: true, value: undefined });
385
- return stack.promise;
386
- }
387
- return stacks.get(index).promise;
388
- },
389
- async return() {
390
- if (!curRequestController.signal.aborted)
391
- curRequestController.abort();
392
- for (const [_, iterator] of stacks)
393
- iterator.resolve({ done: true, value: undefined });
394
- return { done: true, value: undefined };
395
- },
396
- async throw(err) {
397
- if (!curRequestController.signal.aborted)
398
- curRequestController.abort();
399
- for (const [_, iterator] of stacks)
400
- iterator.resolve({ done: true, value: undefined });
401
- return { done: true, value: undefined };
402
- }
403
- },
404
- [Symbol.asyncIterator]() {
405
- return this;
406
- }
407
- };
408
- try {
409
- return iterator;
410
- } catch (error) {
411
- return error;
412
- }
413
- }
414
- },
415
- __astraEmitEvent: async (key, options) => {
416
- const opts = options ?? {};
417
- if (opts.headers === undefined)
418
- opts.headers = {};
419
- if (opts.headers["Content-Type"] === undefined)
420
- opts.headers["Content-Type"] = "application/json";
421
- let url;
422
- if (!resolvedBaseUrl)
423
- resolvedBaseUrl = await baseUrlPromise;
424
- let base64Name;
425
- if (typeof btoa !== "undefined") {
426
- base64Name = btoa(key);
427
- } else if (typeof Buffer !== "undefined") {
428
- base64Name = Buffer.from(key).toString("base64");
429
- } else {
430
- throw new Error("No base64 encoder available");
431
- }
432
- url = `${resolvedBaseUrl}/$event/${encodeURIComponent(base64Name)}`;
433
- try {
434
- const body = JSON.stringify(opts.params) ?? "";
435
- const response = await $fetch(url, { method: "POST", body, headers: opts.headers });
436
- const text = await response.text();
437
- const parsed = reviveJSONParse(JSON.parse(text));
438
- if (parsed.success !== true) {
439
- const err = {};
440
- err[parsed.code] = parsed.reject ?? null;
441
- return [err, null, { executeId: parsed.executeId }];
442
- }
443
- return [null, parsed.data, { executeId: parsed.executeId }];
444
- } catch (error) {
445
- const errorPined = { REQUEST_FAIL: error };
446
- return [errorPined, null, { executeId: "unknown" }];
447
- }
448
- },
449
- async ping(options) {
450
- return await new Promise(async (resolve) => {
451
- const url = `${await baseUrlPromise}/generate_204`;
452
- const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;
453
- const startsTime = Date.now();
454
- const timer = setTimeout(() => {
455
- const endsTime = Date.now();
456
- resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } } }, null]);
457
- }, timeout);
458
- try {
459
- const response = await $fetch(url, { method: "HEAD" });
460
- const endsTime = Date.now();
461
- clearTimeout(timer);
462
- if (response.status !== 204) {
463
- resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_FAIL: { response, status: response.status, message: "Status code not 204" } } }, null]);
464
- }
465
- resolve([null, { connect: true, delay: endsTime - startsTime, serverTimestamp: Number(response.headers.get("Content-Type").substring(17)) }]);
466
- } catch (error) {
467
- const endsTime = Date.now();
468
- return [{ connect: false, delay: endsTime - startsTime, error }, null];
469
- }
470
- });
471
- },
472
- $types: undefined
473
- };
474
- return stargate;
58
+ const $fetch = stargateOptions.fetch ?? fetch;
59
+ const $abort = stargateOptions.abort ?? AbortController;
60
+ /**
61
+ * Restored wire failures are cast to the generated failure union: the server contract guarantees the
62
+ * fail-code string is one of the generated codes, only the runtime value is unknown statically.
63
+ */
64
+ const reviveFailure = (wire) => reviveFailureWire(wire);
65
+ /** only `fail` failures have a public business code; fault can never be matched by code */
66
+ const handleError = async (failure, code, handler) => {
67
+ if (failure === null || failure === void 0) return false;
68
+ if (failure.kind !== "fail") return false;
69
+ if (failure.code !== code) return false;
70
+ return await handler(failure.data) === true;
71
+ };
72
+ const __initEventManager = () => {
73
+ const handlers = /* @__PURE__ */ new Map();
74
+ const indexed = /* @__PURE__ */ new Map();
75
+ return {
76
+ on: (key, handler) => {
77
+ handlers.set(handler, key);
78
+ if (indexed.has(key) === false) indexed.set(key, /* @__PURE__ */ new Set());
79
+ const set = indexed.get(key);
80
+ set.add(handler);
81
+ handlers.set(handler, key);
82
+ return () => {
83
+ handlers.delete(handler);
84
+ set.delete(handler);
85
+ };
86
+ },
87
+ off: (key, handler) => {
88
+ const set = indexed.get(key);
89
+ if (!set) return;
90
+ handlers.delete(handler);
91
+ set.delete(handler);
92
+ },
93
+ emit: async (key, value) => {
94
+ const h = indexed.get(key);
95
+ if (h) for (const handler of h) await handler(value);
96
+ }
97
+ };
98
+ };
99
+ const eventManager = __initEventManager();
100
+ const bootstrap = async () => {
101
+ let baseUrl = stargateOptions.baseUrl;
102
+ if (typeof baseUrl === "function") baseUrl = await baseUrl();
103
+ if (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
104
+ return baseUrl;
105
+ };
106
+ const baseUrlPromise = bootstrap();
107
+ let resolvedBaseUrl = null;
108
+ let cachedUrlPath = null;
109
+ let cachedUrl = null;
110
+ return {
111
+ ...eventManager,
112
+ options: stargateOptions,
113
+ async execute(path, options) {
114
+ if (options.headers === void 0) options.headers = {};
115
+ let url;
116
+ if (options.baseUrl) {
117
+ let baseUrl = options.baseUrl;
118
+ if (typeof baseUrl === "function") baseUrl = await baseUrl();
119
+ if (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
120
+ url = baseUrl + path;
121
+ } else {
122
+ if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;
123
+ if (path === cachedUrlPath && cachedUrl !== null) url = cachedUrl;
124
+ else {
125
+ url = resolvedBaseUrl + path;
126
+ cachedUrlPath = path;
127
+ cachedUrl = url;
128
+ }
129
+ }
130
+ if (!path.endsWith("~")) {
131
+ const h = options.headers;
132
+ if (h.Accept === void 0) h.Accept = "application/json";
133
+ if (h["Content-Type"] === void 0) h["Content-Type"] = "application/json";
134
+ const cacheStrategy = options.cacheStrategy ?? "off";
135
+ let retryCount = 0;
136
+ if (options.retryStrategy === true || options.retryStrategy === 2) retryCount = 2;
137
+ else if (typeof options.retryStrategy === "number" && options.retryStrategy > 0) retryCount = options.retryStrategy;
138
+ const timeout = options.timeout ?? stargateOptions.timeout ?? 6e3;
139
+ if (cacheStrategy === "off" && retryCount === 0) {
140
+ const controller = new $abort();
141
+ const timer = setTimeout(() => controller.abort(), timeout);
142
+ try {
143
+ await eventManager.emit("milkio:executeBefore", {
144
+ path,
145
+ options
146
+ });
147
+ const body = JSON.stringify(options.params) ?? "";
148
+ await eventManager.emit("milkio:fetchBefore", {
149
+ path,
150
+ options,
151
+ body
152
+ });
153
+ const text = await (await $fetch(url, {
154
+ method: "POST",
155
+ body,
156
+ headers: options.headers,
157
+ signal: controller.signal
158
+ })).text();
159
+ const parsed = reviveJSONParse(JSON.parse(text));
160
+ if (parsed.success !== true) {
161
+ const failure = reviveFailure(parsed.error);
162
+ await eventManager.emit("milkio:executeError", {
163
+ handleError,
164
+ path,
165
+ options,
166
+ failure
167
+ });
168
+ return [
169
+ failure,
170
+ null,
171
+ { executeId: parsed.executeId ?? "" }
172
+ ];
173
+ }
174
+ return [
175
+ null,
176
+ parsed.data,
177
+ { executeId: parsed.executeId }
178
+ ];
179
+ } catch (error) {
180
+ const failure = controller.signal.aborted ? createTimeoutFailure(timeout) : createNetworkFailure(error);
181
+ await eventManager.emit("milkio:executeError", {
182
+ handleError,
183
+ path,
184
+ options,
185
+ failure
186
+ });
187
+ return [
188
+ failure,
189
+ null,
190
+ { executeId: "unknown" }
191
+ ];
192
+ } finally {
193
+ clearTimeout(timer);
194
+ }
195
+ }
196
+ const cacheThrottleMs = options.cacheThrottleMs ?? 0;
197
+ const cacheKey = generateCacheKey(path, options.params);
198
+ let cacheStorage = stargateOptions.cacheStorage;
199
+ if (cacheStrategy !== "off" && !cacheStorage) cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });
200
+ if (cacheStrategy !== "off" && cacheStorage && options.onCacheHit) {
201
+ const cached = await cacheStorage.get(cacheKey);
202
+ if (cached) try {
203
+ await options.onCacheHit(cached.data);
204
+ } catch {}
205
+ }
206
+ if (cacheStrategy === "throttle" && cacheStorage) {
207
+ const cached = await cacheStorage.get(cacheKey);
208
+ if (cached && Date.now() - cached.timestamp < cacheThrottleMs) return [
209
+ null,
210
+ cached.data,
211
+ { executeId: "cached" }
212
+ ];
213
+ }
214
+ await eventManager.emit("milkio:executeBefore", {
215
+ path,
216
+ options
217
+ });
218
+ const body = JSON.stringify(options.params) ?? "";
219
+ await eventManager.emit("milkio:fetchBefore", {
220
+ path,
221
+ options,
222
+ body
223
+ });
224
+ const executeRequest = async () => {
225
+ const controller = new $abort();
226
+ const timer = setTimeout(() => controller.abort(), timeout);
227
+ try {
228
+ const text = await (await $fetch(url, {
229
+ method: "POST",
230
+ body,
231
+ headers: options.headers,
232
+ signal: controller.signal
233
+ })).text();
234
+ const parsed = reviveJSONParse(JSON.parse(text));
235
+ if (parsed.success !== true) return {
236
+ failure: reviveFailure(parsed.error),
237
+ data: void 0,
238
+ executeId: parsed.executeId ?? "",
239
+ timedOut: false
240
+ };
241
+ return {
242
+ failure: null,
243
+ data: parsed.data,
244
+ executeId: parsed.executeId,
245
+ timedOut: false
246
+ };
247
+ } catch (error) {
248
+ if (controller.signal.aborted) return {
249
+ failure: createTimeoutFailure(timeout),
250
+ data: void 0,
251
+ executeId: "unknown",
252
+ timedOut: true
253
+ };
254
+ return {
255
+ failure: createNetworkFailure(error),
256
+ data: void 0,
257
+ executeId: "unknown",
258
+ timedOut: false
259
+ };
260
+ } finally {
261
+ clearTimeout(timer);
262
+ }
263
+ };
264
+ let requestResult = await executeRequest();
265
+ let { failure, data, executeId } = requestResult;
266
+ for (let retryIndex = 0; retryIndex < retryCount && failure !== null && !requestResult.timedOut && isTransportFailure(failure); retryIndex++) {
267
+ if (retryIndex > 0) await new Promise((resolve) => setTimeout(resolve, 500));
268
+ requestResult = await executeRequest();
269
+ ({failure, data, executeId} = requestResult);
270
+ }
271
+ if (failure) {
272
+ if (cacheStrategy !== "off" && cacheStorage && failure.kind !== "fail") {
273
+ const cached = await cacheStorage.get(cacheKey);
274
+ if (cached) return [
275
+ null,
276
+ cached.data,
277
+ { executeId: "cached" }
278
+ ];
279
+ }
280
+ await eventManager.emit("milkio:executeError", {
281
+ handleError,
282
+ path,
283
+ options,
284
+ failure
285
+ });
286
+ return [
287
+ failure,
288
+ null,
289
+ { executeId }
290
+ ];
291
+ }
292
+ if (cacheStrategy !== "off" && cacheStorage) await cacheStorage.set(cacheKey, data);
293
+ return [
294
+ null,
295
+ data,
296
+ { executeId }
297
+ ];
298
+ } else {
299
+ options.cacheStrategy = "off";
300
+ options.onCacheHit = void 0;
301
+ options.cacheThrottleMs = void 0;
302
+ if (options.headers.Accept === void 0) options.headers.Accept = "text/event-stream";
303
+ if (options.headers["Content-Type"] === void 0) options.headers["Content-Type"] = "application/json";
304
+ const stacks = /* @__PURE__ */ new Map();
305
+ let stacksIndex = 0;
306
+ let iteratorIndex = 0;
307
+ let streamResult;
308
+ const streamResultFetched = withResolvers();
309
+ const timeout = options?.timeout ?? stargateOptions?.timeout ?? 6e3;
310
+ const timer = setTimeout(() => {
311
+ failStream(createTimeoutFailure(timeout), "unknown");
312
+ }, timeout);
313
+ /** SSE error frames are `data:[wireFailure, null]`, success frames are `data:[null, value]` */
314
+ const reviveStreamFrame = (frame) => {
315
+ if (Array.isArray(frame) && frame.length === 2 && frame[0] !== null && frame[0] !== void 0) return [reviveFailure(frame[0]), null];
316
+ return frame;
317
+ };
318
+ let curRequestController;
319
+ const failStream = async (failure, executeId) => {
320
+ clearTimeout(timer);
321
+ if (!curRequestController.signal.aborted) curRequestController.abort();
322
+ await eventManager.emit("milkio:executeError", {
323
+ handleError,
324
+ path,
325
+ options,
326
+ failure
327
+ });
328
+ await iterator.throw();
329
+ streamResultFetched.reject([
330
+ failure,
331
+ null,
332
+ { executeId }
333
+ ]);
334
+ };
335
+ const onmessage = (event) => {
336
+ if (event.data.startsWith("@")) {
337
+ clearTimeout(timer);
338
+ try {
339
+ const parsed = reviveJSONParse(JSON.parse(event.data.slice(1)));
340
+ if (parsed.success !== true) {
341
+ failStream(reviveFailure(parsed.error), typeof parsed.executeId === "string" ? parsed.executeId : "");
342
+ return;
343
+ }
344
+ streamResult = parsed;
345
+ streamResultFetched.resolve(void 0);
346
+ } catch {
347
+ failStream(createNetworkFailure(), "unknown");
348
+ }
349
+ } else {
350
+ const index = ++stacksIndex;
351
+ if (stacks.has(index)) {
352
+ const stack = stacks.get(index);
353
+ stack.done = true;
354
+ stack.resolve({
355
+ done: false,
356
+ value: reviveStreamFrame(reviveJSONParse(JSON.parse(event.data)))
357
+ });
358
+ } else {
359
+ const stack = withResolvers();
360
+ stack.resolve({
361
+ done: false,
362
+ value: reviveStreamFrame(reviveJSONParse(JSON.parse(event.data)))
363
+ });
364
+ stacks.set(index, {
365
+ ...stack,
366
+ done: false
367
+ });
368
+ }
369
+ }
370
+ };
371
+ async function create() {
372
+ curRequestController = new $abort();
373
+ curRequestController.signal.addEventListener("abort", () => {
374
+ iterator.return();
375
+ });
376
+ try {
377
+ await eventManager.emit("milkio:executeBefore", {
378
+ path,
379
+ options
380
+ });
381
+ const body = JSON.stringify(options.params) ?? "";
382
+ await eventManager.emit("milkio:fetchBefore", {
383
+ path,
384
+ options,
385
+ body
386
+ });
387
+ const response = await $fetch(url, {
388
+ method: "POST",
389
+ headers: options.headers,
390
+ body,
391
+ signal: curRequestController.signal
392
+ });
393
+ if (!response.headers.get("Content-Type")?.startsWith("text/event-stream")) {
394
+ let envelope = null;
395
+ try {
396
+ envelope = reviveJSONParse(JSON.parse(await response.text()));
397
+ } catch {
398
+ envelope = null;
399
+ }
400
+ if (envelope !== null && typeof envelope === "object" && envelope.success === false) {
401
+ await failStream(reviveFailure(envelope.error), typeof envelope.executeId === "string" ? envelope.executeId : "");
402
+ return;
403
+ }
404
+ await failStream(createNetworkFailure(), "unknown");
405
+ return;
406
+ }
407
+ await getBytes(response.body, getLines(getMessages(onmessage)));
408
+ await iterator.return();
409
+ } catch {
410
+ if (curRequestController.signal.aborted) return;
411
+ await failStream(createNetworkFailure(), "unknown");
412
+ }
413
+ }
414
+ create();
415
+ const iterator = {
416
+ next() {
417
+ const index = ++iteratorIndex;
418
+ if (stacks.has(index - 2)) stacks.delete(index - 2);
419
+ if (!stacks.has(index) && !curRequestController.signal.aborted) {
420
+ const stack = withResolvers();
421
+ stacks.set(index, {
422
+ ...stack,
423
+ done: false
424
+ });
425
+ return stack.promise;
426
+ }
427
+ if (!stacks.has(index) && curRequestController.signal.aborted) {
428
+ const stack = withResolvers();
429
+ stack.resolve({
430
+ done: true,
431
+ value: void 0
432
+ });
433
+ return stack.promise;
434
+ }
435
+ return stacks.get(index).promise;
436
+ },
437
+ async return() {
438
+ if (!curRequestController.signal.aborted) curRequestController.abort();
439
+ for (const [_, iterator] of stacks) iterator.resolve({
440
+ done: true,
441
+ value: void 0
442
+ });
443
+ return {
444
+ done: true,
445
+ value: void 0
446
+ };
447
+ },
448
+ async throw() {
449
+ if (!curRequestController.signal.aborted) curRequestController.abort();
450
+ for (const [_index, stack] of stacks) {
451
+ if (stack.done) continue;
452
+ stack.done = true;
453
+ stack.resolve({
454
+ done: true,
455
+ value: void 0
456
+ });
457
+ }
458
+ return {
459
+ done: true,
460
+ value: void 0
461
+ };
462
+ },
463
+ [Symbol.asyncIterator]() {
464
+ return this;
465
+ }
466
+ };
467
+ try {
468
+ await streamResultFetched.promise;
469
+ return [
470
+ null,
471
+ iterator,
472
+ { executeId: streamResult.executeId ?? "" }
473
+ ];
474
+ } catch (error) {
475
+ return error;
476
+ }
477
+ }
478
+ },
479
+ __cookbook: { subscribe: async (baseUrl) => {
480
+ const headers = {
481
+ "Content-Type": "application/json",
482
+ Accept: "text/event-stream"
483
+ };
484
+ const body = JSON.stringify({}) ?? "";
485
+ const stacks = /* @__PURE__ */ new Map();
486
+ let stacksIndex = 0;
487
+ let iteratorIndex = 0;
488
+ const onmessage = (event) => {
489
+ const index = ++stacksIndex;
490
+ if (stacks.has(index)) stacks.get(index).resolve({
491
+ done: false,
492
+ value: reviveJSONParse(JSON.parse(event.data))
493
+ });
494
+ else {
495
+ const stack = withResolvers();
496
+ stack.resolve({
497
+ done: false,
498
+ value: reviveJSONParse(JSON.parse(event.data))
499
+ });
500
+ stacks.set(index, {
501
+ ...stack,
502
+ done: false
503
+ });
504
+ }
505
+ };
506
+ let curRequestController;
507
+ async function create() {
508
+ curRequestController = new $abort();
509
+ curRequestController.signal.addEventListener("abort", () => {
510
+ iterator.return();
511
+ });
512
+ try {
513
+ const response = await $fetch(`${baseUrl}/$subscribe`, {
514
+ method: "POST",
515
+ headers,
516
+ body,
517
+ signal: curRequestController.signal
518
+ });
519
+ const contentType = response.headers.get("Content-Type");
520
+ if (!contentType?.startsWith("text/event-stream")) throw new Error(`Expected content-type to be text/event-stream, Actual: ${contentType}`);
521
+ await getBytes(response.body, getLines(getMessages(onmessage)));
522
+ await iterator.return();
523
+ } catch (err) {
524
+ if (!curRequestController.signal.aborted) curRequestController.abort();
525
+ await iterator.throw(err);
526
+ }
527
+ }
528
+ create();
529
+ const iterator = {
530
+ next() {
531
+ const index = ++iteratorIndex;
532
+ if (stacks.has(index - 2)) stacks.delete(index - 2);
533
+ if (!stacks.has(index) && !curRequestController.signal.aborted) {
534
+ const stack = withResolvers();
535
+ stacks.set(index, {
536
+ ...stack,
537
+ done: false
538
+ });
539
+ return stack.promise;
540
+ }
541
+ if (!stacks.has(index) && curRequestController.signal.aborted) {
542
+ const stack = withResolvers();
543
+ stack.resolve({
544
+ done: true,
545
+ value: void 0
546
+ });
547
+ return stack.promise;
548
+ }
549
+ return stacks.get(index).promise;
550
+ },
551
+ async return() {
552
+ if (!curRequestController.signal.aborted) curRequestController.abort();
553
+ for (const [_, iterator] of stacks) iterator.resolve({
554
+ done: true,
555
+ value: void 0
556
+ });
557
+ return {
558
+ done: true,
559
+ value: void 0
560
+ };
561
+ },
562
+ async throw(_err) {
563
+ if (!curRequestController.signal.aborted) curRequestController.abort();
564
+ for (const [_, iterator] of stacks) iterator.resolve({
565
+ done: true,
566
+ value: void 0
567
+ });
568
+ return {
569
+ done: true,
570
+ value: void 0
571
+ };
572
+ },
573
+ [Symbol.asyncIterator]() {
574
+ return this;
575
+ }
576
+ };
577
+ try {
578
+ return iterator;
579
+ } catch (error) {
580
+ return error;
581
+ }
582
+ } },
583
+ __astraEmitEvent: async (key, options) => {
584
+ const opts = options ?? {};
585
+ if (opts.headers === void 0) opts.headers = {};
586
+ if (opts.headers["Content-Type"] === void 0) opts.headers["Content-Type"] = "application/json";
587
+ let url;
588
+ if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;
589
+ let base64Name;
590
+ if (typeof btoa !== "undefined") base64Name = btoa(key);
591
+ else if (typeof Buffer !== "undefined") base64Name = Buffer.from(key).toString("base64");
592
+ else throw new Error("No base64 encoder available");
593
+ url = `${resolvedBaseUrl}/$event/${encodeURIComponent(base64Name)}`;
594
+ try {
595
+ const body = JSON.stringify(opts.params) ?? "";
596
+ const text = await (await $fetch(url, {
597
+ method: "POST",
598
+ body,
599
+ headers: opts.headers
600
+ })).text();
601
+ const parsed = reviveJSONParse(JSON.parse(text));
602
+ if (parsed.success !== true) return [
603
+ reviveFailure(parsed.error),
604
+ null,
605
+ { executeId: parsed.executeId ?? "" }
606
+ ];
607
+ return [
608
+ null,
609
+ parsed.data,
610
+ { executeId: parsed.executeId }
611
+ ];
612
+ } catch {
613
+ return [
614
+ createNetworkFailure(),
615
+ null,
616
+ { executeId: "unknown" }
617
+ ];
618
+ }
619
+ },
620
+ async ping(options) {
621
+ return await new Promise(async (resolve) => {
622
+ const url = `${await baseUrlPromise}/generate_204`;
623
+ const timeout = options?.timeout ?? stargateOptions?.timeout ?? 6e3;
624
+ const startsTime = Date.now();
625
+ const timer = setTimeout(() => {
626
+ resolve([{
627
+ connect: false,
628
+ delay: Date.now() - startsTime,
629
+ error: { REQUEST_TIMEOUT: {
630
+ timeout,
631
+ message: `Execute timeout after ${timeout}ms.`
632
+ } }
633
+ }, null]);
634
+ }, timeout);
635
+ try {
636
+ const response = await $fetch(url, { method: "HEAD" });
637
+ const endsTime = Date.now();
638
+ clearTimeout(timer);
639
+ if (response.status !== 204) resolve([{
640
+ connect: false,
641
+ delay: endsTime - startsTime,
642
+ error: { REQUEST_FAIL: {
643
+ response,
644
+ status: response.status,
645
+ message: "Status code not 204"
646
+ } }
647
+ }, null]);
648
+ resolve([null, {
649
+ connect: true,
650
+ delay: endsTime - startsTime,
651
+ serverTimestamp: Number(response.headers.get("Content-Type").substring(17))
652
+ }]);
653
+ } catch (error) {
654
+ return [{
655
+ connect: false,
656
+ delay: Date.now() - startsTime,
657
+ error
658
+ }, null];
659
+ }
660
+ });
661
+ },
662
+ $types: void 0
663
+ };
475
664
  }
476
- var isoDatePattern = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)(Z|[+-]\d{2}:?\d{2})?$/;
665
+ const isoDatePattern = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)(Z|[+-]\d{2}:?\d{2})?$/;
477
666
  function reviveJSONParse(json) {
478
- if (json === null || json === undefined)
479
- return json;
480
- const type = typeof json;
481
- if (type === "object") {
482
- if (json instanceof Date)
483
- return json;
484
- if (Array.isArray(json)) {
485
- const len = json.length;
486
- for (let i = 0;i < len; i++) {
487
- const result = reviveJSONParse(json[i]);
488
- if (result !== json[i])
489
- json[i] = result;
490
- }
491
- return json;
492
- }
493
- const keys = Object.keys(json);
494
- const obj = json;
495
- for (const key of keys) {
496
- const value = obj[key];
497
- const result = reviveJSONParse(value);
498
- if (result !== value)
499
- obj[key] = result;
500
- }
501
- return json;
502
- }
503
- if (type === "string") {
504
- const str = json;
505
- const len = str.length;
506
- if (len >= 20 && len <= 32 && str.charCodeAt(0) >= 48 && str.charCodeAt(0) <= 57 && str.indexOf("T") !== -1) {
507
- const match = str.match(isoDatePattern);
508
- if (match !== null) {
509
- const datePart = match[1];
510
- const tzPart = match[2];
511
- if (tzPart !== undefined) {
512
- const colonPos = tzPart.charCodeAt(3) === 58 ? (datePart?.length ?? 0) + 3 : -1;
513
- if (colonPos >= 0) {
514
- return new Date(str.substring(0, colonPos) + str.substring(colonPos + 1));
515
- }
516
- return new Date(str);
517
- }
518
- if (datePart !== undefined) {
519
- return new Date(datePart + "Z");
520
- }
521
- }
522
- }
523
- }
524
- return json;
667
+ if (json === null || json === void 0) return json;
668
+ const type = typeof json;
669
+ if (type === "object") {
670
+ if (json instanceof Date) return json;
671
+ if (Array.isArray(json)) {
672
+ const len = json.length;
673
+ for (let i = 0; i < len; i++) {
674
+ const result = reviveJSONParse(json[i]);
675
+ if (result !== json[i]) json[i] = result;
676
+ }
677
+ return json;
678
+ }
679
+ const keys = Object.keys(json);
680
+ const obj = json;
681
+ for (const key of keys) {
682
+ const value = obj[key];
683
+ const result = reviveJSONParse(value);
684
+ if (result !== value) obj[key] = result;
685
+ }
686
+ return json;
687
+ }
688
+ if (type === "string") {
689
+ const str = json;
690
+ const len = str.length;
691
+ if (len >= 20 && len <= 32 && str.charCodeAt(0) >= 48 && str.charCodeAt(0) <= 57 && str.indexOf("T") !== -1) {
692
+ const match = str.match(isoDatePattern);
693
+ if (match !== null) {
694
+ const datePart = match[1];
695
+ const tzPart = match[2];
696
+ if (tzPart !== void 0) {
697
+ const colonPos = tzPart.charCodeAt(3) === 58 ? (datePart?.length ?? 0) + 3 : -1;
698
+ if (colonPos >= 0) return new Date(str.substring(0, colonPos) + str.substring(colonPos + 1));
699
+ return new Date(str);
700
+ }
701
+ if (datePart !== void 0) return /* @__PURE__ */ new Date(datePart + "Z");
702
+ }
703
+ }
704
+ }
705
+ return json;
525
706
  }
707
+ /**
708
+ * Converts a ReadableStream into a callback pattern.
709
+ * @param stream The input ReadableStream.
710
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
711
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
712
+ */
526
713
  async function getBytes(stream, onChunk) {
527
- const reader = stream.getReader();
528
- let result;
529
- while (!(result = await reader.read()).done) {
530
- onChunk(result.value);
531
- }
714
+ const reader = stream.getReader();
715
+ let result;
716
+ while (!(result = await reader.read()).done) onChunk(result.value);
532
717
  }
718
+ /**
719
+ * Parses arbitary byte chunks into EventSource line buffers.
720
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
721
+ * @param onLine A function that will be called on each new EventSource line.
722
+ * @returns A function that should be called for each incoming byte chunk.
723
+ */
533
724
  function getLines(onLine) {
534
- let buffer;
535
- let position;
536
- let fieldLength;
537
- let discardTrailingNewline = false;
538
- return function onChunk(arr) {
539
- if (buffer === undefined) {
540
- buffer = arr;
541
- position = 0;
542
- fieldLength = -1;
543
- } else {
544
- buffer = concat(buffer, arr);
545
- }
546
- const bufLength = buffer.length;
547
- let lineStart = 0;
548
- while (position < bufLength) {
549
- if (discardTrailingNewline) {
550
- if (buffer[position] === 10) {
551
- lineStart = ++position;
552
- }
553
- discardTrailingNewline = false;
554
- }
555
- let lineEnd = -1;
556
- for (;position < bufLength && lineEnd === -1; ++position) {
557
- switch (buffer[position]) {
558
- case 58:
559
- if (fieldLength === -1) {
560
- fieldLength = position - lineStart;
561
- }
562
- break;
563
- case 13: {
564
- discardTrailingNewline = true;
565
- lineEnd = position;
566
- break;
567
- }
568
- case 10:
569
- lineEnd = position;
570
- break;
571
- }
572
- }
573
- if (lineEnd === -1) {
574
- break;
575
- }
576
- onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
577
- lineStart = position;
578
- fieldLength = -1;
579
- }
580
- if (lineStart === bufLength) {
581
- buffer = undefined;
582
- } else if (lineStart !== 0) {
583
- buffer = buffer.subarray(lineStart);
584
- position -= lineStart;
585
- }
586
- };
725
+ let buffer;
726
+ let position;
727
+ let fieldLength;
728
+ let discardTrailingNewline = false;
729
+ return function onChunk(arr) {
730
+ if (buffer === void 0) {
731
+ buffer = arr;
732
+ position = 0;
733
+ fieldLength = -1;
734
+ } else buffer = concat(buffer, arr);
735
+ const bufLength = buffer.length;
736
+ let lineStart = 0;
737
+ while (position < bufLength) {
738
+ if (discardTrailingNewline) {
739
+ if (buffer[position] === 10) lineStart = ++position;
740
+ discardTrailingNewline = false;
741
+ }
742
+ let lineEnd = -1;
743
+ for (; position < bufLength && lineEnd === -1; ++position) switch (buffer[position]) {
744
+ case 58:
745
+ if (fieldLength === -1) fieldLength = position - lineStart;
746
+ break;
747
+ case 13:
748
+ discardTrailingNewline = true;
749
+ lineEnd = position;
750
+ break;
751
+ case 10: lineEnd = position;
752
+ }
753
+ if (lineEnd === -1) break;
754
+ onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
755
+ lineStart = position;
756
+ fieldLength = -1;
757
+ }
758
+ if (lineStart === bufLength) buffer = void 0;
759
+ else if (lineStart !== 0) {
760
+ buffer = buffer.subarray(lineStart);
761
+ position -= lineStart;
762
+ }
763
+ };
587
764
  }
765
+ /**
766
+ * Parses line buffers into EventSourceMessages.
767
+ * @param onId A function that will be called on each `id` field.
768
+ * @param onRetry A function that will be called on each `retry` field.
769
+ * @param onMessage A function that will be called on each message.
770
+ * @returns A function that should be called for each incoming line buffer.
771
+ */
588
772
  function getMessages(onMessage) {
589
- let message = newMessage();
590
- const decoder = new TextDecoder;
591
- return function onLine(line, fieldLength) {
592
- if (line.length === 0) {
593
- onMessage?.(message);
594
- message = newMessage();
595
- } else if (fieldLength > 0) {
596
- const field = decoder.decode(line.subarray(0, fieldLength));
597
- const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
598
- const value = decoder.decode(line.subarray(valueOffset));
599
- switch (field) {
600
- case "data":
601
- message.data = message.data ? `${message.data}
602
- ${value}` : value;
603
- break;
604
- }
605
- }
606
- };
773
+ let message = newMessage();
774
+ const decoder = new TextDecoder();
775
+ return function onLine(line, fieldLength) {
776
+ if (line.length === 0) {
777
+ onMessage?.(message);
778
+ message = newMessage();
779
+ } else if (fieldLength > 0) {
780
+ const field = decoder.decode(line.subarray(0, fieldLength));
781
+ const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
782
+ const value = decoder.decode(line.subarray(valueOffset));
783
+ switch (field) {
784
+ case "data": message.data = message.data ? `${message.data}\n${value}` : value;
785
+ }
786
+ }
787
+ };
607
788
  }
608
789
  function concat(a, b) {
609
- const res = new Uint8Array(a.length + b.length);
610
- res.set(a);
611
- res.set(b, a.length);
612
- return res;
790
+ const res = new Uint8Array(a.length + b.length);
791
+ res.set(a);
792
+ res.set(b, a.length);
793
+ return res;
613
794
  }
614
795
  function newMessage() {
615
- return {
616
- data: ""
617
- };
796
+ return { data: "" };
618
797
  }
619
798
  function withResolvers() {
620
- let resolve;
621
- let reject;
622
- const promise = new Promise((res, rej) => {
623
- resolve = res;
624
- reject = rej;
625
- });
626
- return { promise, resolve, reject };
799
+ let resolve;
800
+ let reject;
801
+ return {
802
+ promise: new Promise((res, rej) => {
803
+ resolve = res;
804
+ reject = rej;
805
+ }),
806
+ resolve,
807
+ reject
808
+ };
627
809
  }
628
- var DB_NAME = "Stargate";
629
- var STORE_NAME = "caches";
630
- var dbInstance = null;
810
+ const DB_NAME = "Stargate";
811
+ const STORE_NAME = "caches";
812
+ let dbInstance = null;
631
813
  async function openDB() {
632
- if (dbInstance)
633
- return dbInstance;
634
- return new Promise((resolve, reject) => {
635
- const request = indexedDB.open(DB_NAME, 1);
636
- request.onerror = () => reject(request.error);
637
- request.onsuccess = () => {
638
- dbInstance = request.result;
639
- resolve(dbInstance);
640
- };
641
- request.onupgradeneeded = (event) => {
642
- const db = event.target.result;
643
- if (!db.objectStoreNames.contains(STORE_NAME)) {
644
- db.createObjectStore(STORE_NAME);
645
- }
646
- };
647
- });
814
+ if (dbInstance) return dbInstance;
815
+ return new Promise((resolve, reject) => {
816
+ const request = indexedDB.open(DB_NAME, 1);
817
+ request.onerror = () => reject(request.error);
818
+ request.onsuccess = () => {
819
+ dbInstance = request.result;
820
+ resolve(dbInstance);
821
+ };
822
+ request.onupgradeneeded = (event) => {
823
+ const db = event.target.result;
824
+ if (!db.objectStoreNames.contains(STORE_NAME)) db.createObjectStore(STORE_NAME);
825
+ };
826
+ });
648
827
  }
649
828
  async function createDefaultCacheStorage(options) {
650
- await openDB();
651
- let encryptionKey = null;
652
- const counter = new Uint8Array(16);
653
- if (options?.encryption) {
654
- const keyString = options.encryptionKey ?? DB_NAME;
655
- new TextEncoder().encode(keyString).forEach((byte, i) => {
656
- if (i < 16)
657
- counter[i] = byte;
658
- });
659
- const encoder = new TextEncoder;
660
- const keyData = encoder.encode(keyString);
661
- const importedKey = await crypto.subtle.importKey("raw", keyData, { name: "PBKDF2" }, false, ["deriveKey"]);
662
- encryptionKey = await crypto.subtle.deriveKey({
663
- name: "PBKDF2",
664
- salt: encoder.encode("milkio-stargate-cache"),
665
- iterations: 1e5,
666
- hash: "SHA-256"
667
- }, importedKey, { name: "AES-CTR", length: 256 }, false, ["encrypt", "decrypt"]);
668
- }
669
- const encryptData = async (data) => {
670
- if (!encryptionKey)
671
- return data;
672
- const jsonString = JSON.stringify(data);
673
- const encoder = new TextEncoder;
674
- const dataBytes = encoder.encode(jsonString);
675
- const encryptedArrayBuffer = await crypto.subtle.encrypt({
676
- name: "AES-CTR",
677
- counter,
678
- length: 64
679
- }, encryptionKey, dataBytes);
680
- return new Uint8Array(encryptedArrayBuffer);
681
- };
682
- const decryptData = async (encryptedData) => {
683
- if (!encryptionKey || !encryptedData)
684
- return encryptedData;
685
- const arrayBuffer = encryptedData instanceof Uint8Array ? encryptedData.buffer : encryptedData;
686
- const decryptedBytes = await crypto.subtle.decrypt({
687
- name: "AES-CTR",
688
- counter,
689
- length: 64
690
- }, encryptionKey, arrayBuffer);
691
- const decoder = new TextDecoder;
692
- const jsonString = decoder.decode(decryptedBytes);
693
- return reviveJSONParse(JSON.parse(jsonString));
694
- };
695
- return {
696
- async get(key) {
697
- const db = await openDB();
698
- return new Promise((resolve, reject) => {
699
- const transaction = db.transaction(STORE_NAME, "readonly");
700
- const store = transaction.objectStore(STORE_NAME);
701
- const request = store.get(key);
702
- request.onerror = () => reject(request.error);
703
- request.onsuccess = async () => {
704
- const result = request.result;
705
- if (!result) {
706
- resolve(null);
707
- return;
708
- }
709
- if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {
710
- const decryptedData = await decryptData(result.data);
711
- resolve({ data: decryptedData, timestamp: result.timestamp });
712
- return;
713
- }
714
- resolve(result ?? null);
715
- };
716
- });
717
- },
718
- async set(key, data) {
719
- const db = await openDB();
720
- let dataToStore = data;
721
- if (options?.encryption) {
722
- dataToStore = await encryptData(data);
723
- }
724
- return new Promise((resolve, reject) => {
725
- const transaction = db.transaction(STORE_NAME, "readwrite");
726
- const store = transaction.objectStore(STORE_NAME);
727
- const request = store.put({ data: dataToStore, timestamp: Date.now() }, key);
728
- request.onerror = () => reject(request.error);
729
- request.onsuccess = () => resolve();
730
- });
731
- }
732
- };
829
+ await openDB();
830
+ let encryptionKey = null;
831
+ const counter = /* @__PURE__ */ new Uint8Array(16);
832
+ if (options?.encryption) {
833
+ const keyString = options.encryptionKey ?? DB_NAME;
834
+ new TextEncoder().encode(keyString).forEach((byte, i) => {
835
+ if (i < 16) counter[i] = byte;
836
+ });
837
+ const encoder = new TextEncoder();
838
+ const keyData = encoder.encode(keyString);
839
+ const importedKey = await crypto.subtle.importKey("raw", keyData, { name: "PBKDF2" }, false, ["deriveKey"]);
840
+ encryptionKey = await crypto.subtle.deriveKey({
841
+ name: "PBKDF2",
842
+ salt: encoder.encode("milkio-stargate-cache"),
843
+ iterations: 1e5,
844
+ hash: "SHA-256"
845
+ }, importedKey, {
846
+ name: "AES-CTR",
847
+ length: 256
848
+ }, false, ["encrypt", "decrypt"]);
849
+ }
850
+ const encryptData = async (data) => {
851
+ if (!encryptionKey) return data;
852
+ const jsonString = JSON.stringify(data);
853
+ const dataBytes = new TextEncoder().encode(jsonString);
854
+ const encryptedArrayBuffer = await crypto.subtle.encrypt({
855
+ name: "AES-CTR",
856
+ counter,
857
+ length: 64
858
+ }, encryptionKey, dataBytes);
859
+ return new Uint8Array(encryptedArrayBuffer);
860
+ };
861
+ const decryptData = async (encryptedData) => {
862
+ if (!encryptionKey || !encryptedData) return encryptedData;
863
+ const arrayBuffer = encryptedData instanceof Uint8Array ? encryptedData.buffer : encryptedData;
864
+ const decryptedBytes = await crypto.subtle.decrypt({
865
+ name: "AES-CTR",
866
+ counter,
867
+ length: 64
868
+ }, encryptionKey, arrayBuffer);
869
+ const jsonString = new TextDecoder().decode(decryptedBytes);
870
+ return reviveJSONParse(JSON.parse(jsonString));
871
+ };
872
+ return {
873
+ async get(key) {
874
+ const db = await openDB();
875
+ return new Promise((resolve, reject) => {
876
+ const request = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(key);
877
+ request.onerror = () => reject(request.error);
878
+ request.onsuccess = async () => {
879
+ const result = request.result;
880
+ if (!result) {
881
+ resolve(null);
882
+ return;
883
+ }
884
+ if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {
885
+ resolve({
886
+ data: await decryptData(result.data),
887
+ timestamp: result.timestamp
888
+ });
889
+ return;
890
+ }
891
+ resolve(result ?? null);
892
+ };
893
+ });
894
+ },
895
+ async set(key, data) {
896
+ const db = await openDB();
897
+ let dataToStore = data;
898
+ if (options?.encryption) dataToStore = await encryptData(data);
899
+ return new Promise((resolve, reject) => {
900
+ const request = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put({
901
+ data: dataToStore,
902
+ timestamp: Date.now()
903
+ }, key);
904
+ request.onerror = () => reject(request.error);
905
+ request.onsuccess = () => resolve();
906
+ });
907
+ }
908
+ };
733
909
  }
734
910
  function generateCacheKey(path, params) {
735
- return `${path}:${JSON.stringify(params ?? {})}`;
911
+ return `${path}:${JSON.stringify(params ?? {})}`;
736
912
  }
737
- export {
738
- createDefaultCacheStorage,
739
- createStargate,
740
- getBytes,
741
- getLines,
742
- getMessages,
743
- reviveJSONParse,
744
- withResolvers
745
- };
746
913
 
747
- //# debugId=BFA86016C93C122564756E2164756E21
748
- //# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../index.ts"],
  "sourcesContent": [
    "export type MilkioStargateOptions = {\n    baseUrl: string | (() => string) | (() => Promise<string>);\n    timeout?: number;\n    fetch?: typeof fetch;\n    abort?: typeof AbortController;\n    cacheStorage?: CacheStorage;\n    cacheEncryption?: boolean;\n};\n\nexport type Mixin<T, U> = U & Omit<T, keyof U>;\n\nexport type CacheStrategy = 'off' | 'fallback' | 'throttle';\n\nexport type RetryStrategy = boolean | number;\n\nexport interface CacheStorage {\n    get: (key: string) => Promise<{ data: any; timestamp: number } | null>;\n    set: (key: string, data: any) => Promise<void>;\n}\n\nexport type ExecuteOptions<T extends any> = {\n    params?: Record<any, any>;\n    headers?: Record<string, string>;\n    timeout?: number;\n    baseUrl?: string | (() => string) | (() => Promise<string>);\n    cacheStrategy?: CacheStrategy;\n    cacheThrottleMs?: number;\n    onCacheHit?: (result: T) => void | Promise<void>;\n    retryStrategy?: RetryStrategy;\n};\n\nexport type ExecuteResultsOption = { executeId: string };\n\nexport type Ping =\n    | [\n        {\n            connect: false;\n            delay: number;\n            error: any;\n        },\n        null,\n    ]\n    | [\n        null,\n        {\n            connect: true;\n            delay: number;\n            serverTimestamp: number;\n        },\n    ];\nexport async function createStargate<Generated extends { routeSchema: any; rejectCode: any; events: any }>(stargateOptions: MilkioStargateOptions) {\n    const $fetch = stargateOptions.fetch ?? fetch;\n    const $abort = stargateOptions.abort ?? AbortController;\n\n    type StargateEvents = {\n        'milkio:executeBefore': { path: string; options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }> };\n        'milkio:fetchBefore': { path: string; options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }>; body: string };\n        'milkio:executeError': {\n            path: string;\n            options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }>;\n            error: Partial<Generated['rejectCode']>;\n            handleError: <K extends keyof Partial<Generated['rejectCode']>>(error: any, key: K, handler: (error: Partial<Generated['rejectCode'][K]>) => boolean | Promise<boolean>) => Promise<void>;\n        };\n    };\n\n    const handleError: any = async (error: any, key: string, handler: (error: any) => boolean | Promise<boolean>) => {\n        if (key in error) {\n            const handled = await handler(error[key]);\n            if (handled) delete error[key];\n        }\n    };\n\n    const __initEventManager = () => {\n        const handlers = new Map<(event: any) => void, string>();\n        const indexed = new Map<string, Set<(event: any) => void>>();\n\n        const eventManager = {\n            on: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {\n                handlers.set(handler, key as string);\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                handlers.set(handler, key as string);\n\n                return () => {\n                    handlers.delete(handler);\n                    set.delete(handler);\n                };\n            },\n            off: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {\n                const set = indexed.get(key as string);\n                if (!set) return;\n                handlers.delete(handler);\n                set.delete(handler);\n            },\n            emit: async <Key extends keyof StargateEvents, Value extends StargateEvents[Key]>(key: Key, value: Value): Promise<void> => {\n                const h = indexed.get(key as string);\n                if (h) {\n                    for (const handler of h) {\n                        await handler(value);\n                    }\n                }\n            },\n        };\n\n        return eventManager;\n    };\n\n    const eventManager = __initEventManager();\n\n    const bootstrap = async () => {\n        let baseUrl = stargateOptions.baseUrl;\n        if (typeof baseUrl === 'function') baseUrl = await baseUrl();\n        if (baseUrl.endsWith('/')) baseUrl = baseUrl.slice(0, -1);\n\n        return baseUrl;\n    };\n\n    const baseUrlPromise: Promise<string> = bootstrap();\n    // Cache resolved baseUrl to avoid await overhead on repeated calls\n    let resolvedBaseUrl: string | null = null;\n    // Cache URL for last path to avoid string concatenation per request\n    let cachedUrlPath: string | null = null;\n    let cachedUrl: string | null = null;\n\n    const stargate = {\n        ...eventManager,\n        options: stargateOptions,\n        async execute<Path extends keyof Generated['routeSchema']>(\n            path: Path,\n            options: Mixin<\n                ExecuteOptions<Generated['routeSchema'][Path]['types']['result']>,\n                {\n                    params?: Generated['routeSchema'][Path]['types']['params'];\n                }\n            >,\n        ): Promise<\n            Generated['routeSchema'][Path]['types']['🥛'] extends boolean\n            ? // action\n            [Partial<Generated['rejectCode']>, null, ExecuteResultsOption] | [null, Generated['routeSchema'][Path]['types']['result'], ExecuteResultsOption]\n            : // stream\n            // Stream schemas store the yield type directly in `result` (route-generate.ts\n            // uses `Awaited<ReturnType<handler>> extends AsyncGenerator<infer I> ? I : never`),\n            // so no `GeneratorGeneric` wrapper is needed here.\n            [Partial<Generated['rejectCode']>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated['rejectCode']>, null] | [null, Generated['routeSchema'][Path]['types']['result']], undefined>, ExecuteResultsOption]\n        > {\n            if (options.headers === undefined) options.headers = {};\n\n            let url: string;\n            if (options.baseUrl) {\n                let baseUrl = options.baseUrl;\n                if (typeof baseUrl === 'function') baseUrl = await baseUrl();\n                if (baseUrl.endsWith('/')) baseUrl = baseUrl.slice(0, -1);\n                url = baseUrl + (path as string);\n            } else {\n                if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;\n                // Cache URL for repeated path to avoid string concatenation\n                if (path === cachedUrlPath && cachedUrl !== null) {\n                    url = cachedUrl;\n                } else {\n                    url = resolvedBaseUrl + (path as string);\n                    cachedUrlPath = path as string;\n                    cachedUrl = url;\n                }\n            }\n\n            if (!(path as string).endsWith('~')) {\n                // action\n                // Set default headers only if not already present\n                const h = options.headers;\n                if (h.Accept === undefined) h.Accept = 'application/json';\n                if (h['Content-Type'] === undefined) h['Content-Type'] = 'application/json';\n\n                const cacheStrategy = options.cacheStrategy ?? 'off';\n                let retryCount = 0;\n                if (options.retryStrategy === true || options.retryStrategy === 2) {\n                    retryCount = 2;\n                } else if (typeof options.retryStrategy === 'number' && options.retryStrategy > 0) {\n                    retryCount = options.retryStrategy;\n                }\n\n                // Fast path: no cache, no retry\n                if (cacheStrategy === 'off' && retryCount === 0) {\n                    try {\n                        await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n                        const body = JSON.stringify(options.params) ?? '';\n                        await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n                        let text: string;\n                        const response = await $fetch(url, { method: 'POST', body, headers: options.headers });\n                        text = await response.text();\n                        const parsed = reviveJSONParse(JSON.parse(text));\n                        if (parsed.success !== true) {\n                            const err: any = {};\n                            err[parsed.code] = parsed.reject ?? null;\n                            return [err, null, { executeId: parsed.executeId }];\n                        }\n                        return [null, parsed.data, { executeId: parsed.executeId }];\n                    } catch (error: any) {\n                        if (error?.[0]?.REQUEST_TIMEOUT) {\n                            return [error, null, { executeId: '' }];\n                        }\n                        const errorPined = { REQUEST_FAIL: error };\n                        return [errorPined, null, { executeId: 'unknown' }];\n                    }\n                }\n\n                const cacheThrottleMs = options.cacheThrottleMs ?? 0;\n                const cacheKey = generateCacheKey(path as string, options.params);\n\n                let cacheStorage = stargateOptions.cacheStorage;\n                if (cacheStrategy !== 'off' && !cacheStorage) {\n                    cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });\n                }\n\n                if (cacheStrategy !== 'off' && cacheStorage && options.onCacheHit) {\n                    const cached = await cacheStorage.get(cacheKey);\n                    if (cached) {\n                        try {\n                            await options.onCacheHit(cached.data);\n                        } catch {\n                            // ignore onCacheHit errors\n                        }\n                    }\n                }\n\n                if (cacheStrategy === 'throttle' && cacheStorage) {\n                    const cached = await cacheStorage.get(cacheKey);\n                    if (cached && Date.now() - cached.timestamp < cacheThrottleMs) {\n                        return [null, cached.data, { executeId: 'cached' }] as any;\n                    }\n                }\n\n                await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n                const body = JSON.stringify(options.params) ?? '';\n                await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n\n                const executeRequest = async (isRetry: boolean): Promise<{ result: { value: Record<any, any> } | null; error: any; isNetworkError: boolean }> => {\n                    try {\n                        const response = await $fetch(url, { method: 'POST', body, headers: options.headers });\n                        const text = await response.text();\n                        const parsed = JSON.parse(text);\n                        return { result: { value: parsed }, error: null, isNetworkError: false };\n                    } catch (error: any) {\n                        const isNetworkError = !error?.[0]?.REQUEST_TIMEOUT;\n                        return { result: null, error, isNetworkError };\n                    }\n                };\n\n                let { result, error, isNetworkError } = await executeRequest(false);\n\n                for (let retryIndex = 0; retryIndex < retryCount && error && isNetworkError; retryIndex++) {\n                    if (retryIndex > 0) {\n                        await new Promise((resolve) => setTimeout(resolve, 500));\n                    }\n                    const retryResult = await executeRequest(true);\n                    result = retryResult.result;\n                    error = retryResult.error;\n                    isNetworkError = retryResult.isNetworkError;\n                }\n\n                if (error) {\n                    if (error?.[0]?.REQUEST_TIMEOUT) {\n                        await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, error });\n                        return error;\n                    }\n\n                    if (cacheStrategy !== 'off' && cacheStorage && isNetworkError) {\n                        const cached = await cacheStorage.get(cacheKey);\n                        if (cached) {\n                            return [null, cached.data, { executeId: 'cached' }] as any;\n                        }\n                    }\n\n                    const errorPined = { REQUEST_FAIL: error };\n                    await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, error: errorPined });\n                    return [errorPined, null, { executeId: 'unknown' }];\n                }\n\n                if (result!.value.success !== true) {\n                    const err: any = {};\n                    err[result!.value.code] = result!.value.reject ?? null;\n                    await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, error: err });\n                    return [err, null, { executeId: result!.value.executeId }];\n                }\n\n                if (cacheStrategy !== 'off' && cacheStorage) {\n                    await cacheStorage.set(cacheKey, result!.value.data);\n                }\n\n                return [null, result!.value.data, { executeId: result!.value.executeId }] as any;\n            } else {\n                // stream\n                options.cacheStrategy = 'off';\n                options.onCacheHit = undefined;\n                options.cacheThrottleMs = undefined;\n\n                if (options.headers.Accept === undefined) options.headers.Accept = 'text/event-stream';\n                if (options.headers['Content-Type'] === undefined) options.headers['Content-Type'] = 'application/json';\n\n                const stacks: Map<\n                    number,\n                    {\n                        done: boolean;\n                        promise: Promise<IteratorResult<any>>;\n                        resolve: (value: IteratorResult<any>) => void;\n                        reject: (reason: any) => void;\n                    }\n                > = new Map();\n                let stacksIndex = 0;\n                let iteratorIndex = 0;\n                let streamResult: any;\n                const streamResultFetched = withResolvers<undefined>();\n\n                const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;\n                const timer = setTimeout(() => {\n                    streamResultFetched.reject([{ REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } }, null, { executeId: 'unknown' }]);\n                }, timeout);\n\n                const onmessage = (event: EventSourceMessage) => {\n                    if (event.data.startsWith('@')) {\n                        try {\n                            streamResult = reviveJSONParse(JSON.parse(event.data.slice(1)));\n                            streamResultFetched.resolve(undefined);\n                            clearTimeout(timer);\n                        } catch (error) {\n                            streamResultFetched.reject([{ REQUEST_FAIL: error }, null, { executeId: 'unknown' }]);\n                            clearTimeout(timer);\n                        }\n                    } else {\n                        const index = ++stacksIndex;\n                        if (stacks.has(index)) {\n                            const stack = stacks.get(index);\n                            stack!.done = true;\n                            stack!.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                        } else {\n                            const stack = withResolvers<IteratorResult<any>>();\n                            stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                            stacks.set(index, { ...stack, done: false });\n                        }\n                    }\n                };\n\n                let curRequestController: AbortController;\n\n                async function create() {\n                    curRequestController = new $abort();\n                    curRequestController.signal.addEventListener('abort', () => {\n                        iterator.return();\n                    });\n                    try {\n                        await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n\n                        const body = JSON.stringify(options!.params) ?? '';\n                        await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n\n                        const response = await $fetch(url, {\n                            method: 'POST',\n                            headers: options!.headers,\n                            body,\n                            signal: curRequestController.signal,\n                        });\n\n                        const contentType = response.headers.get('Content-Type');\n                        if (!contentType?.startsWith('text/event-stream')) {\n                            throw new Error(`Expected content-type to be ${'text/event-stream'}, Actual: ${contentType}`);\n                        }\n\n                        await getBytes(response.body!, getLines(getMessages(onmessage)));\n\n                        await iterator.return();\n                    } catch (err) {\n                        if (!curRequestController.signal.aborted) curRequestController.abort();\n                        const error = { REQUEST_FAIL: err };\n                        await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, error });\n                        await iterator.throw(err);\n                        streamResultFetched.reject([error, null, { executeId: 'unknown' }]);\n                    }\n                }\n\n                void create();\n\n                const iterator = {\n                    ...({\n                        next(): Promise<IteratorResult<unknown>> {\n                            const index = ++iteratorIndex;\n                            if (stacks.has(index - 2)) stacks.delete(index - 2);\n                            if (!stacks.has(index) && !curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stacks.set(index, { ...stack, done: false });\n                                return stack.promise;\n                            }\n                            if (!stacks.has(index) && curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stack.resolve({ done: true, value: undefined });\n                                return stack.promise;\n                            }\n                            return stacks.get(index)!.promise;\n                        },\n                        async return(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                        async throw(err: any): Promise<IteratorResult<void>> {\n                            streamResult = {\n                                success: false,\n                                executeId: streamResult?.executeId ?? '',\n                                fail: {\n                                    code: 'NETWORK_ERROR',\n                                    message: 'Network Error',\n                                    fromClient: true,\n                                    data: err,\n                                },\n                            };\n                            for (const [_index, stack] of stacks) {\n                                if (stack.done) continue;\n                                stack.done = true;\n                                stack.resolve({ done: true, value: undefined });\n                            }\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                    } satisfies AsyncIterator<unknown>),\n                    [Symbol.asyncIterator]() {\n                        return this;\n                    },\n                };\n\n                try {\n                    await streamResultFetched.promise;\n                    return [null, iterator, { executeId: streamResult.executeId }] as any;\n                } catch (error) {\n                    return error as any;\n                }\n            }\n        },\n        __cookbook: {\n            subscribe: async (baseUrl: string) => {\n                const headers = {\n                    'Content-Type': 'application/json',\n                    Accept: 'text/event-stream',\n                };\n                const params = {};\n\n                const body = JSON.stringify(params) ?? '';\n                const stacks: Map<\n                    number,\n                    {\n                        done: boolean;\n                        promise: Promise<IteratorResult<any>>;\n                        resolve: (value: IteratorResult<any>) => void;\n                        reject: (reason: any) => void;\n                    }\n                > = new Map();\n                let stacksIndex = 0;\n                let iteratorIndex = 0;\n\n                const onmessage = (event: EventSourceMessage) => {\n                    const index = ++stacksIndex;\n                    if (stacks.has(index)) {\n                        const stack = stacks.get(index);\n                        stack!.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                    } else {\n                        const stack = withResolvers<IteratorResult<any>>();\n                        stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                        stacks.set(index, { ...stack, done: false });\n                    }\n                };\n\n                let curRequestController: AbortController;\n\n                async function create() {\n                    curRequestController = new $abort();\n                    curRequestController.signal.addEventListener('abort', () => {\n                        iterator.return();\n                    });\n                    try {\n                        const response = await $fetch(`${baseUrl}/$subscribe`, {\n                            method: 'POST',\n                            headers,\n                            body,\n                            signal: curRequestController.signal,\n                        });\n\n                        const contentType = response.headers.get('Content-Type');\n                        if (!contentType?.startsWith('text/event-stream')) {\n                            throw new Error(`Expected content-type to be ${'text/event-stream'}, Actual: ${contentType}`);\n                        }\n\n                        await getBytes(response.body!, getLines(getMessages(onmessage)));\n\n                        await iterator.return();\n                    } catch (err) {\n                        if (!curRequestController.signal.aborted) curRequestController.abort();\n                        await iterator.throw(err);\n                    }\n                }\n\n                void create();\n\n                const iterator = {\n                    ...({\n                        next(): Promise<IteratorResult<unknown>> {\n                            const index = ++iteratorIndex;\n                            if (stacks.has(index - 2)) stacks.delete(index - 2);\n                            if (!stacks.has(index) && !curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stacks.set(index, { ...stack, done: false });\n                                return stack.promise;\n                            }\n                            if (!stacks.has(index) && curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stack.resolve({ done: true, value: undefined });\n                                return stack.promise;\n                            }\n                            return stacks.get(index)!.promise;\n                        },\n                        async return(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                        async throw(err: any): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                    } satisfies AsyncIterator<unknown>),\n                    [Symbol.asyncIterator]() {\n                        return this;\n                    },\n                };\n\n                try {\n                    return iterator;\n                } catch (error) {\n                    return error as any;\n                }\n            },\n        },\n        __astraEmitEvent: async (key: any, options?: { params?: any; headers?: Record<string, string> }) => {\n            const opts = options ?? {};\n            if (opts.headers === undefined) opts.headers = {};\n            if (opts.headers['Content-Type'] === undefined) opts.headers['Content-Type'] = 'application/json';\n\n            let url: string;\n            if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;\n            // 兼容不同运行时：优先使用 btoa，回退到 Buffer\n            let base64Name: string;\n            if (typeof btoa !== 'undefined') {\n                base64Name = btoa(key as string);\n            } else if (typeof Buffer !== 'undefined') {\n                base64Name = Buffer.from(key as string).toString('base64');\n            } else {\n                throw new Error('No base64 encoder available');\n            }\n            url = `${resolvedBaseUrl}/$event/${encodeURIComponent(base64Name)}`;\n\n            try {\n                const body = JSON.stringify(opts.params) ?? '';\n                const response = await $fetch(url, { method: 'POST', body, headers: opts.headers });\n                const text = await response.text();\n                const parsed = reviveJSONParse(JSON.parse(text));\n                if (parsed.success !== true) {\n                    const err: any = {};\n                    err[parsed.code] = parsed.reject ?? null;\n                    return [err, null, { executeId: parsed.executeId }];\n                }\n                return [null, parsed.data, { executeId: parsed.executeId }];\n            } catch (error: any) {\n                const errorPined = { REQUEST_FAIL: error };\n                return [errorPined, null, { executeId: 'unknown' }];\n            }\n        },\n\n        async ping(options?: { timeout?: number }): Promise<Ping> {\n            // oxlint-disable-next-line no-async-promise-executor\n            return await new Promise<Ping>(async (resolve) => {\n                const url = `${await baseUrlPromise}/generate_204`;\n                const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;\n                const startsTime = Date.now();\n                const timer = setTimeout(() => {\n                    const endsTime = Date.now();\n                    resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } } }, null]);\n                }, timeout);\n\n                try {\n                    const response = await $fetch(url, { method: 'HEAD' });\n                    const endsTime = Date.now();\n                    clearTimeout(timer);\n                    if (response.status !== 204) {\n                        resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_FAIL: { response, status: response.status, message: 'Status code not 204' } } }, null]);\n                    }\n\n                    resolve([null, { connect: true, delay: endsTime - startsTime, serverTimestamp: Number(response.headers.get('Content-Type')!.substring(17)) }]);\n                } catch (error: any) {\n                    const endsTime = Date.now();\n                    return [{ connect: false, delay: endsTime - startsTime, error }, null];\n                }\n            });\n        },\n        $types: undefined as unknown as {\n            generated: Generated;\n            error: Generated['rejectCode'];\n            params: {\n                [Path in keyof Generated['routeSchema']]: Generated['routeSchema'][Path]['types']['params'];\n            };\n            results: {\n                [Path in keyof Generated['routeSchema']]: Generated['routeSchema'][Path]['types']['🥛'] extends boolean\n                ? // action\n                Generated['routeSchema'][Path]['types']['result']\n                : // stream\n                // Result is already the yield type (see route-generate.ts comment).\n                AsyncGenerator<[Partial<Generated['rejectCode']>, null] | [null, Generated['routeSchema'][Path]['types']['result']], undefined>;\n            };\n        },\n    };\n\n    return stargate;\n}\n\nconst isoDatePattern = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?)(Z|[+-]\\d{2}:?\\d{2})?$/;\n\nexport function reviveJSONParse<T>(json: T): T {\n    if (json === null || json === undefined) return json;\n    const type = typeof json;\n    if (type === '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 result = reviveJSONParse(json[i]);\n                if (result !== json[i]) json[i] = result;\n            }\n            return json;\n        }\n        const keys = Object.keys(json as object);\n        const obj = json as Record<string, unknown>;\n        for (const key of keys) {\n            const value = obj[key];\n            const result = reviveJSONParse(value);\n            if (result !== value) obj[key] = result;\n        }\n        return json;\n    }\n    if (type === 'string') {\n        const str = json as unknown as string;\n        // Quick reject: ISO date strings must start with a digit and contain 'T'\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 = str.match(isoDatePattern);\n            if (match !== null) {\n                const datePart = match[1];\n                const tzPart = match[2];\n                if (tzPart !== undefined) {\n                    const colonPos = tzPart.charCodeAt(3) === 58 ? (datePart?.length ?? 0) + 3 : -1;\n                    if (colonPos >= 0) {\n                        return new Date(str.substring(0, colonPos) + str.substring(colonPos + 1)) as any;\n                    }\n                    return new Date(str) as any;\n                }\n                if (datePart !== undefined) {\n                    return new Date(datePart + 'Z') as any;\n                }\n            }\n        }\n    }\n    return json;\n}\n\nexport interface ExecuteStreamOptions {\n    headers?: Record<string, string>;\n    timeout?: number;\n}\n\nexport interface ApiSchemaExtend {\n    apiValidator: {\n        generatedAt: number;\n        validate: Record<any, any>;\n    };\n    apiMethodsSchema: Record<any, any>;\n    apiMethodsTypeSchema: Record<any, any>;\n    apiTestsSchema: Record<any, any>;\n}\n\nexport type FailCodeExtend = Record<any, (...args: Array<any>) => any>;\n\nexport type BootstrapMiddleware = (data: { storage: ClientStorage }) => Promise<void> | void;\nexport type BeforeExecuteMiddleware = (data: { path: string; params: any; headers: Record<string, string>; storage: ClientStorage }) => Promise<void> | void;\nexport type AfterExecuteMiddleware = (data: { path: string; result: { value: any }; storage: ClientStorage }) => Promise<void> | void;\n\nexport interface MiddlewareOptions {\n    bootstrap?: BootstrapMiddleware;\n    beforeExecute?: BeforeExecuteMiddleware;\n    afterExecute?: AfterExecuteMiddleware;\n}\n\nexport interface ClientStorage {\n    getItem: (key: string) => Promise<string | null>;\n    setItem: (key: string, value: string) => Promise<void>;\n    removeItem: (key: string) => Promise<void>;\n}\n\nexport interface ExecuteResultSuccess<Result> {\n    executeId: string;\n    success: true;\n    data: Result;\n}\n\nexport type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;\n\nexport type FlattenKeys<T, Prefix extends string = ''> = {\n    [K in keyof T]: T[K] extends object ? FlattenKeys<T[K], `${Prefix}${Exclude<K, symbol>}.`> : `$input.${Prefix}${Exclude<K, symbol>}`;\n}[keyof T];\n\n// *** This part of the code is based on `@microsoft/fetch-event-source` rewrite, thanks to the work of Microsoft *** //\n// *** https://github.com/Azure/fetch-event-source/blob/main/src/parse.ts                                         *** //\n\n/**\n * Represents a message sent in an event stream\n * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format\n */\nexport interface EventSourceMessage {\n    data: string;\n}\n\n/**\n * Converts a ReadableStream into a callback pattern.\n * @param stream The input ReadableStream.\n * @param onChunk A function that will be called on each new byte chunk in the stream.\n * @returns {Promise<void>} A promise that will be resolved when the stream closes.\n */\nexport async function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array) => void) {\n    const reader = stream.getReader();\n    let result: ReadableStreamReadResult<Uint8Array>;\n    // @ts-ignore\n    while (!(result = await reader.read()).done) {\n        onChunk(result.value);\n    }\n}\n\n/**\n * Parses arbitary byte chunks into EventSource line buffers.\n * Each line should be of the format \"field: value\" and ends with \\r, \\n, or \\r\\n.\n * @param onLine A function that will be called on each new EventSource line.\n * @returns A function that should be called for each incoming byte chunk.\n */\nexport function getLines(onLine: (line: Uint8Array, fieldLength: number) => void) {\n    let buffer: Uint8Array | undefined;\n    let position: number; // current read position\n    let fieldLength: number; // length of the `field` portion of the line\n    let discardTrailingNewline = false;\n\n    // return a function that can process each incoming byte chunk:\n    return function onChunk(arr: Uint8Array) {\n        if (buffer === undefined) {\n            buffer = arr;\n            position = 0;\n            fieldLength = -1;\n        } else {\n            // we're still parsing the old line. Append the new bytes into buffer:\n            buffer = concat(buffer, arr);\n        }\n\n        const bufLength = buffer.length;\n        let lineStart = 0; // index where the current line starts\n        while (position < bufLength) {\n            if (discardTrailingNewline) {\n                if (buffer[position] === 10) {\n                    lineStart = ++position; // skip to next char\n                }\n\n                discardTrailingNewline = false;\n            }\n\n            // start looking forward till the end of line:\n            let lineEnd = -1; // index of the \\r or \\n char\n            for (; position < bufLength && lineEnd === -1; ++position) {\n                switch (buffer[position]) {\n                    case 58:\n                        if (fieldLength === -1) {\n                            // first colon in line\n                            fieldLength = position - lineStart;\n                        }\n                        break;\n                    case 13: {\n                        discardTrailingNewline = true;\n                        lineEnd = position;\n                        break;\n                    }\n                    case 10:\n                        lineEnd = position;\n                        break;\n                }\n            }\n\n            if (lineEnd === -1) {\n                // We reached the end of the buffer but the line hasn't ended.\n                // Wait for the next arr and then continue parsing:\n                break;\n            }\n\n            // we've reached the line end, send it out:\n            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);\n            lineStart = position; // we're now on the next line\n            fieldLength = -1;\n        }\n\n        if (lineStart === bufLength) {\n            buffer = undefined; // we've finished reading it\n        } else if (lineStart !== 0) {\n            // Create a new view into buffer beginning at lineStart so we don't\n            // need to copy over the previous lines when we get the new arr:\n            buffer = buffer.subarray(lineStart);\n            position -= lineStart;\n        }\n    };\n}\n\n/**\n * Parses line buffers into EventSourceMessages.\n * @param onId A function that will be called on each `id` field.\n * @param onRetry A function that will be called on each `retry` field.\n * @param onMessage A function that will be called on each message.\n * @returns A function that should be called for each incoming line buffer.\n */\nexport function getMessages(onMessage?: (msg: EventSourceMessage) => void) {\n    let message = newMessage();\n    const decoder = new TextDecoder();\n\n    // return a function that can process each incoming line buffer:\n    return function onLine(line: Uint8Array, fieldLength: number) {\n        if (line.length === 0) {\n            // empty line denotes end of message. Trigger the callback and start a new message:\n            onMessage?.(message);\n            message = newMessage();\n        } else if (fieldLength > 0) {\n            // exclude comments and lines with no values\n            // line is of format \"<field>:<value>\" or \"<field>: <value>\"\n            // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation\n            const field = decoder.decode(line.subarray(0, fieldLength));\n            const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);\n            const value = decoder.decode(line.subarray(valueOffset));\n\n            switch (field) {\n                case 'data':\n                    // if this message already has data, append the new value to the old.\n                    // otherwise, just set to the new value:\n                    message.data = message.data ? `${message.data}\\n${value}` : value; // otherwise,\n                    break;\n            }\n        }\n    };\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array) {\n    const res = new Uint8Array(a.length + b.length);\n    res.set(a);\n    res.set(b, a.length);\n    return res;\n}\n\nfunction newMessage(): EventSourceMessage {\n    return {\n        data: '',\n    };\n}\n\nexport function withResolvers<T = any>(): PromiseWithResolvers<T> {\n    let resolve: PromiseWithResolvers<T>['resolve'];\n    let reject: PromiseWithResolvers<T>['reject'];\n    const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n    });\n    return { promise, resolve: resolve!, reject: reject! };\n}\n\nconst DB_NAME = 'Stargate';\nconst STORE_NAME = 'caches';\nlet dbInstance: IDBDatabase | null = null;\n\nasync function openDB(): Promise<IDBDatabase> {\n    if (dbInstance) return dbInstance;\n\n    return new Promise((resolve, reject) => {\n        const request = indexedDB.open(DB_NAME, 1);\n        request.onerror = () => reject(request.error);\n        request.onsuccess = () => {\n            dbInstance = request.result;\n            resolve(dbInstance);\n        };\n        request.onupgradeneeded = (event) => {\n            const db = (event.target as IDBOpenDBRequest).result;\n            if (!db.objectStoreNames.contains(STORE_NAME)) {\n                db.createObjectStore(STORE_NAME);\n            }\n        };\n    });\n}\n\nexport async function createDefaultCacheStorage(options?: { encryption?: boolean; encryptionKey?: string }): Promise<CacheStorage> {\n    await openDB();\n\n    let encryptionKey: CryptoKey | null = null;\n    const counter = new Uint8Array(16);\n\n    if (options?.encryption) {\n        const keyString = options.encryptionKey ?? DB_NAME;\n        new TextEncoder().encode(keyString).forEach((byte, i) => {\n            if (i < 16) counter[i] = byte;\n        });\n\n        const encoder = new TextEncoder();\n        const keyData = encoder.encode(keyString);\n        const importedKey = await crypto.subtle.importKey('raw', keyData, { name: 'PBKDF2' }, false, ['deriveKey']);\n\n        encryptionKey = await crypto.subtle.deriveKey(\n            {\n                name: 'PBKDF2',\n                salt: encoder.encode('milkio-stargate-cache'),\n                iterations: 100000,\n                hash: 'SHA-256',\n            },\n            importedKey,\n            { name: 'AES-CTR', length: 256 },\n            false,\n            ['encrypt', 'decrypt'],\n        );\n    }\n\n    const encryptData = async (data: any): Promise<Uint8Array> => {\n        if (!encryptionKey) return data;\n\n        const jsonString = JSON.stringify(data);\n        const encoder = new TextEncoder();\n        const dataBytes = encoder.encode(jsonString);\n\n        const encryptedArrayBuffer = await crypto.subtle.encrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            dataBytes,\n        );\n\n        return new Uint8Array(encryptedArrayBuffer);\n    };\n\n    const decryptData = async (encryptedData: ArrayBuffer | Uint8Array): Promise<any> => {\n        if (!encryptionKey || !encryptedData) return encryptedData;\n\n        const arrayBuffer = encryptedData instanceof Uint8Array ? (encryptedData.buffer as ArrayBuffer) : encryptedData;\n\n        const decryptedBytes = await crypto.subtle.decrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            arrayBuffer,\n        );\n\n        const decoder = new TextDecoder();\n        const jsonString = decoder.decode(decryptedBytes);\n        return reviveJSONParse(JSON.parse(jsonString));\n    };\n\n    return {\n        async get(key: string): Promise<{ data: any; timestamp: number } | null> {\n            const db = await openDB();\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readonly');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.get(key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = async () => {\n                    const result = request.result;\n                    if (!result) {\n                        resolve(null);\n                        return;\n                    }\n\n                    if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {\n                        const decryptedData = await decryptData(result.data);\n                        resolve({ data: decryptedData, timestamp: result.timestamp });\n                        return;\n                    }\n\n                    resolve(result ?? null);\n                };\n            });\n        },\n        async set(key: string, data: any): Promise<void> {\n            const db = await openDB();\n            let dataToStore: any = data;\n\n            if (options?.encryption) {\n                dataToStore = await encryptData(data);\n            }\n\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readwrite');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.put({ data: dataToStore, timestamp: Date.now() }, key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = () => resolve();\n            });\n        },\n    };\n}\n\nfunction generateCacheKey(path: string, params: any): string {\n    return `${path}:${JSON.stringify(params ?? {})}`;\n}\n"
  ],
  "mappings": "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",
  "debugId": "BFA86016C93C122564756E2164756E21",
  "names": []
}
914
+ export { createDefaultCacheStorage, createStargate, getBytes, getLines, getMessages, reviveJSONParse, withResolvers };
915
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../index.ts"],"sourcesContent":["export type MilkioStargateOptions = {\n    baseUrl: string | (() => string) | (() => Promise<string>);\n    /** 默认请求超时（毫秒）；可被单次 execute 的 options.timeout 覆盖。action / stream / ping 均生效，默认 6000。 */\n    timeout?: number;\n    fetch?: typeof fetch;\n    abort?: typeof AbortController;\n    cacheStorage?: CacheStorage;\n    cacheEncryption?: boolean;\n};\n\nexport type Mixin<T, U> = U & Omit<T, keyof U>;\n\nexport type CacheStrategy = 'off' | 'fallback' | 'throttle';\n\nexport type RetryStrategy = boolean | number;\n\nexport interface CacheStorage {\n    get: (key: string) => Promise<{ data: any; timestamp: number } | null>;\n    set: (key: string, data: any) => Promise<void>;\n}\n\nexport type ExecuteOptions<T extends any> = {\n    params?: Record<any, any>;\n    headers?: Record<string, string>;\n    /** 单次请求超时（毫秒），优先于 MilkioStargateOptions.timeout；默认 6000。 */\n    timeout?: number;\n    baseUrl?: string | (() => string) | (() => Promise<string>);\n    cacheStrategy?: CacheStrategy;\n    cacheThrottleMs?: number;\n    onCacheHit?: (result: T) => void | Promise<void>;\n    retryStrategy?: RetryStrategy;\n};\n\nexport type ExecuteResultsOption = { executeId: string };\n\nexport type Ping =\n    | [\n        {\n            connect: false;\n            delay: number;\n            error: any;\n        },\n        null,\n    ]\n    | [\n        null,\n        {\n            connect: true;\n            delay: number;\n            serverTimestamp: number;\n        },\n    ];\n// ---------------------------------------------------------------------------\n// Failure protocol v2: `fail` (business rejection, code + data kept) and\n// `fault` (unexpected/internal, only the generic INTERNAL_SERVER_ERROR code).\n// The wire shapes are defined locally on purpose: stargate does not depend on milkio.\n// ---------------------------------------------------------------------------\n\nexport type MilkioFailureWire =\n    | { kind: \"fail\"; code: string; data: unknown }\n    | { kind: \"fault\"; code: \"INTERNAL_SERVER_ERROR\" };\n\n/** structural shape of a failure restored from the wire (fail keeps code/data; fault stays generic) */\nexport interface MilkioClientFailure {\n    readonly $milkioFailure: true;\n    readonly kind: \"fail\" | \"fault\";\n    readonly code: string;\n    readonly data?: unknown;\n}\n\n/** transport faults carry the root-cause details locally (never sent to the server) */\nexport interface MilkioTransportFailureData {\n    name?: string;\n    message?: string;\n    /** node/undici error code, e.g. ECONNREFUSED / ENOTFOUND */\n    code?: string;\n}\n\n/** faults synthesized by the client itself; they are not server fault-codes */\nexport type MilkioClientTransportFailure =\n    | (MilkioClientFailure & { readonly kind: \"fault\"; readonly code: \"NETWORK_ERROR\"; readonly data?: MilkioTransportFailureData })\n    | (MilkioClientFailure & { readonly kind: \"fault\"; readonly code: \"REQUEST_TIMEOUT\"; readonly data: { timeout: number; message: string } });\n\n/**\n * Everything a stargate call can fail with: the generated client-visible failure union\n * (all fail-codes with typed data + the generic server fault) plus the client transport faults.\n * The transport members carry literal codes so `failure.code` narrowing still works for fail-codes.\n */\nexport type MilkioPublicFailure<Generated extends { failure: any } = { failure: any }> = Generated[\"failure\"] | MilkioClientTransportFailure;\n\nfunction createFail(code: string, data?: unknown): MilkioClientFailure {\n    return { $milkioFailure: true, kind: \"fail\", code, data };\n}\n\nfunction createFault(code: string, data?: unknown): MilkioClientFailure {\n    return { $milkioFailure: true, kind: \"fault\", code, data };\n}\n\nfunction createNetworkFailure(error?: unknown): MilkioClientFailure & { readonly kind: \"fault\"; readonly code: \"NETWORK_ERROR\"; readonly data?: MilkioTransportFailureData } {\n    const data: MilkioTransportFailureData = {};\n    if (error instanceof Error) {\n        data.name = error.name;\n        if (error.message) data.message = error.message;\n    } else if (typeof error === \"string\" && error !== \"\") {\n        data.message = error;\n    }\n    const code = (error as any)?.code;\n    if (typeof code === \"string\" && code !== \"\") data.code = code;\n    return { $milkioFailure: true, kind: \"fault\", code: \"NETWORK_ERROR\", data: Object.keys(data).length > 0 ? data : undefined };\n}\n\nfunction createTimeoutFailure(timeout: number): MilkioClientTransportFailure {\n    return { $milkioFailure: true, kind: \"fault\", code: \"REQUEST_TIMEOUT\", data: { timeout, message: `Execute timeout after ${timeout}ms.` } };\n}\n\n/** only transport-level faults are retried; fail and server faults are never retried */\nfunction isTransportFailure(failure: { readonly kind: string; readonly code: string }): boolean {\n    return failure.kind === \"fault\" && (failure.code === \"NETWORK_ERROR\" || failure.code === \"REQUEST_TIMEOUT\");\n}\n\n/** restore a wire failure: fail keeps code/data, fault is always reduced to the generic code by the server */\nfunction reviveFailureWire(wire: unknown): MilkioClientFailure {\n    if (typeof wire === \"object\" && wire !== null) {\n        const parsed = wire as { kind?: unknown; code?: unknown; data?: unknown };\n        if (parsed.kind === \"fail\" && typeof parsed.code === \"string\") return createFail(parsed.code, parsed.data);\n        if (parsed.kind === \"fault\") return createFault(\"INTERNAL_SERVER_ERROR\");\n    }\n    return createFault(\"INTERNAL_SERVER_ERROR\");\n}\n\nexport async function createStargate<Generated extends { routeSchema: any; failure: MilkioClientFailure; events: any }>(stargateOptions: MilkioStargateOptions) {\n    const $fetch = stargateOptions.fetch ?? fetch;\n    const $abort = stargateOptions.abort ?? AbortController;\n\n    type PublicFailure = MilkioPublicFailure<Generated>;\n    type FailureData<Code extends string> = Extract<Generated[\"failure\"], { kind: \"fail\"; code: Code }> extends { data: infer Data } ? Data : unknown;\n    type HandleError = <Code extends string>(failure: PublicFailure, code: Code, handler: (data: FailureData<Code>) => boolean | Promise<boolean>) => Promise<boolean>;\n\n    /**\n     * Restored wire failures are cast to the generated failure union: the server contract guarantees the\n     * fail-code string is one of the generated codes, only the runtime value is unknown statically.\n     */\n    const reviveFailure = (wire: unknown): PublicFailure => reviveFailureWire(wire) as unknown as PublicFailure;\n\n    type StargateEvents = {\n        'milkio:executeBefore': { path: string; options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }> };\n        'milkio:fetchBefore': { path: string; options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }>; body: string };\n        'milkio:executeError': {\n            path: string;\n            options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }>;\n            failure: PublicFailure;\n            handleError: HandleError;\n        };\n    };\n\n    /** only `fail` failures have a public business code; fault can never be matched by code */\n    const handleError = async <Code extends string>(failure: PublicFailure, code: Code, handler: (data: FailureData<Code>) => boolean | Promise<boolean>): Promise<boolean> => {\n        if (failure === null || failure === undefined) return false;\n        if (failure.kind !== \"fail\") return false;\n        if ((failure as { readonly code: string }).code !== code) return false;\n        return (await handler((failure as { readonly data?: unknown }).data as FailureData<Code>)) === true;\n    };\n\n    const __initEventManager = () => {\n        const handlers = new Map<(event: any) => void, string>();\n        const indexed = new Map<string, Set<(event: any) => void>>();\n\n        const eventManager = {\n            on: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {\n                handlers.set(handler, key as string);\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                handlers.set(handler, key as string);\n\n                return () => {\n                    handlers.delete(handler);\n                    set.delete(handler);\n                };\n            },\n            off: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {\n                const set = indexed.get(key as string);\n                if (!set) return;\n                handlers.delete(handler);\n                set.delete(handler);\n            },\n            emit: async <Key extends keyof StargateEvents, Value extends StargateEvents[Key]>(key: Key, value: Value): Promise<void> => {\n                const h = indexed.get(key as string);\n                if (h) {\n                    for (const handler of h) {\n                        await handler(value);\n                    }\n                }\n            },\n        };\n\n        return eventManager;\n    };\n\n    const eventManager = __initEventManager();\n\n    const bootstrap = async () => {\n        let baseUrl = stargateOptions.baseUrl;\n        if (typeof baseUrl === 'function') baseUrl = await baseUrl();\n        if (baseUrl.endsWith('/')) baseUrl = baseUrl.slice(0, -1);\n\n        return baseUrl;\n    };\n\n    const baseUrlPromise: Promise<string> = bootstrap();\n    // Cache resolved baseUrl to avoid await overhead on repeated calls\n    let resolvedBaseUrl: string | null = null;\n    // Cache URL for last path to avoid string concatenation per request\n    let cachedUrlPath: string | null = null;\n    let cachedUrl: string | null = null;\n\n    const stargate = {\n        ...eventManager,\n        options: stargateOptions,\n        async execute<Path extends keyof Generated['routeSchema']>(\n            path: Path,\n            options: Mixin<\n                ExecuteOptions<Generated['routeSchema'][Path]['types']['result']>,\n                {\n                    params?: Generated['routeSchema'][Path]['types']['params'];\n                }\n            >,\n        ): Promise<\n            Generated['routeSchema'][Path]['types']['🥛'] extends boolean\n            ? // action\n            [PublicFailure, null, ExecuteResultsOption] | [null, Generated['routeSchema'][Path]['types']['result'], ExecuteResultsOption]\n            : // stream\n            // Stream schemas store the yield type directly in `result` (route-generate.ts\n            // uses `Awaited<ReturnType<handler>> extends AsyncGenerator<infer I> ? I : never`),\n            // so no `GeneratorGeneric` wrapper is needed here.\n            [PublicFailure, null, ExecuteResultsOption] | [null, AsyncGenerator<[PublicFailure, null] | [null, Generated['routeSchema'][Path]['types']['result']], undefined>, ExecuteResultsOption]\n        > {\n            if (options.headers === undefined) options.headers = {};\n\n            let url: string;\n            if (options.baseUrl) {\n                let baseUrl = options.baseUrl;\n                if (typeof baseUrl === 'function') baseUrl = await baseUrl();\n                if (baseUrl.endsWith('/')) baseUrl = baseUrl.slice(0, -1);\n                url = baseUrl + (path as string);\n            } else {\n                if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;\n                // Cache URL for repeated path to avoid string concatenation\n                if (path === cachedUrlPath && cachedUrl !== null) {\n                    url = cachedUrl;\n                } else {\n                    url = resolvedBaseUrl + (path as string);\n                    cachedUrlPath = path as string;\n                    cachedUrl = url;\n                }\n            }\n\n            if (!(path as string).endsWith('~')) {\n                // action\n                // Set default headers only if not already present\n                const h = options.headers;\n                if (h.Accept === undefined) h.Accept = 'application/json';\n                if (h['Content-Type'] === undefined) h['Content-Type'] = 'application/json';\n\n                const cacheStrategy = options.cacheStrategy ?? 'off';\n                let retryCount = 0;\n                if (options.retryStrategy === true || options.retryStrategy === 2) {\n                    retryCount = 2;\n                } else if (typeof options.retryStrategy === 'number' && options.retryStrategy > 0) {\n                    retryCount = options.retryStrategy;\n                }\n\n                // Action-level timeout: per-call option wins over the instance default (6000ms).\n                const timeout = options.timeout ?? stargateOptions.timeout ?? 6000;\n\n                // Fast path: no cache, no retry\n                if (cacheStrategy === 'off' && retryCount === 0) {\n                    const controller = new $abort();\n                    const timer = setTimeout(() => controller.abort(), timeout);\n                    try {\n                        await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n                        const body = JSON.stringify(options.params) ?? '';\n                        await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n                        const response = await $fetch(url, { method: 'POST', body, headers: options.headers, signal: controller.signal });\n                        const text = await response.text();\n                        const parsed = reviveJSONParse(JSON.parse(text));\n                        if (parsed.success !== true) {\n                            const failure = reviveFailure(parsed.error);\n                            await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, failure });\n                            return [failure, null, { executeId: parsed.executeId ?? '' }] as any;\n                        }\n                        return [null, parsed.data, { executeId: parsed.executeId }] as any;\n                    } catch (error) {\n                        // transport-level failure (server failure is a JSON envelope with HTTP 200)\n                        const failure = controller.signal.aborted ? createTimeoutFailure(timeout) : createNetworkFailure(error);\n                        await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, failure });\n                        return [failure, null, { executeId: 'unknown' }] as any;\n                    } finally {\n                        clearTimeout(timer);\n                    }\n                }\n\n                const cacheThrottleMs = options.cacheThrottleMs ?? 0;\n                const cacheKey = generateCacheKey(path as string, options.params);\n\n                let cacheStorage = stargateOptions.cacheStorage;\n                if (cacheStrategy !== 'off' && !cacheStorage) {\n                    cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });\n                }\n\n                if (cacheStrategy !== 'off' && cacheStorage && options.onCacheHit) {\n                    const cached = await cacheStorage.get(cacheKey);\n                    if (cached) {\n                        try {\n                            await options.onCacheHit(cached.data);\n                        } catch {\n                            // ignore onCacheHit errors\n                        }\n                    }\n                }\n\n                if (cacheStrategy === 'throttle' && cacheStorage) {\n                    const cached = await cacheStorage.get(cacheKey);\n                    if (cached && Date.now() - cached.timestamp < cacheThrottleMs) {\n                        return [null, cached.data, { executeId: 'cached' }] as any;\n                    }\n                }\n\n                await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n                const body = JSON.stringify(options.params) ?? '';\n                await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n\n                const executeRequest = async (): Promise<{ failure: PublicFailure | null; data: any; executeId: string; timedOut: boolean }> => {\n                    const controller = new $abort();\n                    const timer = setTimeout(() => controller.abort(), timeout);\n                    try {\n                        const response = await $fetch(url, { method: 'POST', body, headers: options.headers, signal: controller.signal });\n                        const text = await response.text();\n                        const parsed = reviveJSONParse(JSON.parse(text));\n                        if (parsed.success !== true) {\n                            return { failure: reviveFailure(parsed.error), data: undefined, executeId: parsed.executeId ?? '', timedOut: false };\n                        }\n                        return { failure: null, data: parsed.data, executeId: parsed.executeId, timedOut: false };\n                    } catch (error) {\n                        // transport-level failure only: HTTP status does not matter (all milkio envelopes are 200)\n                        if (controller.signal.aborted) {\n                            return { failure: createTimeoutFailure(timeout) as PublicFailure, data: undefined, executeId: 'unknown', timedOut: true };\n                        }\n                        return { failure: createNetworkFailure(error) as PublicFailure, data: undefined, executeId: 'unknown', timedOut: false };\n                    } finally {\n                        clearTimeout(timer);\n                    }\n                };\n\n                let requestResult = await executeRequest();\n                let { failure, data, executeId } = requestResult;\n\n                // only transport-level faults are retried; timeouts, fail and server faults are never retried\n                for (let retryIndex = 0; retryIndex < retryCount && failure !== null && !requestResult.timedOut && isTransportFailure(failure); retryIndex++) {\n                    if (retryIndex > 0) {\n                        await new Promise((resolve) => setTimeout(resolve, 500));\n                    }\n                    requestResult = await executeRequest();\n                    ({ failure, data, executeId } = requestResult);\n                }\n\n                if (failure) {\n                    // fail is a real business result and never falls back to cache; faults may fall back\n                    if (cacheStrategy !== 'off' && cacheStorage && failure.kind !== 'fail') {\n                        const cached = await cacheStorage.get(cacheKey);\n                        if (cached) {\n                            return [null, cached.data, { executeId: 'cached' }] as any;\n                        }\n                    }\n\n                    await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, failure });\n                    return [failure, null, { executeId }] as any;\n                }\n\n                if (cacheStrategy !== 'off' && cacheStorage) {\n                    await cacheStorage.set(cacheKey, data);\n                }\n\n                return [null, data, { executeId }] as any;\n            } else {\n                // stream\n                options.cacheStrategy = 'off';\n                options.onCacheHit = undefined;\n                options.cacheThrottleMs = undefined;\n\n                if (options.headers.Accept === undefined) options.headers.Accept = 'text/event-stream';\n                if (options.headers['Content-Type'] === undefined) options.headers['Content-Type'] = 'application/json';\n\n                const stacks: Map<\n                    number,\n                    {\n                        done: boolean;\n                        promise: Promise<IteratorResult<any>>;\n                        resolve: (value: IteratorResult<any>) => void;\n                        reject: (reason: any) => void;\n                    }\n                > = new Map();\n                let stacksIndex = 0;\n                let iteratorIndex = 0;\n                let streamResult: any;\n                const streamResultFetched = withResolvers<undefined>();\n\n                const timeout = options?.timeout ?? stargateOptions?.timeout ?? 6000;\n                const timer = setTimeout(() => {\n                    void failStream(createTimeoutFailure(timeout), 'unknown');\n                }, timeout);\n\n                /** SSE error frames are `data:[wireFailure, null]`, success frames are `data:[null, value]` */\n                const reviveStreamFrame = (frame: any): any => {\n                    if (Array.isArray(frame) && frame.length === 2 && frame[0] !== null && frame[0] !== undefined) {\n                        return [reviveFailure(frame[0]), null];\n                    }\n                    return frame;\n                };\n\n                let curRequestController: AbortController;\n\n                const failStream = async (failure: PublicFailure, executeId: string) => {\n                    clearTimeout(timer);\n                    if (!curRequestController.signal.aborted) curRequestController.abort();\n                    await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, failure });\n                    await iterator.throw();\n                    streamResultFetched.reject([failure, null, { executeId }]);\n                };\n\n                const onmessage = (event: EventSourceMessage) => {\n                    if (event.data.startsWith('@')) {\n                        clearTimeout(timer);\n                        try {\n                            const parsed = reviveJSONParse(JSON.parse(event.data.slice(1)));\n                            if (parsed.success !== true) {\n                                // the stream rejected before producing any data (protocol v2 envelope in the first frame)\n                                void failStream(reviveFailure(parsed.error), typeof parsed.executeId === 'string' ? parsed.executeId : '');\n                                return;\n                            }\n                            streamResult = parsed;\n                            streamResultFetched.resolve(undefined);\n                        } catch {\n                            void failStream(createNetworkFailure(), 'unknown');\n                        }\n                    } else {\n                        const index = ++stacksIndex;\n                        if (stacks.has(index)) {\n                            const stack = stacks.get(index);\n                            stack!.done = true;\n                            stack!.resolve({ done: false, value: reviveStreamFrame(reviveJSONParse(JSON.parse(event.data))) });\n                        } else {\n                            const stack = withResolvers<IteratorResult<any>>();\n                            stack.resolve({ done: false, value: reviveStreamFrame(reviveJSONParse(JSON.parse(event.data))) });\n                            stacks.set(index, { ...stack, done: false });\n                        }\n                    }\n                };\n\n                async function create() {\n                    curRequestController = new $abort();\n                    curRequestController.signal.addEventListener('abort', () => {\n                        iterator.return();\n                    });\n                    try {\n                        await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n\n                        const body = JSON.stringify(options!.params) ?? '';\n                        await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n\n                        const response = await $fetch(url, {\n                            method: 'POST',\n                            headers: options!.headers,\n                            body,\n                            signal: curRequestController.signal,\n                        });\n\n                        const contentType = response.headers.get('Content-Type');\n                        if (!contentType?.startsWith('text/event-stream')) {\n                            // the server answered with a JSON envelope instead of a stream (failure before streaming started)\n                            let envelope: any = null;\n                            try {\n                                envelope = reviveJSONParse(JSON.parse(await response.text()));\n                            } catch {\n                                envelope = null;\n                            }\n\n                            if (envelope !== null && typeof envelope === 'object' && envelope.success === false) {\n                                await failStream(reviveFailure(envelope.error), typeof envelope.executeId === 'string' ? envelope.executeId : '');\n                                return;\n                            }\n\n                            await failStream(createNetworkFailure(), 'unknown');\n                            return;\n                        }\n\n                        await getBytes(response.body!, getLines(getMessages(onmessage)));\n\n                        await iterator.return();\n                    } catch {\n                        if (curRequestController.signal.aborted) return;\n                        await failStream(createNetworkFailure(), 'unknown');\n                    }\n                }\n\n                void create();\n\n                const iterator = {\n                    ...({\n                        next(): Promise<IteratorResult<unknown>> {\n                            const index = ++iteratorIndex;\n                            if (stacks.has(index - 2)) stacks.delete(index - 2);\n                            if (!stacks.has(index) && !curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stacks.set(index, { ...stack, done: false });\n                                return stack.promise;\n                            }\n                            if (!stacks.has(index) && curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stack.resolve({ done: true, value: undefined });\n                                return stack.promise;\n                            }\n                            return stacks.get(index)!.promise;\n                        },\n                        async return(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                        async throw(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_index, stack] of stacks) {\n                                if (stack.done) continue;\n                                stack.done = true;\n                                stack.resolve({ done: true, value: undefined });\n                            }\n                            return { done: true, value: undefined };\n                        },\n                    } satisfies AsyncIterator<unknown>),\n                    [Symbol.asyncIterator]() {\n                        return this;\n                    },\n                };\n\n                try {\n                    await streamResultFetched.promise;\n                    return [null, iterator, { executeId: streamResult.executeId ?? '' }] as any;\n                } catch (error) {\n                    return error as any;\n                }\n            }\n        },\n        __cookbook: {\n            subscribe: async (baseUrl: string) => {\n                const headers = {\n                    'Content-Type': 'application/json',\n                    Accept: 'text/event-stream',\n                };\n                const params = {};\n\n                const body = JSON.stringify(params) ?? '';\n                const stacks: Map<\n                    number,\n                    {\n                        done: boolean;\n                        promise: Promise<IteratorResult<any>>;\n                        resolve: (value: IteratorResult<any>) => void;\n                        reject: (reason: any) => void;\n                    }\n                > = new Map();\n                let stacksIndex = 0;\n                let iteratorIndex = 0;\n\n                const onmessage = (event: EventSourceMessage) => {\n                    const index = ++stacksIndex;\n                    if (stacks.has(index)) {\n                        const stack = stacks.get(index);\n                        stack!.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                    } else {\n                        const stack = withResolvers<IteratorResult<any>>();\n                        stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                        stacks.set(index, { ...stack, done: false });\n                    }\n                };\n\n                let curRequestController: AbortController;\n\n                async function create() {\n                    curRequestController = new $abort();\n                    curRequestController.signal.addEventListener('abort', () => {\n                        iterator.return();\n                    });\n                    try {\n                        const response = await $fetch(`${baseUrl}/$subscribe`, {\n                            method: 'POST',\n                            headers,\n                            body,\n                            signal: curRequestController.signal,\n                        });\n\n                        const contentType = response.headers.get('Content-Type');\n                        if (!contentType?.startsWith('text/event-stream')) {\n                            throw new Error(`Expected content-type to be ${'text/event-stream'}, Actual: ${contentType}`);\n                        }\n\n                        await getBytes(response.body!, getLines(getMessages(onmessage)));\n\n                        await iterator.return();\n                    } catch (err) {\n                        if (!curRequestController.signal.aborted) curRequestController.abort();\n                        await iterator.throw(err);\n                    }\n                }\n\n                void create();\n\n                const iterator = {\n                    ...({\n                        next(): Promise<IteratorResult<unknown>> {\n                            const index = ++iteratorIndex;\n                            if (stacks.has(index - 2)) stacks.delete(index - 2);\n                            if (!stacks.has(index) && !curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stacks.set(index, { ...stack, done: false });\n                                return stack.promise;\n                            }\n                            if (!stacks.has(index) && curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stack.resolve({ done: true, value: undefined });\n                                return stack.promise;\n                            }\n                            return stacks.get(index)!.promise;\n                        },\n                        async return(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                        async throw(_err: any): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                    } satisfies AsyncIterator<unknown>),\n                    [Symbol.asyncIterator]() {\n                        return this;\n                    },\n                };\n\n                try {\n                    return iterator;\n                } catch (error) {\n                    return error as any;\n                }\n            },\n        },\n        __astraEmitEvent: async (key: any, options?: { params?: any; headers?: Record<string, string> }) => {\n            const opts = options ?? {};\n            if (opts.headers === undefined) opts.headers = {};\n            if (opts.headers['Content-Type'] === undefined) opts.headers['Content-Type'] = 'application/json';\n\n            let url: string;\n            if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;\n            // 兼容不同运行时：优先使用 btoa，回退到 Buffer\n            let base64Name: string;\n            if (typeof btoa !== 'undefined') {\n                base64Name = btoa(key as string);\n            } else if (typeof Buffer !== 'undefined') {\n                base64Name = Buffer.from(key as string).toString('base64');\n            } else {\n                throw new Error('No base64 encoder available');\n            }\n            url = `${resolvedBaseUrl}/$event/${encodeURIComponent(base64Name)}`;\n\n            try {\n                const body = JSON.stringify(opts.params) ?? '';\n                const response = await $fetch(url, { method: 'POST', body, headers: opts.headers });\n                const text = await response.text();\n                const parsed = reviveJSONParse(JSON.parse(text));\n                if (parsed.success !== true) {\n                    return [reviveFailure(parsed.error), null, { executeId: parsed.executeId ?? '' }] as any;\n                }\n                return [null, parsed.data, { executeId: parsed.executeId }] as any;\n            } catch {\n                return [createNetworkFailure(), null, { executeId: 'unknown' }] as any;\n            }\n        },\n\n        async ping(options?: { timeout?: number }): Promise<Ping> {\n            // oxlint-disable-next-line no-async-promise-executor\n            return await new Promise<Ping>(async (resolve) => {\n                const url = `${await baseUrlPromise}/generate_204`;\n                const timeout = options?.timeout ?? stargateOptions?.timeout ?? 6000;\n                const startsTime = Date.now();\n                const timer = setTimeout(() => {\n                    const endsTime = Date.now();\n                    resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } } }, null]);\n                }, timeout);\n\n                try {\n                    const response = await $fetch(url, { method: 'HEAD' });\n                    const endsTime = Date.now();\n                    clearTimeout(timer);\n                    if (response.status !== 204) {\n                        resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_FAIL: { response, status: response.status, message: 'Status code not 204' } } }, null]);\n                    }\n\n                    resolve([null, { connect: true, delay: endsTime - startsTime, serverTimestamp: Number(response.headers.get('Content-Type')!.substring(17)) }]);\n                } catch (error: any) {\n                    const endsTime = Date.now();\n                    return [{ connect: false, delay: endsTime - startsTime, error }, null];\n                }\n            });\n        },\n        $types: undefined as unknown as {\n            generated: Generated;\n            failure: PublicFailure;\n            params: {\n                [Path in keyof Generated['routeSchema']]: Generated['routeSchema'][Path]['types']['params'];\n            };\n            results: {\n                [Path in keyof Generated['routeSchema']]: Generated['routeSchema'][Path]['types']['🥛'] extends boolean\n                ? // action\n                Generated['routeSchema'][Path]['types']['result']\n                : // stream\n                // Result is already the yield type (see route-generate.ts comment).\n                AsyncGenerator<[PublicFailure, null] | [null, Generated['routeSchema'][Path]['types']['result']], undefined>;\n            };\n        },\n    };\n\n    return stargate;\n}\n\nconst isoDatePattern = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?)(Z|[+-]\\d{2}:?\\d{2})?$/;\n\nexport function reviveJSONParse<T>(json: T): T {\n    if (json === null || json === undefined) return json;\n    const type = typeof json;\n    if (type === '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 result = reviveJSONParse(json[i]);\n                if (result !== json[i]) json[i] = result;\n            }\n            return json;\n        }\n        const keys = Object.keys(json as object);\n        const obj = json as Record<string, unknown>;\n        for (const key of keys) {\n            const value = obj[key];\n            const result = reviveJSONParse(value);\n            if (result !== value) obj[key] = result;\n        }\n        return json;\n    }\n    if (type === 'string') {\n        const str = json as unknown as string;\n        // Quick reject: ISO date strings must start with a digit and contain 'T'\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 = str.match(isoDatePattern);\n            if (match !== null) {\n                const datePart = match[1];\n                const tzPart = match[2];\n                if (tzPart !== undefined) {\n                    const colonPos = tzPart.charCodeAt(3) === 58 ? (datePart?.length ?? 0) + 3 : -1;\n                    if (colonPos >= 0) {\n                        return new Date(str.substring(0, colonPos) + str.substring(colonPos + 1)) as any;\n                    }\n                    return new Date(str) as any;\n                }\n                if (datePart !== undefined) {\n                    return new Date(datePart + 'Z') as any;\n                }\n            }\n        }\n    }\n    return json;\n}\n\nexport interface ExecuteStreamOptions {\n    headers?: Record<string, string>;\n    timeout?: number;\n}\n\nexport interface ApiSchemaExtend {\n    apiValidator: {\n        generatedAt: number;\n        validate: Record<any, any>;\n    };\n    apiMethodsSchema: Record<any, any>;\n    apiMethodsTypeSchema: Record<any, any>;\n    apiTestsSchema: Record<any, any>;\n}\n\nexport type FailCodeExtend = Record<any, (...args: Array<any>) => any>;\n\nexport type BootstrapMiddleware = (data: { storage: ClientStorage }) => Promise<void> | void;\nexport type BeforeExecuteMiddleware = (data: { path: string; params: any; headers: Record<string, string>; storage: ClientStorage }) => Promise<void> | void;\nexport type AfterExecuteMiddleware = (data: { path: string; result: { value: any }; storage: ClientStorage }) => Promise<void> | void;\n\nexport interface MiddlewareOptions {\n    bootstrap?: BootstrapMiddleware;\n    beforeExecute?: BeforeExecuteMiddleware;\n    afterExecute?: AfterExecuteMiddleware;\n}\n\nexport interface ClientStorage {\n    getItem: (key: string) => Promise<string | null>;\n    setItem: (key: string, value: string) => Promise<void>;\n    removeItem: (key: string) => Promise<void>;\n}\n\nexport interface ExecuteResultSuccess<Result> {\n    executeId: string;\n    success: true;\n    data: Result;\n}\n\nexport type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;\n\nexport type FlattenKeys<T, Prefix extends string = ''> = {\n    [K in keyof T]: T[K] extends object ? FlattenKeys<T[K], `${Prefix}${Exclude<K, symbol>}.`> : `$input.${Prefix}${Exclude<K, symbol>}`;\n}[keyof T];\n\n// *** This part of the code is based on `@microsoft/fetch-event-source` rewrite, thanks to the work of Microsoft *** //\n// *** https://github.com/Azure/fetch-event-source/blob/main/src/parse.ts                                         *** //\n\n/**\n * Represents a message sent in an event stream\n * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format\n */\nexport interface EventSourceMessage {\n    data: string;\n}\n\n/**\n * Converts a ReadableStream into a callback pattern.\n * @param stream The input ReadableStream.\n * @param onChunk A function that will be called on each new byte chunk in the stream.\n * @returns {Promise<void>} A promise that will be resolved when the stream closes.\n */\nexport async function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array) => void) {\n    const reader = stream.getReader();\n    let result: ReadableStreamReadResult<Uint8Array>;\n    // @ts-ignore\n    while (!(result = await reader.read()).done) {\n        onChunk(result.value);\n    }\n}\n\n/**\n * Parses arbitary byte chunks into EventSource line buffers.\n * Each line should be of the format \"field: value\" and ends with \\r, \\n, or \\r\\n.\n * @param onLine A function that will be called on each new EventSource line.\n * @returns A function that should be called for each incoming byte chunk.\n */\nexport function getLines(onLine: (line: Uint8Array, fieldLength: number) => void) {\n    let buffer: Uint8Array | undefined;\n    let position: number; // current read position\n    let fieldLength: number; // length of the `field` portion of the line\n    let discardTrailingNewline = false;\n\n    // return a function that can process each incoming byte chunk:\n    return function onChunk(arr: Uint8Array) {\n        if (buffer === undefined) {\n            buffer = arr;\n            position = 0;\n            fieldLength = -1;\n        } else {\n            // we're still parsing the old line. Append the new bytes into buffer:\n            buffer = concat(buffer, arr);\n        }\n\n        const bufLength = buffer.length;\n        let lineStart = 0; // index where the current line starts\n        while (position < bufLength) {\n            if (discardTrailingNewline) {\n                if (buffer[position] === 10) {\n                    lineStart = ++position; // skip to next char\n                }\n\n                discardTrailingNewline = false;\n            }\n\n            // start looking forward till the end of line:\n            let lineEnd = -1; // index of the \\r or \\n char\n            for (; position < bufLength && lineEnd === -1; ++position) {\n                switch (buffer[position]) {\n                    case 58:\n                        if (fieldLength === -1) {\n                            // first colon in line\n                            fieldLength = position - lineStart;\n                        }\n                        break;\n                    case 13: {\n                        discardTrailingNewline = true;\n                        lineEnd = position;\n                        break;\n                    }\n                    case 10:\n                        lineEnd = position;\n                        break;\n                }\n            }\n\n            if (lineEnd === -1) {\n                // We reached the end of the buffer but the line hasn't ended.\n                // Wait for the next arr and then continue parsing:\n                break;\n            }\n\n            // we've reached the line end, send it out:\n            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);\n            lineStart = position; // we're now on the next line\n            fieldLength = -1;\n        }\n\n        if (lineStart === bufLength) {\n            buffer = undefined; // we've finished reading it\n        } else if (lineStart !== 0) {\n            // Create a new view into buffer beginning at lineStart so we don't\n            // need to copy over the previous lines when we get the new arr:\n            buffer = buffer.subarray(lineStart);\n            position -= lineStart;\n        }\n    };\n}\n\n/**\n * Parses line buffers into EventSourceMessages.\n * @param onId A function that will be called on each `id` field.\n * @param onRetry A function that will be called on each `retry` field.\n * @param onMessage A function that will be called on each message.\n * @returns A function that should be called for each incoming line buffer.\n */\nexport function getMessages(onMessage?: (msg: EventSourceMessage) => void) {\n    let message = newMessage();\n    const decoder = new TextDecoder();\n\n    // return a function that can process each incoming line buffer:\n    return function onLine(line: Uint8Array, fieldLength: number) {\n        if (line.length === 0) {\n            // empty line denotes end of message. Trigger the callback and start a new message:\n            onMessage?.(message);\n            message = newMessage();\n        } else if (fieldLength > 0) {\n            // exclude comments and lines with no values\n            // line is of format \"<field>:<value>\" or \"<field>: <value>\"\n            // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation\n            const field = decoder.decode(line.subarray(0, fieldLength));\n            const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);\n            const value = decoder.decode(line.subarray(valueOffset));\n\n            switch (field) {\n                case 'data':\n                    // if this message already has data, append the new value to the old.\n                    // otherwise, just set to the new value:\n                    message.data = message.data ? `${message.data}\\n${value}` : value; // otherwise,\n                    break;\n            }\n        }\n    };\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array) {\n    const res = new Uint8Array(a.length + b.length);\n    res.set(a);\n    res.set(b, a.length);\n    return res;\n}\n\nfunction newMessage(): EventSourceMessage {\n    return {\n        data: '',\n    };\n}\n\n/** locally declared so the package does not require the `ESNext.Promise` lib (PromiseWithResolvers) */\nexport interface MilkioPromiseWithResolvers<T> {\n    promise: Promise<T>;\n    resolve: (value: T | PromiseLike<T>) => void;\n    reject: (reason?: any) => void;\n}\n\nexport function withResolvers<T = any>(): MilkioPromiseWithResolvers<T> {\n    let resolve: MilkioPromiseWithResolvers<T>['resolve'];\n    let reject: MilkioPromiseWithResolvers<T>['reject'];\n    const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n    });\n    return { promise, resolve: resolve!, reject: reject! };\n}\n\nconst DB_NAME = 'Stargate';\nconst STORE_NAME = 'caches';\nlet dbInstance: IDBDatabase | null = null;\n\nasync function openDB(): Promise<IDBDatabase> {\n    if (dbInstance) return dbInstance;\n\n    return new Promise((resolve, reject) => {\n        const request = indexedDB.open(DB_NAME, 1);\n        request.onerror = () => reject(request.error);\n        request.onsuccess = () => {\n            dbInstance = request.result;\n            resolve(dbInstance);\n        };\n        request.onupgradeneeded = (event) => {\n            const db = (event.target as IDBOpenDBRequest).result;\n            if (!db.objectStoreNames.contains(STORE_NAME)) {\n                db.createObjectStore(STORE_NAME);\n            }\n        };\n    });\n}\n\nexport async function createDefaultCacheStorage(options?: { encryption?: boolean; encryptionKey?: string }): Promise<CacheStorage> {\n    await openDB();\n\n    let encryptionKey: CryptoKey | null = null;\n    const counter = new Uint8Array(16);\n\n    if (options?.encryption) {\n        const keyString = options.encryptionKey ?? DB_NAME;\n        new TextEncoder().encode(keyString).forEach((byte, i) => {\n            if (i < 16) counter[i] = byte;\n        });\n\n        const encoder = new TextEncoder();\n        const keyData = encoder.encode(keyString);\n        const importedKey = await crypto.subtle.importKey('raw', keyData, { name: 'PBKDF2' }, false, ['deriveKey']);\n\n        encryptionKey = await crypto.subtle.deriveKey(\n            {\n                name: 'PBKDF2',\n                salt: encoder.encode('milkio-stargate-cache'),\n                iterations: 100000,\n                hash: 'SHA-256',\n            },\n            importedKey,\n            { name: 'AES-CTR', length: 256 },\n            false,\n            ['encrypt', 'decrypt'],\n        );\n    }\n\n    const encryptData = async (data: any): Promise<Uint8Array> => {\n        if (!encryptionKey) return data;\n\n        const jsonString = JSON.stringify(data);\n        const encoder = new TextEncoder();\n        const dataBytes = encoder.encode(jsonString);\n\n        const encryptedArrayBuffer = await crypto.subtle.encrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            dataBytes,\n        );\n\n        return new Uint8Array(encryptedArrayBuffer);\n    };\n\n    const decryptData = async (encryptedData: ArrayBuffer | Uint8Array): Promise<any> => {\n        if (!encryptionKey || !encryptedData) return encryptedData;\n\n        const arrayBuffer = encryptedData instanceof Uint8Array ? (encryptedData.buffer as ArrayBuffer) : encryptedData;\n\n        const decryptedBytes = await crypto.subtle.decrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            arrayBuffer,\n        );\n\n        const decoder = new TextDecoder();\n        const jsonString = decoder.decode(decryptedBytes);\n        return reviveJSONParse(JSON.parse(jsonString));\n    };\n\n    return {\n        async get(key: string): Promise<{ data: any; timestamp: number } | null> {\n            const db = await openDB();\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readonly');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.get(key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = async () => {\n                    const result = request.result;\n                    if (!result) {\n                        resolve(null);\n                        return;\n                    }\n\n                    if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {\n                        const decryptedData = await decryptData(result.data);\n                        resolve({ data: decryptedData, timestamp: result.timestamp });\n                        return;\n                    }\n\n                    resolve(result ?? null);\n                };\n            });\n        },\n        async set(key: string, data: any): Promise<void> {\n            const db = await openDB();\n            let dataToStore: any = data;\n\n            if (options?.encryption) {\n                dataToStore = await encryptData(data);\n            }\n\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readwrite');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.put({ data: dataToStore, timestamp: Date.now() }, key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = () => resolve();\n            });\n        },\n    };\n}\n\nfunction generateCacheKey(path: string, params: any): string {\n    return `${path}:${JSON.stringify(params ?? {})}`;\n}\n"],"mappings":"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"}