@solidjs/web 2.0.0-rc.2 → 2.0.0-rc.21

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 (124) hide show
  1. package/README.md +1 -1
  2. package/dist/server.dev.js +5165 -0
  3. package/dist/server.js +1876 -374
  4. package/dist/{server.cjs → server.observe.js} +2070 -577
  5. package/dist/{dev.cjs → web.dev.js} +955 -567
  6. package/dist/web.js +646 -350
  7. package/dist/{dev.js → web.observe.js} +699 -421
  8. package/frames/dist/assets.js +92 -0
  9. package/frames/dist/client.dev.js +1296 -1198
  10. package/frames/dist/client.js +1128 -1191
  11. package/frames/dist/client.observe.js +2041 -0
  12. package/frames/dist/regions.js +171 -0
  13. package/frames/dist/server.dev.js +2545 -0
  14. package/frames/dist/server.js +1683 -3004
  15. package/frames/dist/server.observe.js +2544 -0
  16. package/frames/dist/trace.js +45 -0
  17. package/frames/dist/wire.js +594 -0
  18. package/frames/package.json +2 -25
  19. package/package.json +244 -256
  20. package/performance-tracks/dist/performance-tracks.dev.js +679 -0
  21. package/performance-tracks/dist/performance-tracks.js +6 -0
  22. package/performance-tracks/dist/performance-tracks.observe.js +667 -0
  23. package/performance-tracks/package.json +7 -0
  24. package/performance-tracks/types/index.d.ts +69 -0
  25. package/serialization/decode/package.json +2 -15
  26. package/serialization/dist/decode.js +121 -25
  27. package/serialization/dist/serialization.js +282 -88
  28. package/serialization/package.json +2 -15
  29. package/serialization/types/index.d.ts +115 -153
  30. package/serialization/types/serializer-decode.d.ts +173 -114
  31. package/serialization/types/serializer.d.ts +144 -0
  32. package/server-functions/dist/client.dev.js +1462 -0
  33. package/server-functions/dist/client.js +667 -165
  34. package/server-functions/dist/client.observe.js +1441 -0
  35. package/server-functions/dist/rich-args.js +102 -1
  36. package/server-functions/dist/server.dev.js +2802 -299
  37. package/server-functions/dist/server.js +2724 -314
  38. package/server-functions/dist/server.observe.js +3680 -0
  39. package/server-functions/package.json +2 -35
  40. package/server-functions/rich-args/package.json +2 -15
  41. package/skills/server-components/SKILL.md +117 -0
  42. package/storage/package.json +2 -15
  43. package/types/client.d.ts +342 -288
  44. package/types/constants.d.ts +22 -0
  45. package/types/cookies.d.ts +32 -84
  46. package/types/diagnostics.d.ts +80 -0
  47. package/types/frames/assets-tier.d.ts +78 -0
  48. package/types/frames/client.d.ts +40 -1
  49. package/types/frames/frame-client.d.ts +443 -280
  50. package/types/frames/frame-container-plugin.d.ts +64 -0
  51. package/types/frames/frame-morph.d.ts +29 -0
  52. package/types/frames/frame-sink.d.ts +141 -161
  53. package/types/frames/frame-transport.d.ts +263 -184
  54. package/types/frames/regions-tier.d.ts +60 -0
  55. package/types/frames/serializer-decode.d.ts +241 -0
  56. package/types/frames/serializer.d.ts +115 -153
  57. package/types/frames/server.d.ts +2 -2
  58. package/types/frames/trace-tier.d.ts +2 -0
  59. package/types/frames/tree-rewrite.d.ts +39 -0
  60. package/types/frames/wire-tier.d.ts +169 -0
  61. package/types/head.d.ts +20 -0
  62. package/types/index.d.ts +98 -81
  63. package/types/index.server.d.ts +159 -0
  64. package/types/jsx.d.ts +49 -44
  65. package/types/observe.d.ts +535 -0
  66. package/types/reconcile.d.ts +1 -0
  67. package/types/render.d.ts +11 -0
  68. package/types/request-error-hook.d.ts +5 -0
  69. package/types/response.d.ts +95 -147
  70. package/types/serializer-decode.d.ts +173 -114
  71. package/types/serializer.d.ts +115 -153
  72. package/types/server-functions/argument-codec.d.ts +30 -0
  73. package/types/server-functions/client.d.ts +237 -223
  74. package/types/server-functions/flash.d.ts +28 -30
  75. package/types/server-functions/registry.d.ts +105 -0
  76. package/types/server-functions/rich-args.d.ts +1 -10
  77. package/types/server-functions/server.d.ts +538 -531
  78. package/types/server-functions/shared.d.ts +398 -425
  79. package/types/server-functions/uploads.d.ts +53 -0
  80. package/types/server-mock.d.ts +154 -20
  81. package/types/server-observe.d.ts +86 -0
  82. package/types/server.d.ts +601 -422
  83. package/types/trace.d.ts +127 -0
  84. package/LICENSE +0 -21
  85. package/dist/web.cjs +0 -2033
  86. package/frames/dist/client.cjs +0 -2002
  87. package/frames/dist/client.dev.cjs +0 -2022
  88. package/frames/dist/server.cjs +0 -3877
  89. package/serialization/dist/decode.cjs +0 -139
  90. package/serialization/dist/serialization.cjs +0 -261
  91. package/serialization/types-cjs/index.d.cts +0 -182
  92. package/serialization/types-cjs/package.json +0 -3
  93. package/serialization/types-cjs/serializer-decode.d.cts +0 -182
  94. package/server-functions/dist/client.cjs +0 -834
  95. package/server-functions/dist/rich-args.cjs +0 -11
  96. package/server-functions/dist/server.cjs +0 -1242
  97. package/server-functions/dist/server.dev.cjs +0 -1242
  98. package/storage/dist/storage.cjs +0 -12
  99. package/storage/types-cjs/index.d.cts +0 -28
  100. package/storage/types-cjs/package.json +0 -3
  101. package/types/core.d.ts +0 -9
  102. package/types-cjs/client.d.cts +0 -337
  103. package/types-cjs/cookies.d.cts +0 -93
  104. package/types-cjs/core.d.cts +0 -9
  105. package/types-cjs/frames/client.d.cts +0 -36
  106. package/types-cjs/frames/frame-client.d.cts +0 -356
  107. package/types-cjs/frames/frame-sink.d.cts +0 -194
  108. package/types-cjs/frames/frame-transport.d.cts +0 -222
  109. package/types-cjs/frames/serializer.d.cts +0 -182
  110. package/types-cjs/frames/server.d.cts +0 -52
  111. package/types-cjs/index.d.cts +0 -244
  112. package/types-cjs/jsx-properties.d.cts +0 -93
  113. package/types-cjs/jsx.d.cts +0 -4159
  114. package/types-cjs/package.json +0 -3
  115. package/types-cjs/response.d.cts +0 -174
  116. package/types-cjs/serializer-decode.d.cts +0 -182
  117. package/types-cjs/serializer.d.cts +0 -182
  118. package/types-cjs/server-functions/client.d.cts +0 -262
  119. package/types-cjs/server-functions/flash.d.cts +0 -38
  120. package/types-cjs/server-functions/rich-args.d.cts +0 -10
  121. package/types-cjs/server-functions/server.d.cts +0 -681
  122. package/types-cjs/server-functions/shared.d.cts +0 -523
  123. package/types-cjs/server-mock.d.cts +0 -286
  124. package/types-cjs/server.d.cts +0 -544
@@ -0,0 +1,2545 @@
1
+ import { sharedConfig, ssrSanitizeError, creationStamp, ssrHandleError, runInServerComponentScope, trackFillReads, shareAsyncIterable, getProjectionTrace } from 'solid-js/internal';
2
+ import { getOwner, NoHydration, runWithOwner, createMemo, createOwner, Hydration } from 'solid-js';
3
+ import { isResponseEnvelope, RequestContext, renderToStream, createLiveHoles } from '@solidjs/web';
4
+ import { Feature, createStream, toCrossJSONStream } from 'seroval';
5
+ import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
6
+ import { frameAddress, getEventServerFunctionInvocation, ChunkReader, serializeStream, guardFailures, armLiveBody, createEventChunk, createChunk, textDigest } from '@solidjs/web/server-functions/server';
7
+
8
+ const DESCEND = Symbol("descend");
9
+ const CYCLE = {};
10
+ const TRACK = 16;
11
+ function rewriteTree(value, visit, withPath) {
12
+ if (value === null || typeof value !== "object") return value;
13
+ const path = withPath ? "" : undefined;
14
+ const state = {
15
+ memo: undefined,
16
+ ancestors: undefined
17
+ };
18
+ try {
19
+ return cow(value, visit, path, 0, state);
20
+ } catch (err) {
21
+ if (err !== CYCLE) throw err;
22
+ }
23
+ return clone(value, visit, path, state.memo || (state.memo = new Map()));
24
+ }
25
+ function shape(value) {
26
+ return Array.isArray(value) ? 1 : Object.getPrototypeOf(value) === Object.prototype ? 2 : 0;
27
+ }
28
+ function cow(value, visit, path, depth, state) {
29
+ const memo = state.memo;
30
+ if (memo !== undefined && memo.has(value)) return memo.get(value);
31
+ const r = visit(value, path);
32
+ if (r !== DESCEND) {
33
+ if (r !== value) (memo || (state.memo = new Map())).set(value, r);
34
+ return r;
35
+ }
36
+ const s = shape(value);
37
+ if (s === 0) return value;
38
+ let ancestors;
39
+ if (depth >= TRACK) {
40
+ ancestors = state.ancestors || (state.ancestors = new Set());
41
+ if (ancestors.has(value)) throw CYCLE;
42
+ ancestors.add(value);
43
+ }
44
+ let out = value;
45
+ if (s === 1) {
46
+ for (let i = 0; i < value.length; i++) {
47
+ const c = value[i];
48
+ if (c === null || typeof c !== "object") continue;
49
+ const next = cow(c, visit, path === undefined ? undefined : `${path}[${i}]`, depth + 1, state);
50
+ if (next !== c) {
51
+ if (out === value) out = value.slice();
52
+ out[i] = next;
53
+ }
54
+ }
55
+ } else {
56
+ for (const k of Object.keys(value)) {
57
+ const c = value[k];
58
+ if (c === null || typeof c !== "object") continue;
59
+ const next = cow(c, visit, path === undefined ? undefined : `${path}.${k}`, depth + 1, state);
60
+ if (next !== c) {
61
+ if (out === value) out = {
62
+ ...value
63
+ };
64
+ out[k] = next;
65
+ }
66
+ }
67
+ }
68
+ if (ancestors !== undefined) ancestors.delete(value);
69
+ return out;
70
+ }
71
+ function clone(value, visit, path, memo) {
72
+ if (memo.has(value)) return memo.get(value);
73
+ const r = visit(value, path);
74
+ if (r !== DESCEND) {
75
+ memo.set(value, r);
76
+ return r;
77
+ }
78
+ const s = shape(value);
79
+ if (s === 0) return value;
80
+ const out = s === 1 ? value.slice() : {
81
+ ...value
82
+ };
83
+ memo.set(value, out);
84
+ if (s === 1) {
85
+ for (let i = 0; i < value.length; i++) {
86
+ const c = value[i];
87
+ if (c !== null && typeof c === "object") out[i] = clone(c, visit, path === undefined ? undefined : `${path}[${i}]`, memo);
88
+ }
89
+ } else {
90
+ for (const k of Object.keys(value)) {
91
+ const c = value[k];
92
+ if (c !== null && typeof c === "object") out[k] = clone(c, visit, path === undefined ? undefined : `${path}.${k}`, memo);
93
+ }
94
+ }
95
+ return out;
96
+ }
97
+
98
+ const STATE = Symbol.for("solid.container-trace-state");
99
+ const state = globalThis[STATE] || (globalThis[STATE] = {
100
+ materialized: new WeakMap(),
101
+ materializedValues: new WeakSet()
102
+ });
103
+ function setContainerTraceResolver(fn) {
104
+ state.resolveTrace = fn;
105
+ }
106
+ function setAsyncIterableSharer(fn) {
107
+ state.shareIterable = fn;
108
+ }
109
+ function setContainerTraceStreamMint(fn) {
110
+ state.streamOf = fn;
111
+ }
112
+ function isContainerTraced(value) {
113
+ const resolve = state.resolveTrace;
114
+ return !!(resolve && value && typeof value === "object" && resolve(value));
115
+ }
116
+ const TRACE = Symbol.for("solid.container-trace");
117
+ function toBorderForm(value, envelopeContainers) {
118
+ if (value == null || typeof value !== "object") return value;
119
+ const resolve = state.resolveTrace ;
120
+ const share = state.shareIterable;
121
+ if (!resolve && !share) return value;
122
+ return rewriteTree(value, v => {
123
+ if (resolve) {
124
+ const trace = resolve(v);
125
+ if (trace) return {
126
+ [TRACE]: trace
127
+ };
128
+ }
129
+ if (share && isShareableIterable(v)) return share(v);
130
+ return DESCEND;
131
+ }, false);
132
+ }
133
+ function isShareableIterable(value) {
134
+ try {
135
+ return typeof value[Symbol.asyncIterator] === "function" && !(typeof ReadableStream !== "undefined" && value instanceof ReadableStream);
136
+ } catch {
137
+ return false;
138
+ }
139
+ }
140
+ function materialize(marker, claiming) {
141
+ let value = state.materialized.get(marker.$tr);
142
+ if (value === undefined) {
143
+ value = state.materializeTrace(marker, claiming);
144
+ state.materialized.set(marker.$tr, value);
145
+ if (value !== null && typeof value === "object") state.materializedValues.add(value);
146
+ }
147
+ return value;
148
+ }
149
+ function parseTrace(value, ctx) {
150
+ const trace = value[TRACE];
151
+ const sub = trace.subscribe();
152
+ return {
153
+ a: trace.array ? 1 : 0,
154
+ i: ctx.parse(state.streamOf ? state.streamOf(sub) : sub)
155
+ };
156
+ }
157
+ const ContainerTracePlugin = {
158
+ tag: "solid/container-trace",
159
+ test(value) {
160
+ return value != null && typeof value === "object" && TRACE in value;
161
+ },
162
+ parse: {
163
+ sync() {
164
+ throw new Error("A reactive container can only be serialized by a streaming serializer.");
165
+ },
166
+ async async(value, ctx) {
167
+ const trace = value[TRACE];
168
+ const sub = trace.subscribe();
169
+ return {
170
+ a: trace.array ? 1 : 0,
171
+ i: await ctx.parse(state.streamOf ? state.streamOf(sub) : sub)
172
+ };
173
+ },
174
+ stream: parseTrace
175
+ },
176
+ serialize(node, ctx) {
177
+ return "{$tr:" + ctx.serialize(node.i) + ",$ta:" + node.a + "}";
178
+ },
179
+ deserialize(node, ctx) {
180
+ const iterable = ctx.deserialize(node.i);
181
+ const marker = {
182
+ $tr: iterable,
183
+ $ta: node.a
184
+ };
185
+ return state.materializeTrace ? materialize(marker) : marker;
186
+ }
187
+ };
188
+
189
+ setContainerTraceStreamMint(iterable => {
190
+ const stream = createStream();
191
+ (async () => {
192
+ try {
193
+ for await (const value of iterable) stream.next(value);
194
+ stream.return(undefined);
195
+ } catch (error) {
196
+ stream.throw(error);
197
+ }
198
+ })();
199
+ return stream;
200
+ });
201
+ const DEFAULT_WEB_PLUGINS = /* @__PURE__ */Object.freeze([AbortSignalPlugin,
202
+ CustomEventPlugin, DOMExceptionPlugin, EventPlugin,
203
+ FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin,
204
+ ContainerTracePlugin]);
205
+ function resolveSerializerPlugins(customPlugins) {
206
+ return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
207
+ }
208
+ const jsonCodecDisabledFeatures = () => Feature.RegExp;
209
+ const JSON_CODEC_DEPTH_LIMIT = 64;
210
+ const RESOLVED_PLUGINS = Symbol.for("solid.codec.resolvedPlugins");
211
+ function resolveCodecOptions(options = {}) {
212
+ const {
213
+ plugins,
214
+ disabledFeatures,
215
+ depthLimit,
216
+ serializeErrorStacks
217
+ } = options;
218
+ return {
219
+ plugins: options[RESOLVED_PLUGINS] || resolveSerializerPlugins(plugins),
220
+ disabledFeatures: disabledFeatures === undefined ? jsonCodecDisabledFeatures() : disabledFeatures,
221
+ depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit,
222
+ serializeErrorStacks
223
+ };
224
+ }
225
+
226
+ const serializeOnlyDisabledFeatures = serializeErrorStacks => (serializeErrorStacks === undefined ? process.env.NODE_ENV === "development" : serializeErrorStacks) ? 0 : Feature.ErrorPrototypeStack;
227
+ function createKeyedSerializer(serialize, onError, onDone) {
228
+ const cancels = new Set();
229
+ let pendingWrites = 0;
230
+ let flushed = false;
231
+ let done = false;
232
+ let closed = false;
233
+ const maybeDone = () => {
234
+ if (flushed && pendingWrites === 0 && !done) {
235
+ done = true;
236
+ onDone && onDone();
237
+ }
238
+ };
239
+ return {
240
+ write(key, value) {
241
+ if (flushed) return;
242
+ pendingWrites++;
243
+ let settled = false;
244
+ let failed = false;
245
+ let cancel = null;
246
+ const settle = () => {
247
+ if (settled) return;
248
+ settled = true;
249
+ if (cancel) cancels.delete(cancel);
250
+ pendingWrites--;
251
+ maybeDone();
252
+ };
253
+ let stream;
254
+ try {
255
+ stream = serialize(key, value, {
256
+ onError: onError && (err => {
257
+ failed = true;
258
+ onError(err);
259
+ if (cancel) {
260
+ cancel();
261
+ settle();
262
+ }
263
+ }),
264
+ onDone: settle
265
+ }, () => !closed);
266
+ } catch (err) {
267
+ settle();
268
+ throw err;
269
+ }
270
+ if (settled) return;
271
+ if (closed || failed) {
272
+ stream();
273
+ settle();
274
+ return;
275
+ }
276
+ cancel = stream;
277
+ cancels.add(cancel);
278
+ },
279
+ flush() {
280
+ flushed = true;
281
+ maybeDone();
282
+ },
283
+ close() {
284
+ closed = flushed = true;
285
+ for (const cancel of cancels) cancel();
286
+ cancels.clear();
287
+ if (!done) {
288
+ done = true;
289
+ onDone && onDone();
290
+ }
291
+ }
292
+ };
293
+ }
294
+ function createJSONSerializer({
295
+ onData,
296
+ onDone,
297
+ onError,
298
+ plugins,
299
+ disabledFeatures,
300
+ depthLimit,
301
+ serializeErrorStacks
302
+ }) {
303
+ const resolved = resolveCodecOptions({
304
+ plugins,
305
+ disabledFeatures,
306
+ depthLimit,
307
+ serializeErrorStacks
308
+ });
309
+ const refs = new Map();
310
+ return createKeyedSerializer((key, value, callbacks, live) => toCrossJSONStream(value, {
311
+ refs,
312
+ plugins: resolved.plugins,
313
+ disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures(resolved.serializeErrorStacks),
314
+ onParse(node, initial) {
315
+ if (live()) onData({
316
+ key,
317
+ node,
318
+ initial
319
+ });
320
+ },
321
+ ...callbacks
322
+ }), onError, onDone);
323
+ }
324
+
325
+ const RECORDS = Symbol.for("@solidjs/signals/observe/records");
326
+ function records() {
327
+ return globalThis[RECORDS];
328
+ }
329
+ function frameRecordCensus(event, message, own) {
330
+ const r = message.r;
331
+ let counted = !r;
332
+ for (const key in r) {
333
+ if (key === ":complete" || key === ":bound") continue;
334
+ counted = true;
335
+ countEvent(event, key === "" ? "html" : key.endsWith(":error") ? "error" : key.startsWith("slot:") ? "slot" : key.startsWith("seg:") && r[key] && r[key].kind === "html" ? "fragment" : key, own);
336
+ }
337
+ if (counted) event.chunks++;
338
+ }
339
+ function countEvent(event, type, own) {
340
+ switch (type) {
341
+ case "html":
342
+ if (!own) event.regions++;else if (event.shellMs === undefined) event.shellMs = performance.now() - event.at;
343
+ break;
344
+ case "fragment":
345
+ event.fragments++;
346
+ break;
347
+ case "slot":
348
+ event.slots++;
349
+ break;
350
+ case "error":
351
+ event.errors++;
352
+ break;
353
+ }
354
+ }
355
+
356
+ function observeFrame(frame) {
357
+ const channel = records();
358
+ if (channel === undefined || !channel.observed("frame")) return undefined;
359
+ const event = {
360
+ side: "server",
361
+ id: frame.id,
362
+ version: frame.version,
363
+ at: performance.now(),
364
+ durationMs: 0,
365
+ outcome: "complete",
366
+ chunks: 0,
367
+ fragments: 0,
368
+ slots: 0,
369
+ regions: 0,
370
+ errors: 0
371
+ };
372
+ let settled = false;
373
+ return {
374
+ chunk(message) {
375
+ frameRecordCensus(event, message, message.id === frame.id);
376
+ },
377
+ settle(outcome, error) {
378
+ if (settled) return;
379
+ settled = true;
380
+ event.durationMs = performance.now() - event.at;
381
+ event.outcome = outcome;
382
+ const live = {};
383
+ if (outcome === "error") live.error = error;
384
+ channel.emit("frame", event, live);
385
+ }
386
+ };
387
+ }
388
+
389
+ const FRAME_STREAM_HEADER = "X-Frame-Stream";
390
+ const FRAME_TIERS_HEADER = "X-Frame-Tiers";
391
+ const FRAME_HAVE_HEADER = "X-Frame-Have";
392
+ const FRAME_HAVE_BUDGET = 4096;
393
+ function decodeHaveList(text) {
394
+ if (!text) return undefined;
395
+ const have = {};
396
+ let any = false;
397
+ for (const entry of text.split(",")) {
398
+ const eq = entry.indexOf("=");
399
+ if (eq === -1) continue;
400
+ const digest = entry.slice(eq + 1).trim();
401
+ if (!/^[0-9a-f]{16}$/.test(digest)) continue;
402
+ have[entry.slice(0, eq).trim()] = digest;
403
+ any = true;
404
+ }
405
+ return any ? have : undefined;
406
+ }
407
+ function isFrameStreamResponse(response) {
408
+ return response.headers.has(FRAME_STREAM_HEADER);
409
+ }
410
+ const SERVER_COMPONENT = /*#__PURE__*/Symbol.for("solid.server-component");
411
+ const SERVER_COMPONENT_SOURCE = /*#__PURE__*/Symbol.for("solid.server-component-source");
412
+ const SERVER_COMPONENT_ADDRESS = /*#__PURE__*/Symbol.for("solid.server-component-address");
413
+ let serverComponentRegistryExpr;
414
+ function setServerComponentBootstrap(resolve) {
415
+ serverComponentRegistryExpr = resolve;
416
+ }
417
+ function parseServerComponent(value, ctx) {
418
+ return {
419
+ id: ctx.parse(value[SERVER_COMPONENT]),
420
+ address: ctx.parse(value[SERVER_COMPONENT_ADDRESS])
421
+ };
422
+ }
423
+ const ServerComponentPlugin = {
424
+ tag: "solid/server-component",
425
+ test(value) {
426
+ return typeof value === "function" && SERVER_COMPONENT in value;
427
+ },
428
+ parse: {
429
+ sync: parseServerComponent,
430
+ async async(value, ctx) {
431
+ return {
432
+ id: await ctx.parse(value[SERVER_COMPONENT]),
433
+ address: await ctx.parse(value[SERVER_COMPONENT_ADDRESS])
434
+ };
435
+ },
436
+ stream: parseServerComponent
437
+ },
438
+ serialize(node, ctx) {
439
+ const registry = serverComponentRegistryExpr ? serverComponentRegistryExpr(ctx) : "self._$SC";
440
+ return registry + ".r(" + ctx.serialize(node.id) + "," + ctx.serialize(node.address) + ")";
441
+ },
442
+ deserialize(node, ctx) {
443
+ const id = ctx.deserialize(node.id);
444
+ ctx.deserialize(node.address);
445
+ return globalThis._$SC.r(id);
446
+ }
447
+ };
448
+ function flightCodec(codec) {
449
+ const plugins = codec && codec.plugins || [];
450
+ if (plugins.some(plugin => plugin && plugin.tag === ServerComponentPlugin.tag)) return codec;
451
+ return {
452
+ ...codec,
453
+ plugins: [...plugins, ServerComponentPlugin]
454
+ };
455
+ }
456
+
457
+ const runWithHydrationScope = (id, fn) => runWithOwner(createOwner({
458
+ id
459
+ }), fn);
460
+ const ssrAsyncValue = value => createMemo(() => value, {
461
+ serialize: false
462
+ });
463
+ const scopeStamp = typeof creationStamp === "function" ? creationStamp : () => 0;
464
+ function serverOwned(render) {
465
+ return NoHydration ? NoHydration({
466
+ get children() {
467
+ return render();
468
+ }
469
+ }) : render();
470
+ }
471
+ function serverComponentScope(render, live = false) {
472
+ return runInServerComponentScope ? runInServerComponentScope(render, live ? {
473
+ live: true
474
+ } : undefined) : render();
475
+ }
476
+ const LIVE_SOURCE = Symbol.for("solid.LiveSource");
477
+ function wirePreload(entry) {
478
+ return entry.href ? {
479
+ href: entry.href,
480
+ attrs: entry.attrs
481
+ } : {
482
+ attrs: entry.attrs
483
+ };
484
+ }
485
+ const SERVER_COMPONENT_BOOTSTRAP_EXPR = "(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));" + "if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);" + 'return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for("solid.component-binding")]:{component:c,address:a}}))}}))';
486
+ const bootstrappedScripts = new WeakSet();
487
+ setServerComponentBootstrap(ctx => {
488
+ if (bootstrappedScripts.has(ctx)) return "self._$SC";
489
+ bootstrappedScripts.add(ctx);
490
+ return SERVER_COMPONENT_BOOTSTRAP_EXPR;
491
+ });
492
+ const SERVER_COMPONENT_BOOTSTRAP = SERVER_COMPONENT_BOOTSTRAP_EXPR + ";";
493
+ const HOLE_RANGE = /<!--lh:(\d+)-->([\s\S]*?)<!--lh:\/\1-->/g;
494
+ const SLOT_RANGE = /<!--slot:([^>]*?):start-->[\s\S]*?<!--slot:\1:end-->/g;
495
+ const ATTR_ADDRESS = / data-lha="([^"]*)"/g;
496
+ const stripHoleMarkers = html => html.replace(/<!--lh:\/?\d+-->/g, "");
497
+ function frameSkeleton(html) {
498
+ return html.replace(HOLE_RANGE, "<!--lh:$1--><!--lh:/$1-->").replace(SLOT_RANGE, "<!--slot:$1:start--><!--slot:$1:end-->");
499
+ }
500
+ const ROW_HTML = Symbol.for("solid.rowHtml");
501
+ function holeDigests(html, attrText, into = {}) {
502
+ for (const m of html.matchAll(HOLE_RANGE)) {
503
+ into["lh:" + m[1]] = textDigest(stripHoleMarkers(m[2]));
504
+ holeDigests(m[2], null, into);
505
+ }
506
+ if (attrText) {
507
+ for (const m of html.matchAll(ATTR_ADDRESS)) {
508
+ const key = "lha:" + m[1];
509
+ const text = attrText.get(key);
510
+ if (text !== undefined) into[key] = textDigest(text);
511
+ }
512
+ }
513
+ return into;
514
+ }
515
+ function withHoles(chunk, holes) {
516
+ for (const _ in holes) {
517
+ chunk.holes = holes;
518
+ break;
519
+ }
520
+ return chunk;
521
+ }
522
+ function createFrameSink(write, frame, have, hooks) {
523
+ const {
524
+ id,
525
+ version
526
+ } = frame;
527
+ const tiers = new Set();
528
+ let staged = [];
529
+ const send = message => {
530
+ if (staged.length) {
531
+ message.tiers = staged;
532
+ staged = [];
533
+ }
534
+ write(message);
535
+ };
536
+ let queue = [];
537
+ let open = null;
538
+ let scheduled = false;
539
+ const flush = () => {
540
+ scheduled = false;
541
+ open = null;
542
+ const out = queue;
543
+ queue = [];
544
+ for (const message of out) send(message);
545
+ };
546
+ const put = (fid, r) => {
547
+ if (swept) swept.emitted = true;
548
+ showing(r);
549
+ let merge = open && open.id === fid;
550
+ if (merge) for (const key in r) if (key in open.r) merge = false;
551
+ if (merge) Object.assign(open.r, r);else queue.push(open = {
552
+ id: fid,
553
+ version,
554
+ r
555
+ });
556
+ if (!scheduled) {
557
+ scheduled = true;
558
+ queueMicrotask(flush);
559
+ }
560
+ };
561
+ const putError = (fid, key, error) => put(fid, {
562
+ [key ? `${/^lha?:/.test(key) ? "hole" : "seg"}:${key}:error` : ":error"]: error
563
+ });
564
+ const needs = name => {
565
+ if (!tiers.has(name)) {
566
+ tiers.add(name);
567
+ staged.push(name);
568
+ }
569
+ };
570
+ let conditional = false;
571
+ const skipped = new Set();
572
+ const attrText = new Map();
573
+ const holeDigest = new Map();
574
+ if (have) for (const key in have) key.startsWith("lh:") && holeDigest.set(key, have[key]);
575
+ function showing(r) {
576
+ if ("" in r) holeDigest.clear();
577
+ for (const k in r) {
578
+ const record = r[k];
579
+ if (k.startsWith("hole:lh:") && !k.endsWith(":error")) holeDigest.set(k.slice(5), record.digest);
580
+ if (record) for (const key in record.holes) key.startsWith("lh:") && holeDigest.set(key, record.holes[key]);
581
+ }
582
+ }
583
+ const html = (value, digest, holes) => withHoles({
584
+ kind: "html",
585
+ value,
586
+ digest
587
+ }, holes);
588
+ const emitDiffering = source => {
589
+ for (const m of source.matchAll(HOLE_RANGE)) {
590
+ const key = "lh:" + m[1];
591
+ const digest = textDigest(stripHoleMarkers(m[2]));
592
+ if (have[key] === digest) continue;
593
+ put(id, {
594
+ ["hole:" + key]: html(m[2], digest, holeDigests(m[2], null))
595
+ });
596
+ }
597
+ for (const m of source.matchAll(ATTR_ADDRESS)) {
598
+ const text = attrText.get("lha:" + m[1]);
599
+ if (text === undefined) continue;
600
+ const digest = textDigest(text);
601
+ if (have["lha:" + m[1]] === digest) continue;
602
+ put(id, {
603
+ ["attr:" + m[1]]: {
604
+ kind: "attrs",
605
+ value: text,
606
+ digest
607
+ }
608
+ });
609
+ }
610
+ };
611
+ const bindings = new Map();
612
+ const sweepMinted = new Set();
613
+ const argRefVersions = new Map();
614
+ let sweepScheduled = false;
615
+ let closed = false;
616
+ let epoch = 0;
617
+ let swept = null;
618
+ const sweep = () => {
619
+ epoch++;
620
+ const pass = swept = {
621
+ r: {},
622
+ emitted: false
623
+ };
624
+ try {
625
+ for (const [key, b] of [...bindings]) {
626
+ if (bindings.get(key) !== b) continue;
627
+ try {
628
+ b.sweep();
629
+ } catch (_) {
630
+ }
631
+ }
632
+ for (const _ in pass.r) {
633
+ put(id, pass.r);
634
+ break;
635
+ }
636
+ flush();
637
+ if (pass.emitted && hooks && hooks.onYield) hooks.onYield();
638
+ } finally {
639
+ swept = null;
640
+ }
641
+ };
642
+ const scheduleSweep = () => {
643
+ if (closed || sweepScheduled || !bindings.size) return;
644
+ sweepScheduled = true;
645
+ queueMicrotask(() => {
646
+ sweepScheduled = false;
647
+ if (!closed) sweep();
648
+ });
649
+ };
650
+ const regionKeys = new Map();
651
+ const frameOf = key => regionKeys.get(key) || id;
652
+ return {
653
+ tagRegion(key, childId) {
654
+ if (!regionKeys.has(key)) regionKeys.set(key, childId);
655
+ },
656
+ shell(source, meta = {}) {
657
+ const digest = textDigest(frameSkeleton(source));
658
+ if (have && have[""] === digest) {
659
+ conditional = true;
660
+ emitDiffering(source);
661
+ return;
662
+ }
663
+ if (meta.preloads && meta.preloads.size || meta.preloadLinks) {
664
+ const record = {};
665
+ if (meta.preloads && meta.preloads.size) {
666
+ const styles = [];
667
+ const modules = [];
668
+ for (const url of meta.preloads) {
669
+ (url.endsWith(".css") ? styles : modules).push(url);
670
+ }
671
+ if (styles.length) record.styles = styles;
672
+ if (modules.length) record.modules = modules;
673
+ }
674
+ if (meta.preloadLinks) {
675
+ record.preloads = [];
676
+ for (const entry of meta.preloadLinks) {
677
+ record.preloads.push(wirePreload(entry));
678
+ }
679
+ }
680
+ needs("assets");
681
+ put(id, {
682
+ "seg::assets": record
683
+ });
684
+ }
685
+ put(id, {
686
+ "": html(source, digest, holeDigests(source, attrText))
687
+ });
688
+ },
689
+ data(record) {
690
+ if (record && typeof record.key === "string" && (record.key.endsWith("_fr") || /^\d+$/.test(record.key))) {
691
+ return;
692
+ }
693
+ if (swept) swept.emitted = true;
694
+ flush();
695
+ if (typeof record === "string") {
696
+ send({
697
+ type: "data",
698
+ id,
699
+ version,
700
+ payload: record
701
+ });
702
+ scheduleSweep();
703
+ } else {
704
+ send({
705
+ type: "data",
706
+ id,
707
+ version,
708
+ key: record.key,
709
+ node: record.node,
710
+ initial: record.initial
711
+ });
712
+ if (!sweepMinted.has(record.key)) scheduleSweep();
713
+ }
714
+ },
715
+ fragment(key, value, meta = {}) {
716
+ const fid = frameOf(key);
717
+ if (conditional && fid === id && have[key] !== undefined) {
718
+ skipped.add(key);
719
+ scheduleSweep();
720
+ if (meta.error) {
721
+ putError(fid, key, {
722
+ message: String(meta.error && meta.error.message || meta.error)
723
+ });
724
+ } else emitDiffering(value);
725
+ return;
726
+ }
727
+ const links = meta.styles && meta.styles.links || [];
728
+ const inline = meta.styles && meta.styles.inline || [];
729
+ const r = {};
730
+ if (links.length || inline.length) {
731
+ const record = {};
732
+ if (links.length) {
733
+ record.styles = links.map(e => typeof e === "string" ? e : e.attrs ? {
734
+ href: e.href,
735
+ attrs: e.attrs
736
+ } : e.href);
737
+ }
738
+ if (inline.length) {
739
+ record.inlineStyles = inline.map(e => ({
740
+ id: e.id,
741
+ content: e.content,
742
+ attrs: e.attrs
743
+ }));
744
+ }
745
+ needs("assets");
746
+ r[`seg:${key}:assets`] = record;
747
+ }
748
+ r[`seg:${key}`] = html(value, textDigest(value), holeDigests(value, attrText));
749
+ scheduleSweep();
750
+ if (meta.error) r[`seg:${key}:error`] = {
751
+ message: String(meta.error && meta.error.message || meta.error)
752
+ };
753
+ if (!meta.revealGroup) r[`seg:${key}:reveal`] = true;
754
+ put(fid, r);
755
+ },
756
+ reveal(keys, meta = {}) {
757
+ const byFrame = new Map();
758
+ for (const key of keys) {
759
+ if (conditional && (skipped.has(key) || meta.fallback && have[key] !== undefined)) continue;
760
+ const fid = frameOf(key);
761
+ let group = byFrame.get(fid);
762
+ if (!group) byFrame.set(fid, group = []);
763
+ group.push(key);
764
+ }
765
+ const gate = meta.fallback ? "fallback" : "reveal";
766
+ for (const [fid, groupKeys] of byFrame) {
767
+ const r = {};
768
+ for (const key of groupKeys) r[`seg:${key}:${gate}`] = true;
769
+ put(fid, r);
770
+ }
771
+ },
772
+ asset(type, value) {
773
+ if (type === "module") {
774
+ needs("assets");
775
+ put(id, {
776
+ "seg::assets": {
777
+ modules: [value]
778
+ }
779
+ });
780
+ } else if (type === "preload") {
781
+ needs("assets");
782
+ put(id, {
783
+ "seg::assets": {
784
+ preloads: [wirePreload(value)]
785
+ }
786
+ });
787
+ }
788
+ },
789
+ end(bound) {
790
+ if (closed) return;
791
+ if (bindings.size && !swept) sweep();
792
+ closed = true;
793
+ put(id, bound ? {
794
+ ":complete": true,
795
+ ":bound": bound
796
+ } : {
797
+ ":complete": true
798
+ });
799
+ flush();
800
+ },
801
+ error(errorId, error) {
802
+ putError(id, errorId, error);
803
+ },
804
+ flush,
805
+ slot(key, args) {
806
+ const r = {
807
+ [`slot:${key}`]: {
808
+ kind: "slot",
809
+ args
810
+ }
811
+ };
812
+ swept ? Object.assign(swept.r, r) : put(id, r);
813
+ },
814
+ region(childId, value) {
815
+ needs("regions");
816
+ put(childId, {
817
+ "": {
818
+ kind: "html",
819
+ value
820
+ }
821
+ });
822
+ },
823
+ hole(key, source, rows) {
824
+ const record = {
825
+ kind: "html",
826
+ digest: textDigest(source)
827
+ };
828
+ const base = holeDigest.get(key);
829
+ if (rows && base && hooks && hooks.live) {
830
+ record.rows = rows;
831
+ record.base = base;
832
+ } else record.value = source;
833
+ withHoles(record, holeDigests(record.rows ? (rows[ROW_HTML] || rows.r.map(r => r[1])).join("") : source, null));
834
+ if (record.rows && hooks && hooks.retain) record[HOLE_SOURCE] = withHoles({
835
+ kind: "html",
836
+ value: source,
837
+ digest: record.digest
838
+ }, holeDigests(source, null));
839
+ const r = {
840
+ ["hole:" + key]: record
841
+ };
842
+ showing(r);
843
+ swept ? Object.assign(swept.r, r) : put(id, r);
844
+ },
845
+ attr(key, attrs, removed) {
846
+ const record = {
847
+ kind: "attrs",
848
+ value: attrs,
849
+ digest: textDigest(attrs)
850
+ };
851
+ if (removed && removed.length) record.removed = removed;
852
+ const r = {
853
+ ["attr:" + key]: record
854
+ };
855
+ swept ? Object.assign(swept.r, r) : put(id, r);
856
+ },
857
+ attrBaseline(key, text) {
858
+ attrText.set(key, text);
859
+ if (hooks && hooks.retain) hooks.retain(key, text);
860
+ },
861
+ openBinding(key, b) {
862
+ if (/^lha?:/.test(key)) needs("wire");
863
+ bindings.set(key, b);
864
+ },
865
+ closeBinding(key) {
866
+ bindings.delete(key);
867
+ },
868
+ mintRef(ref) {
869
+ sweepMinted.add(ref);
870
+ },
871
+ nextArgRef(ledgerKey) {
872
+ const n = (argRefVersions.get(ledgerKey) || 0) + 1;
873
+ argRefVersions.set(ledgerKey, n);
874
+ return n;
875
+ },
876
+ commit: scheduleSweep,
877
+ get epoch() {
878
+ return epoch;
879
+ },
880
+ needs,
881
+ announce() {
882
+ staged = [];
883
+ return [...tiers];
884
+ }
885
+ };
886
+ }
887
+ function renderServerComponent(component, options = {}) {
888
+ return frameStream((sink, frame) => {
889
+ const props = createSlotProps(sink, frame);
890
+ return () => {
891
+ const ctx = sharedConfig.context;
892
+ if (ctx) {
893
+ ctx.commit = sink.commit;
894
+ ctx.commitEpoch = () => sink.epoch;
895
+ let unsettled = !!options.live;
896
+ if (!unsettled) ctx.unsettled = () => void (unsettled = true);
897
+ ctx.liveHoles = createLiveHoles(sink, false, () => !unsettled, ctx._errorScope);
898
+ }
899
+ return serverComponentScope(() => component(props));
900
+ };
901
+ }, options);
902
+ }
903
+ const DEFAULT_MAX_YIELDS = 64;
904
+ const DEFAULT_MAX_DURATION_MS = 30_000;
905
+ const DISCONNECTED = Symbol("solid.frames.disconnected");
906
+ const ANNOUNCE = Symbol("solid.frames.announce");
907
+ function frameStream(makeCode, options) {
908
+ const {
909
+ id = "",
910
+ version = 1
911
+ } = options.frame || {};
912
+ const frame = {
913
+ id,
914
+ version
915
+ };
916
+ const bounded = !options.live;
917
+ const maxYields = bounded ? options.maxYields ?? DEFAULT_MAX_YIELDS : 0;
918
+ const maxDurationMs = bounded ? options.maxDurationMs ?? DEFAULT_MAX_DURATION_MS : 0;
919
+ function stream(w) {
920
+ const observation = observeFrame(frame);
921
+ const render = new AbortController();
922
+ const upstream = options.signal;
923
+ let ended = false;
924
+ let flushed = false;
925
+ let yields = 0;
926
+ let timer;
927
+ function finish() {
928
+ if (ended) return;
929
+ ended = true;
930
+ sink.flush();
931
+ if (timer) clearTimeout(timer);
932
+ if (upstream) upstream.removeEventListener("abort", onSignal);
933
+ w.end && w.end();
934
+ }
935
+ function cut(bound) {
936
+ if (ended) return;
937
+ sink.end(bound);
938
+ observation && observation.settle("complete");
939
+ finish();
940
+ render.abort({
941
+ quiet: true,
942
+ bound
943
+ });
944
+ }
945
+ function onSignal() {
946
+ const gone = upstream.reason && upstream.reason[DISCONNECTED];
947
+ if (bounded && flushed && !gone) return cut("time");
948
+ finish();
949
+ render.abort(upstream.reason);
950
+ }
951
+ const emit = message => {
952
+ if (observation) observation.chunk(message);
953
+ w.write(message);
954
+ if (bounded && !flushed && message.id === id && message.r && "" in message.r) {
955
+ flushed = true;
956
+ if (maxDurationMs > 0 && maxDurationMs !== Infinity) timer = setTimeout(() => cut("time"), maxDurationMs);
957
+ }
958
+ };
959
+ const sink = createFrameSink(emit, frame, options.resume && options.resume.have, {
960
+ live: options.live,
961
+ retain: options.broadcast,
962
+ onYield: bounded ? () => {
963
+ if (flushed && maxYields > 0 && ++yields >= maxYields) cut("yields");
964
+ } : undefined
965
+ });
966
+ if (options.live) sink.needs("wire");
967
+ w.write({
968
+ type: "start",
969
+ id,
970
+ version
971
+ });
972
+ if (upstream && upstream.aborted) return finish();
973
+ if (upstream) upstream.addEventListener("abort", onSignal, {
974
+ once: true
975
+ });
976
+ const code = makeCode(sink, frame);
977
+ try {
978
+ renderToStream(() => serverOwned(code), {
979
+ serializer: createJSONSerializer,
980
+ ...options,
981
+ signal: render.signal,
982
+ sink
983
+ }).pipe({
984
+ write() {},
985
+ end() {
986
+ if (ended) return;
987
+ sink.end();
988
+ observation && observation.settle("complete");
989
+ finish();
990
+ }
991
+ });
992
+ } catch (err) {
993
+ const wire = ssrSanitizeError(err, null);
994
+ sink.error("", wire instanceof Error ? wire.message : String(wire));
995
+ sink.end();
996
+ observation && observation.settle("error", err);
997
+ finish();
998
+ }
999
+ if (w[ANNOUNCE]) w[ANNOUNCE](sink.announce());
1000
+ sink.flush();
1001
+ }
1002
+ return {
1003
+ pipe: stream,
1004
+ then(onFulfilled, onRejected) {
1005
+ return new Promise((resolve, reject) => {
1006
+ const chunks = [];
1007
+ try {
1008
+ stream({
1009
+ write: chunk => chunks.push(chunk),
1010
+ end: () => resolve(chunks)
1011
+ });
1012
+ } catch (err) {
1013
+ reject(err);
1014
+ }
1015
+ }).then(onFulfilled, onRejected);
1016
+ }
1017
+ };
1018
+ }
1019
+ function slotRange(occurrence) {
1020
+ return {
1021
+ t: `<!--slot:${occurrence}:start--><!--slot:${occurrence}:end-->`,
1022
+ $slot: true
1023
+ };
1024
+ }
1025
+ function argBorderForm(value, needs) {
1026
+ return toBorderForm(noteTraces(value, needs));
1027
+ }
1028
+ function noteTraces(value, needs) {
1029
+ return rewriteTree(value, v => {
1030
+ if (isContainerTraced(v)) {
1031
+ needs("trace");
1032
+ return v;
1033
+ }
1034
+ return DESCEND;
1035
+ }, true);
1036
+ }
1037
+ const OCCURRENCE_UNSAFE = /[^A-Za-z0-9_.-]/g;
1038
+ function encodeOccurrenceKey(key) {
1039
+ return String(key).replace(OCCURRENCE_UNSAFE, c => {
1040
+ const code = c.codePointAt(0);
1041
+ return "%" + (code < 16 ? "0" : "") + code.toString(16);
1042
+ });
1043
+ }
1044
+ function occurrenceId(prop, raw, counts) {
1045
+ const keyed = keyedId(prop, raw);
1046
+ if (keyed !== undefined) return keyed;
1047
+ const n = counts[prop] || 0;
1048
+ counts[prop] = n + 1;
1049
+ return `${prop}#${n}`;
1050
+ }
1051
+ function keyedId(prop, raw) {
1052
+ const k = raw.$key;
1053
+ return typeof k === "string" || typeof k === "number" ? `${prop}#${encodeOccurrenceKey(k)}` : undefined;
1054
+ }
1055
+ function structuralArgsKey(raw) {
1056
+ let out = "";
1057
+ let ancestors;
1058
+ const walk = (v, top) => {
1059
+ if (v === null) out += "N";else if (typeof v === "string") out += "s" + v.length + ":" + v;else if (typeof v === "boolean") out += v ? "T" : "F";else if (typeof v === "undefined") out += "U";else if (typeof v === "number") out += "n" + v + ";";else if (typeof v === "bigint") out += "b" + v + ";";else if (typeof v !== "object") return false;else {
1060
+ const isArray = Array.isArray(v);
1061
+ if (!isArray) {
1062
+ const proto = Object.getPrototypeOf(v);
1063
+ if (proto !== Object.prototype && proto !== null) return false;
1064
+ }
1065
+ if (ancestors === undefined) ancestors = new Set();else if (ancestors.has(v)) return false;
1066
+ ancestors.add(v);
1067
+ try {
1068
+ if (isArray) {
1069
+ out += "[";
1070
+ for (const item of v) if (!walk(item)) return false;
1071
+ out += "]";
1072
+ } else {
1073
+ out += "{";
1074
+ for (const k of Object.keys(v).sort()) {
1075
+ if (top && k === "$key") continue;
1076
+ const desc = Object.getOwnPropertyDescriptor(v, k);
1077
+ if (desc.get || desc.set) return false;
1078
+ out += "k" + k.length + ":" + k;
1079
+ if (!walk(desc.value)) return false;
1080
+ }
1081
+ out += "}";
1082
+ }
1083
+ } finally {
1084
+ ancestors.delete(v);
1085
+ }
1086
+ }
1087
+ return true;
1088
+ };
1089
+ return walk(raw, true) ? out : undefined;
1090
+ }
1091
+ function argDigest(value) {
1092
+ const t = typeof value;
1093
+ if (value == null || t !== "object" && t !== "function" && value === value) return value;
1094
+ if (isContainerTraced(value)) return value;
1095
+ try {
1096
+ const key = structuralArgsKey([value]);
1097
+ return key === undefined ? value : key;
1098
+ } catch (_) {
1099
+ return value;
1100
+ }
1101
+ }
1102
+ const PENDING_ARG = {};
1103
+ const noDigest = () => NaN;
1104
+ function isAsyncValue(v) {
1105
+ return !!v && typeof v === "object" && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
1106
+ }
1107
+ function tapFirstYield(iterable) {
1108
+ const rest = shareAsyncIterable(iterable);
1109
+ const iter = shareAsyncIterable(iterable)[Symbol.asyncIterator]();
1110
+ const first = Promise.resolve(iter.next()).then(r => {
1111
+ if (!r.done) iter.return?.();
1112
+ return r.done ? undefined : r.value;
1113
+ });
1114
+ return {
1115
+ first,
1116
+ rest
1117
+ };
1118
+ }
1119
+ function packOccurrences(occs) {
1120
+ const out = [];
1121
+ let prop = "",
1122
+ a = -1,
1123
+ b = -1;
1124
+ const flush = () => a >= 0 && out.push(prop + "#" + (a === b ? a : a + "-" + b));
1125
+ for (const o of occs) {
1126
+ const m = /^(.*)#(\d+)$/.exec(o);
1127
+ if (m && m[1] === prop && +m[2] === b + 1 && a >= 0) {
1128
+ b++;
1129
+ continue;
1130
+ }
1131
+ flush();
1132
+ a = b = -1;
1133
+ if (m) {
1134
+ prop = m[1];
1135
+ a = b = +m[2];
1136
+ } else out.push(o);
1137
+ }
1138
+ flush();
1139
+ return out.join(" ");
1140
+ }
1141
+ function hasAsyncHoles(node, depth = 0) {
1142
+ if (!node || typeof node !== "object" || depth > 64) return false;
1143
+ if (Array.isArray(node)) {
1144
+ for (const n of node) if (hasAsyncHoles(n, depth + 1)) return true;
1145
+ return false;
1146
+ }
1147
+ if (node.h && node.h.length) return true;
1148
+ return false;
1149
+ }
1150
+ function suppressedFill(render) {
1151
+ const live = sharedConfig.context && sharedConfig.context.liveHoles;
1152
+ if (!live) return render();
1153
+ live.suppressed++;
1154
+ try {
1155
+ return render();
1156
+ } finally {
1157
+ live.suppressed--;
1158
+ }
1159
+ }
1160
+ let parked = null;
1161
+ let parkedIds = 0;
1162
+ const PARKED = /<!--sc-n:(\d+)-->/;
1163
+ function park(render) {
1164
+ if (!parked) return render();
1165
+ const id = ++parkedIds;
1166
+ parked.set(id, {
1167
+ render,
1168
+ out: undefined
1169
+ });
1170
+ return {
1171
+ t: `<!--sc-n:${id}-->`
1172
+ };
1173
+ }
1174
+ const runParked = (entry, owner) => entry.out || (entry.out = entry.render(owner));
1175
+ function placeParked(node, nested, owner) {
1176
+ const out = expandParked(node, nested, owner);
1177
+ for (const entry of nested.values()) runParked(entry, owner);
1178
+ return out;
1179
+ }
1180
+ function expandParked(node, nested, owner) {
1181
+ if (Array.isArray(node)) {
1182
+ const out = node.map(n => expandParked(n, nested, owner));
1183
+ out.$slot = node.$slot;
1184
+ return out;
1185
+ }
1186
+ if (!node || node.t === undefined) return node;
1187
+ if (!node.h) return splitParked(node.t, nested, owner) || node;
1188
+ const out = [];
1189
+ node.t.forEach((t, i) => {
1190
+ out.push(splitParked(t, nested, owner) || {
1191
+ t
1192
+ });
1193
+ if (i < node.h.length) out.push({
1194
+ t: ["", ""],
1195
+ h: [node.h[i]],
1196
+ p: [node.p[i]]
1197
+ });
1198
+ });
1199
+ return out;
1200
+ }
1201
+ function splitParked(t, nested, owner) {
1202
+ const parts = typeof t === "string" ? t.split(PARKED) : [t];
1203
+ return parts.length > 1 ? parts.map((part, i) => i & 1 ? runParked(nested.get(+part), owner) : {
1204
+ t: part
1205
+ }) : undefined;
1206
+ }
1207
+ function createDocumentSlotProps(clientProps, frameId) {
1208
+ const counts = Object.create(null);
1209
+ let depsBatch = null;
1210
+ let depsN = 0;
1211
+ let wideSent = 0;
1212
+ const depsContext = sharedConfig.context;
1213
+ const noteDeps = (occurrence, reads, untracked) => {
1214
+ if (!depsContext || !depsContext.serialize || !depsContext.edges) return;
1215
+ const own = `sc-${frameId}-${occurrence}-`;
1216
+ const batch = () => {
1217
+ if (depsBatch) return depsBatch;
1218
+ queueMicrotask(() => {
1219
+ const b = {};
1220
+ for (const sid in depsBatch) b[sid] = packOccurrences(depsBatch[sid]);
1221
+ depsBatch = null;
1222
+ const wide = depsContext.edgeWide?.s || null;
1223
+ if (wide && wide.size > wideSent) {
1224
+ b["*"] = [...wide].slice(wideSent).join(" ");
1225
+ wideSent = wide.size;
1226
+ }
1227
+ if (depsN === 0 || Object.keys(b).length) depsContext.serialize(`sc:deps:${frameId}:${depsN++}`, b);
1228
+ });
1229
+ return depsBatch = Object.create(null);
1230
+ };
1231
+ const b = batch();
1232
+ if (reads) for (const sid of reads) if (!sid.startsWith(own)) (b[sid] ||= []).push(occurrence);
1233
+ if (untracked) (b["!"] ||= []).push(occurrence);
1234
+ };
1235
+ const getters = new Map();
1236
+ const repeats = new Map();
1237
+ const range = (occurrence, content, tail) => {
1238
+ const r = [{
1239
+ t: `<!--slot:${occurrence}:start-->`
1240
+ }, content, tail, {
1241
+ t: `<!--slot:${occurrence}:end-->`
1242
+ }];
1243
+ r.$slot = true;
1244
+ return r;
1245
+ };
1246
+ const zoneOwner = getOwner ? getOwner() : null;
1247
+ const scoped = (occurrence, render, owner) => {
1248
+ const id = `sc-${frameId}-${occurrence}-`;
1249
+ if (owner) return runWithOwner(owner, () => runWithHydrationScope(id, render));
1250
+ const run = () => Hydration ? Hydration({
1251
+ id,
1252
+ get children() {
1253
+ return render();
1254
+ }
1255
+ }) : runWithHydrationScope(id, render);
1256
+ return zoneOwner ? runWithOwner(zoneOwner, run) : run();
1257
+ };
1258
+ return new Proxy(Object.create(null), {
1259
+ has() {
1260
+ return true;
1261
+ },
1262
+ get(_, prop) {
1263
+ if (typeof prop !== "string") return undefined;
1264
+ if (prop === "then") return undefined;
1265
+ let fn = getters.get(prop);
1266
+ if (!fn) {
1267
+ fn = (...callArgs) => {
1268
+ if (callArgs.length === 0 || callArgs[0] === undefined) {
1269
+ return park(owner => suppressedFill(() => scoped(prop, () => {
1270
+ const value = clientProps[prop];
1271
+ return range(prop, typeof value === "function" ? value() : value);
1272
+ }, owner)));
1273
+ }
1274
+ const raw = callArgs[0];
1275
+ const rk = keyedId(prop, raw);
1276
+ const repeat = rk !== undefined && repeats.get(rk);
1277
+ if (repeat) return repeat;
1278
+ const occurrence = occurrenceId(prop, raw, counts);
1279
+ const slot = clientProps[prop];
1280
+ if (typeof slot !== "function") return range(occurrence, undefined);
1281
+ const context = sharedConfig.context;
1282
+ const recordKey = `sc:slot:${frameId}:${occurrence}`;
1283
+ const deferred = !!parked;
1284
+ let settleRecord;
1285
+ const declare = () => context && context.async && context.serialize(recordKey, new Promise(resolve => settleRecord = resolve));
1286
+ deferred || declare();
1287
+ try {
1288
+ const resolved = {};
1289
+ const liveArgs = sharedConfig.context && sharedConfig.context.live && sharedConfig.context.live.args;
1290
+ const vals = {};
1291
+ const evals = {};
1292
+ const states = {};
1293
+ const minted = {};
1294
+ const nestedOf = {};
1295
+ for (const key of Object.keys(raw)) {
1296
+ if (key === "$key") continue;
1297
+ const desc = Object.getOwnPropertyDescriptor(raw, key);
1298
+ let evaluate = null;
1299
+ let value;
1300
+ if (desc.get) {
1301
+ const get = desc.get;
1302
+ evaluate = () => unwrapThunks(get.call(raw));
1303
+ } else {
1304
+ value = desc.value;
1305
+ if (typeof value === "function") {
1306
+ const fn = value;
1307
+ evaluate = () => unwrapThunks(fn);
1308
+ }
1309
+ }
1310
+ if (evaluate) {
1311
+ evals[key] = evaluate;
1312
+ const stampBefore = scopeStamp();
1313
+ const outer = parked;
1314
+ const nested = nestedOf[key] = parked = new Map();
1315
+ try {
1316
+ value = evaluate();
1317
+ states[key] = {
1318
+ settled: true,
1319
+ last: value
1320
+ };
1321
+ } catch (err) {
1322
+ parked = outer;
1323
+ for (const entry of nested.values()) runParked(entry);
1324
+ nested.clear();
1325
+ const blocked = ssrHandleError && ssrHandleError(err);
1326
+ if (!blocked) throw err;
1327
+ const state = states[key] = {
1328
+ settled: false,
1329
+ last: undefined
1330
+ };
1331
+ value = retryArgUntilSettled(evaluate, blocked, key, occurrence, v => {
1332
+ state.settled = true;
1333
+ state.last = v;
1334
+ if (liveArgs) liveArgs.commit();
1335
+ });
1336
+ }
1337
+ parked = outer;
1338
+ if (scopeStamp() !== stampBefore) minted[key] = true;
1339
+ }
1340
+ vals[key] = value;
1341
+ }
1342
+ const regions = [];
1343
+ for (const key of Object.keys(vals)) {
1344
+ const value = vals[key];
1345
+ if (isContainerTraced(value)) {
1346
+ documentNeeds("trace");
1347
+ resolved[key] = value;
1348
+ } else if (isServerContent(value)) {
1349
+ const childId = `${frameId}.${occurrence}.${key}`;
1350
+ const region = {
1351
+ key,
1352
+ childId,
1353
+ value,
1354
+ nested: nestedOf[key],
1355
+ used: false,
1356
+ locked: false
1357
+ };
1358
+ regions.push(region);
1359
+ documentNeeds("regions");
1360
+ resolved[key] = () => {
1361
+ if (region.locked) return [];
1362
+ region.used = true;
1363
+ return [{
1364
+ t: frameElementOpen(childId)
1365
+ }, region.nested && region.nested.size ? placeParked(value, region.nested, getOwner()) : value, {
1366
+ t: FRAME_ELEMENT_CLOSE
1367
+ }];
1368
+ };
1369
+ } else if (ssrAsyncValue && isAsyncValue(value)) {
1370
+ let readable = value;
1371
+ if (typeof value.then !== "function") {
1372
+ const {
1373
+ first,
1374
+ rest
1375
+ } = tapFirstYield(value);
1376
+ readable = first;
1377
+ vals[key] = rest;
1378
+ }
1379
+ const read = ssrAsyncValue(readable);
1380
+ Object.defineProperty(resolved, key, {
1381
+ get: read,
1382
+ enumerable: true,
1383
+ configurable: true
1384
+ });
1385
+ } else {
1386
+ resolved[key] = vals[key] = noteTraces(value, documentNeeds);
1387
+ }
1388
+ }
1389
+ for (const key in nestedOf) if (!regions.some(r => r.key === key)) for (const entry of nestedOf[key].values()) runParked(entry);
1390
+ const flip = () => {
1391
+ if (flip.done || !context) return;
1392
+ flip.done = true;
1393
+ for (const region of regions) {
1394
+ if (region.used) continue;
1395
+ region.locked = true;
1396
+ context.serialize(`sc:region:${region.childId}`, resolveRegionHtml(context, region.nested && region.nested.size ? placeParked(region.value, region.nested) : region.value));
1397
+ }
1398
+ };
1399
+ flip.$lhSkip = true;
1400
+ const finish = owner => {
1401
+ if (deferred) declare();
1402
+ try {
1403
+ const tracked = trackFillReads(() => suppressedFill(() => scoped(occurrence, () => range(occurrence, slot(resolved), flip), owner)));
1404
+ const out = tracked.result;
1405
+ noteDeps(occurrence, tracked.reads, tracked.untracked || hasAsyncHoles(out));
1406
+ if (context) {
1407
+ const args = {};
1408
+ for (const key of Object.keys(vals)) {
1409
+ const value = vals[key];
1410
+ const region = regions.find(r => r.key === key);
1411
+ if (region) {
1412
+ args[key] = {
1413
+ $frame: region.childId
1414
+ };
1415
+ continue;
1416
+ }
1417
+ if (!isContainerTraced(value) && isServerContent(value)) continue;
1418
+ args[key] = argBorderForm(value, documentNeeds);
1419
+ }
1420
+ settleRecord ? settleRecord({
1421
+ ...args
1422
+ }) : context.serialize(recordKey, {
1423
+ ...args
1424
+ });
1425
+ if (liveArgs) {
1426
+ for (const key of Object.keys(evals)) {
1427
+ if (regions.some(r => r.key === key)) continue;
1428
+ if (minted[key]) continue;
1429
+ const ledgerKey = `${frameId}:${occurrence}:${key}`;
1430
+ openArgBinding(liveArgs, ledgerKey, occurrence, key, evals[key], states[key], value => {
1431
+ args[key] = argBorderForm(value, documentNeeds);
1432
+ liveArgs.slot(frameId, occurrence, {
1433
+ ...args
1434
+ });
1435
+ });
1436
+ }
1437
+ }
1438
+ }
1439
+ return out;
1440
+ } catch (error) {
1441
+ settleRecord && settleRecord(undefined);
1442
+ throw error;
1443
+ }
1444
+ };
1445
+ const out = park(finish);
1446
+ if (rk !== undefined && rk === occurrence) repeats.has(rk) || repeats.set(rk, out);
1447
+ return out;
1448
+ } catch (error) {
1449
+ settleRecord && settleRecord(undefined);
1450
+ throw error;
1451
+ }
1452
+ };
1453
+ fn.$lhSkip = true;
1454
+ getters.set(prop, fn);
1455
+ }
1456
+ return fn;
1457
+ }
1458
+ });
1459
+ }
1460
+ const FRAME_TAG = "solid-frame";
1461
+ const FRAME_ID_ATTR = "data-fid";
1462
+ const FRAME_ARGS_ATTR = "data-fa";
1463
+ function frameElementOpen(id, args) {
1464
+ const escaped = sharedConfig.context ? sharedConfig.context.escape(String(id), true) : String(id);
1465
+ return `<${FRAME_TAG} ${FRAME_ID_ATTR}="${escaped}"${args ? ` ${FRAME_ARGS_ATTR}="${args}"` : ""} style="display:contents">`;
1466
+ }
1467
+ const DOCUMENT_SITES = Symbol();
1468
+ function contextSites(ctx) {
1469
+ if (ctx[DOCUMENT_SITES]) return ctx[DOCUMENT_SITES];
1470
+ const proto = Object.getPrototypeOf(ctx);
1471
+ if (proto && proto[DOCUMENT_SITES]) return ctx[DOCUMENT_SITES] = proto[DOCUMENT_SITES];
1472
+ if (proto && typeof proto.escape === "function") return ctx[DOCUMENT_SITES] = contextSites(proto);
1473
+ return ctx[DOCUMENT_SITES] = {
1474
+ byOwner: new Map(),
1475
+ counts: Object.create(null)
1476
+ };
1477
+ }
1478
+ function mintSiteId(sites, fnId) {
1479
+ const n = sites.counts[fnId] || 0;
1480
+ sites.counts[fnId] = n + 1;
1481
+ return n === 0 ? fnId : fnId + "~" + (n + 1);
1482
+ }
1483
+ function documentSiteId(fnId) {
1484
+ const ctx = sharedConfig.context;
1485
+ if (!ctx) return fnId;
1486
+ const sites = contextSites(ctx);
1487
+ const owner = getOwner ? getOwner() : null;
1488
+ if (!owner) return mintSiteId(sites, fnId);
1489
+ let byFn = sites.byOwner.get(owner);
1490
+ if (!byFn) sites.byOwner.set(owner, byFn = new Map());
1491
+ const prev = byFn.get(fnId);
1492
+ if (prev) return prev;
1493
+ const siteId = mintSiteId(sites, fnId);
1494
+ byFn.set(fnId, siteId);
1495
+ return siteId;
1496
+ }
1497
+ const FRAME_ELEMENT_CLOSE = `</${FRAME_TAG}>`;
1498
+ function documentNeeds(name) {
1499
+ const ctx = sharedConfig.context;
1500
+ const live = ctx && ctx.live;
1501
+ if (!live || !ctx.serialize) return;
1502
+ const tiers = live.tiers || (live.tiers = []);
1503
+ if (tiers.includes(name)) return;
1504
+ tiers.push(name);
1505
+ ctx.serialize("sc:tiers", tiers.slice());
1506
+ const url = live.tierUrls && live.tierUrls[name];
1507
+ if (url && ctx.registerAsset) ctx.registerAsset("module", url);
1508
+ }
1509
+ function armDocumentLiveHoles(ctx) {
1510
+ if (!ctx || ctx.liveHoles !== undefined) return;
1511
+ const live = ctx.live;
1512
+ if (live && live.holes !== undefined) {
1513
+ ctx.liveHoles = live.holes;
1514
+ if (live.holes) {
1515
+ ctx.commit = live.commit;
1516
+ ctx.commitEpoch = live.commitEpoch;
1517
+ ctx.unsettled = live.unsettled;
1518
+ }
1519
+ return;
1520
+ }
1521
+ if (!live || !ctx.async || !ctx.serialize || typeof ReadableStream !== "function") {
1522
+ ctx.liveHoles = null;
1523
+ if (live) live.holes = null;
1524
+ return;
1525
+ }
1526
+ let unsettled = false;
1527
+ const bindings = new Map();
1528
+ let epoch = 0;
1529
+ let sweepScheduled = false;
1530
+ let closed = false;
1531
+ let swept = null;
1532
+ const sweep = () => {
1533
+ epoch++;
1534
+ const r = swept = {};
1535
+ try {
1536
+ for (const b of [...bindings.values()]) {
1537
+ try {
1538
+ b.sweep();
1539
+ } catch (_) {
1540
+ }
1541
+ }
1542
+ } finally {
1543
+ swept = null;
1544
+ }
1545
+ for (const _ in r) return push({
1546
+ r
1547
+ });
1548
+ };
1549
+ const scheduleSweep = () => {
1550
+ if (closed || sweepScheduled || !bindings.size) return;
1551
+ sweepScheduled = true;
1552
+ queueMicrotask(() => {
1553
+ sweepScheduled = false;
1554
+ if (!closed) sweep();
1555
+ });
1556
+ };
1557
+ let channel;
1558
+ ctx.serialize("sc:live", new ReadableStream({
1559
+ start(c) {
1560
+ channel = c;
1561
+ },
1562
+ cancel() {
1563
+ closed = true;
1564
+ }
1565
+ }));
1566
+ const push = batch => {
1567
+ if (!closed) channel.enqueue(batch);
1568
+ };
1569
+ const write = r => swept ? Object.assign(swept, r) : push({
1570
+ r
1571
+ });
1572
+ ctx.liveHoles = live.holes = createLiveHoles({
1573
+ openBinding(key, b) {
1574
+ documentNeeds("wire");
1575
+ bindings.set(key, b);
1576
+ },
1577
+ closeBinding(key) {
1578
+ bindings.delete(key);
1579
+ },
1580
+ hole(key, value) {
1581
+ write({
1582
+ ["hole:" + key]: {
1583
+ kind: "html",
1584
+ value,
1585
+ digest: textDigest(value)
1586
+ }
1587
+ });
1588
+ },
1589
+ attr(key, value, removed) {
1590
+ const record = {
1591
+ kind: "attrs",
1592
+ value,
1593
+ digest: textDigest(value)
1594
+ };
1595
+ if (removed && removed.length) record.removed = removed;
1596
+ write({
1597
+ ["attr:" + key]: record
1598
+ });
1599
+ },
1600
+ error(key, error) {
1601
+ push({
1602
+ r: {
1603
+ [`hole:${key}:error`]: error
1604
+ }
1605
+ });
1606
+ },
1607
+ commit: scheduleSweep,
1608
+ get epoch() {
1609
+ return epoch;
1610
+ }
1611
+ }, true, () => !unsettled, ctx._errorScope);
1612
+ ctx.commit = live.commit = scheduleSweep;
1613
+ ctx.commitEpoch = live.commitEpoch = () => epoch;
1614
+ ctx.unsettled = live.unsettled = () => {
1615
+ unsettled = true;
1616
+ };
1617
+ live.args = {
1618
+ openBinding(key, b) {
1619
+ bindings.set(key, b);
1620
+ },
1621
+ closeBinding(key) {
1622
+ bindings.delete(key);
1623
+ },
1624
+ slot(fid, occurrence, args) {
1625
+ push({
1626
+ r: {
1627
+ [`slot:${occurrence}`]: {
1628
+ kind: "slot",
1629
+ args
1630
+ }
1631
+ },
1632
+ fid
1633
+ });
1634
+ },
1635
+ commit: scheduleSweep
1636
+ };
1637
+ live.error = (fid, error) => {
1638
+ push({
1639
+ r: {
1640
+ ":error": error
1641
+ },
1642
+ fid
1643
+ });
1644
+ };
1645
+ live.end = () => {
1646
+ if (closed) return;
1647
+ if (bindings.size) sweep();
1648
+ closed = true;
1649
+ channel.close();
1650
+ };
1651
+ }
1652
+ function frameTransformDirectResult(value, {
1653
+ id,
1654
+ args,
1655
+ tierUrls
1656
+ }) {
1657
+ if (typeof value !== "function") return value;
1658
+ const component = value;
1659
+ const address = frameAddress(id, args);
1660
+ const wrapped = props => {
1661
+ const siteId = documentSiteId(id);
1662
+ return [{
1663
+ t: frameElementOpen(siteId, address.slice(id.length + 1))
1664
+ },
1665
+ serverOwned(() => {
1666
+ const page = sharedConfig.context;
1667
+ armDocumentLiveHoles(page);
1668
+ if (tierUrls && page && page.live && !page.live.tierUrls) page.live.tierUrls = tierUrls;
1669
+ const ctx = Object.create(page);
1670
+ ctx.frameId = siteId;
1671
+ sharedConfig.context = ctx;
1672
+ try {
1673
+ const slotProps = createDocumentSlotProps(props, siteId);
1674
+ const live = !!wrapped[LIVE_SOURCE];
1675
+ if (live) documentNeeds("wire");
1676
+ return serverComponentScope(() => component(slotProps), live);
1677
+ } finally {
1678
+ sharedConfig.context = page;
1679
+ }
1680
+ }), {
1681
+ t: FRAME_ELEMENT_CLOSE
1682
+ }];
1683
+ };
1684
+ wrapped[SERVER_COMPONENT] = id;
1685
+ wrapped[SERVER_COMPONENT_SOURCE] = component;
1686
+ wrapped[SERVER_COMPONENT_ADDRESS] = address;
1687
+ return wrapped;
1688
+ }
1689
+ function resolveRegionHtml(ctx, node) {
1690
+ const res = ctx.resolve(node);
1691
+ if (!res || !res.t) return String(res ?? "");
1692
+ if (!res.h || !res.h.length) return res.t[0];
1693
+ return Promise.all(res.p).then(() => {
1694
+ let out = Promise.resolve(res.t[0]);
1695
+ for (let i = 0; i < res.h.length; i++) {
1696
+ const hole = res.h[i];
1697
+ const tail = res.t[i + 1];
1698
+ out = out.then(acc => Promise.resolve(resolveRegionHtml(ctx, hole)).then(part => acc + part + tail));
1699
+ }
1700
+ return out;
1701
+ });
1702
+ }
1703
+ function isServerContent(value) {
1704
+ if (value && typeof value === "object") {
1705
+ if ("t" in value) return true;
1706
+ if (Array.isArray(value) && value.length > 0) {
1707
+ for (const item of value) {
1708
+ if (!(item && typeof item === "object" && "t" in item)) return false;
1709
+ }
1710
+ return true;
1711
+ }
1712
+ }
1713
+ return false;
1714
+ }
1715
+ function unwrapThunks(value) {
1716
+ for (let d = 0; typeof value === "function" && d < 16; d++) value = value();
1717
+ return value;
1718
+ }
1719
+ function contentArgError(key, occurrence) {
1720
+ return new Error("Async slot arg resolved to JSX (arg '" + key + "' of " + occurrence + "). Async args must resolve to serializable values; render async content through a boundary instead.");
1721
+ }
1722
+ function retryArgUntilSettled(evaluate, blocked, key, occurrence, onSettle) {
1723
+ const owner = getOwner();
1724
+ return new Promise((resolve, reject) => {
1725
+ const retry = () => {
1726
+ try {
1727
+ const value = owner ? runWithOwner(owner, evaluate) : evaluate();
1728
+ if (isServerContent(value)) {
1729
+ reject(contentArgError(key, occurrence));
1730
+ return;
1731
+ }
1732
+ if (onSettle) onSettle(value);
1733
+ resolve(value);
1734
+ } catch (err) {
1735
+ const next = ssrHandleError && ssrHandleError(err);
1736
+ if (next) next.then(retry, retry);else reject(err);
1737
+ }
1738
+ };
1739
+ blocked.then(retry, retry);
1740
+ });
1741
+ }
1742
+ function openArgBinding(sink, ledgerKey, occurrence, key, evaluate, state, emit) {
1743
+ const owner = getOwner();
1744
+ sink.openBinding(ledgerKey, {
1745
+ sweep() {
1746
+ if (!state.settled) return;
1747
+ let value;
1748
+ const stampBefore = scopeStamp();
1749
+ try {
1750
+ value = owner ? runWithOwner(owner, evaluate) : evaluate();
1751
+ } catch (err) {
1752
+ const blocked = ssrHandleError && ssrHandleError(err);
1753
+ if (!blocked) {
1754
+ sink.closeBinding(ledgerKey);
1755
+ emit(Promise.reject(err instanceof Error ? err : new Error(String(err))));
1756
+ return;
1757
+ }
1758
+ if (scopeStamp() !== stampBefore) {
1759
+ sink.closeBinding(ledgerKey);
1760
+ return;
1761
+ }
1762
+ state.settled = false;
1763
+ emit(retryArgUntilSettled(evaluate, blocked, key, occurrence, v => {
1764
+ state.settled = true;
1765
+ state.last = v;
1766
+ sink.commit();
1767
+ }));
1768
+ return;
1769
+ }
1770
+ if (scopeStamp() !== stampBefore) {
1771
+ sink.closeBinding(ledgerKey);
1772
+ return;
1773
+ }
1774
+ if (value === state.last) return;
1775
+ state.last = value;
1776
+ if (isServerContent(value)) {
1777
+ sink.closeBinding(ledgerKey);
1778
+ emit(Promise.reject(contentArgError(key, occurrence)));
1779
+ return;
1780
+ }
1781
+ emit(value);
1782
+ }
1783
+ });
1784
+ }
1785
+ function createSlotProps(sink, frame) {
1786
+ const counts = Object.create(null);
1787
+ const getters = new Map();
1788
+ const repeats = new Map();
1789
+ let pass = null;
1790
+ let passRepeats = null;
1791
+ const recs = new Map();
1792
+ const forget = occurrence => {
1793
+ const rec = recs.get(occurrence);
1794
+ if (!rec) return;
1795
+ recs.delete(occurrence);
1796
+ for (const key in rec.vals) sink.closeBinding(`${occurrence}:${key}`);
1797
+ };
1798
+ const needs = sink.needs || (() => {});
1799
+ return new Proxy(Object.create(null), {
1800
+ has() {
1801
+ return true;
1802
+ },
1803
+ get(_, prop) {
1804
+ if (typeof prop !== "string") return undefined;
1805
+ if (prop === "then") return undefined;
1806
+ let fn = getters.get(prop);
1807
+ if (!fn) {
1808
+ fn = (...callArgs) => {
1809
+ if (callArgs.length === 0 || callArgs[0] === undefined) {
1810
+ return slotRange(prop);
1811
+ }
1812
+ const live = sharedConfig.context && sharedConfig.context.liveHoles;
1813
+ const sweeping = !!live && live.sweeping;
1814
+ let rmap = repeats;
1815
+ if (sweeping) {
1816
+ if (pass !== live.visit) passRepeats = new Map();
1817
+ pass = live.visit;
1818
+ rmap = passRepeats;
1819
+ }
1820
+ const rk = keyedId(prop, callArgs[0]);
1821
+ const repeat = rk !== undefined && rmap.get(rk);
1822
+ if (repeat) return repeat;
1823
+ if (sweeping && !live.scope) {
1824
+ live.gateHit = true;
1825
+ return {
1826
+ t: "",
1827
+ $slot: true
1828
+ };
1829
+ }
1830
+ const raw = callArgs[0];
1831
+ let occurrence = keyedId(prop, raw);
1832
+ if (occurrence === undefined) {
1833
+ const positional = sweeping ? undefined : occurrenceId(prop, raw, counts);
1834
+ occurrence = live ? live.slotId(prop, positional) : positional;
1835
+ }
1836
+ if (sweeping && live.dry) return slotRange(occurrence);
1837
+ const prev = recs.get(occurrence);
1838
+ let changed = !prev;
1839
+ const digest = live && live.scope ? argDigest : noDigest;
1840
+ const args = {};
1841
+ const vals = {};
1842
+ const opened = [];
1843
+ for (const key of Object.keys(raw)) {
1844
+ if (key === "$key") continue;
1845
+ const childId = `${frame.id}.${occurrence}.${key}`;
1846
+ const ctx = sharedConfig.context;
1847
+ const origRegister = ctx.registerFragment;
1848
+ ctx.registerFragment = (fragKey, fragOptions) => {
1849
+ sink.tagRegion(fragKey, childId);
1850
+ return origRegister.call(ctx, fragKey, fragOptions);
1851
+ };
1852
+ try {
1853
+ const desc = Object.getOwnPropertyDescriptor(raw, key);
1854
+ let evaluate = null;
1855
+ let value;
1856
+ let state = null;
1857
+ let pending = false;
1858
+ const stampBefore = scopeStamp();
1859
+ try {
1860
+ if (desc.get) {
1861
+ const get = desc.get;
1862
+ evaluate = () => unwrapThunks(get.call(raw));
1863
+ value = evaluate();
1864
+ } else {
1865
+ value = desc.value;
1866
+ if (typeof value === "function") {
1867
+ const fn = value;
1868
+ evaluate = () => unwrapThunks(fn);
1869
+ value = evaluate();
1870
+ }
1871
+ }
1872
+ } catch (err) {
1873
+ const blocked = ssrHandleError && ssrHandleError(err);
1874
+ if (!blocked) throw err;
1875
+ state = {
1876
+ settled: false,
1877
+ last: undefined
1878
+ };
1879
+ pending = true;
1880
+ const pendingState = state;
1881
+ value = retryArgUntilSettled(evaluate, blocked, key, occurrence, v => {
1882
+ pendingState.settled = true;
1883
+ pendingState.last = v;
1884
+ sink.commit();
1885
+ });
1886
+ }
1887
+ const mintedEval = scopeStamp() !== stampBefore;
1888
+ const t = typeof value;
1889
+ if (value == null || t === "string" || t === "number" || t === "boolean") {
1890
+ args[key] = value;
1891
+ vals[key] = digest(value);
1892
+ if (evaluate) state = {
1893
+ settled: true,
1894
+ last: value
1895
+ };
1896
+ } else if (!isContainerTraced(value) && isServerContent(value)) {
1897
+ const resolved = ctx.resolve(value);
1898
+ if (resolved.h.length) {
1899
+ throw new Error("Async server content in a slot arg needs a boundary (arg '" + key + "' of " + occurrence + "). Wrap the async read in a <Suspense>, or move it above the slot.");
1900
+ }
1901
+ vals[key] = "<" + resolved.t[0];
1902
+ if (!prev || prev.vals[key] !== vals[key]) sink.region(childId, resolved.t[0]);
1903
+ args[key] = {
1904
+ $frame: childId
1905
+ };
1906
+ } else {
1907
+ vals[key] = pending ? PENDING_ARG : digest(value);
1908
+ if (prev && prev.vals[key] === vals[key]) args[key] = prev.args[key];else {
1909
+ const ref = prev ? `arg:${occurrence}:${key}@${sink.nextArgRef(`${occurrence}:${key}`)}` : `arg:${occurrence}:${key}`;
1910
+ if (prev) sink.mintRef(ref);
1911
+ ctx.serialize(ref, argBorderForm(value, needs));
1912
+ args[key] = {
1913
+ $ref: ref
1914
+ };
1915
+ }
1916
+ if (evaluate && !state) state = {
1917
+ settled: true,
1918
+ last: value
1919
+ };
1920
+ }
1921
+ if (prev && prev.vals[key] !== vals[key]) changed = true;
1922
+ if (evaluate && state && !mintedEval) opened.push({
1923
+ key,
1924
+ evaluate,
1925
+ state
1926
+ });
1927
+ } finally {
1928
+ ctx.registerFragment = origRegister;
1929
+ }
1930
+ }
1931
+ if (prev) for (const key in prev.vals) if (!(key in vals)) changed = true;
1932
+ const rec = changed ? {
1933
+ args,
1934
+ vals
1935
+ } : prev;
1936
+ if (changed) {
1937
+ recs.set(occurrence, rec);
1938
+ sink.slot(occurrence, {
1939
+ ...args
1940
+ });
1941
+ }
1942
+ if (live && live.visit) live.seen(occurrence, () => recs.get(occurrence) === rec && forget(occurrence));
1943
+ const ctx = sharedConfig.context;
1944
+ for (const b of opened) {
1945
+ const key = b.key;
1946
+ const ledgerKey = `${occurrence}:${key}`;
1947
+ openArgBinding(sink, ledgerKey, occurrence, key, b.evaluate, b.state, value => {
1948
+ const t = typeof value;
1949
+ if (value == null || t === "string" || t === "number" || t === "boolean") {
1950
+ rec.args[key] = value;
1951
+ } else {
1952
+ const ref = `arg:${occurrence}:${key}@${sink.nextArgRef(ledgerKey)}`;
1953
+ sink.mintRef(ref);
1954
+ ctx.serialize(ref, argBorderForm(value, needs));
1955
+ rec.args[key] = {
1956
+ $ref: ref
1957
+ };
1958
+ }
1959
+ rec.vals[key] = digest(value);
1960
+ sink.slot(occurrence, {
1961
+ ...rec.args
1962
+ });
1963
+ });
1964
+ }
1965
+ const out = slotRange(occurrence);
1966
+ if (rk !== undefined && rk === occurrence) rmap.set(rk, out);
1967
+ return out;
1968
+ };
1969
+ fn.$lhSkip = true;
1970
+ getters.set(prop, fn);
1971
+ }
1972
+ return fn;
1973
+ }
1974
+ });
1975
+ }
1976
+ function copyInitHeaders(init) {
1977
+ if (!init || !init.getSetCookie) return new Headers(init);
1978
+ const headers = new Headers();
1979
+ init.forEach((value, key) => {
1980
+ if (key !== "set-cookie") headers.append(key, value);
1981
+ });
1982
+ for (const cookie of init.getSetCookie()) headers.append("Set-Cookie", cookie);
1983
+ return headers;
1984
+ }
1985
+ function serverComponentResponse(component, options = {}, init = {}) {
1986
+ const {
1987
+ id = "",
1988
+ version = 1
1989
+ } = options.frame || {};
1990
+ const live = !!options.live;
1991
+ const headers = copyInitHeaders(init.headers);
1992
+ headers.set(FRAME_STREAM_HEADER, id);
1993
+ headers.set("X-Content-Raw", "1");
1994
+ if (live) {
1995
+ headers.set("Content-Type", "text/event-stream");
1996
+ headers.set("Cache-Control", "no-store");
1997
+ headers.set("X-Accel-Buffering", "no");
1998
+ } else headers.set("Content-Type", "application/x-frame-stream");
1999
+ const frame = live ? createEventChunk : createChunk;
2000
+ const teardown = new AbortController();
2001
+ const disarm = followSignal(options.signal, teardown);
2002
+ const stream = renderServerComponent(component, {
2003
+ ...options,
2004
+ signal: teardown.signal,
2005
+ frame: {
2006
+ id,
2007
+ version
2008
+ }
2009
+ });
2010
+ let closed = false;
2011
+ let stopLive = null;
2012
+ let failed = false;
2013
+ const body = new ReadableStream({
2014
+ start(controller) {
2015
+ const end = () => {
2016
+ if (closed) return;
2017
+ closed = true;
2018
+ disarm();
2019
+ if (stopLive) stopLive();
2020
+ try {
2021
+ controller.close();
2022
+ } catch (_) {}
2023
+ };
2024
+ if (teardown.signal.aborted) return end();
2025
+ if (live) stopLive = armLiveBody(controller, () => {
2026
+ closed = true;
2027
+ disarm();
2028
+ teardown.abort();
2029
+ });
2030
+ stream.pipe({
2031
+ write(message) {
2032
+ if (message.r && ":error" in message.r) failed = true;
2033
+ if (closed) return;
2034
+ try {
2035
+ controller.enqueue(frame(JSON.stringify(message)));
2036
+ } catch (_) {
2037
+ closed = true;
2038
+ }
2039
+ },
2040
+ end,
2041
+ [ANNOUNCE](tiers) {
2042
+ if (tiers.length) headers.set(FRAME_TIERS_HEADER, tiers.join(","));
2043
+ }
2044
+ });
2045
+ },
2046
+ cancel() {
2047
+ closed = true;
2048
+ disarm();
2049
+ if (stopLive) stopLive();
2050
+ teardown.abort({
2051
+ [DISCONNECTED]: true
2052
+ });
2053
+ }
2054
+ });
2055
+ if (failed) {
2056
+ headers.set("Cache-Control", "no-store");
2057
+ for (const name of [...headers.keys()]) if (name === "surrogate-control" || name.endsWith("cdn-cache-control")) headers.delete(name);
2058
+ }
2059
+ return new Response(body, {
2060
+ status: init.status || 200,
2061
+ headers
2062
+ });
2063
+ }
2064
+ function followSignal(upstream, controller) {
2065
+ if (!upstream) return () => {};
2066
+ if (upstream.aborted) {
2067
+ controller.abort(upstream.reason);
2068
+ return () => {};
2069
+ }
2070
+ const forward = () => controller.abort(upstream.reason);
2071
+ upstream.addEventListener("abort", forward, {
2072
+ once: true
2073
+ });
2074
+ return () => upstream.removeEventListener("abort", forward);
2075
+ }
2076
+ function frameTransformResult(event, result, context) {
2077
+ let init;
2078
+ if (isResponseEnvelope(result)) {
2079
+ const {
2080
+ response,
2081
+ value
2082
+ } = result;
2083
+ if (typeof value !== "function") return result;
2084
+ init = response ? {
2085
+ headers: response.headers,
2086
+ status: response.status
2087
+ } : undefined;
2088
+ result = value;
2089
+ }
2090
+ if (typeof result !== "function") return result;
2091
+ if (context && context.collectsFlight) return init ? {
2092
+ response: init,
2093
+ value: result
2094
+ } : result;
2095
+ const invocation = getEventServerFunctionInvocation(event);
2096
+ const live = !!(invocation && invocation.live);
2097
+ const have = live ? decodeHaveList(requestHeader(event, FRAME_HAVE_HEADER)) : undefined;
2098
+ if (live && invocation.broadcast && invocation.shareKey !== undefined) return broadcastResponse(invocation.id + "\0" + invocation.shareKey, result, {
2099
+ frame: {
2100
+ id: invocation.id || ""
2101
+ },
2102
+ live: true
2103
+ }, requestSignal(event), have, init);
2104
+ return serverComponentResponse(result, {
2105
+ frame: {
2106
+ id: invocation && invocation.id || ""
2107
+ },
2108
+ signal: requestSignal(event),
2109
+ live,
2110
+ resume: have && {
2111
+ have
2112
+ }
2113
+ }, init);
2114
+ }
2115
+ const HOLE_SOURCE = Symbol("solid.frames.holeSource");
2116
+ const BROADCASTS = new Map();
2117
+ function broadcastResponse(key, component, options, signal, have, init) {
2118
+ let shared = BROADCASTS.get(key);
2119
+ if (!shared || shared.ended) shared = startBroadcast(key, component, options);
2120
+ return tapResponse(shared, signal, have, init);
2121
+ }
2122
+ function startBroadcast(key, component, options) {
2123
+ const shared = {
2124
+ key,
2125
+ id: options.frame.id,
2126
+ start: null,
2127
+ taps: new Set(),
2128
+ records: new Map(),
2129
+ data: [],
2130
+ kept: 0,
2131
+ attrs: new Map(),
2132
+ tiers: new Set(["wire"]),
2133
+ failed: false,
2134
+ ended: false,
2135
+ teardown: new AbortController()
2136
+ };
2137
+ BROADCASTS.set(key, shared);
2138
+ const stream = renderServerComponent(component, {
2139
+ ...options,
2140
+ broadcast: (key, text) => shared.attrs.set(key, text),
2141
+ signal: shared.teardown.signal
2142
+ });
2143
+ const run = () => stream.pipe({
2144
+ write(message) {
2145
+ const bytes = createEventChunk(JSON.stringify(message));
2146
+ if (message.type === "start") return void (shared.start = bytes);
2147
+ retain(shared, message);
2148
+ for (const tap of shared.taps) tap.write(bytes);
2149
+ },
2150
+ end() {
2151
+ shared.ended = true;
2152
+ if (BROADCASTS.get(key) === shared) BROADCASTS.delete(key);
2153
+ for (const tap of [...shared.taps]) tap.end();
2154
+ },
2155
+ [ANNOUNCE](tiers) {
2156
+ for (const tier of tiers) shared.tiers.add(tier);
2157
+ }
2158
+ });
2159
+ const store = globalThis[RequestContext];
2160
+ store ? store.run(broadcastEvent(), run) : run();
2161
+ return shared;
2162
+ }
2163
+ function broadcastEvent() {
2164
+ const event = {
2165
+ broadcast: true
2166
+ };
2167
+ for (const name of ["request", "locals", "clientAddress", "nativeEvent"]) Object.defineProperty(event, name, {
2168
+ get() {
2169
+ console.warn(`A broadcast server component read the request (\`event.${name}\`). Its answer is ` + "shared by every viewer; read per-viewer state in the server function body instead.");
2170
+ return undefined;
2171
+ }
2172
+ });
2173
+ return event;
2174
+ }
2175
+ function retain(shared, message) {
2176
+ if (message.tiers) for (const tier of message.tiers) shared.tiers.add(tier);
2177
+ if (!message.r) {
2178
+ shared.data.push(message);
2179
+ if (shared.data.length > 64 && shared.data.length > 2 * shared.kept) shared.kept = (shared.data = referencedData(shared)).length;
2180
+ return;
2181
+ }
2182
+ const {
2183
+ id,
2184
+ version
2185
+ } = message;
2186
+ for (const k in message.r) {
2187
+ let record = message.r[k];
2188
+ if (k === ":error") shared.failed = true;
2189
+ if (k === "") for (const [rk, e] of shared.records) if (e.id === id) shared.records.delete(rk);
2190
+ if (record && record[HOLE_SOURCE]) record = record[HOLE_SOURCE];
2191
+ const rk = id + "\0" + k;
2192
+ const prev = shared.records.get(rk);
2193
+ if (prev && record && record.kind === "attrs" && prev.record.removed) {
2194
+ const removed = new Set(prev.record.removed);
2195
+ if (record.removed) for (const name of record.removed) removed.add(name);
2196
+ record = {
2197
+ ...record,
2198
+ removed: [...removed]
2199
+ };
2200
+ }
2201
+ shared.records.delete(rk);
2202
+ shared.records.set(rk, {
2203
+ id,
2204
+ version,
2205
+ k,
2206
+ record
2207
+ });
2208
+ }
2209
+ }
2210
+ function referencedData(shared) {
2211
+ const refs = new Set();
2212
+ for (const {
2213
+ record
2214
+ } of shared.records.values()) if (record && typeof record === "object") for (const m of JSON.stringify(record).matchAll(/"\$ref":"((?:[^"\\]|\\.)*)"/g)) refs.add(JSON.parse(`"${m[1]}"`));
2215
+ return shared.data.filter(m => typeof m.key !== "string" || refs.has(m.key));
2216
+ }
2217
+ function snapshot(shared, have) {
2218
+ const out = referencedData(shared);
2219
+ const root = shared.records.get(shared.id + "\0");
2220
+ const conditional = !!(have && root && root.record && have[""] === root.record.digest);
2221
+ let open = null;
2222
+ const put = (id, version, k, record) => {
2223
+ if (!open || open.id !== id) out.push(open = {
2224
+ id,
2225
+ version,
2226
+ r: {}
2227
+ });
2228
+ open.r[k] = record;
2229
+ };
2230
+ if (!conditional) {
2231
+ for (const {
2232
+ id,
2233
+ version,
2234
+ k,
2235
+ record
2236
+ } of shared.records.values()) put(id, version, k, record);
2237
+ return out;
2238
+ }
2239
+ const containers = [];
2240
+ for (const e of shared.records.values()) if (e.id === shared.id && (e.k === "" || /^seg:[^:]+$/.test(e.k)) && e.record) containers.push({
2241
+ e,
2242
+ value: e.record.value
2243
+ });
2244
+ for (const {
2245
+ k,
2246
+ record
2247
+ } of shared.records.values()) {
2248
+ if (!k.startsWith("hole:lh:") || k.endsWith(":error") || !record || record.value == null) continue;
2249
+ const n = k.slice(8);
2250
+ const startMark = `<!--lh:${n}-->`;
2251
+ const endMark = `<!--lh:/${n}-->`;
2252
+ for (const c of containers) {
2253
+ const start = c.value.indexOf(startMark);
2254
+ if (start < 0) continue;
2255
+ const end = c.value.indexOf(endMark, start);
2256
+ if (end < 0) continue;
2257
+ c.value = c.value.slice(0, start + startMark.length) + record.value + c.value.slice(end);
2258
+ break;
2259
+ }
2260
+ }
2261
+ for (const e of shared.records.values()) {
2262
+ const {
2263
+ id,
2264
+ version,
2265
+ k,
2266
+ record
2267
+ } = e;
2268
+ if (id !== shared.id) {
2269
+ put(id, version, k, record);
2270
+ continue;
2271
+ }
2272
+ if (k === "" || k === "seg::assets" || k.startsWith("hole:lh:") && !k.endsWith(":error")) continue;
2273
+ const seg = /^seg:([^:]+)(?::(.*))?$/.exec(k);
2274
+ if (seg && have[seg[1]] !== undefined && seg[2] !== "error") continue;
2275
+ if (seg && seg[2] === undefined) {
2276
+ const c = containers.find(c => c.e === e);
2277
+ if (c && c.value !== record.value) {
2278
+ put(id, version, k, withHoles({
2279
+ ...record,
2280
+ value: c.value,
2281
+ digest: textDigest(c.value)
2282
+ }, holeDigests(c.value, null)));
2283
+ continue;
2284
+ }
2285
+ }
2286
+ if (k.startsWith("attr:")) continue;
2287
+ put(id, version, k, record);
2288
+ }
2289
+ for (const c of containers) {
2290
+ const seg = c.e.k && /^seg:([^:]+)$/.exec(c.e.k);
2291
+ if (seg && have[seg[1]] === undefined) continue;
2292
+ for (const m of c.value.matchAll(HOLE_RANGE)) {
2293
+ const key = "lh:" + m[1];
2294
+ const digest = textDigest(stripHoleMarkers(m[2]));
2295
+ if (have[key] === digest) continue;
2296
+ put(shared.id, c.e.version, "hole:" + key, withHoles({
2297
+ kind: "html",
2298
+ value: m[2],
2299
+ digest
2300
+ }, holeDigests(m[2], null)));
2301
+ }
2302
+ for (const m of c.value.matchAll(ATTR_ADDRESS)) {
2303
+ const latest = shared.records.get(shared.id + "\0attr:" + m[1]);
2304
+ const text = latest ? latest.record.value : shared.attrs.get("lha:" + m[1]);
2305
+ if (text === undefined) continue;
2306
+ const digest = latest ? latest.record.digest : textDigest(text);
2307
+ if (have["lha:" + m[1]] === digest) continue;
2308
+ put(shared.id, c.e.version, "attr:" + m[1], latest ? latest.record : {
2309
+ kind: "attrs",
2310
+ value: text,
2311
+ digest
2312
+ });
2313
+ }
2314
+ }
2315
+ return out;
2316
+ }
2317
+ function tapResponse(shared, signal, have, init = {}) {
2318
+ const headers = copyInitHeaders(init.headers);
2319
+ headers.set(FRAME_STREAM_HEADER, shared.id);
2320
+ headers.set("X-Content-Raw", "1");
2321
+ headers.set("Content-Type", "text/event-stream");
2322
+ headers.set("Cache-Control", "no-store");
2323
+ headers.set("X-Accel-Buffering", "no");
2324
+ headers.set(FRAME_TIERS_HEADER, [...shared.tiers].join(","));
2325
+ let closed = false;
2326
+ let stopLive = null;
2327
+ let tap = null;
2328
+ const leave = () => {
2329
+ if (closed) return;
2330
+ closed = true;
2331
+ if (stopLive) stopLive();
2332
+ if (signal) signal.removeEventListener("abort", leave);
2333
+ shared.taps.delete(tap);
2334
+ if (!shared.taps.size && !shared.ended) {
2335
+ shared.ended = true;
2336
+ if (BROADCASTS.get(shared.key) === shared) BROADCASTS.delete(shared.key);
2337
+ shared.teardown.abort({
2338
+ [DISCONNECTED]: true
2339
+ });
2340
+ }
2341
+ };
2342
+ const body = new ReadableStream({
2343
+ start(controller) {
2344
+ tap = {
2345
+ write(bytes) {
2346
+ if (closed) return;
2347
+ try {
2348
+ controller.enqueue(bytes);
2349
+ } catch (_) {
2350
+ leave();
2351
+ }
2352
+ },
2353
+ end() {
2354
+ leave();
2355
+ try {
2356
+ controller.close();
2357
+ } catch (_) {}
2358
+ }
2359
+ };
2360
+ if (shared.start) controller.enqueue(shared.start);
2361
+ for (const message of snapshot(shared, have)) controller.enqueue(createEventChunk(JSON.stringify(message)));
2362
+ if (shared.ended || signal && signal.aborted) return tap.end();
2363
+ shared.taps.add(tap);
2364
+ stopLive = armLiveBody(controller, leave);
2365
+ if (signal) signal.addEventListener("abort", leave, {
2366
+ once: true
2367
+ });
2368
+ },
2369
+ cancel() {
2370
+ leave();
2371
+ }
2372
+ });
2373
+ if (shared.failed) headers.set("Cache-Control", "no-store");
2374
+ return new Response(body, {
2375
+ status: init.status || 200,
2376
+ headers
2377
+ });
2378
+ }
2379
+ function requestSignal(event) {
2380
+ const request = event && event.request;
2381
+ return request && request.signal instanceof AbortSignal ? request.signal : undefined;
2382
+ }
2383
+ function requestHeader(event, name) {
2384
+ const request = event && event.request;
2385
+ const headers = request && request.headers;
2386
+ return headers && typeof headers.get === "function" ? headers.get(name) : null;
2387
+ }
2388
+ async function frameTransformFlightResult(event, outcome, context) {
2389
+ const {
2390
+ value,
2391
+ data
2392
+ } = outcome;
2393
+ const regions = [];
2394
+ let serialized = data;
2395
+ if (data && typeof data === "object") {
2396
+ serialized = {};
2397
+ for (const source of Object.keys(data)) {
2398
+ const slice = data[source];
2399
+ if (!slice || typeof slice !== "object" || Array.isArray(slice)) {
2400
+ serialized[source] = slice;
2401
+ continue;
2402
+ }
2403
+ const keys = Object.keys(slice);
2404
+ const settled = await Promise.allSettled(keys.map(key => slice[key]));
2405
+ const out = serialized[source] = {};
2406
+ for (let i = 0; i < keys.length; i++) {
2407
+ const result = settled[i];
2408
+ const entry = result.status === "fulfilled" ? result.value : slice[keys[i]];
2409
+ if (typeof entry !== "function") {
2410
+ out[keys[i]] = entry;
2411
+ continue;
2412
+ }
2413
+ const address = entry[SERVER_COMPONENT_ADDRESS] || keys[i];
2414
+ regions.push({
2415
+ id: address,
2416
+ component: entry[SERVER_COMPONENT_SOURCE] || entry
2417
+ });
2418
+ if (SERVER_COMPONENT in entry) {
2419
+ out[keys[i]] = entry;
2420
+ } else {
2421
+ const reference = () => undefined;
2422
+ reference[SERVER_COMPONENT] = keys[i];
2423
+ reference[SERVER_COMPONENT_ADDRESS] = address;
2424
+ out[keys[i]] = reference;
2425
+ }
2426
+ }
2427
+ }
2428
+ }
2429
+ const invocation = getEventServerFunctionInvocation(event);
2430
+ const primary = typeof value === "function" ? {
2431
+ id: invocation && invocation.id || "",
2432
+ component: value
2433
+ } : undefined;
2434
+ if (!primary && !regions.length) return undefined;
2435
+ return frameFlightResponse({
2436
+ primary,
2437
+ regions,
2438
+ outcome: {
2439
+ value: primary ? undefined : value,
2440
+ data: serialized
2441
+ },
2442
+ codec: context && context.codec,
2443
+ signal: requestSignal(event)
2444
+ });
2445
+ }
2446
+ function frameFlightResponse({
2447
+ primary,
2448
+ regions = [],
2449
+ outcome,
2450
+ codec,
2451
+ signal
2452
+ }, init = {}) {
2453
+ const frames = primary ? [primary, ...regions] : regions;
2454
+ const headers = copyInitHeaders(init.headers);
2455
+ headers.set("Content-Type", "application/x-frame-stream");
2456
+ headers.set(FRAME_STREAM_HEADER, primary ? primary.id : "");
2457
+ headers.set("X-Content-Raw", "1");
2458
+ const teardown = new AbortController();
2459
+ const disarm = followSignal(signal, teardown);
2460
+ let closed = false;
2461
+ const body = new ReadableStream({
2462
+ async start(controller) {
2463
+ const write = message => {
2464
+ if (closed) return;
2465
+ try {
2466
+ controller.enqueue(createChunk(JSON.stringify(message)));
2467
+ } catch (_) {
2468
+ closed = true;
2469
+ }
2470
+ };
2471
+ try {
2472
+ for (const {
2473
+ id,
2474
+ component
2475
+ } of frames) {
2476
+ if (teardown.signal.aborted) break;
2477
+ await new Promise(resolve => {
2478
+ teardown.signal.addEventListener("abort", resolve, {
2479
+ once: true
2480
+ });
2481
+ renderServerComponent(component, {
2482
+ frame: {
2483
+ id,
2484
+ version: 1
2485
+ },
2486
+ signal: teardown.signal
2487
+ }).pipe({
2488
+ write,
2489
+ end: () => {
2490
+ teardown.signal.removeEventListener("abort", resolve);
2491
+ resolve();
2492
+ }
2493
+ });
2494
+ });
2495
+ }
2496
+ if (teardown.signal.aborted) {
2497
+ closed = true;
2498
+ try {
2499
+ controller.close();
2500
+ } catch (_) {}
2501
+ return;
2502
+ }
2503
+ if (outcome) {
2504
+ const reader = new ChunkReader(serializeStream(guardFailures(outcome), flightCodec(codec)));
2505
+ for (let node = await reader.next(); !node.done; node = await reader.next()) {
2506
+ write({
2507
+ type: "outcome",
2508
+ payload: node.value
2509
+ });
2510
+ }
2511
+ }
2512
+ if (!closed) {
2513
+ closed = true;
2514
+ controller.close();
2515
+ }
2516
+ } catch (err) {
2517
+ if (!closed) {
2518
+ closed = true;
2519
+ controller.error(err);
2520
+ }
2521
+ } finally {
2522
+ disarm();
2523
+ }
2524
+ },
2525
+ cancel() {
2526
+ closed = true;
2527
+ disarm();
2528
+ teardown.abort({
2529
+ [DISCONNECTED]: true
2530
+ });
2531
+ }
2532
+ });
2533
+ return new Response(body, {
2534
+ status: init.status || 200,
2535
+ headers
2536
+ });
2537
+ }
2538
+
2539
+ setContainerTraceResolver(getProjectionTrace);
2540
+ setAsyncIterableSharer(shareAsyncIterable);
2541
+ function asyncArg(value) {
2542
+ return value;
2543
+ }
2544
+
2545
+ export { FRAME_HAVE_BUDGET, FRAME_HAVE_HEADER, FRAME_STREAM_HEADER, FRAME_TIERS_HEADER, SERVER_COMPONENT_BOOTSTRAP, ServerComponentPlugin, asyncArg, frameTransformDirectResult, frameTransformFlightResult, frameTransformResult, isFrameStreamResponse };