octane 0.6.2 → 0.7.0

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 (200) hide show
  1. package/dist/cjs/constants.cjs +3 -0
  2. package/dist/cjs/dom-binding-handoff.cjs +2 -1
  3. package/dist/cjs/dom-binding-protocol.cjs +4 -3
  4. package/dist/cjs/dom-binding-styles.cjs +3 -2
  5. package/dist/cjs/dom-bindings.cjs +24 -23
  6. package/dist/cjs/error-codes.client.generated.cjs +7 -1
  7. package/dist/cjs/error-codes.server.generated.cjs +27 -1
  8. package/dist/cjs/hydration/event-capture.cjs +2 -1
  9. package/dist/cjs/independent-hydration-protocol.cjs +3 -2
  10. package/dist/cjs/index.cjs +2 -0
  11. package/dist/cjs/runtime.cjs +866 -370
  12. package/dist/cjs/runtime.server.cjs +250 -62
  13. package/dist/cjs/server/index.cjs +2 -0
  14. package/dist/cjs/server/rpc-stream.cjs +19 -12
  15. package/dist/cjs/server/streamed-signals.cjs +18 -1
  16. package/dist/cjs/shared-value-helpers.cjs +24 -2
  17. package/dist/cjs/signals/control-binding.cjs +7 -6
  18. package/dist/cjs/signals/derived-facade.cjs +2 -1
  19. package/dist/cjs/signals/document-owner.cjs +4 -3
  20. package/dist/cjs/signals/facade.cjs +10 -9
  21. package/dist/cjs/signals/graph.cjs +5 -4
  22. package/dist/cjs/signals/native-read-client.cjs +4 -3
  23. package/dist/cjs/signals/owner-context.cjs +4 -3
  24. package/dist/cjs/signals/query-attempt-observer.cjs +2 -1
  25. package/dist/cjs/signals/query-facade.cjs +2 -1
  26. package/dist/cjs/signals/scalar-computations.cjs +2 -1
  27. package/dist/cjs/signals/transition-action.cjs +10 -9
  28. package/dist/cjs/signals/transition-candidate.cjs +2 -1
  29. package/dist/cjs/version.cjs +1 -1
  30. package/dist/compiler/arm-exits.js +151 -0
  31. package/dist/compiler/compile-universal.js +262 -65
  32. package/dist/compiler/compile.js +1929 -306
  33. package/dist/compiler/deferred-snapshots.js +791 -0
  34. package/dist/compiler/strong-mode.js +59 -10
  35. package/dist/constants.d.ts +5 -1
  36. package/dist/constants.js +2 -0
  37. package/dist/error-codes.client.generated.d.ts +1 -0
  38. package/dist/error-codes.client.generated.js +5 -0
  39. package/dist/error-codes.server.generated.d.ts +5 -0
  40. package/dist/error-codes.server.generated.js +25 -0
  41. package/dist/index.d.ts +1 -1
  42. package/dist/index.js +2 -0
  43. package/dist/node/aria-diagnostics.js +92 -0
  44. package/dist/node/behavior-form-submissions.js +228 -0
  45. package/dist/node/behavior-root-types.js +0 -0
  46. package/dist/node/behavior-root.js +746 -0
  47. package/dist/node/class-names.js +25 -0
  48. package/dist/node/compatibility.js +10 -0
  49. package/dist/node/component-flags.js +23 -0
  50. package/dist/node/constants.js +115 -0
  51. package/dist/node/context-epoch.js +13 -0
  52. package/dist/node/context-identity.js +46 -0
  53. package/dist/node/css.js +80 -0
  54. package/dist/node/data-encoding.js +134 -0
  55. package/dist/node/devtools-hook.js +229 -0
  56. package/dist/node/dom-binding-claims.js +4 -0
  57. package/dist/node/dom-binding-classes.js +152 -0
  58. package/dist/node/dom-binding-controls.js +6 -0
  59. package/dist/node/dom-binding-handoff.js +77 -0
  60. package/dist/node/dom-binding-program.js +1617 -0
  61. package/dist/node/dom-binding-projections.js +204 -0
  62. package/dist/node/dom-binding-protocol.js +130 -0
  63. package/dist/node/dom-binding-signals.js +135 -0
  64. package/dist/node/dom-binding-styles.js +280 -0
  65. package/dist/node/dom-bindings.js +1087 -0
  66. package/dist/node/dom-focused-move.js +46 -0
  67. package/dist/node/dom-stage.js +878 -0
  68. package/dist/node/dom-tables.js +382 -0
  69. package/dist/node/error-codes.client.generated.js +1071 -0
  70. package/dist/node/error-codes.server.generated.js +761 -0
  71. package/dist/node/error-message.js +27 -0
  72. package/dist/node/event-names.js +15 -0
  73. package/dist/node/form-diagnostics.js +96 -0
  74. package/dist/node/form-submission.js +43 -0
  75. package/dist/node/has-own.js +4 -0
  76. package/dist/node/head-ownership.js +31 -0
  77. package/dist/node/hook-slot-cache.js +91 -0
  78. package/dist/node/host-property-diagnostics.js +189 -0
  79. package/dist/node/html-tree-validation.js +193 -0
  80. package/dist/node/hydration/condition.js +15 -0
  81. package/dist/node/hydration/control-capture.js +237 -0
  82. package/dist/node/hydration/document-lifecycle.js +89 -0
  83. package/dist/node/hydration/event-capture.js +362 -0
  84. package/dist/node/hydration/idle.js +23 -0
  85. package/dist/node/hydration/independent-island.js +317 -0
  86. package/dist/node/hydration/index.js +74 -0
  87. package/dist/node/hydration/interaction-config.js +61 -0
  88. package/dist/node/hydration/interaction.js +35 -0
  89. package/dist/node/hydration/load.js +15 -0
  90. package/dist/node/hydration/media.js +33 -0
  91. package/dist/node/hydration/native-intent.js +68 -0
  92. package/dist/node/hydration/never.js +12 -0
  93. package/dist/node/hydration/stream-delivery.js +345 -0
  94. package/dist/node/hydration/stream-receiver.js +190 -0
  95. package/dist/node/hydration/stream-result-receiver.js +276 -0
  96. package/dist/node/hydration/streamed-signals.js +186 -0
  97. package/dist/node/hydration/types.js +0 -0
  98. package/dist/node/hydration/visible.js +69 -0
  99. package/dist/node/hydration-markers.js +44 -0
  100. package/dist/node/independent-hydration-protocol.js +91 -0
  101. package/dist/node/index.js +463 -0
  102. package/dist/node/internal/client.js +7 -0
  103. package/dist/node/internal/context.js +5 -0
  104. package/dist/node/internal/server.js +5 -0
  105. package/dist/node/internal/signal-read.js +4 -0
  106. package/dist/node/method-dep.js +25 -0
  107. package/dist/node/profiling.js +432 -0
  108. package/dist/node/public-types.js +0 -0
  109. package/dist/node/react/fiber-adapter.js +57 -0
  110. package/dist/node/react/index.js +397 -0
  111. package/dist/node/react/react-compat-envelope.js +78 -0
  112. package/dist/node/react/react-compat-server.js +129 -0
  113. package/dist/node/react/react-compat-shared.js +104 -0
  114. package/dist/node/react/react-compat.js +223 -0
  115. package/dist/node/react/server.js +81 -0
  116. package/dist/node/react/shared.js +75 -0
  117. package/dist/node/renderer-bridge.js +35 -0
  118. package/dist/node/resize-observer.js +105 -0
  119. package/dist/node/resource-hint-diagnostics.js +67 -0
  120. package/dist/node/runtime-tags.js +22 -0
  121. package/dist/node/runtime.js +29364 -0
  122. package/dist/node/runtime.server.js +8200 -0
  123. package/dist/node/sanitize-url.js +34 -0
  124. package/dist/node/server/early-signals.js +54 -0
  125. package/dist/node/server/index.js +338 -0
  126. package/dist/node/server/rpc-batch.js +129 -0
  127. package/dist/node/server/rpc-stream.js +132 -0
  128. package/dist/node/server/rpc.js +48 -0
  129. package/dist/node/server/signal-query-observation.js +134 -0
  130. package/dist/node/server/streamed-region.js +31 -0
  131. package/dist/node/server/streamed-signals.js +574 -0
  132. package/dist/node/server-call.js +75 -0
  133. package/dist/node/server-rpc-batch-client.js +119 -0
  134. package/dist/node/server-rpc-client.js +108 -0
  135. package/dist/node/server-rpc-protocol.js +109 -0
  136. package/dist/node/server-rpc-stream-client.js +98 -0
  137. package/dist/node/shared-value-helpers.js +60 -0
  138. package/dist/node/signals/actions.js +463 -0
  139. package/dist/node/signals/client.js +22 -0
  140. package/dist/node/signals/computations.js +452 -0
  141. package/dist/node/signals/control-binding.js +388 -0
  142. package/dist/node/signals/control-handoff.js +12 -0
  143. package/dist/node/signals/derived-facade.js +25 -0
  144. package/dist/node/signals/document-owner.js +48 -0
  145. package/dist/node/signals/early-values.js +124 -0
  146. package/dist/node/signals/encoding.js +6 -0
  147. package/dist/node/signals/engine.js +668 -0
  148. package/dist/node/signals/errors.js +54 -0
  149. package/dist/node/signals/facade.js +441 -0
  150. package/dist/node/signals/graph.js +817 -0
  151. package/dist/node/signals/handle-protocol.js +11 -0
  152. package/dist/node/signals/index.js +87 -0
  153. package/dist/node/signals/native-read-client.js +319 -0
  154. package/dist/node/signals/native-read-collector.js +132 -0
  155. package/dist/node/signals/native-read-events.js +45 -0
  156. package/dist/node/signals/native-read-inspection.js +20 -0
  157. package/dist/node/signals/native-read-retry.js +30 -0
  158. package/dist/node/signals/native-read-seeds.js +243 -0
  159. package/dist/node/signals/native-read-server.js +99 -0
  160. package/dist/node/signals/owner-context.js +88 -0
  161. package/dist/node/signals/query-attempt-observer.js +42 -0
  162. package/dist/node/signals/query-facade.js +41 -0
  163. package/dist/node/signals/read-protocol.js +125 -0
  164. package/dist/node/signals/requests.js +716 -0
  165. package/dist/node/signals/scalar-computations.js +57 -0
  166. package/dist/node/signals/scope-streams.js +147 -0
  167. package/dist/node/signals/server.js +22 -0
  168. package/dist/node/signals/transition-action.js +555 -0
  169. package/dist/node/signals/transition-candidate.js +101 -0
  170. package/dist/node/signals/transition-coordinator.js +255 -0
  171. package/dist/node/signals/transition-state.js +82 -0
  172. package/dist/node/signals/types.js +20 -0
  173. package/dist/node/static/index.js +10 -0
  174. package/dist/node/stream-protocol.js +114 -0
  175. package/dist/node/streamed-signals-protocol.js +130 -0
  176. package/dist/node/style-values.js +96 -0
  177. package/dist/node/sub-slot.js +35 -0
  178. package/dist/node/testing.js +14 -0
  179. package/dist/node/trusted-html.js +6 -0
  180. package/dist/node/tsrx-iterable.js +5 -0
  181. package/dist/node/tsrx-spread.js +10 -0
  182. package/dist/node/universal-core.js +10138 -0
  183. package/dist/node/universal-dom-boundary.js +237 -0
  184. package/dist/node/universal-native.js +28 -0
  185. package/dist/node/universal.js +17 -0
  186. package/dist/node/version.js +4 -0
  187. package/dist/runtime.d.ts +219 -8
  188. package/dist/runtime.js +714 -220
  189. package/dist/runtime.server.d.ts +33 -2
  190. package/dist/runtime.server.js +217 -29
  191. package/dist/server/index.d.ts +1 -1
  192. package/dist/server/index.js +2 -0
  193. package/dist/server/rpc-stream.js +19 -12
  194. package/dist/server/streamed-signals.js +18 -1
  195. package/dist/shared-value-helpers.d.ts +11 -0
  196. package/dist/shared-value-helpers.js +21 -1
  197. package/dist/universal-core.d.ts +3 -1
  198. package/dist/universal-core.js +178 -50
  199. package/dist/version.js +1 -1
  200. package/package.json +62 -1
@@ -0,0 +1,716 @@
1
+ import { formatClientError } from "../error-codes.client.generated.js";
2
+ import { decodeSignalValue, encodeSignalValue } from "./encoding.js";
3
+ import { createResourceCellWith } from "./engine.js";
4
+ import { SignalStreamError } from "./errors.js";
5
+ import {
6
+ ScopedNode,
7
+ CandidateUnsupportedError,
8
+ assertAlive,
9
+ assertWritable,
10
+ errorState,
11
+ idleState,
12
+ invalidateNode,
13
+ isThenable,
14
+ pendingState,
15
+ publishNode,
16
+ pure,
17
+ readyState,
18
+ refreshNode,
19
+ releaseRetention,
20
+ signalBatch,
21
+ untrack,
22
+ untrackCommitted
23
+ } from "./graph.js";
24
+ import {
25
+ QUERY_REQUEST,
26
+ skip
27
+ } from "./types.js";
28
+ import {
29
+ captureCurrentServerSignalQueryAttemptObserver,
30
+ hasServerSignalQueryAttemptObserver,
31
+ serverSignalQueryAttemptObserver
32
+ } from "./query-attempt-observer.js";
33
+ class Request {
34
+ constructor(definition, argument) {
35
+ this.definition = definition;
36
+ this.queryKey = definition.key;
37
+ const encoded = encodeSignalValue(argument);
38
+ this.identity = JSON.stringify([definition.key, encoded]);
39
+ this.argument = decodeSignalValue(encoded);
40
+ Object.freeze(this);
41
+ }
42
+ definition;
43
+ get [QUERY_REQUEST]() {
44
+ return void 0;
45
+ }
46
+ queryKey;
47
+ identity;
48
+ argument;
49
+ }
50
+ function query(key, load, options) {
51
+ if (typeof key !== "string" || !key.trim() || typeof load !== "function") {
52
+ throw new TypeError(formatClientError(195));
53
+ }
54
+ const kind = options?.kind ?? "promise";
55
+ if (kind !== "promise" && kind !== "stream") throw new TypeError(formatClientError(196));
56
+ const definition = Object.freeze({ key, load, kind });
57
+ const describe = Object.assign((argument) => new Request(definition, argument), {
58
+ queryKey: key,
59
+ kind
60
+ });
61
+ return Object.freeze(describe);
62
+ }
63
+ function createResource(owner, key, describe) {
64
+ return createResourceCellWith(owner, key, describe, initializeResource, true);
65
+ }
66
+ function makeAttempt(entry, generation, streamed = false) {
67
+ let resolve;
68
+ const settled = new Promise((done) => {
69
+ resolve = done;
70
+ });
71
+ return {
72
+ entry,
73
+ controller: streamed ? void 0 : new AbortController(),
74
+ iterator: void 0,
75
+ settled,
76
+ generation,
77
+ streamed,
78
+ result: void 0,
79
+ observations: void 0,
80
+ sequence: 0,
81
+ resolve,
82
+ hasYielded: false
83
+ };
84
+ }
85
+ class RequestEntry {
86
+ constructor(owner, request, seed) {
87
+ this.owner = owner;
88
+ this.request = request;
89
+ this.state = seed ? readyState(seed.value, {
90
+ complete: seed.entry.complete,
91
+ connection: request.definition.kind === "stream" ? "closed" : "none",
92
+ requestKey: request.identity
93
+ }) : pendingState(Promise.resolve(), "none", request.identity);
94
+ }
95
+ owner;
96
+ request;
97
+ consumers = /* @__PURE__ */ new Set();
98
+ state;
99
+ attempt;
100
+ generation = 0;
101
+ get active() {
102
+ return this.attempt !== void 0;
103
+ }
104
+ get attemptGeneration() {
105
+ return this.generation;
106
+ }
107
+ observe(nodeKey) {
108
+ const attempt = this.attempt;
109
+ if (!attempt || attempt.streamed) return;
110
+ const context = serverSignalQueryAttemptObserver(this.owner.scopeKey);
111
+ if (context === void 0) return;
112
+ const observations = attempt.observations ??= context.createObservations();
113
+ observations.observe(context, {
114
+ nodeKey,
115
+ selectionKey: this.request.identity,
116
+ attempt: attempt.generation,
117
+ kind: this.request.definition.kind,
118
+ result: attempt.result,
119
+ isCurrent: () => currentEntry(attempt) === this
120
+ });
121
+ return attempt;
122
+ }
123
+ start(pending) {
124
+ if (this.owner.readBarrier !== void 0) return;
125
+ const generation = ++this.generation;
126
+ this.stopAttempt();
127
+ if (generation !== this.generation || this.owner.readBarrier !== void 0 || this.owner.retired || this.owner.requests?.get(this.request.identity) !== this || !this.consumers.size)
128
+ return;
129
+ const previous = this.state.snapshot;
130
+ const attempt = this.attempt = makeAttempt(this, generation);
131
+ const connection = this.request.definition.kind === "stream" ? "connecting" : "none";
132
+ this.state = !pending && previous.status === "ready" ? readyState(previous.value, {
133
+ refreshing: true,
134
+ connection,
135
+ complete: false,
136
+ requestKey: this.request.identity
137
+ }) : pendingState(attempt.settled, connection, this.request.identity);
138
+ this.deliver();
139
+ let result;
140
+ try {
141
+ result = untrack(
142
+ () => signalBatch(
143
+ () => this.request.definition.load(this.request.argument, {
144
+ signal: attempt.controller.signal,
145
+ ...previous.status === "ready" ? { previous: previous.value } : {}
146
+ })
147
+ )
148
+ );
149
+ } catch (error) {
150
+ failAttempt(attempt, error);
151
+ return;
152
+ }
153
+ if (this.request.definition.kind === "stream") observeStream(attempt, result);
154
+ else {
155
+ if (currentEntry(attempt)) attempt.result = result;
156
+ observePromise(attempt, result);
157
+ }
158
+ }
159
+ startStreamed(identity) {
160
+ if (this.owner.readBarrier !== void 0 || identity.selectionKey !== this.request.identity || identity.attempt < this.generation || this.attempt === void 0 && identity.attempt === this.generation && this.state.snapshot.status !== "pending" || this.owner.retired || !this.consumers.size) {
161
+ return false;
162
+ }
163
+ if (this.attempt?.streamed && this.attempt.generation === identity.attempt) {
164
+ return true;
165
+ }
166
+ this.generation = identity.attempt;
167
+ this.stopAttempt();
168
+ if (this.generation !== identity.attempt || this.owner.readBarrier !== void 0 || this.owner.retired || this.owner.requests?.get(this.request.identity) !== this || !this.consumers.size) {
169
+ return false;
170
+ }
171
+ this.attempt = makeAttempt(this, identity.attempt, true);
172
+ return true;
173
+ }
174
+ acceptStreamed(frame) {
175
+ const attempt = this.attempt;
176
+ if (!attempt?.streamed || attempt.generation !== frame.identity.attempt || frame.sequence !== attempt.sequence || currentEntry(attempt) !== this) {
177
+ return false;
178
+ }
179
+ attempt.sequence++;
180
+ signalBatch(() => {
181
+ if (frame.kind === "open") return;
182
+ if (frame.kind === "value") {
183
+ attempt.hasYielded = true;
184
+ this.state = readyState(decodeSignalValue(frame.value), {
185
+ requestKey: this.request.identity,
186
+ connection: this.request.definition.kind === "stream" ? "open" : "none",
187
+ complete: false
188
+ });
189
+ this.deliver();
190
+ return;
191
+ }
192
+ if (frame.kind === "error") {
193
+ this.state = errorState(
194
+ new SignalStreamError(frame.code),
195
+ this.request.definition.kind === "stream" ? "closed" : "none",
196
+ this.request.identity
197
+ );
198
+ completeAttempt(attempt);
199
+ this.deliver();
200
+ return;
201
+ }
202
+ if (!attempt.hasYielded || this.state.snapshot.status !== "ready") {
203
+ this.state = errorState(
204
+ new Error(formatClientError(197)),
205
+ this.request.definition.kind === "stream" ? "closed" : "none",
206
+ this.request.identity
207
+ );
208
+ completeAttempt(attempt);
209
+ this.deliver();
210
+ return;
211
+ }
212
+ this.state = readyState(this.state.snapshot.value, {
213
+ requestKey: this.request.identity,
214
+ connection: this.request.definition.kind === "stream" ? "closed" : "none",
215
+ complete: true
216
+ });
217
+ completeAttempt(attempt);
218
+ this.deliver();
219
+ });
220
+ return true;
221
+ }
222
+ deliver() {
223
+ for (const consumer of this.consumers) consumer.deliver();
224
+ }
225
+ stopAttempt() {
226
+ const attempt = this.attempt;
227
+ if (!attempt) return;
228
+ this.attempt = void 0;
229
+ attempt.entry = void 0;
230
+ const controller = attempt.controller;
231
+ const iterator = attempt.iterator;
232
+ attempt.controller = void 0;
233
+ attempt.iterator = void 0;
234
+ attempt.result = void 0;
235
+ attempt.observations?.retire();
236
+ attempt.resolve();
237
+ if (controller) untrackCommitted(() => signalBatch(() => controller.abort()));
238
+ if (iterator) closeIterator(iterator);
239
+ }
240
+ remove(consumer) {
241
+ this.consumers.delete(consumer);
242
+ if (this.consumers.size) return;
243
+ if (this.owner.requests?.get(this.request.identity) === this) {
244
+ this.owner.requests?.delete(this.request.identity);
245
+ }
246
+ this.stopAttempt();
247
+ }
248
+ }
249
+ function currentEntry(attempt) {
250
+ const entry = attempt.entry;
251
+ return entry && !entry.owner.retired && entry.attempt === attempt ? entry : void 0;
252
+ }
253
+ function completeAttempt(attempt) {
254
+ attempt.observations?.complete();
255
+ const entry = attempt.entry;
256
+ if (entry?.attempt === attempt) entry.attempt = void 0;
257
+ attempt.entry = void 0;
258
+ attempt.controller = void 0;
259
+ attempt.iterator = void 0;
260
+ attempt.result = void 0;
261
+ attempt.resolve();
262
+ }
263
+ function observePromise(attempt, result) {
264
+ Promise.resolve(result).then(
265
+ (value) => {
266
+ const entry = currentEntry(attempt);
267
+ if (!entry) return;
268
+ signalBatch(() => {
269
+ entry.state = readyState(value, { requestKey: entry.request.identity });
270
+ completeAttempt(attempt);
271
+ entry.deliver();
272
+ });
273
+ },
274
+ (error) => failAttempt(attempt, error)
275
+ );
276
+ }
277
+ function failAttempt(attempt, error) {
278
+ const entry = currentEntry(attempt);
279
+ if (!entry) return;
280
+ attempt.observations?.fail(error);
281
+ signalBatch(() => {
282
+ const iterator = attempt.iterator;
283
+ entry.state = errorState(
284
+ error,
285
+ entry.request.definition.kind === "stream" ? "closed" : "none",
286
+ entry.request.identity
287
+ );
288
+ completeAttempt(attempt);
289
+ if (iterator) closeIterator(iterator);
290
+ entry.deliver();
291
+ });
292
+ }
293
+ function ignoreRetiredCloseFailure() {
294
+ }
295
+ function closeIterator(iterator) {
296
+ try {
297
+ const result = untrackCommitted(() => signalBatch(() => iterator.return?.()));
298
+ Promise.resolve(result).catch(ignoreRetiredCloseFailure);
299
+ } catch {
300
+ }
301
+ }
302
+ function observeStream(attempt, result) {
303
+ Promise.resolve(result).then(
304
+ (iterable) => {
305
+ if (!currentEntry(attempt)) return;
306
+ let iterator;
307
+ try {
308
+ if (!iterable || typeof iterable[Symbol.asyncIterator] !== "function") {
309
+ throw new TypeError(formatClientError(198));
310
+ }
311
+ iterator = untrack(
312
+ () => signalBatch(() => iterable[Symbol.asyncIterator]())
313
+ );
314
+ if (!iterator || typeof iterator.next !== "function") {
315
+ throw new TypeError(formatClientError(199));
316
+ }
317
+ } catch (error) {
318
+ failAttempt(attempt, error);
319
+ return;
320
+ }
321
+ if (!currentEntry(attempt)) {
322
+ closeIterator(iterator);
323
+ return;
324
+ }
325
+ attempt.iterator = iterator;
326
+ nextStreamStep(attempt);
327
+ },
328
+ (error) => failAttempt(attempt, error)
329
+ );
330
+ }
331
+ function nextStreamStep(attempt) {
332
+ if (!currentEntry(attempt) || !attempt.iterator) return;
333
+ let step;
334
+ try {
335
+ step = untrack(() => signalBatch(() => attempt.iterator.next()));
336
+ } catch (error) {
337
+ failAttempt(attempt, error);
338
+ return;
339
+ }
340
+ Promise.resolve(step).then(
341
+ (result) => receiveStreamStep(attempt, result),
342
+ (error) => failAttempt(attempt, error)
343
+ );
344
+ }
345
+ function receiveStreamStep(attempt, result) {
346
+ let entry = currentEntry(attempt);
347
+ if (!entry) return;
348
+ if (!result || typeof result !== "object" && typeof result !== "function") {
349
+ failAttempt(attempt, new TypeError(formatClientError(114)));
350
+ return;
351
+ }
352
+ let done = false;
353
+ let value;
354
+ try {
355
+ untrack(
356
+ () => signalBatch(() => {
357
+ done = Boolean(result.done);
358
+ if (!done) value = result.value;
359
+ })
360
+ );
361
+ } catch (error) {
362
+ failAttempt(attempt, error);
363
+ return;
364
+ }
365
+ entry = currentEntry(attempt);
366
+ if (!entry) return;
367
+ const accepted = entry;
368
+ if (done) {
369
+ if (!attempt.hasYielded || entry.state.snapshot.status !== "ready") {
370
+ failAttempt(attempt, new Error(formatClientError(115)));
371
+ return;
372
+ }
373
+ signalBatch(() => {
374
+ accepted.state = readyState(accepted.state.snapshot.value, {
375
+ connection: "closed",
376
+ complete: true,
377
+ requestKey: accepted.request.identity
378
+ });
379
+ completeAttempt(attempt);
380
+ accepted.deliver();
381
+ });
382
+ return;
383
+ }
384
+ attempt.hasYielded = true;
385
+ signalBatch(() => {
386
+ accepted.state = readyState(value, {
387
+ connection: "open",
388
+ complete: false,
389
+ requestKey: accepted.request.identity
390
+ });
391
+ accepted.deliver();
392
+ });
393
+ const observed = attempt.observations?.publish(value);
394
+ if (observed === void 0) nextStreamStep(attempt);
395
+ else observed.then(() => nextStreamStep(attempt));
396
+ }
397
+ class ResourceBinding {
398
+ constructor(owner, node, describe, seed, retained = seed) {
399
+ this.owner = owner;
400
+ this.node = node;
401
+ this.describe = describe;
402
+ this.seeded = seed;
403
+ const identity = retained?.entry.request;
404
+ this.retainedRequest = identity ? {
405
+ queryKey: identity.queryKey,
406
+ kind: identity.kind,
407
+ argument: decodeSignalValue(identity.argument)
408
+ } : void 0;
409
+ node.compute = () => {
410
+ const pending = this.pendingObserver;
411
+ this.pendingObserver = void 0;
412
+ return pending === void 0 || hasServerSignalQueryAttemptObserver(this.owner.scopeKey) ? this.compute() : pending(() => this.compute());
413
+ };
414
+ node.retry = (options) => this.retry(options);
415
+ }
416
+ owner;
417
+ node;
418
+ describe;
419
+ selected;
420
+ selectedIdentity;
421
+ retainedRequest;
422
+ seeded;
423
+ describedAttempt;
424
+ observedAttempt;
425
+ pendingObserver;
426
+ pendingPromise;
427
+ resolvePending;
428
+ streamedSelection;
429
+ selectionAuthority = {};
430
+ request() {
431
+ const request = pure(() => this.describe());
432
+ if (request === skip) return request;
433
+ if (!(request instanceof Request)) throw new TypeError(formatClientError(200));
434
+ return request;
435
+ }
436
+ forkCandidate(target) {
437
+ if (this.streamedSelection || this.owner.streams?.selections.has(this.node.key)) {
438
+ throw new CandidateUnsupportedError(formatClientError(201));
439
+ }
440
+ const fork = new ResourceBinding(this.owner, target, this.describe);
441
+ fork.candidate = true;
442
+ fork.retainedRequest = this.retainedRequest;
443
+ return {
444
+ dispose: () => fork.dispose(),
445
+ prepare: () => {
446
+ if (this.streamedSelection || this.owner.streams?.selections.has(this.node.key))
447
+ return { status: "invalid" };
448
+ const entry = fork.selected;
449
+ const attempt = entry?.attempt;
450
+ if (entry) {
451
+ if (attempt?.streamed) return { status: "invalid" };
452
+ const snapshot = entry.state.snapshot;
453
+ if (attempt && (entry.request.definition.kind !== "stream" || snapshot.status !== "ready"))
454
+ return { status: "pending", waiting: target.state?.waiting ?? attempt.settled };
455
+ if (!(snapshot.status === "ready" && (snapshot.complete || entry.request.definition.kind === "stream") || snapshot.status === "error"))
456
+ return { status: "invalid" };
457
+ } else if (target.state?.snapshot.status !== "idle") {
458
+ const state2 = target.state;
459
+ if (state2?.snapshot.status === "error")
460
+ return { status: "error", error: state2.snapshot.error };
461
+ if (state2?.waiting) return { status: "pending", waiting: state2.waiting };
462
+ return { status: "invalid" };
463
+ }
464
+ const state = entry?.state;
465
+ const authority = this.selectionAuthority;
466
+ const forkAuthority = fork.selectionAuthority;
467
+ return {
468
+ status: "ready",
469
+ receipt: {
470
+ validate: () => !this.streamedSelection && !this.owner.streams?.selections.has(this.node.key) && this.selectionAuthority === authority && fork.selectionAuthority === forkAuthority && fork.selected === entry && (entry ? entry.state === state && entry.attempt === attempt && entry.consumers.has(fork) : target.state?.snapshot.status === "idle"),
471
+ publish: () => {
472
+ const previous = this.selected;
473
+ const resolve = this.resolvePending;
474
+ entry?.consumers.add(this);
475
+ entry?.consumers.delete(fork);
476
+ this.selected = entry;
477
+ this.selectedIdentity = fork.selectedIdentity;
478
+ this.retainedRequest = fork.retainedRequest;
479
+ this.describedAttempt = fork.describedAttempt;
480
+ this.observedAttempt = fork.observedAttempt;
481
+ this.selectionAuthority = fork.selectionAuthority;
482
+ this.pendingObserver = void 0;
483
+ this.pendingPromise = void 0;
484
+ this.resolvePending = void 0;
485
+ this.seeded = void 0;
486
+ fork.selected = void 0;
487
+ return () => {
488
+ resolve?.();
489
+ if (previous !== entry && previous !== this.selected) previous?.remove(this);
490
+ };
491
+ }
492
+ }
493
+ };
494
+ }
495
+ };
496
+ }
497
+ compute() {
498
+ let request;
499
+ try {
500
+ const described = this.request();
501
+ if (described === skip) {
502
+ this.detach();
503
+ this.seeded = void 0;
504
+ return idleState();
505
+ }
506
+ request = described;
507
+ const previousDefinition = this.owner.queryDefinitions?.get(request.queryKey);
508
+ if (previousDefinition && (previousDefinition.load !== request.definition.load || previousDefinition.kind !== request.definition.kind)) {
509
+ throw new TypeError(formatClientError(202, request.queryKey));
510
+ }
511
+ (this.owner.queryDefinitions ??= /* @__PURE__ */ new Map()).set(request.queryKey, request.definition);
512
+ } catch (error) {
513
+ if (isThenable(error)) {
514
+ this.pendingObserver = captureCurrentServerSignalQueryAttemptObserver(this.owner.scopeKey);
515
+ }
516
+ this.detach();
517
+ throw error;
518
+ }
519
+ if (this.selected?.request.identity !== request.identity) {
520
+ this.detach();
521
+ assertAlive(this.owner);
522
+ if (this.candidate && this.describe === void 0) {
523
+ throw new TypeError(formatClientError(203));
524
+ }
525
+ this.selectedIdentity = {
526
+ queryKey: request.queryKey,
527
+ kind: request.definition.kind,
528
+ argument: request.argument
529
+ };
530
+ if (this.retainedRequest && (this.retainedRequest.queryKey !== request.queryKey || this.retainedRequest.kind !== request.definition.kind)) {
531
+ this.retainedRequest = void 0;
532
+ releaseRetention(this.node);
533
+ }
534
+ let entry = this.owner.requests?.get(request.identity);
535
+ let start = false;
536
+ if (!entry) {
537
+ const seed = this.seeded && matchesSeed(request, this.seeded.entry) ? this.seeded : void 0;
538
+ entry = new RequestEntry(this.owner, request, seed);
539
+ (this.owner.requests ??= /* @__PURE__ */ new Map()).set(request.identity, entry);
540
+ start = !seed || !seed.entry.complete;
541
+ }
542
+ this.seeded = void 0;
543
+ this.selected = entry;
544
+ entry.consumers.add(this);
545
+ this.owner.trace("select", this.node);
546
+ const streamed = this.candidate ? void 0 : this.owner.streams?.selections.get(this.node.key);
547
+ if (streamed && streamed.selectionKey !== request.identity) {
548
+ this.owner.streams?.discardCompleted(streamed);
549
+ }
550
+ if (streamed?.selectionKey === request.identity && entry.startStreamed(streamed)) {
551
+ this.streamedSelection = streamed;
552
+ this.owner.streams?.selectionReady(this);
553
+ entry.deliver();
554
+ } else if (start) {
555
+ entry.start(entry.state.snapshot.status !== "ready");
556
+ }
557
+ }
558
+ this.observeSelectedAttempt();
559
+ assertAlive(this.owner);
560
+ return this.state();
561
+ }
562
+ state() {
563
+ const entry = this.selected;
564
+ if (this.describedAttempt !== entry.attempt) {
565
+ this.resolvePending?.();
566
+ this.resolvePending = void 0;
567
+ this.pendingPromise = void 0;
568
+ this.describedAttempt = entry.attempt;
569
+ }
570
+ if (entry.state.snapshot.status !== "pending") {
571
+ if (entry.state.snapshot.status === "ready") this.retainedRequest = this.selectedIdentity;
572
+ this.resolvePending?.();
573
+ this.resolvePending = void 0;
574
+ this.pendingPromise = void 0;
575
+ return entry.state;
576
+ }
577
+ if (!this.pendingPromise) {
578
+ this.pendingPromise = new Promise((resolve) => {
579
+ this.resolvePending = resolve;
580
+ });
581
+ }
582
+ return pendingState(
583
+ this.pendingPromise,
584
+ entry.state.snapshot.connection,
585
+ entry.request.identity,
586
+ this.resolvePending
587
+ );
588
+ }
589
+ deliver() {
590
+ if (this.owner.retired || this.node.evaluating) return;
591
+ publishNode(this.node, this.state());
592
+ this.owner.trace("publish", this.node);
593
+ }
594
+ detach() {
595
+ const entry = this.selected;
596
+ if (!this.candidate && this.streamedSelection === this.owner.streams?.selections.get(this.node.key)) {
597
+ this.owner.streams?.selections.delete(this.node.key);
598
+ }
599
+ this.selected = void 0;
600
+ this.selectedIdentity = void 0;
601
+ this.describedAttempt = void 0;
602
+ this.observedAttempt = void 0;
603
+ this.resolvePending?.();
604
+ this.resolvePending = void 0;
605
+ this.pendingPromise = void 0;
606
+ this.streamedSelection = void 0;
607
+ this.selectionAuthority = {};
608
+ entry?.remove(this);
609
+ }
610
+ observeSelectedAttempt() {
611
+ const attempt = this.selected?.attempt;
612
+ if (!attempt || attempt === this.observedAttempt) return;
613
+ if (this.selected.observe(this.node.key) === attempt) this.observedAttempt = attempt;
614
+ }
615
+ get authority() {
616
+ return this.selected ? this.selectionAuthority : void 0;
617
+ }
618
+ isStreamedSelectionReady(identity) {
619
+ return this.streamedSelection === identity && this.selected?.request.identity === identity.selectionKey;
620
+ }
621
+ bindStreamedSelection(identity) {
622
+ assertAlive(this.owner);
623
+ const entry = this.selected;
624
+ if (identity.nodeKey !== this.node.key) return false;
625
+ if (!entry || entry.request.identity !== identity.selectionKey) {
626
+ this.streamedSelection = void 0;
627
+ return true;
628
+ }
629
+ if (!entry.startStreamed(identity)) return false;
630
+ this.streamedSelection = identity;
631
+ entry.deliver();
632
+ return true;
633
+ }
634
+ acceptStreamed(frame) {
635
+ const identity = this.streamedSelection;
636
+ const entry = this.selected;
637
+ if (!identity || !entry || identity.nodeKey !== frame.identity.nodeKey || identity.selectionKey !== frame.identity.selectionKey || identity.selectionGeneration !== frame.identity.selectionGeneration || identity.attempt !== frame.identity.attempt || frame.kind === "open" && frame.resource !== entry.request.definition.kind) {
638
+ return false;
639
+ }
640
+ return entry.acceptStreamed(frame);
641
+ }
642
+ failStreamed(identity, error) {
643
+ const streamed = this.streamedSelection;
644
+ const entry = this.selected;
645
+ if (!streamed || !entry || streamed.nodeKey !== identity.nodeKey || streamed.selectionKey !== identity.selectionKey || streamed.selectionGeneration !== identity.selectionGeneration || streamed.attempt !== identity.attempt || entry.attempt?.generation !== identity.attempt || !entry.attempt.streamed) {
646
+ return false;
647
+ }
648
+ failAttempt(entry.attempt, error);
649
+ return true;
650
+ }
651
+ retry(options) {
652
+ assertAlive(this.owner);
653
+ assertWritable();
654
+ if (!this.selected && this.node.state?.snapshot.status === "idle") return;
655
+ signalBatch(() => {
656
+ const previous = this.selected;
657
+ if (!previous) invalidateNode(this.node);
658
+ refreshNode(this.node);
659
+ if (!this.selected) {
660
+ throw this.node.state?.snapshot.status === "error" ? this.node.state.snapshot.error : new Error(formatClientError(204));
661
+ }
662
+ this.owner.trace("retry", this.node);
663
+ if (this.selected === previous) this.selected.start(options?.pending === true);
664
+ this.observeSelectedAttempt();
665
+ });
666
+ }
667
+ adopt(requestKey, value) {
668
+ assertAlive(this.owner);
669
+ assertWritable();
670
+ const entry = this.selected;
671
+ if (!entry || entry.request.identity !== requestKey) return false;
672
+ const streaming = entry.request.definition.kind === "stream";
673
+ if (!streaming) entry.stopAttempt();
674
+ entry.state = readyState(value, {
675
+ requestKey: entry.request.identity,
676
+ connection: streaming ? entry.state.snapshot.connection : "none",
677
+ complete: streaming ? entry.state.snapshot.complete : true
678
+ });
679
+ entry.deliver();
680
+ return true;
681
+ }
682
+ seedRequest(retained = false) {
683
+ const request = retained ? this.retainedRequest : this.selectedIdentity;
684
+ if (!request) return void 0;
685
+ return {
686
+ queryKey: request.queryKey,
687
+ kind: request.kind,
688
+ argument: encodeSignalValue(request.argument)
689
+ };
690
+ }
691
+ acceptsSeed(seed) {
692
+ const request = this.request();
693
+ return request !== skip && matchesSeed(request, seed);
694
+ }
695
+ dispose() {
696
+ this.detach();
697
+ this.pendingObserver = void 0;
698
+ this.describe = void 0;
699
+ this.seeded = void 0;
700
+ this.retainedRequest = void 0;
701
+ this.streamedSelection = void 0;
702
+ }
703
+ }
704
+ function matchesSeed(request, seed) {
705
+ return seed.kind === "async" && seed.request?.queryKey === request.queryKey && seed.request.kind === request.definition.kind && JSON.stringify(seed.request.argument) === JSON.stringify(encodeSignalValue(request.argument));
706
+ }
707
+ function initializeResource(owner, node, describe, seed, retained = seed) {
708
+ return new ResourceBinding(owner, node, describe, seed, retained);
709
+ }
710
+ export {
711
+ RequestEntry,
712
+ ResourceBinding,
713
+ createResource,
714
+ initializeResource,
715
+ query
716
+ };