@solidjs/web 2.0.0-rc.11 → 2.0.0-rc.14

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 (60) hide show
  1. package/dist/server.dev.js +705 -151
  2. package/dist/server.js +604 -123
  3. package/dist/server.observe.js +617 -124
  4. package/dist/web.dev.js +102 -41
  5. package/dist/web.js +75 -37
  6. package/dist/web.observe.js +75 -39
  7. package/frames/dist/assets.js +92 -0
  8. package/frames/dist/bind.dev.js +326 -0
  9. package/frames/dist/bind.js +295 -0
  10. package/frames/dist/client.dev.js +693 -919
  11. package/frames/dist/client.js +636 -917
  12. package/frames/dist/client.observe.js +637 -917
  13. package/frames/dist/regions.js +130 -0
  14. package/frames/dist/server.dev.js +607 -212
  15. package/frames/dist/server.js +554 -212
  16. package/frames/dist/server.observe.js +554 -212
  17. package/frames/dist/trace.js +42 -0
  18. package/frames/dist/wire.js +133 -0
  19. package/package.json +30 -3
  20. package/performance-tracks/dist/performance-tracks.dev.js +2 -1
  21. package/performance-tracks/dist/performance-tracks.observe.js +2 -1
  22. package/performance-tracks/types/index.d.ts +8 -6
  23. package/serialization/dist/decode.js +37 -8
  24. package/serialization/dist/serialization.js +39 -10
  25. package/serialization/types/serializer-decode.d.ts +24 -2
  26. package/server-functions/dist/client.dev.js +178 -72
  27. package/server-functions/dist/client.js +99 -61
  28. package/server-functions/dist/client.observe.js +178 -72
  29. package/server-functions/dist/server.dev.js +117 -56
  30. package/server-functions/dist/server.js +117 -56
  31. package/server-functions/dist/server.observe.js +117 -56
  32. package/skills/server-components/SKILL.md +228 -0
  33. package/types/client.d.ts +37 -2
  34. package/types/constants.d.ts +2 -1
  35. package/types/diagnostics.d.ts +8 -0
  36. package/types/frames/assets-tier.d.ts +78 -0
  37. package/types/frames/bind-tier.d.ts +60 -0
  38. package/types/frames/client.d.ts +37 -3
  39. package/types/frames/frame-client.d.ts +249 -96
  40. package/types/frames/frame-container-plugin.d.ts +2 -10
  41. package/types/frames/frame-sink.d.ts +33 -0
  42. package/types/frames/frame-transport.d.ts +66 -18
  43. package/types/frames/regions-tier.d.ts +45 -0
  44. package/types/frames/serializer-decode.d.ts +24 -2
  45. package/types/frames/server.d.ts +53 -1
  46. package/types/frames/trace-tier.d.ts +2 -0
  47. package/types/frames/tree-rewrite.d.ts +39 -0
  48. package/types/frames/wire-tier.d.ts +116 -0
  49. package/types/index.d.ts +38 -0
  50. package/types/index.server.d.ts +10 -1
  51. package/types/jsx.d.ts +11 -1
  52. package/types/observe.d.ts +182 -12
  53. package/types/request-error-hook.d.ts +5 -0
  54. package/types/serializer-decode.d.ts +24 -2
  55. package/types/server-functions/client.d.ts +26 -0
  56. package/types/server-functions/registry.d.ts +4 -1
  57. package/types/server-functions/shared.d.ts +12 -8
  58. package/types/server-mock.d.ts +13 -1
  59. package/types/server-observe.d.ts +8 -0
  60. package/types/server.d.ts +125 -12
@@ -1,7 +1,7 @@
1
1
  import * as core from 'solid-js';
2
- import { getOwner, onCleanup, createMemo, runWithOwner, createSignal, createRenderEffect, createLoadingBoundary, createOwner, sharedConfig } from 'solid-js';
3
- import { delegateEvents, insert } from '@solidjs/web';
4
- import { frameAddress, SINGLE_FLIGHT_HEADER, LIVE_WIRE, deserializeStream, getServerFunctionsCodec, createChunk, deliverFlightData, ERROR_HEADER, hasFlightMetadata, isEventStream, ChunkReader, configureServerFunctionsClient } from '@solidjs/web/server-functions/client';
2
+ import { getOwner, onCleanup, createMemo, runWithOwner, untrack, createRenderEffect, createSignal, createOwner } from 'solid-js';
3
+ import { insert } from '@solidjs/web';
4
+ import { frameAddress, SINGLE_FLIGHT_HEADER, LIVE_WIRE, deserializeStream, getServerFunctionsCodec, createChunk, deliverFlightData, ERROR_HEADER, hasFlightMetadata, ChunkReader, configureServerFunctionsClient } from '@solidjs/web/server-functions/client';
5
5
 
6
6
  const ELEMENT_NODE = 1;
7
7
  const TEXT_NODE = 3;
@@ -16,71 +16,6 @@ function claimNode(handlers, el) {
16
16
  for (let i = 0; i < handlers.length; i++) handlers[i](el);
17
17
  }
18
18
  const claimedAttr = name => name === "href" || name === "action";
19
- const BOUND_SEAM = Symbol.for("solid.bnd");
20
- const boundSeam = globalThis[BOUND_SEAM] || (globalThis[BOUND_SEAM] = {});
21
- const BND_ATTR = "_bnd";
22
- const BND_SELECTOR = "[_bnd]";
23
- function bndMap(el) {
24
- const s = el.getAttribute(BND_ATTR);
25
- if (!s) return undefined;
26
- const map = {};
27
- for (const entry of s.split(",")) {
28
- const eq = entry.indexOf("=");
29
- if (eq < 1) continue;
30
- const pos = entry.slice(0, eq);
31
- const prop = decodeURIComponent(entry.slice(eq + 1));
32
- const prev = map[pos];
33
- if (prev === undefined) map[pos] = prop;else if (Array.isArray(prev)) prev.push(prop);else map[pos] = [prev, prop];
34
- }
35
- return map;
36
- }
37
- boundSeam.resolve = (el, type) => {
38
- const frame = el._$bndFrame;
39
- if (!frame) return undefined;
40
- const map = bndMap(el);
41
- const prop = map && map[type];
42
- if (typeof prop !== "string") return undefined;
43
- return claimFn(frame, type, prop);
44
- };
45
- function claimFn(frame, pos, prop) {
46
- const fn = frame.clientProp(prop);
47
- if (typeof fn === "function") return fn;
48
- return undefined;
49
- }
50
- function sweepBound(root, frame, delegate, scope) {
51
- const isElement = root.nodeType === ELEMENT_NODE;
52
- if (!isElement && root.nodeType !== 11 ) return;
53
- let els;
54
- if (isElement && root.hasAttribute(BND_ATTR)) (els = []).push(root);
55
- const found = root.querySelectorAll(BND_SELECTOR);
56
- if (found.length) {
57
- els || (els = []);
58
- for (let i = 0; i < found.length; i++) els.push(found[i]);
59
- }
60
- if (!els) return;
61
- const run = () => {
62
- let types;
63
- for (const el of els) {
64
- el._$bndFrame = frame;
65
- const map = bndMap(el);
66
- if (!map) continue;
67
- for (const pos in map) {
68
- if (pos === "ref") fireRefs(frame, el, map.ref);else (types || (types = [])).push(pos);
69
- }
70
- }
71
- if (types && delegate) delegate(types);
72
- };
73
- scope ? scope(run) : run();
74
- }
75
- function fireRefs(frame, el, prop) {
76
- const fired = el._$bndFired || (el._$bndFired = new Set());
77
- for (const p of Array.isArray(prop) ? prop : [prop]) {
78
- if (fired.has(p)) continue;
79
- fired.add(p);
80
- const fn = claimFn(frame, "ref", p);
81
- if (fn) fn(el);
82
- }
83
- }
84
19
  function claimTree(handlers, root) {
85
20
  const isElement = root.nodeType === ELEMENT_NODE;
86
21
  if (!isElement && root.nodeType !== 11 ) return;
@@ -92,6 +27,18 @@ const placeholderId = name => `pl-${name}`;
92
27
  const SLOT_START = /^slot:(.+):start$/;
93
28
  const SLOT_END = /^slot:(.+):end$/;
94
29
  const slotEnd = id => `slot:${id}:end`;
30
+ const SLOT_MARKER = "_s:";
31
+ const SLOT_TEXT = SLOT_MARKER + "t=";
32
+ const SLOT_TEXT_END = "/" + SLOT_MARKER + "t";
33
+ const isTextStart = n => n.nodeType === COMMENT_NODE && n.data.startsWith(SLOT_TEXT);
34
+ function hasSlotMarker(el) {
35
+ const attrs = el.attributes;
36
+ for (let i = 0; i < attrs.length; i++) if (attrs[i].name.startsWith(SLOT_MARKER)) return true;
37
+ return false;
38
+ }
39
+ function isAsyncValue(v) {
40
+ return v !== null && typeof v === "object" && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
41
+ }
95
42
  function chunkToRecords(chunk) {
96
43
  switch (chunk.type) {
97
44
  case "start":
@@ -151,9 +98,12 @@ function chunkToRecords(chunk) {
151
98
  digest: chunk.digest
152
99
  }
153
100
  };
101
+ case "ops":
102
+ return Object.assign({}, ...chunk.ops.map(chunkToRecords));
154
103
  case "complete":
155
104
  return {
156
- ":complete": true
105
+ ":complete": true,
106
+ ":bound": chunk.bound
157
107
  };
158
108
  case "error":
159
109
  if (!chunk.key) return {
@@ -177,11 +127,20 @@ function createFrameHost(options = {}) {
177
127
  });
178
128
  return store;
179
129
  };
130
+ const landings = new Map();
131
+ const lands = records => "" in records || ":error" in records || ":complete" in records;
132
+ const applyTo = (id, version, r) => {
133
+ const set = frames.get(id);
134
+ if (set) for (const frame of set) frame.apply({
135
+ version,
136
+ r
137
+ });
138
+ };
180
139
  const write = (store, version, records) => {
181
140
  if (store.version !== undefined && version < store.version) return false;
182
141
  if (store.version === undefined || version > store.version) {
183
142
  store.version = version;
184
- clearStreamRecords(store.records);
143
+ store.records = {};
185
144
  }
186
145
  const assets = records["seg::assets"];
187
146
  const previous = assets && store.records["seg::assets"];
@@ -197,19 +156,47 @@ function createFrameHost(options = {}) {
197
156
  }
198
157
  return true;
199
158
  };
159
+ const settleArgs = (store, recordKey, record, chunk) => {
160
+ const args = record.args;
161
+ const out = {};
162
+ let regions, decoded;
163
+ const settle = () => {
164
+ if (! --record.pending && store.records[recordKey] === record) applyTo(chunk.id, store.version, {
165
+ [recordKey]: record
166
+ });
167
+ };
168
+ for (const key in args) {
169
+ const value = args[key];
170
+ if (value && typeof value.$ref === "string") {
171
+ const resolved = out[key] = options.resolve && options.resolve(value, chunk.id, chunk.version, store.version);
172
+ (decoded ??= {})[key] = true;
173
+ if (resolved instanceof Promise && resolved.s === 0) {
174
+ record.pending = (record.pending || 0) + 1;
175
+ resolved.c.push(settle);
176
+ }
177
+ } else {
178
+ if (value && typeof value.$frame === "string") (regions ??= {})[key] = value.$frame;
179
+ out[key] = value;
180
+ }
181
+ }
182
+ record.args = out;
183
+ record.regions = regions;
184
+ record.decoded = decoded;
185
+ };
200
186
  return {
201
- delegate: options.delegate,
202
187
  register(id, frame) {
203
188
  let set = frames.get(id);
204
189
  if (!set) frames.set(id, set = new Set());
205
190
  set.add(frame);
206
191
  const store = stores.get(id);
207
192
  if (store && store.version !== undefined) {
208
- frame.apply({
193
+ if (!store.open) frame.apply({
209
194
  version: store.version,
210
195
  r: store.records
196
+ });else if (store.shown) frame.apply({
197
+ version: store.shownVersion,
198
+ r: store.shown
211
199
  });
212
- frame.rebase && frame.rebase();
213
200
  }
214
201
  },
215
202
  unregister(id, frame) {
@@ -227,26 +214,65 @@ function createFrameHost(options = {}) {
227
214
  value: html
228
215
  };
229
216
  if (store.version === undefined) store.version = 0;
217
+ store.shown = store.records;
218
+ store.shownVersion = store.version;
230
219
  }
231
220
  }
232
221
  }
233
222
  }
234
- if (!frame) stores.delete(id);
223
+ if (!frame) {
224
+ stores.delete(id);
225
+ landings.delete(id);
226
+ }
235
227
  },
236
228
  apply(chunk) {
237
229
  if (chunk.type === "data") {
238
- options.applyData && options.applyData(chunk);
230
+ const store = stores.get(chunk.id);
231
+ const current = store && store.version;
232
+ if (store && chunk.version < current) return;
233
+ options.applyData && options.applyData(chunk, current);
239
234
  return;
240
235
  }
241
236
  const records = chunkToRecords(chunk);
242
- if (!write(storeFor(chunk.id), chunk.version, records)) return;
243
- const set = frames.get(chunk.id);
244
- if (set) {
245
- for (const frame of set) frame.apply({
246
- version: chunk.version,
247
- r: records
248
- });
237
+ const store = storeFor(chunk.id);
238
+ if (!write(store, chunk.version, records)) return;
239
+ if (chunk.type === "slot") {
240
+ const key = `slot:${chunk.key}`;
241
+ settleArgs(store, key, records[key], chunk);
242
+ }
243
+ let r = records;
244
+ if (chunk.type === "start") store.open = true;else if (lands(records)) {
245
+ store.open = false;
246
+ store.shown = r = store.records;
247
+ store.shownVersion = chunk.version;
248
+ const landed = landings.get(chunk.id);
249
+ if (landed && !(":complete" in records && ":error" in r)) {
250
+ landings.delete(chunk.id);
251
+ ":error" in records ? landed.j(records[":error"]) : landed.r();
252
+ }
253
+ }
254
+ applyTo(chunk.id, chunk.version, r);
255
+ if (":complete" in records || ":error" in records) options.closeData && options.closeData(chunk.id, chunk.version, records[":error"]);
256
+ },
257
+ landing(id) {
258
+ const store = stores.get(id);
259
+ if (!store || !store.open && !store.shown) return undefined;
260
+ if (store.shown && !(":error" in store.shown)) return undefined;
261
+ let wait = landings.get(id);
262
+ if (!wait) {
263
+ landings.set(id, wait = {});
264
+ wait.p = new Promise((r, j) => (wait.r = r, wait.j = j));
249
265
  }
266
+ return wait.p;
267
+ },
268
+ preview(chunk) {
269
+ if (chunk.type !== "slot") return;
270
+ const set = frames.get(chunk.id);
271
+ if (!set) return;
272
+ const records = chunkToRecords(chunk);
273
+ const key = `slot:${chunk.key}`;
274
+ settleArgs(storeFor(chunk.id), key, records[key], chunk);
275
+ for (const frame of set) frame.preview && frame.preview(records);
250
276
  },
251
277
  get(id) {
252
278
  const set = frames.get(id);
@@ -256,66 +282,66 @@ function createFrameHost(options = {}) {
256
282
  if (!options.serialize) throw new Error("host has no serializer");
257
283
  return options.serialize(value);
258
284
  },
259
- resolve(ref, frameId) {
260
- return options.resolve ? options.resolve(ref, frameId) : undefined;
261
- },
262
285
  revive: options.revive,
263
- isContainer: options.isContainer,
264
286
  prepareData: options.prepareData
265
287
  };
266
288
  }
267
289
  const FRAME_APPLIED_EVENT = "frame:applied";
290
+ const tierLoaders = {};
291
+ const tierLoads = {};
292
+ const liveFrames = new Set();
293
+ function prepareTier(name) {
294
+ let load = tierLoads[name];
295
+ if (!load) {
296
+ const loader = tierLoaders[name];
297
+ tierLoads[name] = load = loader ? loader().then(module => {
298
+ load.r = module;
299
+ module.install?.();
300
+ for (const frame of liveFrames) frame.apply({
301
+ version: frame.version,
302
+ r: {}
303
+ });
304
+ }) : Promise.resolve();
305
+ }
306
+ return load;
307
+ }
308
+ const tierReady = name => !tierLoaders[name] || prepareTier(name).r;
309
+ const needsRegions = record => record.regions && !tierReady("regions");
310
+ const carriesTrace = value => value != null && typeof value === "object" && (value.$tr != null || Object.values(value).some(carriesTrace));
311
+ const needsTrace = args => !tierLoads.trace?.r && carriesTrace(args) && !tierReady("trace");
268
312
  class FrameImpl {
269
313
  #element;
270
- #start;
271
- #end;
272
314
  #options;
315
+ #outer;
273
316
  #version;
274
317
  #store = Object.create(null);
275
- #appliedRootValue;
318
+ #appliedRoot;
319
+ #appliedError;
276
320
  #hasContent = false;
277
- #errorNotified = false;
278
- #revealed = new Set();
279
- #fallbackShown = new Set();
280
321
  #appliedHoles = new Map();
281
- #have;
282
322
  #slots;
283
323
  #mountedSlots = new Set();
284
324
  #slotCleanups = new Map();
285
325
  #slotArgs = new Map();
286
326
  #slotUpdaters = new Map();
287
- #slotRegions = new Map();
288
- #slotResolvedRefs = new Map();
289
- #slotNodes = new Map();
290
- #processedAssets = new WeakSet();
291
- #recordRefresh = null;
327
+ #hold;
328
+ #heldRecords = new Map();
292
329
  #disposed = false;
293
- #styleFlush = () => {
294
- if (!this.#disposed) this.#flush();
295
- };
296
330
  #claimTree = (node, direct) => {
297
- if (!direct && node.nodeType !== TEXT_NODE && node.nodeType !== COMMENT_NODE) {
298
- const o = this.#options;
299
- sweepBound(node, this, o.delegate || o.host && o.host.delegate, o.ownerScope);
300
- }
301
331
  const handlers = claimHandlers();
302
332
  if (!handlers) return;
303
333
  this.#scoped(() => direct ? claimNode(handlers, node) : claimTree(handlers, node));
304
334
  };
305
- clientProp(name) {
306
- const props = this.#options.props;
307
- return props ? props[name] : undefined;
308
- }
309
335
  #scoped(fn) {
310
336
  const scope = this.#options.ownerScope;
311
337
  return scope ? scope(fn) : fn();
312
338
  }
313
- constructor(element, start, end, options = {}) {
339
+ constructor(element, options = {}) {
314
340
  this.#element = element;
315
- this.#start = start;
316
- this.#end = end;
317
341
  this.#options = options;
318
342
  this.#slots = options.slots;
343
+ this.#outer = options.parent;
344
+ liveFrames.add(this);
319
345
  if (options.adopt) {
320
346
  this.#hasContent = true;
321
347
  this.#claimContent();
@@ -325,15 +351,12 @@ class FrameImpl {
325
351
  }
326
352
  if (options.adopt && this.#version === undefined) this.#syncSlots();
327
353
  }
328
- #parent() {
329
- return this.#element ?? this.#start.parentNode;
330
- }
331
354
  #applied(version, reason) {
332
355
  this.#options.onApply?.({
333
356
  version,
334
357
  reason
335
358
  });
336
- const parent = this.#parent();
359
+ const parent = this.#element;
337
360
  const Ev = parent && (parent.ownerDocument || parent).defaultView?.CustomEvent;
338
361
  if (Ev) {
339
362
  parent.dispatchEvent(new Ev(FRAME_APPLIED_EVENT, {
@@ -346,18 +369,12 @@ class FrameImpl {
346
369
  }));
347
370
  }
348
371
  }
349
- #firstContent() {
350
- return this.#start ? this.#start.nextSibling : this.#parent().firstChild;
351
- }
352
372
  get version() {
353
373
  return this.#version;
354
374
  }
355
375
  get store() {
356
376
  return this.#store;
357
377
  }
358
- isRevealed(segment) {
359
- return this.#revealed.has(segment);
360
- }
361
378
  get error() {
362
379
  return this.#store[":error"];
363
380
  }
@@ -372,68 +389,59 @@ class FrameImpl {
372
389
  this.#version = v;
373
390
  this.#resetStreamState();
374
391
  }
375
- for (const key in write.r) {
376
- const incoming = write.r[key];
377
- if (incoming && incoming.kind === "slot" && key.charCodeAt(0) === 115 && key.startsWith("slot:")) {
378
- const existing = this.#store[key];
379
- if (existing && existing.kind === "slot" && argsEquivalent(existing.args, incoming.args)) {
380
- continue;
381
- }
382
- }
383
- this.#store[key] = incoming;
384
- }
392
+ for (const key in write.r) this.#store[key] = write.r[key];
385
393
  this.#flush();
386
394
  }
387
- #resetStreamState(root) {
388
- this.#revealed.clear();
389
- this.#fallbackShown.clear();
395
+ preview(records, inherited) {
396
+ const adopted = new Set();
397
+ if (this.#disposed) return adopted;
398
+ const R = tierLoads.regions?.r;
399
+ for (const key in records) {
400
+ const record = records[key];
401
+ if (!record || record.kind !== "slot" || !key.startsWith("slot:")) continue;
402
+ if (inherited && key in this.#store) continue;
403
+ const occurrence = key.slice(5);
404
+ const update = this.#mountedSlots.has(occurrence) && this.#slotUpdaters.get(occurrence);
405
+ if (!update || (R ? R.changed(this, occurrence, record) : record.regions)) continue;
406
+ this.#slotArgs.set(occurrence, record);
407
+ adopted.add(key);
408
+ update(this.#resolveArgs(occurrence, record));
409
+ }
410
+ if (R) for (const frame of R.frames(this)) for (const key of frame.preview(records, true)) adopted.add(key);
411
+ if (!inherited) for (const key of adopted) this.#store[key] = records[key];
412
+ return adopted;
413
+ }
414
+ #resetStreamState() {
415
+ this.#store = Object.create(null);
416
+ this.#appliedRoot = this.#appliedError = undefined;
390
417
  this.#appliedHoles.clear();
391
- this.#processedAssets = new WeakSet();
392
- this.#errorNotified = false;
393
- clearStreamRecords(this.#store, root);
394
418
  }
395
419
  #flush() {
396
420
  if (this.#disposed) return;
397
421
  const version = this.#version;
398
422
  const root = this.#store[""];
399
- if (root && root.kind === "html" && root.value !== this.#appliedRootValue) {
423
+ if (root && root.kind === "html" && root !== this.#appliedRoot) {
400
424
  const reason = this.#hasContent ? "morph" : "materialize";
401
425
  this.#applyRoot(root.value);
402
- this.#appliedRootValue = root.value;
403
- this.#have = root.digest === undefined ? undefined : {
404
- "": root.digest,
405
- ...root.holes
406
- };
426
+ this.#appliedRoot = root;
427
+ this.#recordHave("", root);
407
428
  this.#applied(version, reason);
408
429
  }
409
- if (this.#store[":error"] && !this.#errorNotified) {
410
- this.#errorNotified = true;
430
+ const error = this.#store[":error"];
431
+ if (error && error !== this.#appliedError) {
432
+ this.#appliedError = error;
411
433
  this.#applied(version, "error");
412
434
  }
413
- let progressed = true;
414
- while (progressed) {
415
- progressed = false;
416
- for (const key in this.#store) {
417
- const name = segmentName(key);
418
- if (name === null || this.#revealed.has(name)) continue;
419
- if (this.#segmentReady(name)) {
420
- this.#revealSegment(name);
421
- this.#applied(version, "reveal");
422
- progressed = true;
423
- }
424
- }
425
- for (const key in this.#store) {
426
- const m = /^seg:([^:]+):fallback$/.exec(key);
427
- if (!m) continue;
428
- const name = m[1];
429
- if (this.#revealed.has(name) || this.#fallbackShown.has(name)) continue;
430
- if (this.#showFallback(name)) {
431
- this.#fallbackShown.add(name);
432
- this.#applied(version, "reveal");
433
- progressed = true;
434
- }
435
- }
436
- }
435
+ for (const key in this.#store) {
436
+ const record = this.#store[key];
437
+ if (!key.endsWith(":assets") || !record || this.#appliedHoles.get(key) === record) continue;
438
+ const tier = tierReady("assets");
439
+ if (!tier) break;
440
+ this.#appliedHoles.set(key, record);
441
+ tier.apply(record);
442
+ }
443
+ this.#revealSegments();
444
+ let morphed = false;
437
445
  for (const key in this.#store) {
438
446
  const record = this.#store[key];
439
447
  if (!record || this.#appliedHoles.get(key) === record) continue;
@@ -443,110 +451,102 @@ class FrameImpl {
443
451
  } else if (this.#applyHole(key.slice(5), record.value)) {
444
452
  this.#appliedHoles.set(key, record);
445
453
  this.#recordHave(key.slice(5), record);
446
- this.#applied(version, "morph");
454
+ morphed = true;
447
455
  }
448
456
  } else if (key.startsWith("attr:")) {
449
457
  if (this.#applyAttrs(key.slice(5), record.value, record.removed)) {
450
458
  this.#appliedHoles.set(key, record);
451
459
  this.#recordHave("lha:" + key.slice(5), record);
452
- this.#applied(version, "morph");
460
+ morphed = true;
453
461
  }
454
462
  }
455
463
  }
456
- for (const key in this.#store) {
457
- const record = this.#store[key];
458
- if (!key.endsWith(":assets") || !record || this.#processedAssets.has(record)) {
459
- continue;
460
- }
461
- this.#processedAssets.add(record);
462
- if (record.modules) {
463
- for (const href of record.modules) ensureModulePreload(href);
464
- }
465
- if (record.preloads) {
466
- for (const entry of record.preloads) ensurePreload(entry);
467
- }
468
- }
464
+ if (morphed) this.#applied(version, "morph");
469
465
  this.#syncSlots();
470
466
  }
471
467
  #resolveSlot(prop) {
472
- return this.#slots?.[prop] ?? this.#options.resolveSlot?.(prop);
468
+ return this.#slots?.[prop] ?? (this.#outer && this.#outer.#resolveSlot(prop));
473
469
  }
474
470
  #resolveSlotRecord(occurrence) {
475
471
  const record = this.#store[`slot:${occurrence}`];
476
472
  if (record !== undefined) return record;
477
- return this.#options.resolveSlotRecord?.(occurrence);
473
+ return this.#outer && this.#outer.#resolveSlotRecord(occurrence);
478
474
  }
479
475
  #removeSlotRecord(occurrence) {
480
476
  const key = `slot:${occurrence}`;
481
477
  if (key in this.#store) {
482
478
  if (!this.#mountedSlots.has(occurrence)) delete this.#store[key];
483
- } else this.#options.removeSlotRecord?.(occurrence);
479
+ } else this.#outer && this.#outer.#removeSlotRecord(occurrence);
484
480
  }
485
481
  #syncSlots(root) {
486
- if (!this.#slots && !this.#options.resolveSlot) return;
482
+ if (!this.#slots && !this.#outer) return;
487
483
  const found = new Map();
488
- if (root) collectSlots(root.firstChild, null, found);else this.#collectSlots(found);
484
+ if (root) collectSlots(root.firstChild, null, found, found);else this.#collectSlots(found, found);
485
+ let waiting = false;
486
+ const R = tierLoads.regions?.r;
487
+ const B = tierLoads.bind?.r;
489
488
  for (const [occurrence, start] of found) {
490
489
  const callback = this.#resolveSlot(propOf(occurrence));
491
- if (!callback) continue;
490
+ const consumers = Array.isArray(start) ? start : null;
491
+ if (!callback) {
492
+ continue;
493
+ }
492
494
  const record = this.#resolveSlotRecord(occurrence);
493
- if (record && record.kind === "slot" && this.#refsUnresolved(record.args)) continue;
494
- const prev = this.#slotNodes.get(occurrence);
495
- const prevFirst = Array.isArray(prev) ? prev[0] : prev;
496
- const zombie = this.#mountedSlots.has(occurrence) && prevFirst && !prevFirst.parentNode;
497
- if (zombie) {
498
- this.#mountedSlots.delete(occurrence);
499
- this.#runSlotCleanups(occurrence);
495
+ const mounted = this.#mountedSlots.has(occurrence);
496
+ if (record === undefined && isCalled(occurrence)) {
497
+ waiting ||= !mounted;
498
+ continue;
500
499
  }
501
- if (!this.#mountedSlots.has(occurrence)) {
502
- if (record === undefined && !root && this.#options.adopt && this.#options.recordsPending?.()) {
503
- this.#recordRefresh ??= setTimeout(() => {
504
- this.#recordRefresh = null;
505
- if (this.#disposed) return;
506
- this.#options.drainRecords?.();
507
- this.#syncSlots();
508
- });
509
- continue;
510
- }
511
- if (this.#options.adopt) this.#discoverRegions(occurrence, start);
512
- const nodes = this.#invokeSlot(occurrence, callback, record, start, this.#options.adopt);
513
- if (nodes) this.#replaceRange(occurrence, start, nodes);
514
- this.#slotNodes.set(occurrence, nodes);
500
+ if (!mounted && record && (record.pending || needsRegions(record) || needsTrace(record.args))) {
501
+ waiting = true;
502
+ if (this.#options.adopt && !consumers) this.#heldRecords.has(occurrence) || this.#heldRecords.set(occurrence, record);
503
+ continue;
504
+ }
505
+ if (!mounted) {
506
+ const held = this.#heldRecords.get(occurrence);
507
+ this.#heldRecords.delete(occurrence);
508
+ const mountRecord = held || record;
509
+ this.#invokeSlot(occurrence, callback, mountRecord, start, this.#options.adopt);
510
+ if (consumers) B.sync(this, occurrence, consumers);
515
511
  this.#mountedSlots.add(occurrence);
516
- if (!this.#options.adopt || nodes) this.#discoverRegions(occurrence, start);
517
- this.#bindRegions(occurrence);
518
- } else if (record !== this.#slotArgs.get(occurrence)) {
519
- if (this.#refArgsUnchanged(occurrence, record)) {
520
- this.#slotArgs.set(occurrence, record);
521
- this.#reconcileRegions(occurrence, record);
522
- continue;
523
- }
512
+ R?.bind(this, occurrence);
513
+ if (mountRecord === record || !record || record.kind !== "slot") continue;
514
+ }
515
+ if (consumers) B.sync(this, occurrence, consumers);
516
+ if (record !== this.#slotArgs.get(occurrence)) {
517
+ if (needsRegions(record) || needsTrace(record.args)) continue;
524
518
  const update = this.#slotUpdaters.get(occurrence);
525
519
  if (update) {
526
- const props = this.#resolveArgs(occurrence, record.args);
520
+ const props = this.#resolveArgs(occurrence, record);
527
521
  this.#slotArgs.set(occurrence, record);
528
522
  update(props);
529
- this.#bindRegions(occurrence);
523
+ R?.bind(this, occurrence);
530
524
  continue;
531
525
  }
532
- const nodes = this.#invokeSlot(occurrence, callback, record, start);
533
- if (nodes) this.#replaceRange(occurrence, start, nodes);
534
- this.#slotNodes.set(occurrence, nodes);
535
- this.#bindRegions(occurrence);
526
+ this.#invokeSlot(occurrence, callback, record, start);
527
+ R?.bind(this, occurrence);
536
528
  }
537
529
  }
530
+ if (found.b && !tierReady("bind")) waiting = true;
538
531
  if (!root) {
539
532
  for (const occurrence of [...this.#mountedSlots]) {
540
533
  if (!found.has(occurrence)) this.#unmountSlot(occurrence);
541
534
  }
535
+ if (waiting && !this.#hold) this.#hold = this.#options.hold?.();else if (!waiting && this.#hold) this.#releaseHold();
542
536
  }
543
537
  }
538
+ #releaseHold() {
539
+ const release = this.#hold;
540
+ this.#hold = undefined;
541
+ release && release();
542
+ }
544
543
  #invokeSlot(occurrence, callback, record, start, adopted) {
545
544
  this.#slotUpdaters.delete(occurrence);
546
545
  const cleanups = this.#slotCleanups.get(occurrence) ?? [];
547
546
  let existing = [];
548
547
  let end = null;
549
- if (start) end = eachInRange(start, occurrence, n => existing.push(n));
548
+ const positions = Array.isArray(start) ? start : undefined;
549
+ if (start && !positions) end = eachInRange(start, occurrence, n => existing.push(n));
550
550
  const ctx = {
551
551
  frame: this.#options.claimScope ?? this.#options.id,
552
552
  key: occurrence,
@@ -558,33 +558,24 @@ class FrameImpl {
558
558
  range: end ? {
559
559
  start,
560
560
  end
561
- } : undefined
561
+ } : undefined,
562
+ positions,
563
+ onRebind: positions ? fn => tierLoads.bind.r.rebinder(this, occurrence, fn) : undefined
562
564
  };
563
- const props = record && record.kind === "slot" ? this.#resolveArgs(occurrence, record.args) : {};
564
- const content = this.#scoped(() => callback(props, ctx));
565
+ const props = record && record.kind === "slot" ? this.#resolveArgs(occurrence, record, adopted, start) : {};
566
+ this.#scoped(() => callback(props, ctx));
565
567
  this.#slotArgs.set(occurrence, record);
566
568
  if (cleanups.length) this.#slotCleanups.set(occurrence, cleanups);
567
- if (content == null) return null;
568
- return Array.isArray(content) ? content : [content];
569
- }
570
- #replaceRange(key, start, nodes) {
571
- const parent = start.parentNode;
572
- const end = eachInRange(start, key, n => parent.removeChild(n));
573
- for (const node of nodes) parent.insertBefore(node, end);
574
569
  }
575
570
  #unmountSlot(key) {
576
571
  this.#mountedSlots.delete(key);
577
- this.#slotNodes.delete(key);
578
572
  this.#slotArgs.delete(key);
579
573
  this.#slotUpdaters.delete(key);
580
- this.#slotResolvedRefs.delete(key);
574
+ this.#heldRecords.delete(key);
581
575
  this.#removeSlotRecord(key);
582
576
  this.#runSlotCleanups(key);
583
- const regions = this.#slotRegions.get(key);
584
- if (regions) {
585
- disposeRegions(regions);
586
- this.#slotRegions.delete(key);
587
- }
577
+ tierLoads.regions?.r?.unmount(this, key);
578
+ tierLoads.bind?.r?.unmount(this, key);
588
579
  }
589
580
  #runSlotCleanups(key) {
590
581
  const cleanups = this.#slotCleanups.get(key);
@@ -592,129 +583,33 @@ class FrameImpl {
592
583
  this.#slotCleanups.delete(key);
593
584
  for (const fn of cleanups) fn();
594
585
  }
595
- #refsUnresolved(args) {
596
- const {
597
- host,
598
- id
599
- } = this.#options;
600
- if (host) for (const key in args) {
601
- if (isDataRef(args[key]) && host.resolve(args[key], id) === undefined) return true;
602
- }
603
- return false;
604
- }
605
- #regionsFor(slotKey) {
606
- let regions = this.#slotRegions.get(slotKey);
607
- if (!regions) this.#slotRegions.set(slotKey, regions = new Map());
608
- return regions;
586
+ get options() {
587
+ return this.#options;
609
588
  }
610
- #resolveArgs(slotKey, args) {
611
- const host = this.#options.host;
612
- const regions = this.#regionsFor(slotKey);
589
+ #resolveArgs(slotKey, record, claiming, start) {
590
+ const {
591
+ args,
592
+ regions,
593
+ decoded
594
+ } = record;
595
+ const revive = this.#options.host && this.#options.host.revive;
613
596
  const props = {};
614
597
  for (const key in args) {
598
+ if (regions && key in regions) continue;
615
599
  const value = args[key];
616
- if (isDataRef(value)) {
617
- const resolved = host ? host.resolve(value, this.#options.id) : undefined;
618
- let cache = this.#slotResolvedRefs.get(slotKey);
619
- if (!cache) this.#slotResolvedRefs.set(slotKey, cache = {});
620
- cache[key] = resolved;
621
- props[key] = resolved;
622
- } else if (isFrameRef(value)) {
623
- let entry = regions.get(key);
624
- if (!entry) {
625
- const element = makeFrameElement(value.$frame);
626
- entry = {
627
- childId: value.$frame,
628
- element,
629
- frame: undefined
630
- };
631
- regions.set(key, entry);
632
- } else if (entry.childId !== value.$frame) {
633
- renameRegion(entry, value.$frame);
634
- }
635
- props[key] = entry.element;
636
- } else {
637
- props[key] = host && host.revive ? host.revive(value) : value;
638
- }
600
+ props[key] = revive && !(decoded && key in decoded) ? revive(value, claiming) : value;
639
601
  }
602
+ if (regions) tierLoads.regions.r.resolve(this, slotKey, regions, props, claiming && start);
640
603
  return props;
641
604
  }
642
- #discoverRegions(slotKey, start) {
643
- if (!start) return;
644
- const regions = this.#regionsFor(slotKey);
645
- eachInRange(start, slotKey, n => collectRegionElements(n, regions));
646
- }
647
- #refArgsUnchanged(occurrence, record) {
648
- const old = this.#slotArgs.get(occurrence);
649
- if (!record || record.kind !== "slot") return false;
650
- if (old && old.kind !== "slot") return false;
651
- const a = old && old.args || {};
652
- const b = record.args || {};
653
- const ka = Object.keys(a);
654
- const kb = Object.keys(b);
655
- if (kb.length !== ka.length) return false;
656
- const cache = this.#slotResolvedRefs.get(occurrence);
657
- for (const key of ka) {
658
- const va = a[key];
659
- const vb = b[key];
660
- if (va === vb) continue;
661
- if (isFrameRef(va) && isFrameRef(vb)) continue;
662
- if (isDataRef(va) && isDataRef(vb) && cache && key in cache) {
663
- const host = this.#options.host;
664
- const next = host ? host.resolve(vb, this.#options.id) : undefined;
665
- if (host && host.isContainer && (host.isContainer(next) || host.isContainer(cache[key]))) {
666
- if (next === cache[key]) continue;
667
- return false;
668
- }
669
- if (isAsyncLike(next) || isAsyncLike(cache[key])) return false;
670
- try {
671
- if (JSON.stringify(next) === JSON.stringify(cache[key])) continue;
672
- } catch (e) {
673
- return false;
674
- }
675
- }
676
- return false;
677
- }
678
- return true;
605
+ #collectSlots(found, elements) {
606
+ collectSlots(this.#element.firstChild, null, found, elements);
679
607
  }
680
- #reconcileRegions(occurrence, record) {
681
- const args = record && record.args;
682
- if (!args) return;
683
- const regions = this.#slotRegions.get(occurrence);
684
- if (!regions) return;
685
- for (const key in args) {
686
- const value = args[key];
687
- if (!isFrameRef(value)) continue;
688
- const entry = regions.get(key);
689
- if (entry && entry.childId !== value.$frame) renameRegion(entry, value.$frame);
690
- }
691
- }
692
- #bindRegions(slotKey) {
693
- const regions = this.#slotRegions.get(slotKey);
694
- if (!regions) return;
695
- for (const entry of regions.values()) {
696
- if (!entry.frame) {
697
- entry.frame = new FrameImpl(entry.element, null, null, {
698
- id: entry.childId,
699
- host: this.#options.host,
700
- adopt: entry.adopt,
701
- claimScope: this.#options.claimScope ?? this.#options.id,
702
- ownerScope: this.#options.ownerScope,
703
- resolveSlot: prop => this.#resolveSlot(prop),
704
- resolveSlotRecord: occurrence => this.#resolveSlotRecord(occurrence),
705
- removeSlotRecord: occurrence => this.#removeSlotRecord(occurrence)
706
- });
707
- }
708
- }
709
- }
710
- #collectSlots(found) {
711
- collectSlots(this.#firstContent(), this.#end, found);
712
- }
713
- #findPlaceholder(name) {
714
- return findPlaceholder(this.#firstContent(), this.#end, placeholderId(name));
608
+ #findPlaceholder(name, root) {
609
+ return findPlaceholder((root || this.#element).firstChild, null, placeholderId(name));
715
610
  }
716
611
  contentHTML() {
717
- if (this.#disposed || !this.#element || !this.#hasContent) return null;
612
+ if (this.#disposed || !this.#hasContent) return null;
718
613
  return this.#element.innerHTML;
719
614
  }
720
615
  rebind(id) {
@@ -732,20 +627,11 @@ class FrameImpl {
732
627
  this.#element.setAttribute(FRAME_ID_ATTR, id);
733
628
  }
734
629
  this.#version = undefined;
735
- this.#appliedRootValue = undefined;
736
- this.#resetStreamState(true);
630
+ this.#resetStreamState();
737
631
  if (host) host.register(id, this);
738
632
  }
739
- rebase() {
740
- this.#version = undefined;
741
- }
742
- have() {
743
- return this.#have;
744
- }
745
633
  #recordHave(key, record) {
746
- if (!this.#have || !record || record.digest === undefined) return;
747
- this.#have[key] = record.digest;
748
- if (record.holes) Object.assign(this.#have, record.holes);
634
+ tierLoads.wire?.r?.have(this, key, record);
749
635
  }
750
636
  dispose() {
751
637
  if (this.#disposed) return;
@@ -755,36 +641,33 @@ class FrameImpl {
755
641
  } = this.#options;
756
642
  if (host && id !== undefined) host.unregister(id, this);
757
643
  this.#disposed = true;
758
- if (this.#recordRefresh) {
759
- clearTimeout(this.#recordRefresh);
760
- this.#recordRefresh = null;
761
- }
644
+ liveFrames.delete(this);
645
+ this.#releaseHold();
762
646
  for (const key of [...this.#slotCleanups.keys()]) this.#runSlotCleanups(key);
763
647
  for (const key of this.#mountedSlots) this.#removeSlotRecord(key);
764
- for (const regions of this.#slotRegions.values()) disposeRegions(regions);
765
- this.#slotRegions.clear();
648
+ tierLoads.regions?.r?.unmount(this);
766
649
  this.#mountedSlots.clear();
767
650
  }
768
651
  #applyRoot(html) {
769
652
  const fragment = parseFragment(html);
770
- const parent = this.#parent();
653
+ const parent = this.#element;
771
654
  if (!this.#hasContent) {
772
- this.#clearContent();
655
+ parent.textContent = "";
773
656
  this.#claimTree(fragment);
774
- parent.insertBefore(fragment, this.#end);
657
+ parent.appendChild(fragment);
775
658
  this.#hasContent = true;
776
659
  } else {
777
660
  const claim = this.#claimTree;
778
661
  const ranges = new Map();
779
662
  this.#collectSlots(ranges);
780
663
  const grafts = [];
781
- reconcileChildren(parent, fragment, this.#start, this.#end, claim, ranges, grafts);
664
+ reconcileChildren(parent, fragment, null, null, claim, ranges, grafts);
782
665
  if (ranges.size) for (const root of grafts) flushGrafts(root, ranges);
783
666
  }
784
667
  }
785
668
  #applyHole(marker, html) {
786
669
  if (!this.#hasContent) return false;
787
- const open = findLiveTarget(this.#firstContent(), this.#end, n => n.nodeType === COMMENT_NODE && n.data === marker);
670
+ const open = findLiveTarget(this.#element.firstChild, null, n => n.nodeType === COMMENT_NODE && n.data === marker);
788
671
  if (!open) return false;
789
672
  const close = rangeClose(open, "lh:/" + marker.slice(3));
790
673
  if (!close) {
@@ -795,15 +678,19 @@ class FrameImpl {
795
678
  }
796
679
  #applyAttrs(addr, text, removed) {
797
680
  if (!this.#hasContent) return false;
798
- const el = findLiveTarget(this.#firstContent(), this.#end, n => n.nodeType === ELEMENT_NODE && n.getAttribute("data-lha") === addr);
681
+ const el = findLiveTarget(this.#element.firstChild, null, n => n.nodeType === ELEMENT_NODE && n.getAttribute("data-lha") === addr);
799
682
  if (!el) return false;
800
683
  const parsed = parseFragment(`<i${text}></i>`).firstChild;
801
684
  const keepOpen = preservesOpen(el);
685
+ const owned = parsed ? ownedPositions(parsed) : null;
802
686
  const current = el.attributes;
803
687
  for (let i = current.length - 1; i >= 0; i--) {
804
688
  const name = current[i].name;
805
689
  if (name === "data-lha" || keepOpen && name === "open") continue;
806
- if (!parsed || !parsed.hasAttribute(name)) el.removeAttribute(name);
690
+ if (!parsed || !parsed.hasAttribute(name)) {
691
+ if (applyOwned(el, name, "", owned) !== undefined) continue;
692
+ el.removeAttribute(name);
693
+ }
807
694
  }
808
695
  if (parsed) {
809
696
  for (let i = 0; i < parsed.attributes.length; i++) {
@@ -812,72 +699,76 @@ class FrameImpl {
812
699
  value
813
700
  } = parsed.attributes[i];
814
701
  if (keepOpen && name === "open") continue;
702
+ if (applyOwned(el, name, value, owned) !== undefined) continue;
815
703
  if (el.getAttribute(name) !== value) el.setAttribute(name, value);
816
704
  }
817
705
  }
818
- if (removed) for (const name of removed) if (!(keepOpen && name === "open")) el.removeAttribute(name);
706
+ if (removed) for (const name of removed) {
707
+ if (keepOpen && name === "open") continue;
708
+ if (applyOwned(el, name, "", owned) !== undefined) continue;
709
+ el.removeAttribute(name);
710
+ }
819
711
  return true;
820
712
  }
821
- #clearContent() {
822
- removeUntil(this.#parent(), this.#firstContent(), this.#end);
823
- }
824
713
  #claimContent() {
825
- let n = this.#firstContent();
826
- while (n && n !== this.#end) {
827
- this.#claimTree(n);
828
- n = n.nextSibling;
714
+ for (let n = this.#element.firstChild; n; n = n.nextSibling) this.#claimTree(n);
715
+ }
716
+ #revealSegments(root) {
717
+ const version = this.#version;
718
+ for (const key in this.#store) {
719
+ const record = this.#store[key];
720
+ const name = segmentName(key);
721
+ if (name === null || !record || this.#appliedHoles.get(key) === record) continue;
722
+ if (this.#segmentReady(name, root)) {
723
+ this.#appliedHoles.set(key, record);
724
+ this.#revealSegment(name, root);
725
+ this.#applied(version, "reveal");
726
+ }
727
+ }
728
+ for (const key in this.#store) {
729
+ const m = /^seg:([^:]+):fallback$/.exec(key);
730
+ if (!m || this.#appliedHoles.has(key) || this.#appliedHoles.has(`seg:${m[1]}`)) continue;
731
+ if (this.#showFallback(m[1], root)) {
732
+ this.#appliedHoles.set(key, this.#store[key]);
733
+ this.#applied(version, "reveal");
734
+ }
829
735
  }
830
736
  }
831
- #segmentReady(name) {
737
+ #segmentReady(name, root) {
832
738
  const content = this.#store[`seg:${name}`];
833
739
  if (!content || content.kind !== "html") return false;
834
740
  if (!this.#store[`seg:${name}:reveal`]) return false;
835
741
  const assets = this.#store[`seg:${name}:assets`];
836
- if (assets && assets.styles) {
837
- let ready = true;
838
- for (const entry of assets.styles) ready = ensureStylesheet(entry, this.#styleFlush) && ready;
839
- if (!ready) return false;
840
- }
841
- if (!this.#findPlaceholder(name)) return false;
842
- return true;
742
+ if (assets && (assets.styles || assets.inlineStyles) && !tierReady("assets")?.gate(assets.styles || [], this)) return false;
743
+ return !!this.#findPlaceholder(name, root);
843
744
  }
844
- #revealSegment(name) {
845
- const tpl = this.#findPlaceholder(name);
745
+ #revealSegment(name, root) {
746
+ const tpl = this.#findPlaceholder(name, root);
846
747
  if (!tpl) return;
847
- const assets = this.#store[`seg:${name}:assets`];
848
- if (assets && assets.inlineStyles) applyInlineStyles(assets.inlineStyles);
849
748
  const content = this.#store[`seg:${name}`];
850
749
  const closing = rangeClose(tpl, placeholderId(name));
851
- const parent = tpl.parentNode;
852
- removeUntil(parent, tpl.nextSibling, closing);
853
- if (this.#options.reveal) {
854
- const fallbackFrag = tpl.content.cloneNode(true);
855
- this.#claimTree(fallbackFrag);
856
- this.#options.reveal({
857
- before: closing,
858
- fallback: [...fallbackFrag.childNodes],
859
- content: () => {
860
- const materialized = this.#materialize(content);
861
- this.#syncSlots(materialized);
862
- this.#claimTree(materialized);
863
- return materialized;
864
- }
865
- });
866
- tpl.remove();
867
- this.#revealed.add(name);
868
- this.#recordHave(name, content);
750
+ if (!closing) {
869
751
  return;
870
752
  }
871
- const materialized = this.#materialize(content);
872
- this.#claimTree(materialized);
873
- parent.insertBefore(materialized, closing);
753
+ removeUntil(tpl.parentNode, tpl.nextSibling, closing);
754
+ const fallbackFrag = tpl.content.cloneNode(true);
755
+ this.#claimTree(fallbackFrag);
756
+ (this.#options.reveal || revealAtOnce)({
757
+ before: closing,
758
+ fallback: [...fallbackFrag.childNodes],
759
+ content: () => {
760
+ const materialized = this.#materialize(content);
761
+ this.#syncSlots(materialized);
762
+ this.#claimTree(materialized);
763
+ this.#revealSegments(materialized);
764
+ return materialized;
765
+ }
766
+ });
874
767
  tpl.remove();
875
- closing && closing.remove();
876
- this.#revealed.add(name);
877
768
  this.#recordHave(name, content);
878
769
  }
879
- #showFallback(name) {
880
- const tpl = this.#findPlaceholder(name);
770
+ #showFallback(name, root) {
771
+ const tpl = this.#findPlaceholder(name, root);
881
772
  if (!tpl) return false;
882
773
  const closing = rangeClose(tpl, placeholderId(name));
883
774
  if (!closing) return false;
@@ -891,13 +782,13 @@ class FrameImpl {
891
782
  }
892
783
  }
893
784
  function createFrame(boundary, options) {
894
- return new FrameImpl(boundary, null, null, options);
785
+ return new FrameImpl(boundary, options);
895
786
  }
896
787
  const FRAME_TAG = "solid-frame";
897
788
  const FRAME_ID_ATTR = "data-fid";
898
789
  function createFrameElement(options) {
899
790
  const el = makeFrameElement(options.id);
900
- const frame = new FrameImpl(el, null, null, options);
791
+ const frame = new FrameImpl(el, options);
901
792
  return {
902
793
  element: el,
903
794
  frame,
@@ -920,23 +811,16 @@ function segmentName(key) {
920
811
  const m = /^seg:([^:]+)$/.exec(key);
921
812
  return m ? m[1] : null;
922
813
  }
923
- function isAsyncLike(v) {
924
- return !!v && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
925
- }
926
814
  function propOf(occurrence) {
927
815
  const hash = occurrence.indexOf("#");
928
816
  return hash === -1 ? occurrence : occurrence.slice(0, hash);
929
817
  }
930
- function isDataRef(value) {
931
- return !!value && typeof value.$ref === "string";
818
+ function isCalled(occurrence) {
819
+ return occurrence.indexOf("#") !== -1;
932
820
  }
933
- function isFrameRef(value) {
934
- return !!value && typeof value.$frame === "string";
935
- }
936
- function disposeRegions(regions) {
937
- for (const {
938
- frame
939
- } of regions.values()) frame?.dispose();
821
+ function revealAtOnce(seam) {
822
+ seam.before.parentNode.insertBefore(seam.content(), seam.before);
823
+ seam.before.remove();
940
824
  }
941
825
  function removeUntil(parent, n, stop) {
942
826
  while (n && n !== stop) {
@@ -950,80 +834,6 @@ function parseFragment(html) {
950
834
  template.innerHTML = html;
951
835
  return template.content;
952
836
  }
953
- const PRELOAD_QUALIFIERS = ["as", "crossorigin", "type", "media", "imagesrcset", "imagesizes"];
954
- function qualifierValue(name, value) {
955
- if (value == null) return null;
956
- if (name === "imagesrcset" || name === "imagesizes") return value === "" ? null : value;
957
- if (name === "as") return value.replace(/[A-Z]/g, c => String.fromCharCode(c.charCodeAt(0) + 32));
958
- if (name !== "crossorigin") return value;
959
- return value.length === 15 && value.toLowerCase() === "use-credentials" ? "use-credentials" : "anonymous";
960
- }
961
- function findHeadElement(selector, attr, value, qualifiers) {
962
- candidate: for (const node of document.head.querySelectorAll(selector)) {
963
- if (node.getAttribute(attr) !== value) continue;
964
- if (!qualifiers) return node;
965
- for (let i = 0; i < PRELOAD_QUALIFIERS.length; i++) {
966
- const name = PRELOAD_QUALIFIERS[i];
967
- if (qualifierValue(name, node.getAttribute(name)) !== qualifierValue(name, qualifiers[name] ?? null)) continue candidate;
968
- }
969
- return node;
970
- }
971
- return null;
972
- }
973
- function ensurePreload(entry) {
974
- const attrs = entry.attrs;
975
- const href = entry.href;
976
- if (findHeadElement('link[rel="preload"]', "href", href || null, attrs)) return;
977
- const link = document.createElement("link");
978
- link.rel = "preload";
979
- for (const name in attrs) link.setAttribute(name, attrs[name]);
980
- if (href) link.setAttribute("href", href);
981
- document.head.appendChild(link);
982
- }
983
- function ensureStylesheet(entry, onSettle) {
984
- const href = typeof entry === "string" ? entry : entry.href;
985
- let link = findHeadElement('link[rel="stylesheet"]', "href", href);
986
- if (!link) {
987
- link = document.createElement("link");
988
- link.rel = "stylesheet";
989
- if (typeof entry !== "string" && entry.attrs) {
990
- for (const name in entry.attrs) link.setAttribute(name, entry.attrs[name]);
991
- }
992
- link.href = href;
993
- const waiters = new Set();
994
- link._$frWaiters = waiters;
995
- const settle = () => {
996
- link._$frWaiters = null;
997
- for (const fn of waiters) fn();
998
- };
999
- link.addEventListener("load", settle);
1000
- link.addEventListener("error", settle);
1001
- document.head.appendChild(link);
1002
- }
1003
- const waiters = link._$frWaiters;
1004
- if (waiters == null) return true;
1005
- waiters.add(onSettle);
1006
- return false;
1007
- }
1008
- function ensureModulePreload(href) {
1009
- if (findHeadElement('link[rel="modulepreload"]', "href", href)) return;
1010
- const link = document.createElement("link");
1011
- link.rel = "modulepreload";
1012
- link.href = href;
1013
- document.head.appendChild(link);
1014
- }
1015
- function applyInlineStyles(inlineStyles) {
1016
- for (const entry of inlineStyles) {
1017
- if (findHeadElement("style[data-asset]", "data-asset", entry.id)) continue;
1018
- const el = document.createElement("style");
1019
- el.setAttribute("data-asset", entry.id);
1020
- if (entry.attrs) {
1021
- for (const name in entry.attrs) el.setAttribute(name, entry.attrs[name]);
1022
- }
1023
- el.textContent = entry.content || "";
1024
- document.head.appendChild(el);
1025
- }
1026
- }
1027
837
  function isPlaceholderStart(node, id) {
1028
838
  return node.tagName === "TEMPLATE" && node.id === id;
1029
839
  }
@@ -1060,7 +870,7 @@ function findPlaceholder(n, end, id) {
1060
870
  }
1061
871
  return null;
1062
872
  }
1063
- function collectSlots(n, end, out) {
873
+ function collectSlots(n, end, out, elements) {
1064
874
  while (n && n !== end) {
1065
875
  const id = slotStartId(n);
1066
876
  if (id !== null) {
@@ -1068,32 +878,19 @@ function collectSlots(n, end, out) {
1068
878
  n = afterRange(n, id);
1069
879
  continue;
1070
880
  }
1071
- if (n.nodeType === ELEMENT_NODE && !isFrameElement(n)) collectSlots(n.firstChild, null, out);
1072
- n = n.nextSibling;
1073
- }
1074
- }
1075
- function collectRegionElements(node, regions) {
1076
- if (node.nodeType !== ELEMENT_NODE) return;
1077
- if (isFrameElement(node)) {
1078
- const childId = node.getAttribute(FRAME_ID_ATTR);
1079
- if (childId && childId.includes(".")) {
1080
- const argKey = childId.slice(childId.lastIndexOf(".") + 1);
1081
- if (!regions.has(argKey)) {
1082
- regions.set(argKey, {
1083
- childId,
1084
- element: node,
1085
- frame: undefined,
1086
- adopt: true
1087
- });
881
+ if (elements !== undefined && isTextStart(n)) {
882
+ const B = tierLoads.bind?.r;
883
+ B ? B.text(n, elements) : elements.b = true;
884
+ }
885
+ if (n.nodeType === ELEMENT_NODE && !isFrameElement(n)) {
886
+ if (elements !== undefined && n.hasAttributes()) {
887
+ const B = tierLoads.bind?.r;
888
+ B ? B.positions(n, elements) : hasSlotMarker(n) && (elements.b = true);
1088
889
  }
890
+ collectSlots(n.firstChild, null, out, elements);
1089
891
  }
1090
- return;
892
+ n = n.nextSibling;
1091
893
  }
1092
- for (let c = node.firstChild; c; c = c.nextSibling) collectRegionElements(c, regions);
1093
- }
1094
- function renameRegion(entry, childId) {
1095
- entry.childId = childId;
1096
- if (entry.frame) entry.frame.rebind(childId);else entry.element.setAttribute(FRAME_ID_ATTR, childId);
1097
894
  }
1098
895
  function eachInRange(start, key, cb) {
1099
896
  const end = slotEnd(key);
@@ -1105,28 +902,6 @@ function eachInRange(start, key, cb) {
1105
902
  }
1106
903
  return n;
1107
904
  }
1108
- function clearStreamRecords(records, root) {
1109
- for (const key in records) {
1110
- if (/^(seg|hole|attr):/.test(key) || key === ":error" || root && key === "") {
1111
- delete records[key];
1112
- }
1113
- }
1114
- }
1115
- function argsEquivalent(a, b) {
1116
- if (a === b) return true;
1117
- if (!a || !b) return false;
1118
- const ka = Object.keys(a);
1119
- const kb = Object.keys(b);
1120
- if (ka.length !== kb.length) return false;
1121
- for (const key of ka) {
1122
- const va = a[key];
1123
- const vb = b[key];
1124
- if (va === vb) continue;
1125
- if (isFrameRef(va) && va.$frame === vb?.$frame) continue;
1126
- return false;
1127
- }
1128
- return true;
1129
- }
1130
905
  function slotStartId(node) {
1131
906
  if (node.nodeType !== COMMENT_NODE) return null;
1132
907
  const m = SLOT_START.exec(node.data);
@@ -1146,15 +921,26 @@ function preservesOpen(el) {
1146
921
  const t = el.tagName;
1147
922
  return t === "DETAILS" || t === "DIALOG";
1148
923
  }
924
+ const ownedPositions = el => {
925
+ const B = tierLoads.bind?.r;
926
+ return B ? B.owned(el) : null;
927
+ };
928
+ const applyOwned = (oldEl, name, value, owned) => owned === null ? undefined : tierLoads.bind.r.apply(oldEl, name, value, owned);
1149
929
  function morphAttributes(oldEl, newEl, claim) {
1150
930
  let reclaim = false;
1151
931
  let changed = false;
1152
932
  const keepOpen = preservesOpen(oldEl);
933
+ const owned = ownedPositions(newEl);
1153
934
  const oldAttrs = oldEl.attributes;
1154
935
  for (let i = oldAttrs.length - 1; i >= 0; i--) {
1155
936
  const name = oldAttrs[i].name;
1156
937
  if (keepOpen && name === "open") continue;
1157
938
  if (!newEl.hasAttribute(name)) {
939
+ const handled = applyOwned(oldEl, name, "", owned);
940
+ if (handled !== undefined) {
941
+ changed = handled || changed;
942
+ continue;
943
+ }
1158
944
  oldEl.removeAttribute(name);
1159
945
  changed = true;
1160
946
  reclaim ||= claimedAttr(name);
@@ -1163,11 +949,17 @@ function morphAttributes(oldEl, newEl, claim) {
1163
949
  const newAttrs = newEl.attributes;
1164
950
  for (let i = 0; i < newAttrs.length; i++) {
1165
951
  const attr = newAttrs[i];
1166
- if (keepOpen && attr.name === "open") continue;
1167
- if (oldEl.getAttribute(attr.name) !== attr.value) {
1168
- oldEl.setAttribute(attr.name, attr.value);
952
+ const name = attr.name;
953
+ if (keepOpen && name === "open") continue;
954
+ const handled = applyOwned(oldEl, name, attr.value, owned);
955
+ if (handled !== undefined) {
956
+ changed = handled || changed;
957
+ continue;
958
+ }
959
+ if (oldEl.getAttribute(name) !== attr.value) {
960
+ oldEl.setAttribute(name, attr.value);
1169
961
  changed = true;
1170
- reclaim ||= claimedAttr(attr.name);
962
+ reclaim ||= claimedAttr(name);
1171
963
  }
1172
964
  }
1173
965
  if (claim && (reclaim || changed && oldEl.matches(CLAIMED_ELEMENTS))) claim(oldEl, true);
@@ -1181,8 +973,9 @@ function morphNode(oldNode, newNode, claim, ranges, grafts) {
1181
973
  oldNode.data = newNode.data;
1182
974
  }
1183
975
  }
1184
- function afterRange(start, id) {
1185
- const end = slotEnd(id);
976
+ const afterRange = (start, id) => afterMarker(start, slotEnd(id));
977
+ const afterText = start => afterMarker(start, SLOT_TEXT_END);
978
+ function afterMarker(start, end) {
1186
979
  let n = start.nextSibling;
1187
980
  while (n) {
1188
981
  if (n.nodeType === COMMENT_NODE && n.data === end) return n.nextSibling;
@@ -1241,6 +1034,11 @@ function reconcileChildren(parent, source, boundStart = null, boundEnd = null, c
1241
1034
  const nextNew = newChild.nextSibling;
1242
1035
  const pid = slotStartId(newChild);
1243
1036
  const old = oldChild === boundEnd ? null : oldChild;
1037
+ if (old && isTextStart(newChild) && old.nodeType === COMMENT_NODE && old.data === newChild.data) {
1038
+ oldChild = afterText(old);
1039
+ newChild = afterText(newChild);
1040
+ continue;
1041
+ }
1244
1042
  if (pid !== null) {
1245
1043
  if (old && slotStartId(old) === pid) {
1246
1044
  oldChild = afterRange(old, pid);
@@ -1417,18 +1215,7 @@ function observeFrameApply(response) {
1417
1215
  }
1418
1216
 
1419
1217
  const FRAME_STREAM_HEADER = "X-Frame-Stream";
1420
- const FRAME_HAVE_HEADER = "X-Frame-Have";
1421
- const FRAME_HAVE_BUDGET = 4096;
1422
- function encodeHaveList(have) {
1423
- let out = "";
1424
- for (const key in have) {
1425
- const digest = have[key];
1426
- if (typeof digest !== "string") continue;
1427
- out += (out ? "," : "") + key + "=" + digest;
1428
- if (out.length > FRAME_HAVE_BUDGET) return undefined;
1429
- }
1430
- return out || undefined;
1431
- }
1218
+ const FRAME_TIERS_HEADER = "X-Frame-Tiers";
1432
1219
  function isFrameStreamResponse(response) {
1433
1220
  return response.headers.has(FRAME_STREAM_HEADER);
1434
1221
  }
@@ -1448,26 +1235,12 @@ async function observedApplyFrameResponse(response, host, options = {}) {
1448
1235
  }
1449
1236
  function applyFrames(response, host, options = {}, observation) {
1450
1237
  const rootId = response.headers.get(FRAME_STREAM_HEADER) ?? "";
1238
+ response.headers.get(FRAME_TIERS_HEADER)?.split(",").forEach(prepareTier);
1451
1239
  const as = options.as;
1452
1240
  const version = options.version;
1453
1241
  const perFrame = typeof version === "function" ? new Map() : null;
1454
- const wire = options[LIVE_WIRE];
1455
- const connection = wire && wire.connection;
1456
- const reader = wire && isEventStream(response) ? wire.open(response.body) : new ChunkReader(response.body);
1242
+ const reader = options[LIVE_WIRE] || new ChunkReader(response.body);
1457
1243
  const open = new Map();
1458
- let cancelled;
1459
- let resolveEnd;
1460
- if (connection) {
1461
- connection.ended = new Promise(resolve => resolveEnd = resolve);
1462
- connection.cancel = reason => {
1463
- if (cancelled !== undefined) return;
1464
- cancelled = reason;
1465
- try {
1466
- const r = reader.cancel && reader.cancel(reason);
1467
- if (r && typeof r.then === "function") r.then(undefined, () => {});
1468
- } catch {}
1469
- };
1470
- }
1471
1244
  const errorRecord = (id, error) => ({
1472
1245
  type: "error",
1473
1246
  id,
@@ -1492,26 +1265,15 @@ function applyFrames(response, host, options = {}, observation) {
1492
1265
  } else if (version !== undefined) chunk.version = version;
1493
1266
  if (chunk.type === "start") open.set(chunk.id, chunk.version);else if (chunk.type === "complete" || chunk.type === "error" && !chunk.key) open.delete(chunk.id);
1494
1267
  if (observation) observation.chunk(chunk, wireId);
1495
- if (chunk.type === "data" && host.prepareData) await host.prepareData();
1268
+ const needs = chunk.tiers?.map(prepareTier) || [];
1269
+ if (chunk.type === "data" || chunk.type === "slot" && Object.values(chunk.args).some(v => v && v.$ref)) await Promise.all([host.prepareData?.(), ...needs]);
1496
1270
  host.apply(chunk);
1497
1271
  }
1498
1272
  result = await reader.next();
1499
1273
  }
1500
1274
  };
1501
1275
  const end = error => {
1502
- const dead = error || cancelled || new Error("Frame stream ended before the frame completed.");
1503
- const sweep = () => {
1504
- for (const id of open.keys()) host.apply(errorRecord(id, dead));
1505
- };
1506
- if (connection) {
1507
- connection.done = true;
1508
- resolveEnd({
1509
- open: open.size,
1510
- error: dead,
1511
- sweep,
1512
- close: () => {}
1513
- });
1514
- } else if (error === undefined) sweep();
1276
+ if (error === undefined) for (const id of open.keys()) host.apply(errorRecord(id, new Error("Frame stream ended before the frame completed.")));
1515
1277
  };
1516
1278
  return drain().then(() => {
1517
1279
  end(undefined);
@@ -1524,7 +1286,19 @@ function applyFrames(response, host, options = {}, observation) {
1524
1286
  const SERVER_COMPONENT = /*#__PURE__*/Symbol.for("solid.server-component");
1525
1287
  const SERVER_COMPONENT_ADDRESS = /*#__PURE__*/Symbol.for("solid.server-component-address");
1526
1288
  const COMPONENT_BINDING = /*#__PURE__*/Symbol.for("solid.component-binding");
1289
+ const CONTENT_TOKEN = "\u0000";
1290
+ function contentAddress(token) {
1291
+ return token.split(CONTENT_TOKEN)[0];
1292
+ }
1293
+ const stagedContent = {
1294
+ preview() {},
1295
+ commit() {}
1296
+ };
1527
1297
  let resolveServerComponent;
1298
+ const calls = new Map();
1299
+ function callFor(address) {
1300
+ return calls.get(address);
1301
+ }
1528
1302
  function parseServerComponent(value, ctx) {
1529
1303
  return {
1530
1304
  id: ctx.parse(value[SERVER_COMPONENT]),
@@ -1570,7 +1344,6 @@ function flightCodec(codec) {
1570
1344
  function createServerComponentHandler({
1571
1345
  host,
1572
1346
  component,
1573
- onStream,
1574
1347
  intercept
1575
1348
  }) {
1576
1349
  const byFn = new Map();
@@ -1593,46 +1366,78 @@ function createServerComponentHandler({
1593
1366
  }
1594
1367
  return binding;
1595
1368
  };
1596
- resolveServerComponent = (id, address) => bindingFor(address, id);
1369
+ const staged = new Map();
1370
+ const latest = new Map();
1371
+ const stage = (address, base, version) => {
1372
+ if (!base) return undefined;
1373
+ let committed = false;
1374
+ const chunks = [];
1375
+ const token = address + CONTENT_TOKEN + version;
1376
+ const entry = {
1377
+ token,
1378
+ prepareData: host.prepareData,
1379
+ apply(chunk) {
1380
+ if (committed || chunk.type === "data") host.apply(chunk);else chunks.push(chunk);
1381
+ },
1382
+ preview() {
1383
+ if (host.preview) for (const chunk of chunks) host.preview(chunk);
1384
+ },
1385
+ commit() {
1386
+ committed = true;
1387
+ staged.delete(address);
1388
+ for (const chunk of chunks) host.apply(chunk);
1389
+ }
1390
+ };
1391
+ staged.set(address, entry);
1392
+ const comp = base[COMPONENT_BINDING].component;
1393
+ const binding = props => comp(props, () => token);
1394
+ binding[COMPONENT_BINDING] = {
1395
+ component: comp,
1396
+ address: token
1397
+ };
1398
+ latest.set(address, binding);
1399
+ return entry;
1400
+ };
1401
+ const settled = (address, binding) => latest.get(address) || binding;
1402
+ const showing = address => {
1403
+ const frame = host.get(address);
1404
+ return frame !== undefined && frame.error === undefined;
1405
+ };
1406
+ const named = (token, half) => {
1407
+ const entry = staged.get(contentAddress(token));
1408
+ if (entry && entry.token === token) entry[half]();
1409
+ };
1410
+ stagedContent.preview = token => named(token, "preview");
1411
+ stagedContent.commit = token => named(token, "commit");
1412
+ resolveServerComponent = (id, address) => settled(address, bindingFor(address, id));
1597
1413
  const versions = new Map();
1598
- const connections = new Map();
1599
1414
  const bump = address => {
1600
1415
  const version = (versions.get(address) || 0) + 1;
1601
1416
  versions.set(address, version);
1602
- const connection = connections.get(address);
1603
- if (connection) {
1604
- connections.delete(address);
1605
- connection.cancel(new Error("Superseded by a newer response for the address."));
1606
- }
1417
+ staged.delete(address);
1418
+ tierLoads.wire?.r?.cancel(host, address);
1607
1419
  return version;
1608
1420
  };
1609
- const hold = (address, connection) => {
1610
- connections.set(address, connection);
1611
- connection.ended.then(() => {
1612
- if (connections.get(address) === connection) connections.delete(address);
1613
- });
1614
- };
1421
+ const begin = (address, version) => host.apply({
1422
+ type: "start",
1423
+ id: address,
1424
+ version
1425
+ });
1615
1426
  return {
1616
1427
  intercept: intercept && (info => {
1617
1428
  const hit = intercept(info);
1618
1429
  if (hit === undefined) return undefined;
1619
- const binding = () => bindingFor(frameAddress(info.id, info.args), info.id);
1430
+ const address = frameAddress(info.id, info.args);
1431
+ if (!info.meta?.live) calls.set(address, info);
1432
+ const binding = () => bindingFor(address, info.id);
1620
1433
  if (typeof hit.then === "function") return hit.then(landed => landed ? binding() : undefined);
1621
1434
  return binding();
1622
1435
  }),
1436
+ onLive() {
1437
+ prepareTier("wire");
1438
+ },
1623
1439
  resume(info) {
1624
- const address = frameAddress(info.id, info.args);
1625
- const version = versions.get(address);
1626
- const frame = host.get(address);
1627
- const have = frame && frame.have ? frame.have() : undefined;
1628
- if (version === undefined && !have) return undefined;
1629
- const encoded = have && encodeHaveList(have);
1630
- return {
1631
- position: String(version || 0),
1632
- headers: encoded ? {
1633
- [FRAME_HAVE_HEADER]: encoded
1634
- } : undefined
1635
- };
1440
+ return tierLoads.wire?.r?.resume(host, info, versions);
1636
1441
  },
1637
1442
  handle(response, ctx) {
1638
1443
  if (!isFrameStreamResponse(response)) return undefined;
@@ -1642,31 +1447,16 @@ function createServerComponentHandler({
1642
1447
  return applyFlightResponse(response, address, binding);
1643
1448
  }
1644
1449
  const wire = ctx[LIVE_WIRE];
1645
- const connection = wire && wire.connection;
1646
- if (connection) {
1647
- const current = connections.get(address);
1648
- if (current && !current.done) {
1649
- connection.ended = current.ended;
1650
- const body = response.body;
1651
- if (body) body.cancel().catch(() => {});
1652
- return binding;
1653
- }
1654
- const version = bump(address);
1655
- if (onStream) onStream(address, version, response);
1656
- applyFrameResponse(response, host, {
1657
- as: address,
1658
- version,
1659
- [LIVE_WIRE]: wire
1660
- }).catch(() => {});
1661
- hold(address, connection);
1662
- return binding;
1663
- }
1450
+ if (wire) return prepareTier("wire").then(() => tierLoads.wire.r.connect(response, wire, address, binding, host, bump, begin));
1451
+ calls.set(address, ctx);
1664
1452
  const version = bump(address);
1665
- if (onStream) onStream(address, version, response);
1666
- applyFrameResponse(response, host, {
1453
+ const entry = showing(address) ? stage(address, binding, version) : undefined;
1454
+ if (!entry) begin(address, version);
1455
+ const target = entry || host;
1456
+ const applied = applyFrameResponse(response, target, {
1667
1457
  as: address,
1668
1458
  version
1669
- }).catch(err => host.apply({
1459
+ }).catch(err => target.apply({
1670
1460
  type: "error",
1671
1461
  id: address,
1672
1462
  version,
@@ -1674,17 +1464,10 @@ function createServerComponentHandler({
1674
1464
  message: String(err && err.message)
1675
1465
  }
1676
1466
  }));
1677
- return binding;
1467
+ return entry ? applied.then(() => settled(address, binding)) : binding;
1678
1468
  },
1679
1469
  showing(address, functionId) {
1680
1470
  bindingFor(address, functionId);
1681
- const comp = componentFor(functionId);
1682
- if (comp && (typeof comp === "function" || typeof comp === "object") && !comp[COMPONENT_BINDING]) {
1683
- comp[COMPONENT_BINDING] = {
1684
- component: comp,
1685
- address
1686
- };
1687
- }
1688
1471
  }
1689
1472
  };
1690
1473
  async function applyFlightResponse(response, address, binding) {
@@ -1698,11 +1481,26 @@ function createServerComponentHandler({
1698
1481
  });
1699
1482
  const payload = deserializeStream(new Response(source), flightCodec(getServerFunctionsCodec()));
1700
1483
  let carried = false;
1701
- await applyFrameResponse(response, host, {
1484
+ const regions = new Map();
1485
+ const regionOf = id => {
1486
+ for (const [root, entry] of regions) if (id === root || id.startsWith(root + ".")) return entry;
1487
+ };
1488
+ const target = {
1489
+ apply: chunk => {
1490
+ const entry = regionOf(chunk.id);
1491
+ if (entry) entry.apply(chunk);else host.apply(chunk);
1492
+ },
1493
+ prepareData: host.prepareData
1494
+ };
1495
+ await applyFrameResponse(response, target, {
1702
1496
  as,
1703
1497
  version: frameId => {
1704
1498
  const version = bump(frameId);
1705
- if (onStream) onStream(frameId, version, response);
1499
+ let entry = regionOf(frameId);
1500
+ if (!entry && showing(frameId)) {
1501
+ entry = stage(frameId, frameId === as ? binding : byAddress.get(frameId), version);
1502
+ if (entry) regions.set(frameId, entry);
1503
+ }
1706
1504
  return version;
1707
1505
  },
1708
1506
  onOutcome: text => {
@@ -1717,49 +1515,19 @@ function createServerComponentHandler({
1717
1515
  if (response.headers.has(ERROR_HEADER) && !hasFlightMetadata(response)) {
1718
1516
  throw envelope.value;
1719
1517
  }
1720
- return rootId ? binding : envelope.value;
1518
+ return rootId ? settled(address, binding) : envelope.value;
1721
1519
  }
1722
1520
  }
1723
1521
 
1724
- const STATE = Symbol.for("solid.container-trace-state");
1725
- const state = globalThis[STATE] || (globalThis[STATE] = {
1726
- materialized: new WeakMap(),
1727
- materializedValues: new WeakSet()
1728
- });
1729
- function setContainerTraceMaterializer(fn) {
1730
- state.materializeTrace = fn;
1731
- }
1732
- function materialize(marker) {
1733
- let value = state.materialized.get(marker.$tr);
1734
- if (value === undefined) {
1735
- value = state.materializeTrace(marker);
1736
- state.materialized.set(marker.$tr, value);
1737
- if (value !== null && typeof value === "object") state.materializedValues.add(value);
1738
- }
1739
- return value;
1740
- }
1741
- function isMaterializedContainer(value) {
1742
- return value !== null && typeof value === "object" && state.materializedValues.has(value);
1743
- }
1744
- function isContainerTraceMarker(value) {
1745
- if (value == null || typeof value !== "object" || value.$tr == null) return false;
1746
- const tr = value.$tr;
1747
- return tr.__SEROVAL_STREAM__ === true || typeof tr[Symbol.asyncIterator] === "function";
1748
- }
1749
- function reviveContainerTraces(value) {
1750
- if (!state.materializeTrace || value == null || typeof value !== "object") return value;
1751
- if (isContainerTraceMarker(value)) return materialize(value);
1752
- if (Array.isArray(value)) {
1753
- for (let i = 0; i < value.length; i++) value[i] = reviveContainerTraces(value[i]);
1754
- } else if (Object.getPrototypeOf(value) === Object.prototype) {
1755
- for (const key of Object.keys(value)) value[key] = reviveContainerTraces(value[key]);
1756
- }
1757
- return value;
1758
- }
1522
+ const createLoadingBoundary = core.createLoadingBoundary;
1523
+ const sharedConfig = core.sharedConfig;
1759
1524
 
1760
- const materializeContainerTrace = core.materializeContainerTrace;
1761
-
1762
- setContainerTraceMaterializer(materializeContainerTrace);
1525
+ const TRACE_STATE = Symbol.for("solid.container-trace-state");
1526
+ tierLoaders.trace = () => import('@solidjs/web/frames/trace');
1527
+ tierLoaders.regions = () => import('@solidjs/web/frames/regions');
1528
+ tierLoaders.assets = () => import('@solidjs/web/frames/assets');
1529
+ tierLoaders.bind = () => import('@solidjs/web/frames/bind');
1530
+ tierLoaders.wire = () => import('@solidjs/web/frames/wire');
1763
1531
  function asyncArg(value) {
1764
1532
  return value;
1765
1533
  }
@@ -1772,117 +1540,119 @@ function loadCodec() {
1772
1540
  });
1773
1541
  }
1774
1542
  const tables = new Map();
1775
- function ensureTable(root) {
1776
- let table = tables.get(root);
1777
- if (!table && codec) tables.set(root, table = codec.createJSONDataTable());
1778
- return table;
1543
+ function tableFor(id, version, current) {
1544
+ let byVersion = tables.get(id);
1545
+ if (!byVersion) tables.set(id, byVersion = new Map());else for (const v of byVersion.keys()) if (v < current) byVersion.delete(v);
1546
+ let t = byVersion.get(version);
1547
+ if (!t && codec) byVersion.set(version, t = codec.createJSONDataTable());
1548
+ return t;
1549
+ }
1550
+ function followAddress(host, frame, binding) {
1551
+ createRenderEffect(() => {
1552
+ const token = binding();
1553
+ stagedContent.preview(token);
1554
+ return token;
1555
+ }, token => {
1556
+ stagedContent.commit(token);
1557
+ frame.rebind(contentAddress(token));
1558
+ });
1559
+ }
1560
+ function landing(host, address, value, failed) {
1561
+ let thrown = host.get(address)?.error;
1562
+ return createMemo(() => {
1563
+ failed();
1564
+ const error = host.get(address)?.error;
1565
+ if (error !== undefined && error !== thrown) {
1566
+ thrown = error;
1567
+ throw error;
1568
+ }
1569
+ const wait = host.landing(address);
1570
+ if (!wait) return value;
1571
+ const asked = error !== undefined ? reask(address) : undefined;
1572
+ return (asked ? asked.then(() => wait) : wait).then(() => value);
1573
+ });
1779
1574
  }
1780
- function tableFor(id) {
1781
- if (tables.has(id)) return ensureTable(id);
1782
- for (const root of tables.keys()) if (id.startsWith(root + ".")) return ensureTable(root);
1783
- return undefined;
1575
+ function reask(address) {
1576
+ const call = callFor(address);
1577
+ return call && call.retry();
1784
1578
  }
1785
- function beginStream(frameId) {
1786
- tables.set(frameId, undefined);
1579
+ function failing() {
1580
+ const [failed, setFailed] = createSignal(0, {
1581
+ ownedWrite: true
1582
+ });
1583
+ return [failed, info => info.reason === "error" && setFailed(n => n + 1)];
1787
1584
  }
1788
1585
  function getFrameHost() {
1789
1586
  if (!sharedHost) {
1790
1587
  sharedHost = createFrameHost({
1791
1588
  prepareData: loadCodec,
1792
- applyData: c => tableFor(c.id)?.apply(c),
1793
- resolve: (ref, id) => tableFor(id)?.resolve(ref),
1794
- revive: reviveContainerTraces,
1795
- isContainer: isMaterializedContainer,
1796
- delegate: delegateEvents
1589
+ applyData: (c, current) => tableFor(c.id, c.version, current)?.apply(c),
1590
+ resolve: (ref, id, version, current) => tableFor(id, version, current)?.resolve(ref),
1591
+ closeData: (id, version, error) => tables.get(id)?.get(version)?.close(error)
1797
1592
  });
1798
1593
  }
1799
1594
  return sharedHost;
1800
1595
  }
1801
- function normalizeSlotContent(value) {
1802
- while (typeof value === "function") value = value();
1803
- if (Array.isArray(value)) {
1804
- const out = [];
1805
- for (const v of value) {
1806
- const n = normalizeSlotContent(v);
1807
- Array.isArray(n) ? out.push(...n) : out.push(n);
1808
- }
1809
- return out;
1810
- }
1811
- if (value == null || typeof value === "boolean") return document.createTextNode("");
1812
- return value instanceof Node ? value : document.createTextNode(String(value));
1813
- }
1814
- function gatherClaims(el, registry) {
1815
- if (el.hasAttribute("_hk")) registry.set(el.getAttribute("_hk"), el);
1816
- if (el.hasAttribute(FRAME_ID_ATTR)) return;
1817
- for (let c = el.firstElementChild; c; c = c.nextElementSibling) gatherClaims(c, registry);
1818
- }
1819
- function hasPendingFragment(existing) {
1820
- for (const n of existing) {
1821
- if (n.nodeType !== 1) continue;
1822
- const el = n;
1823
- if (el.tagName === "TEMPLATE" && el.id.startsWith("pl-")) return true;
1824
- if (el.querySelector?.('template[id^="pl-"]')) return true;
1825
- }
1826
- return false;
1827
- }
1828
- function claimRender(prefix, existing, render) {
1596
+ function claimRender(prefix, existing, render, scope, bound) {
1829
1597
  const sc = sharedConfig;
1830
- if (!sc.getNextContextId) return render();
1831
- const registry = new Map();
1832
- for (const n of existing) {
1833
- if (n.nodeType !== 1) continue;
1834
- gatherClaims(n, registry);
1835
- }
1836
- if (!registry.size && !hasPendingFragment(existing)) return render();
1837
- const prevRegistry = sc.registry;
1838
- const prevHydrating = sc.hydrating;
1839
- const prevClaimRoots = sc.claimRoots;
1840
- if (prevRegistry) for (const key of registry.keys()) prevRegistry.delete(key);
1841
- sc.registry = registry;
1842
- sc.hydrating = true;
1598
+ if (!sc.hydrateWindow || !sc.registry) return render();
1599
+ const prevRoots = sc.claimRoots;
1843
1600
  sc.claimRoots = existing;
1844
1601
  try {
1845
1602
  return runWithOwner(createOwner({
1846
1603
  id: prefix
1847
- }), render);
1604
+ }), () => sc.hydrateWindow(bound ? undefined : prefix, render, scope));
1848
1605
  } finally {
1849
- sc.registry = prevRegistry;
1850
- sc.hydrating = prevHydrating;
1851
- sc.claimRoots = prevClaimRoots;
1606
+ sc.claimRoots = prevRoots;
1852
1607
  }
1853
1608
  }
1854
1609
  function liveSlotProps(initial, ctx) {
1855
- const [args, setArgs] = createSignal(initial);
1610
+ const [args, setArgs] = createSignal(initial, {
1611
+ ownedWrite: true
1612
+ });
1856
1613
  ctx.onUpdate(next => setArgs(() => next));
1857
1614
  return slotArgsProxy(args);
1858
1615
  }
1859
- function isAsyncValue(v) {
1860
- return v !== null && typeof v === "object" && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
1616
+ function sameArg(a, b) {
1617
+ if (a === b) return true;
1618
+ if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
1619
+ if (a instanceof Boxed || b instanceof Boxed) return a instanceof Boxed && b instanceof Boxed && a.c === b.c;
1620
+ if (isAsyncValue(a) || isAsyncValue(b) || a instanceof Node || b instanceof Node) return false;
1621
+ try {
1622
+ return JSON.stringify(a) === JSON.stringify(b);
1623
+ } catch {
1624
+ return false;
1625
+ }
1626
+ }
1627
+ class Boxed {
1628
+ constructor(c) {
1629
+ this.c = c;
1630
+ }
1861
1631
  }
1862
1632
  function slotArgsProxy(args) {
1863
1633
  const owner = getOwner();
1864
- const asyncReads = new Map();
1634
+ const reads = new Map();
1865
1635
  return new Proxy({}, {
1866
1636
  get: (_, key) => {
1867
- const v = args()[key];
1868
- if (isMaterializedContainer(v)) return v;
1869
- if (!isAsyncValue(v)) return v;
1870
- let read = asyncReads.get(key);
1637
+ let read = reads.get(key);
1871
1638
  if (!read) {
1872
1639
  const make = () => createMemo(() => {
1873
1640
  const raw = args()[key];
1641
+ if (globalThis[TRACE_STATE]?.materializedValues.has(raw)) return new Boxed(raw);
1874
1642
  if (raw != null && typeof raw.then === "function") {
1875
1643
  if (raw.s === 1) return raw.v;
1876
1644
  if (raw.s === 2) throw raw.v;
1877
1645
  }
1878
1646
  return raw;
1879
1647
  }, {
1880
- transparent: true
1648
+ transparent: true,
1649
+ equals: sameArg
1881
1650
  });
1882
1651
  read = owner ? runWithOwner(owner, make) : make();
1883
- asyncReads.set(key, read);
1652
+ reads.set(key, read);
1884
1653
  }
1885
- return read();
1654
+ const v = read();
1655
+ return v instanceof Boxed ? v.c : v;
1886
1656
  },
1887
1657
  has: (_, key) => key in args(),
1888
1658
  ownKeys: () => Reflect.ownKeys(args()),
@@ -1892,31 +1662,37 @@ function slotArgsProxy(args) {
1892
1662
  } : undefined
1893
1663
  });
1894
1664
  }
1895
- function isReactiveContent(value) {
1896
- if (typeof value === "function") return true;
1897
- if (Array.isArray(value)) {
1898
- for (const v of value) if (isReactiveContent(v)) return true;
1899
- }
1900
- return false;
1901
- }
1902
- function slotsFor(props) {
1903
- const bindings = new Map();
1665
+ function slotsFor(props, scope) {
1904
1666
  const fillScopes = new Map();
1905
1667
  return new Proxy({}, {
1906
1668
  get(_, prop) {
1907
1669
  if (typeof prop !== "string" || !(prop in props)) return undefined;
1908
1670
  return (slotProps, ctx) => {
1909
1671
  const key = ctx && ctx.key;
1910
- const prev = key !== undefined && bindings.get(key);
1911
- if (prev) {
1912
- bindings.delete(key);
1913
- prev.dispose();
1914
- }
1915
1672
  const prevFill = key !== undefined && fillScopes.get(key);
1916
1673
  if (prevFill) {
1917
1674
  fillScopes.delete(key);
1918
1675
  prevFill.dispose();
1919
1676
  }
1677
+ if (ctx && ctx.positions) {
1678
+ const fill = props[prop];
1679
+ if (typeof fill !== "function") {
1680
+ return undefined;
1681
+ }
1682
+ const owner = createOwner();
1683
+ fillScopes.set(key, owner);
1684
+ ctx.onCleanup(() => {
1685
+ if (fillScopes.get(key) === owner) fillScopes.delete(key);
1686
+ owner.dispose();
1687
+ });
1688
+ runWithOwner(owner, () => {
1689
+ const args = ctx.onUpdate ? liveSlotProps(slotProps, ctx) : slotArgsProxy(() => slotProps);
1690
+ tierLoads.bind.r.bind(fill, args, ctx, undefined);
1691
+ });
1692
+ return undefined;
1693
+ }
1694
+ const range = ctx && ctx.range;
1695
+ if (!range) return undefined;
1920
1696
  const fillOwner = streamInvoke ? createOwner() : null;
1921
1697
  if (fillOwner && key !== undefined && ctx) {
1922
1698
  fillScopes.set(key, fillOwner);
@@ -1925,42 +1701,31 @@ function slotsFor(props) {
1925
1701
  fillOwner.dispose();
1926
1702
  });
1927
1703
  }
1928
- const settle = out => {
1929
- const existing = ctx && ctx.existing || [];
1930
- if (existing.length) {
1931
- const list = Array.isArray(out) ? out : [out];
1932
- const inPlace = list.every(n => existing.some(e => e === n || e.nodeType === 1 && e.contains(n)));
1933
- if (inPlace) return undefined;
1934
- }
1935
- return out;
1936
- };
1937
1704
  const evaluate = () => {
1938
1705
  const v = props[prop];
1939
1706
  if (typeof v === "function" && ctx && ctx.invoked) {
1940
- return v(ctx.onUpdate ? liveSlotProps(slotProps, ctx) : slotArgsProxy(() => slotProps));
1707
+ const fillProps = ctx.onUpdate ? liveSlotProps(slotProps, ctx) : slotArgsProxy(() => slotProps);
1708
+ return untrack(() => v(fillProps), undefined);
1941
1709
  }
1942
1710
  return v;
1943
1711
  };
1944
1712
  const adopted = !!(ctx && ctx.frame && ctx.adopted && ctx.existing && ctx.existing.length);
1945
1713
  const prefix = ctx && ctx.frame ? `sc-${ctx.frame}-${ctx.key}-` : "";
1946
- const value = fillOwner ? runWithOwner(fillOwner, () => adopted ? claimRender(prefix, ctx.existing, evaluate) : evaluate()) : adopted ? claimRender(prefix, ctx.existing, evaluate) : evaluate();
1947
- if (!isReactiveContent(value)) {
1948
- return settle(normalizeSlotContent(value));
1949
- }
1950
- if (ctx && ctx.range) {
1951
- const source = value;
1952
- const owner = createOwner();
1953
- bindings.set(key, owner);
1714
+ const value = fillOwner ? runWithOwner(fillOwner, () => adopted ? claimRender(prefix, ctx.existing, evaluate, scope) : evaluate()) : adopted ? claimRender(prefix, ctx.existing, evaluate, scope) : evaluate();
1715
+ const owner = fillOwner || createOwner({
1716
+ transparent: true
1717
+ });
1718
+ if (!fillOwner) {
1719
+ fillScopes.set(key, owner);
1954
1720
  ctx.onCleanup(() => {
1955
- if (bindings.get(key) === owner) bindings.delete(key);
1721
+ if (fillScopes.get(key) === owner) fillScopes.delete(key);
1956
1722
  owner.dispose();
1957
1723
  });
1958
- const end = ctx.range.end;
1959
- const bind = () => insert(end.parentNode, () => typeof source === "function" ? source() : source, end, [...ctx.existing]);
1960
- runWithOwner(owner, () => adopted ? claimRender(prefix, ctx.existing, bind) : bind());
1961
- return undefined;
1962
1724
  }
1963
- return settle(normalizeSlotContent(value));
1725
+ const end = range.end;
1726
+ const bind = () => insert(end.parentNode, value, end, [...ctx.existing]);
1727
+ runWithOwner(owner, () => adopted ? claimRender(prefix, ctx.existing, bind, scope, true) : bind());
1728
+ return undefined;
1964
1729
  };
1965
1730
  }
1966
1731
  });
@@ -1983,12 +1748,8 @@ function boundaryScope(owner) {
1983
1748
  function boundaryComponent(host, fnId) {
1984
1749
  return (props, binding) => {
1985
1750
  const owner = getOwner();
1986
- const id = binding ? binding() : fnId;
1987
- let applied = !tables.has(id);
1988
- let release;
1989
- const arm = () => new Promise(r => release = r);
1990
- const mountGate = applied ? undefined : arm();
1991
- let setGate;
1751
+ const id = binding ? contentAddress(binding()) : fnId;
1752
+ const [failed, onApply] = failing();
1992
1753
  const {
1993
1754
  element,
1994
1755
  frame,
@@ -1997,33 +1758,14 @@ function boundaryComponent(host, fnId) {
1997
1758
  host,
1998
1759
  id,
1999
1760
  slots: slotsFor(props),
2000
- props,
2001
1761
  ownerScope: boundaryScope(owner),
2002
1762
  reveal: revealSeam(owner),
2003
- onApply: () => {
2004
- applied = true;
2005
- if (release) {
2006
- release();
2007
- release = undefined;
2008
- }
2009
- setGate && setGate(undefined);
2010
- }
1763
+ onApply
2011
1764
  });
2012
- const [gatePromise, setGatePromise] = createSignal(applied ? undefined : mountGate);
2013
- setGate = setGatePromise;
2014
- if (binding) {
2015
- createRenderEffect(binding, (address, prev) => {
2016
- if (prev !== undefined && address !== prev && tables.has(address)) {
2017
- applied = false;
2018
- setGatePromise(arm());
2019
- }
2020
- frame.rebind(address);
2021
- });
2022
- }
2023
1765
  onCleanup(dispose);
2024
- if (applied && !binding) return element;
2025
- const gate = createMemo(() => gatePromise());
2026
- return createMemo(() => (gate(), element));
1766
+ if (!binding) return landing(host, id, element, failed);
1767
+ followAddress(host, frame, binding);
1768
+ return createMemo(() => landing(host, contentAddress(binding()), element, failed));
2027
1769
  };
2028
1770
  }
2029
1771
  const claimedBoundaries = new Set();
@@ -2038,7 +1780,7 @@ function pumpLiveChannel() {
2038
1780
  const pump = () => reader.read().then(r => {
2039
1781
  if (r.done) return;
2040
1782
  const op = r.value;
2041
- liveOps.set(`${op.type}:${op.fid || ""}:${op.key || ""}`, op);
1783
+ for (const m of op.type === "ops" ? op.ops : [op]) liveOps.set(`${m.type}:${m.fid || ""}:${m.key || ""}`, m);
2042
1784
  for (const apply of liveAppliers) apply(op);
2043
1785
  return pump();
2044
1786
  });
@@ -2048,7 +1790,7 @@ function pumpLiveChannel() {
2048
1790
  let boundaryIndex = null;
2049
1791
  const isBoundaryId = id => !id.includes(".");
2050
1792
  function indexBoundaries(root) {
2051
- root.querySelectorAll(`[${FRAME_ID_ATTR}]`).forEach(el => {
1793
+ root.querySelectorAll(FRAME_SELECTOR).forEach(el => {
2052
1794
  const key = el.getAttribute(FRAME_ID_ATTR);
2053
1795
  if (key && isBoundaryId(key) && !boundaryIndex.has(key)) boundaryIndex.set(key, el);
2054
1796
  });
@@ -2060,8 +1802,9 @@ function findBoundaryElement(id) {
2060
1802
  }
2061
1803
  return boundaryIndex.get(id);
2062
1804
  }
2063
- const boundaryWaiters = new Map();
2064
1805
  const arrivals = new Map();
1806
+ const FRAME_SELECTOR = `[${FRAME_ID_ATTR}]`;
1807
+ const disposedFrames = new WeakSet();
2065
1808
  function awaitBoundary(id) {
2066
1809
  let arrival = arrivals.get(id);
2067
1810
  if (!arrival) {
@@ -2083,18 +1826,16 @@ function installRevealHook() {
2083
1826
  const hy = globalThis._$HY;
2084
1827
  if (!hy || hy.$sc || !hy.fr) return;
2085
1828
  hy.$sc = true;
1829
+ hy.fa = pl => {
1830
+ const el = pl.closest(FRAME_SELECTOR);
1831
+ return !!el && !disposedFrames.has(el);
1832
+ };
2086
1833
  hy.fr.subscribe((_id, parent) => {
2087
1834
  if (!boundaryIndex) return;
2088
1835
  const root = parent || (typeof document !== "undefined" ? document.body : null);
2089
1836
  if (root) indexBoundaries(root);
2090
- if (!boundaryWaiters.size && !arrivals.size) return;
1837
+ if (!arrivals.size) return;
2091
1838
  const exhausted = hy.done && !hy.fr.pending();
2092
- for (const [id, notify] of boundaryWaiters) {
2093
- const el = boundaryIndex && boundaryIndex.get(id);
2094
- if (!el && !exhausted) continue;
2095
- boundaryWaiters.delete(id);
2096
- notify(el);
2097
- }
2098
1839
  for (const [id, arrival] of arrivals) {
2099
1840
  const el = boundaryIndex && boundaryIndex.get(id);
2100
1841
  if (!el && !exhausted) continue;
@@ -2108,37 +1849,21 @@ function documentBoundary(host, id, props, binding) {
2108
1849
  const claimed = claimedBoundaries.has(id);
2109
1850
  const el = !claimed ? findBoundaryElement(id) : undefined;
2110
1851
  if (el) return adoptBoundary(host, id, el, props, binding);
2111
- if (!claimed && !boundaryWaiters.has(id) && boundaryMayArrive()) {
1852
+ if (!claimed && boundaryMayArrive()) {
2112
1853
  const owner = getOwner();
2113
- const arrival = new Promise(resolve => boundaryWaiters.set(id, resolve));
2114
- onCleanup(() => boundaryWaiters.delete(id));
2115
- return createMemo(() => arrival.then(node => runWithOwner(owner, () =>
2116
- node ? adoptBoundary(host, id, node, props, binding) : boundaryComponent(host, id)(props, binding))));
1854
+ let live = true;
1855
+ onCleanup(() => live = false);
1856
+ return createMemo(() => awaitBoundary(id).then(() => live && runWithOwner(owner, () => {
1857
+ const node = claimedBoundaries.has(id) ? undefined : findBoundaryElement(id);
1858
+ return node ? adoptBoundary(host, id, node, props, binding) : boundaryComponent(host, id)(props, binding);
1859
+ })));
2117
1860
  }
2118
1861
  return boundaryComponent(host, id)(props, binding);
2119
1862
  }
2120
- function documentAddress(id) {
2121
- const records = globalThis._$SC?.a;
2122
- if (records) {
2123
- for (const address in records) if (records[address] === id) return address;
2124
- }
2125
- return id;
2126
- }
2127
1863
  function adoptBoundary(host, id, el, props, binding) {
2128
1864
  claimedBoundaries.add(id);
2129
- const address = binding ? binding() : documentAddress(id);
1865
+ const address = binding ? contentAddress(binding()) : id;
2130
1866
  const appliedRecords = new Set();
2131
- const claimedFragments = new Set();
2132
- const claimRegionFragments = root => {
2133
- const fr = globalThis._$HY?.fr;
2134
- if (!fr || !fr.claim) return;
2135
- root.querySelectorAll('template[id^="pl-"]').forEach(tpl => {
2136
- const fragId = tpl.id.slice(3);
2137
- if (claimedFragments.has(fragId)) return;
2138
- claimedFragments.add(fragId);
2139
- fr.claim(fragId);
2140
- });
2141
- };
2142
1867
  const drainRecords = () => {
2143
1868
  const hy = globalThis._$HY;
2144
1869
  if (!hy || !hy.r) return;
@@ -2148,13 +1873,17 @@ function adoptBoundary(host, id, el, props, binding) {
2148
1873
  if (appliedRecords.has(key)) continue;
2149
1874
  if (key.startsWith(slotPrefix)) {
2150
1875
  appliedRecords.add(key);
2151
- host.apply({
1876
+ const apply = args => host.apply({
2152
1877
  type: "slot",
2153
1878
  id: address,
2154
1879
  version: 0,
2155
1880
  key: key.slice(slotPrefix.length),
2156
- args: hy.r[key]
1881
+ args
2157
1882
  });
1883
+ const value = hy.r[key];
1884
+ if (value && typeof value.then === "function") {
1885
+ if (value.s === 1) apply(value.v);else if (value.s === 2) value.then(undefined, () => {});else value.then(apply, () => {});
1886
+ } else apply(value);
2158
1887
  } else if (key.startsWith("sc:region:")) {
2159
1888
  const childId = key.slice("sc:region:".length);
2160
1889
  if (childId.startsWith(id + ".")) {
@@ -2171,14 +1900,18 @@ function adoptBoundary(host, id, el, props, binding) {
2171
1900
  }
2172
1901
  }
2173
1902
  };
2174
- claimRegionFragments(el);
2175
1903
  const fr = globalThis._$HY?.fr;
1904
+ let frame;
2176
1905
  const unsubscribe = fr ? fr.subscribe((_fragId, parent) => {
2177
- if (fr.claim && parent && el.contains(parent)) claimRegionFragments(parent);
1906
+ const inside = !!parent && el.contains(parent);
2178
1907
  drainRecords();
1908
+ if (inside && frame) frame.apply({
1909
+ version: frame.version ?? 0,
1910
+ r: {}
1911
+ });
2179
1912
  }) : undefined;
2180
1913
  const applyLiveOp = op => {
2181
- if (op.type === "slot" && op.fid !== id) return;
1914
+ if (op.fid && op.fid !== id) return;
2182
1915
  host.apply({
2183
1916
  ...op,
2184
1917
  id: address,
@@ -2189,56 +1922,44 @@ function adoptBoundary(host, id, el, props, binding) {
2189
1922
  onCleanup(() => {
2190
1923
  liveAppliers.delete(applyLiveOp);
2191
1924
  unsubscribe && unsubscribe();
2192
- if (fr && fr.release) for (const fragId of claimedFragments) fr.release(fragId);
2193
1925
  });
2194
1926
  drainRecords();
2195
1927
  for (const op of liveOps.values()) applyLiveOp(op);
2196
1928
  const owner = getOwner();
2197
- let release;
2198
- let setGate;
2199
- const frame = createFrame(el, {
1929
+ const sc = sharedConfig;
1930
+ const [failed, onApply] = failing();
1931
+ frame = createFrame(el, {
2200
1932
  adopt: true,
2201
1933
  host,
2202
1934
  id: address,
2203
- slots: slotsFor(props),
2204
- props,
1935
+ slots: slotsFor(props, {
1936
+ registry: sc.registry,
1937
+ gather: sc.gather
1938
+ }),
2205
1939
  ownerScope: boundaryScope(owner),
2206
1940
  reveal: revealSeam(owner),
2207
- onApply: () => {
2208
- if (release) {
2209
- release();
2210
- release = undefined;
2211
- }
2212
- setGate && setGate(undefined);
2213
- },
1941
+ onApply,
1942
+ hold: () => sc.isHydrationInProgress?.() ? runWithOwner(owner, () => untrack(() => sc.holdBoundary("sc:" + id))) : () => {},
2214
1943
  ...{
2215
- recordsPending: () => {
2216
- if (document.readyState === "loading") return true;
2217
- const hy = globalThis._$HY;
2218
- return !!(hy && hy.fr && hy.fr.pending());
2219
- },
2220
- drainRecords,
2221
1944
  claimScope: id
2222
1945
  }
2223
1946
  });
2224
1947
  if (binding) {
2225
- const arm = () => new Promise(r => release = r);
2226
- const [gatePromise, setGatePromise] = createSignal(undefined);
2227
- setGate = setGatePromise;
2228
- const gate = createMemo(() => gatePromise());
2229
- createRenderEffect(binding, (address, prev) => {
2230
- if (prev !== undefined && address !== prev && tables.has(address)) {
2231
- setGatePromise(arm());
2232
- }
2233
- frame.rebind(address);
2234
- });
2235
- createRenderEffect(() => (gate(), undefined), () => {});
1948
+ followAddress(host, frame, binding);
1949
+ const source = createMemo(() => landing(host, contentAddress(binding()), true, failed));
1950
+ createRenderEffect(() => source()(), () => {});
2236
1951
  }
2237
- onCleanup(() => frame.dispose());
1952
+ onCleanup(() => {
1953
+ frame.dispose();
1954
+ disposedFrames.add(el);
1955
+ el.querySelectorAll(FRAME_SELECTOR).forEach(e => disposedFrames.add(e));
1956
+ });
2238
1957
  return el;
2239
1958
  }
2240
- function installServerComponents(host = getFrameHost()) {
1959
+ function installServerComponents(host = getFrameHost(), options) {
2241
1960
  const g = globalThis;
1961
+ Object.assign(tierLoaders, options?.tiers);
1962
+ g._$HY?.r?.["sc:tiers"]?.forEach(prepareTier);
2242
1963
  if (!g._$SC) {
2243
1964
  g._$SC = {
2244
1965
  c: {},
@@ -2263,7 +1984,6 @@ function installServerComponents(host = getFrameHost()) {
2263
1984
  const handler = createServerComponentHandler({
2264
1985
  host,
2265
1986
  component: fnId => g._$SC.r(fnId),
2266
- onStream: address => beginStream(address),
2267
1987
  intercept: ({
2268
1988
  id
2269
1989
  }) => {
@@ -2283,4 +2003,4 @@ function installServerComponents(host = getFrameHost()) {
2283
2003
  });
2284
2004
  }
2285
2005
 
2286
- export { FRAME_APPLIED_EVENT, FRAME_HAVE_BUDGET, FRAME_HAVE_HEADER, FRAME_STREAM_HEADER, applyFrameResponse, asyncArg, createFrame, createFrameElement, createFrameHost, createServerComponentHandler, getFrameHost, installServerComponents, isFrameStreamResponse };
2006
+ export { FRAME_APPLIED_EVENT, FRAME_STREAM_HEADER, applyFrameResponse, asyncArg, createFrame, createFrameElement, createFrameHost, createServerComponentHandler, getFrameHost, installServerComponents, isAsyncValue, isFrameStreamResponse };