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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (124) hide show
  1. package/README.md +1 -1
  2. package/dist/server.dev.js +5165 -0
  3. package/dist/server.js +1876 -374
  4. package/dist/{server.cjs → server.observe.js} +2070 -577
  5. package/dist/{dev.cjs → web.dev.js} +955 -567
  6. package/dist/web.js +646 -350
  7. package/dist/{dev.js → web.observe.js} +699 -421
  8. package/frames/dist/assets.js +92 -0
  9. package/frames/dist/client.dev.js +1296 -1198
  10. package/frames/dist/client.js +1128 -1191
  11. package/frames/dist/client.observe.js +2041 -0
  12. package/frames/dist/regions.js +171 -0
  13. package/frames/dist/server.dev.js +2545 -0
  14. package/frames/dist/server.js +1683 -3004
  15. package/frames/dist/server.observe.js +2544 -0
  16. package/frames/dist/trace.js +45 -0
  17. package/frames/dist/wire.js +594 -0
  18. package/frames/package.json +2 -25
  19. package/package.json +244 -256
  20. package/performance-tracks/dist/performance-tracks.dev.js +679 -0
  21. package/performance-tracks/dist/performance-tracks.js +6 -0
  22. package/performance-tracks/dist/performance-tracks.observe.js +667 -0
  23. package/performance-tracks/package.json +7 -0
  24. package/performance-tracks/types/index.d.ts +69 -0
  25. package/serialization/decode/package.json +2 -15
  26. package/serialization/dist/decode.js +121 -25
  27. package/serialization/dist/serialization.js +282 -88
  28. package/serialization/package.json +2 -15
  29. package/serialization/types/index.d.ts +115 -153
  30. package/serialization/types/serializer-decode.d.ts +173 -114
  31. package/serialization/types/serializer.d.ts +144 -0
  32. package/server-functions/dist/client.dev.js +1462 -0
  33. package/server-functions/dist/client.js +667 -165
  34. package/server-functions/dist/client.observe.js +1441 -0
  35. package/server-functions/dist/rich-args.js +102 -1
  36. package/server-functions/dist/server.dev.js +2802 -299
  37. package/server-functions/dist/server.js +2724 -314
  38. package/server-functions/dist/server.observe.js +3680 -0
  39. package/server-functions/package.json +2 -35
  40. package/server-functions/rich-args/package.json +2 -15
  41. package/skills/server-components/SKILL.md +117 -0
  42. package/storage/package.json +2 -15
  43. package/types/client.d.ts +342 -288
  44. package/types/constants.d.ts +22 -0
  45. package/types/cookies.d.ts +32 -84
  46. package/types/diagnostics.d.ts +80 -0
  47. package/types/frames/assets-tier.d.ts +78 -0
  48. package/types/frames/client.d.ts +40 -1
  49. package/types/frames/frame-client.d.ts +443 -280
  50. package/types/frames/frame-container-plugin.d.ts +64 -0
  51. package/types/frames/frame-morph.d.ts +29 -0
  52. package/types/frames/frame-sink.d.ts +141 -161
  53. package/types/frames/frame-transport.d.ts +263 -184
  54. package/types/frames/regions-tier.d.ts +60 -0
  55. package/types/frames/serializer-decode.d.ts +241 -0
  56. package/types/frames/serializer.d.ts +115 -153
  57. package/types/frames/server.d.ts +2 -2
  58. package/types/frames/trace-tier.d.ts +2 -0
  59. package/types/frames/tree-rewrite.d.ts +39 -0
  60. package/types/frames/wire-tier.d.ts +169 -0
  61. package/types/head.d.ts +20 -0
  62. package/types/index.d.ts +98 -81
  63. package/types/index.server.d.ts +159 -0
  64. package/types/jsx.d.ts +49 -44
  65. package/types/observe.d.ts +535 -0
  66. package/types/reconcile.d.ts +1 -0
  67. package/types/render.d.ts +11 -0
  68. package/types/request-error-hook.d.ts +5 -0
  69. package/types/response.d.ts +95 -147
  70. package/types/serializer-decode.d.ts +173 -114
  71. package/types/serializer.d.ts +115 -153
  72. package/types/server-functions/argument-codec.d.ts +30 -0
  73. package/types/server-functions/client.d.ts +237 -223
  74. package/types/server-functions/flash.d.ts +28 -30
  75. package/types/server-functions/registry.d.ts +105 -0
  76. package/types/server-functions/rich-args.d.ts +1 -10
  77. package/types/server-functions/server.d.ts +538 -531
  78. package/types/server-functions/shared.d.ts +398 -425
  79. package/types/server-functions/uploads.d.ts +53 -0
  80. package/types/server-mock.d.ts +154 -20
  81. package/types/server-observe.d.ts +86 -0
  82. package/types/server.d.ts +601 -422
  83. package/types/trace.d.ts +127 -0
  84. package/LICENSE +0 -21
  85. package/dist/web.cjs +0 -2033
  86. package/frames/dist/client.cjs +0 -2002
  87. package/frames/dist/client.dev.cjs +0 -2022
  88. package/frames/dist/server.cjs +0 -3877
  89. package/serialization/dist/decode.cjs +0 -139
  90. package/serialization/dist/serialization.cjs +0 -261
  91. package/serialization/types-cjs/index.d.cts +0 -182
  92. package/serialization/types-cjs/package.json +0 -3
  93. package/serialization/types-cjs/serializer-decode.d.cts +0 -182
  94. package/server-functions/dist/client.cjs +0 -834
  95. package/server-functions/dist/rich-args.cjs +0 -11
  96. package/server-functions/dist/server.cjs +0 -1242
  97. package/server-functions/dist/server.dev.cjs +0 -1242
  98. package/storage/dist/storage.cjs +0 -12
  99. package/storage/types-cjs/index.d.cts +0 -28
  100. package/storage/types-cjs/package.json +0 -3
  101. package/types/core.d.ts +0 -9
  102. package/types-cjs/client.d.cts +0 -337
  103. package/types-cjs/cookies.d.cts +0 -93
  104. package/types-cjs/core.d.cts +0 -9
  105. package/types-cjs/frames/client.d.cts +0 -36
  106. package/types-cjs/frames/frame-client.d.cts +0 -356
  107. package/types-cjs/frames/frame-sink.d.cts +0 -194
  108. package/types-cjs/frames/frame-transport.d.cts +0 -222
  109. package/types-cjs/frames/serializer.d.cts +0 -182
  110. package/types-cjs/frames/server.d.cts +0 -52
  111. package/types-cjs/index.d.cts +0 -244
  112. package/types-cjs/jsx-properties.d.cts +0 -93
  113. package/types-cjs/jsx.d.cts +0 -4159
  114. package/types-cjs/package.json +0 -3
  115. package/types-cjs/response.d.cts +0 -174
  116. package/types-cjs/serializer-decode.d.cts +0 -182
  117. package/types-cjs/serializer.d.cts +0 -182
  118. package/types-cjs/server-functions/client.d.cts +0 -262
  119. package/types-cjs/server-functions/flash.d.cts +0 -38
  120. package/types-cjs/server-functions/rich-args.d.cts +0 -10
  121. package/types-cjs/server-functions/server.d.cts +0 -681
  122. package/types-cjs/server-functions/shared.d.cts +0 -523
  123. package/types-cjs/server-mock.d.cts +0 -286
  124. package/types-cjs/server.d.cts +0 -544
package/types/server.d.ts CHANGED
@@ -1,62 +1,109 @@
1
+ import { getOwner, createComponent, untrack, merge as mergeProps } from "solid-js";
2
+ import { ssrScope as scope } from "solid-js/internal";
3
+ import type { Owner } from "solid-js";
4
+ import type { ServerErrorSite } from "solid-js/internal";
5
+ import { effect, memo } from "./render.js";
6
+ import { type TraceContext } from "./trace.js";
7
+ export { parseCookieHeader, serializeCookie } from "./cookies.js";
8
+ export { clearFlashCookie, hasFlashCookie } from "./cookies.js";
9
+ export { getServerFunctionMetadata, getServerFunctionRPC, isServerFunction } from "./server-functions/registry.js";
1
10
  import { JSX } from "./jsx.js";
2
11
  import { SerializerPlugin } from "./serializer-decode.js";
3
- export const DOMWithState: Record<string, Record<string, 1 | 2>>;
4
- export const ChildProperties: Set<string>;
5
- export const DelegatedEvents: Set<string>;
6
- export const DOMElements: Set<string>;
7
- export const SVGElements: Set<string>;
8
- export const MathMLElements: Set<string>;
9
- export const VoidElements: Set<string>;
10
- export const RawTextElements: Set<string>;
11
- export const Namespaces: Record<string, string>;
12
-
13
- type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
14
-
15
- /** Static asset manifest produced by a build (e.g. parsed Vite manifest.json). */
16
- export type AssetManifest = Record<
17
- string,
18
- { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
19
- > & { _base?: string };
20
-
12
+ type PreloadLinkAttributes = {
13
+ type?: string;
14
+ crossorigin?: JSX.HTMLCrossorigin;
15
+ integrity?: string;
16
+ referrerpolicy?: JSX.HTMLReferrerPolicy;
17
+ fetchpriority?: JSX.HTMLFetchPriority;
18
+ media?: string;
19
+ };
20
+ /**
21
+ * An explicit `<link rel="preload">` emitted by the SSR asset pipeline.
22
+ *
23
+ * `as` is the HTML Standard's set of preload destinations exactly — anything
24
+ * else translates to null and the browser does nothing with the link.
25
+ *
26
+ * `imagesrcset` candidates must already be resolved by the integration: they
27
+ * are carried verbatim (a relative candidate resolves against the DOCUMENT
28
+ * URL, not the manifest base). Pair it with `imagesizes` whenever a candidate
29
+ * uses a width descriptor, which the spec requires — without it the source
30
+ * size falls back to `100vw` and the preload can miss the image the `<img>`
31
+ * selects. Omitting `href` is the spec's own recommendation for the source-set
32
+ * form: it would only serve browsers without `imagesrcset` support, and there
33
+ * it would likely preload the wrong candidate.
34
+ */
35
+ export type PreloadLink = PreloadLinkAttributes & ({
36
+ href: string;
37
+ as: Exclude<JSX.HTMLPreloadAs, "image">;
38
+ imagesrcset?: never;
39
+ imagesizes?: never;
40
+ } | {
41
+ href: string;
42
+ as: "image";
43
+ imagesrcset?: string;
44
+ imagesizes?: string;
45
+ } | {
46
+ href?: never;
47
+ as: "image";
48
+ imagesrcset: string;
49
+ imagesizes?: string;
50
+ });
51
+ /**
52
+ * Static asset graph consumed by the SSR pipeline. This is Solid's own
53
+ * contract — a parsed Vite client manifest satisfies it structurally
54
+ * (unknown fields pass through untyped), but any bundler integration can
55
+ * produce it. Only these fields are ever read: `preloads` is Solid's
56
+ * extension slot for explicit typed links the integration selects.
57
+ *
58
+ * Keys are module ids, except `_`-prefixed metadata strings: `_base` (the
59
+ * public base joined with every `file`), plus any an integration stamps,
60
+ * such as the vite plugin's `_entry`. The index signature carries both
61
+ * (solidjs/solid#4502), so a read by key is an entry only once narrowed,
62
+ * e.g. `typeof entry === "object"`.
63
+ */
64
+ export type AssetManifest = {
65
+ [key: string]: {
66
+ file: string;
67
+ css?: string[];
68
+ isEntry?: boolean;
69
+ imports?: string[];
70
+ preloads?: PreloadLink[];
71
+ } | string | undefined;
72
+ _base?: string;
73
+ };
21
74
  /** Inline style content, e.g. dev CSS collected from a bundler's module graph. */
22
75
  export type InlineStyleAsset = {
23
- id: string;
24
- content: string;
25
- attrs?: Record<string, string>;
76
+ id: string;
77
+ content: string;
78
+ attrs?: Record<string, string>;
26
79
  };
27
-
28
80
  export type ResolvedAssets = {
29
- js: string[];
30
- css: (string | InlineStyleAsset)[];
81
+ js: string[];
82
+ css: (string | InlineStyleAsset)[];
83
+ preloads?: PreloadLink[];
31
84
  };
32
-
33
85
  /**
34
86
  * Resolver form of the manifest option — the primitive a dev server
35
87
  * implements against its live module graph (a static manifest object is
36
88
  * normalized into a sync resolver internally). `resolve` may return a
37
89
  * promise (async resolvers require streaming rendering); CSS entries may be
38
90
  * URL strings (emitted as load-gated `<link>` tags) or inline-style
39
- * descriptors (emitted as `<style>` tags). A bare `resolve`-shaped function
40
- * is accepted as shorthand for `{ resolve }`.
91
+ * descriptors (emitted as `<style>` tags), and `preloads` carries explicit
92
+ * preload links selected by the integration. A bare `resolve`-shaped
93
+ * function is accepted as shorthand for `{ resolve }`.
41
94
  */
42
95
  export type AssetResolver = {
43
- resolve(
44
- key: string
45
- ): ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
46
- /**
47
- * Synchronous fast path answering with whatever is knowable without async
48
- * work (typically js URLs, omitting css). Sync consumers — e.g. a lazy
49
- * component's `moduleUrl` getter used by islands — use this when `resolve`
50
- * would return a promise, so adapters should provide it whenever possible.
51
- */
52
- resolveSync?(key: string): ResolvedAssets | null | undefined;
96
+ resolve(key: string): ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
97
+ /**
98
+ * Synchronous fast path answering with whatever is knowable without async
99
+ * work (typically js URLs, omitting css). Sync consumers — e.g. a lazy
100
+ * component's `moduleUrl` getter used by islands — use this when `resolve`
101
+ * would return a promise, so adapters should provide it whenever possible.
102
+ */
103
+ resolveSync?(key: string): ResolvedAssets | null | undefined;
53
104
  };
54
-
55
105
  /** Bare-function shorthand for `AssetResolver` (no sync fast path). */
56
- export type AssetResolverFn = (
57
- key: string
58
- ) => ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
59
-
106
+ export type AssetResolverFn = (key: string) => ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
60
107
  /**
61
108
  * CSP nonce for the tags a server render emits. A string applies to both
62
109
  * nonce-aware destinations. A `{ script, style }` pair routes each tag to
@@ -67,110 +114,14 @@ export type AssetResolverFn = (
67
114
  * fallback reaches `script-src`. A nonce on a `useHead` tag's own props
68
115
  * always wins.
69
116
  *
70
- * Only `renderToString` / `renderToStream` take this shape. Surfaces that
71
- * emit one script (`HydrationScript`, `generateHydrationScript`,
72
- * `createSSRResponse`) take a string — project with `scriptNonce`.
117
+ * Surfaces that emit one script (`HydrationScript`,
118
+ * `generateHydrationScript`, `createSSRResponse`) take either shape and use
119
+ * its script half.
73
120
  */
74
- export type CSPNonce = string | { script: string | false; style: string | false };
75
-
76
- /** The script-destination half of a render `nonce`. */
77
- export function scriptNonce(nonce?: CSPNonce): string | undefined;
78
- /** The style-destination half of a render `nonce`. */
79
- export function styleNonce(nonce?: CSPNonce): string | undefined;
80
-
81
- export function renderToString<T>(
82
- fn: () => T,
83
- options?: {
84
- nonce?: CSPNonce;
85
- renderId?: string;
86
- noScripts?: boolean;
87
- plugins?: SerializerPlugin[];
88
- manifest?: AssetManifest | AssetResolver | AssetResolverFn;
89
- onError?: (err: any) => void;
90
- /**
91
- * Embedded-render contract for hosts that own the document. When the
92
- * render output contains no `</head>`, everything head-bound (resolved
93
- * `useHead` winners, eager resources, tracked asset links, inline
94
- * styles) is delivered here as one HTML string — prelude (charset/base)
95
- * first — for the host to splice into its own `<head>` template, instead
96
- * of being dropped. Called synchronously before `renderToString`
97
- * returns; not called when the output has a `</head>` (splicing is
98
- * automatic then).
99
- */
100
- onHead?: (head: string) => void;
101
- }
102
- ): string;
103
- export function renderToStream<T>(
104
- fn: () => T,
105
- options?: {
106
- nonce?: CSPNonce;
107
- renderId?: string;
108
- noScripts?: boolean;
109
- plugins?: SerializerPlugin[];
110
- manifest?: AssetManifest | AssetResolver | AssetResolverFn;
111
- onCompleteShell?: (info: { write: (v: string) => void }) => void;
112
- onCompleteAll?: (info: { write: (v: string) => void }) => void;
113
- onError?: (err: any) => void;
114
- /**
115
- * Embedded-render contract for hosts that own the document. When the
116
- * shell contains no `</head>`, everything head-bound at first flush
117
- * (resolved `useHead` winners, eager resources, tracked asset links,
118
- * inline styles) is delivered here as one HTML string — prelude first —
119
- * before the shell chunk is emitted, so the host can write its own
120
- * `<head>` ahead of piping the stream. Post-shell head updates flow
121
- * through the stream itself and apply in the browser. Not called when
122
- * the shell has a `</head>` (splicing is automatic then).
123
- */
124
- onHead?: (head: string) => void;
125
- }
126
- ): {
127
- /**
128
- * Awaiting the stream resolves with the complete HTML once every boundary
129
- * settles — the fully-settled-string form of the render (`const html =
130
- * await renderToStream(...)`). Render errors route through `onError` and
131
- * the promise resolves with whatever HTML the render produced; it never
132
- * rejects.
133
- */
134
- then<TResult1 = string, TResult2 = never>(
135
- onfulfilled?: ((html: string) => TResult1 | PromiseLike<TResult1>) | null,
136
- onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
137
- ): Promise<TResult1 | TResult2>;
138
- pipe: (writable: { write: (v: string) => void; end: () => void }) => void;
139
- pipeTo: (writable: WritableStream) => Promise<void>;
140
- /**
141
- * Lazy `ReadableStream<Uint8Array>` view of the render — hand it straight
142
- * to `new Response(stream.readable)`. First access starts the render
143
- * piping through an internal `TransformStream` (chunks are UTF-8 encoded
144
- * bytes, the same as `pipeTo` writes) and the stream is cached, so
145
- * repeated access returns the same instance. Like `pipe`/`pipeTo`, this
146
- * consumes the render: use exactly one of the three — mixing distinct
147
- * consumers (`readable` after `pipe`/`pipeTo`, or vice versa) throws an
148
- * error naming the conflict.
149
- */
150
- readonly readable: ReadableStream<Uint8Array>;
121
+ export type CSPNonce = string | {
122
+ script: string | false;
123
+ style: string | false;
151
124
  };
152
-
153
- export function HydrationScript(props: { nonce?: string; eventNames?: string[] }): JSX.Element;
154
- export function ssr(template: string[] | string, ...nodes: any[]): { t: string };
155
- export function ssrElement(
156
- name: string,
157
- props: any,
158
- children: any,
159
- needsId: boolean
160
- ): { t: string };
161
- export function ssrClassName(value: string | { [k: string]: boolean } | Array<any>): string;
162
- export function ssrStyle(value: string | { [k: string]: string }): string;
163
- export function ssrStyleProperty(name: string, value: any): string;
164
- export function ssrAttribute(key: string, value: any): string;
165
- export function ssrGroup<T extends () => any[]>(fn: T, n: number): T;
166
- export function scope<T>(fn: () => T): () => unknown;
167
- export function ssrHydrationKey(): string;
168
- export function resolveSSRNode(node: any, result?: any, top?: boolean): any;
169
- export function escape(s: any, attr?: boolean): any;
170
- export function applyRef(
171
- r: ((element: any) => void) | ((element: any) => void)[],
172
- element: any
173
- ): void;
174
125
  /**
175
126
  * A head tag descriptor. Props values may be getters (evaluated lazily on
176
127
  * the server — at the owning flush boundary — and reactively on the client);
@@ -187,39 +138,10 @@ export function applyRef(
187
138
  * docs/head-management-rfc.md.
188
139
  */
189
140
  export type HeadTag = {
190
- tag: "title" | "meta" | "link" | "style" | "script" | "base";
191
- props: Record<string, any>;
192
- key?: string | (() => string);
141
+ tag: "title" | "meta" | "link" | "style" | "script" | "base";
142
+ props: Record<string, any>;
143
+ key?: string | (() => string);
193
144
  };
194
- /**
195
- * Registers head tags with the render's head registry. An array is a group —
196
- * one replacement set; a single tag is a group of one; a function is a
197
- * reactive group whose membership resolves at the owning flush boundary
198
- * (resource tags inside it emit at that flush rather than eagerly).
199
- * Replaceable tags (title/meta/canonical/…) resolve by last-committed group
200
- * and stream as patches with their suspense boundary's reveal; resource tags
201
- * (preload and friends, stylesheets, `script[src]`) emit eagerly and dedupe
202
- * by identity. See docs/head-management-rfc.md.
203
- */
204
- export function useHead(tag: HeadTag | HeadTag[] | (() => HeadTag | HeadTag[])): void;
205
- export function getHydrationKey(): string | undefined;
206
- export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
207
- export function memo<T>(fn: () => T, equal: boolean): () => T;
208
- export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
209
- export function mergeProps(...sources: unknown[]): unknown;
210
- export function getOwner(): unknown;
211
- export function generateHydrationScript(options?: {
212
- nonce?: string;
213
- eventNames?: string[];
214
- }): string;
215
- /**
216
- * Registered symbol (`Symbol.for("solid.RequestContext")`) naming the
217
- * global slot where `provideRequestEvent` parks the AsyncLocalStorage that
218
- * scopes request events. Integration plumbing — application code reads the
219
- * event through `getRequestEvent()` instead.
220
- * @internal
221
- */
222
- export declare const RequestContext: unique symbol;
223
145
  /**
224
146
  * The mutable response head an integration's handler exposes on the request
225
147
  * event as `event.response`: status/statusText/headers it will apply when
@@ -235,22 +157,21 @@ export declare const RequestContext: unique symbol;
235
157
  * and reads it when folding single-flight cookies, but never requires it.
236
158
  */
237
159
  export interface ResponseStub {
238
- status?: number;
239
- statusText?: string;
240
- headers: Headers;
241
- /**
242
- * Set once the response head has been derived/sent from this stub —
243
- * status and headers can no longer change. Flip it through
244
- * `commitResponseStub`, which also instruments the stub's `headers` so
245
- * a post-commit write fails loudly (dev build throws, production
246
- * reports + no-ops) instead of silently missing the wire. `status`/
247
- * `statusText` stay plain fields: consumers that write response
248
- * metadata during render (e.g. JSX response components) must still
249
- * treat later status writes and cleanup-time retractions as no-ops.
250
- */
251
- committed?: boolean;
160
+ status?: number;
161
+ statusText?: string;
162
+ headers: Headers;
163
+ /**
164
+ * Set once the response head has been derived/sent from this stub —
165
+ * status and headers can no longer change. Flip it through
166
+ * `commitResponseStub`, which also instruments the stub's `headers` so
167
+ * a post-commit write fails loudly (dev build throws, production
168
+ * reports + no-ops) instead of silently missing the wire. `status`/
169
+ * `statusText` stay plain fields: consumers that write response
170
+ * metadata during render (e.g. JSX response components) must still
171
+ * treat later status writes and cleanup-time retractions as no-ops.
172
+ */
173
+ committed?: boolean;
252
174
  }
253
-
254
175
  /**
255
176
  * The type of `RequestEvent.locals` — a module-augmentable interface so
256
177
  * applications can type the state their middleware hangs on the event.
@@ -272,9 +193,8 @@ export interface ResponseStub {
272
193
  * `locals` would break every untyped write that works today).
273
194
  */
274
195
  export interface RequestEventLocals {
275
- [key: string | number | symbol]: any;
196
+ [key: string | number | symbol]: any;
276
197
  }
277
-
278
198
  /**
279
199
  * The per-request context available on the server: the incoming `Request`
280
200
  * and a `locals` bag integrations and middleware can hang state on (typed
@@ -283,262 +203,521 @@ export interface RequestEventLocals {
283
203
  * `ResponseStub`).
284
204
  */
285
205
  export interface RequestEvent {
286
- request: Request;
287
- locals: RequestEventLocals;
206
+ request: Request;
207
+ locals: RequestEventLocals;
208
+ }
209
+ export type { CookieOptions } from "./cookies.js";
210
+ export type { ServerFunction, ServerFunctionMetadata, ServerFunctionRPC } from "./server-functions/shared.js";
211
+ export interface SSRResponseOptions {
212
+ /** Base head; the stub's status/headers win over it. */
213
+ responseInit?: ResponseInit;
214
+ /** Nonce carried by the post-flush `<script>` redirect fallback (its script half). */
215
+ nonce?: CSPNonce;
216
+ /** Rewrites each outgoing HTML chunk (entry script injection, ...). */
217
+ transformChunk?: (chunk: string) => string;
288
218
  }
289
219
  /**
290
- * The current request event, when called on the server inside a request
291
- * scope (established by `provideRequestEvent` from `@solidjs/web/storage`
292
- * or by the framework). Undefined on the client and outside a request.
293
- * Read it above `await` boundaries in partially-polyfilled environments.
220
+ * Fetch-style middleware: return a `Response` to answer the request, or
221
+ * call `next()` (optionally with a substitute `Request`) to advance the
222
+ * chain and observe/replace the eventual response.
294
223
  */
295
- export function getRequestEvent(): RequestEvent | undefined;
296
-
297
- /** A fresh, uncommitted response head. */
298
- export function createResponseStub(): ResponseStub;
299
-
224
+ export type FetchMiddleware = (request: Request, next: (request?: Request) => Promise<Response>) => Response | Promise<Response>;
225
+ export { createComponent, effect, memo, untrack, mergeProps, scope, getOwner };
226
+ export { DOMWithState, ChildProperties, DOMElements, SVGElements, MathMLElements, VoidElements, RawTextElements, Namespaces, DelegatedEvents } from "./constants.js";
227
+ export declare function useHead(tag: HeadTag | HeadTag[] | (() => HeadTag | HeadTag[])): void;
228
+ export declare function renderToString<T>(fn: () => T, options?: {
229
+ nonce?: CSPNonce;
230
+ renderId?: string;
231
+ noScripts?: boolean;
232
+ plugins?: SerializerPlugin[];
233
+ manifest?: AssetManifest | AssetResolver | AssetResolverFn;
234
+ /**
235
+ * Server modulepreload hints for modules outside the entry's static import
236
+ * closure (lazy and route chunks) carry `fetchpriority="low"` so they do not
237
+ * compete with the modules hydration waits on. `false` emits them at default
238
+ * priority.
239
+ */
240
+ lowPriorityPreloads?: boolean;
241
+ /**
242
+ * This render's server error hook, ahead of `configureServerErrors`'
243
+ * (see `ServerErrorHook`): every failure the render handles — an
244
+ * `<Errored>` fallback (`handling: "fallback"`), a hydration value that
245
+ * would not serialize (`"serialize"`) — and the throw that fails it
246
+ * (`"failed"`, heard before it is rethrown to the caller), once per
247
+ * error, with where it was met. A one-argument listener still works; it
248
+ * hears them all.
249
+ */
250
+ onError?: ServerErrorHook;
251
+ /**
252
+ * Embedded-render contract for hosts that own the document. When the
253
+ * render output contains no `</head>`, everything head-bound (resolved
254
+ * `useHead` winners, eager resources, tracked asset links, inline
255
+ * styles) is delivered here as one HTML string — prelude (charset/base)
256
+ * first — for the host to splice into its own `<head>` template, instead
257
+ * of being dropped. Called synchronously before `renderToString`
258
+ * returns; not called when the output has a `</head>` (splicing is
259
+ * automatic then).
260
+ */
261
+ onHead?: (head: string) => void;
262
+ }): string;
263
+ export declare function renderToStream<T>(fn: () => T, options?: {
264
+ nonce?: CSPNonce;
265
+ renderId?: string;
266
+ noScripts?: boolean;
267
+ plugins?: SerializerPlugin[];
268
+ manifest?: AssetManifest | AssetResolver | AssetResolverFn;
269
+ /**
270
+ * Server modulepreload hints for modules outside the entry's static import
271
+ * closure (lazy and route chunks) carry `fetchpriority="low"` so they do not
272
+ * compete with the modules hydration waits on. `false` emits them at default
273
+ * priority.
274
+ */
275
+ lowPriorityPreloads?: boolean;
276
+ onCompleteShell?: (info: {
277
+ write: (v: string) => void;
278
+ }) => void;
279
+ onCompleteAll?: (info: {
280
+ write: (v: string) => void;
281
+ }) => void;
282
+ /**
283
+ * This render's server error hook, ahead of `configureServerErrors`'
284
+ * (see `ServerErrorHook`): every failure the render handles — an
285
+ * `<Errored>` fallback (`handling: "fallback"`), a rejected fragment
286
+ * (`"client"`), a hydration value that would not serialize
287
+ * (`"serialize"`: an async value that fails before the first flush
288
+ * also fails the render, with no `onCompleteAll`; after it, its key
289
+ * rejects on the client — #4647) — and the one that fails the request
290
+ * (`"failed"`),
291
+ * once per error per kind per request (per render outside one), with
292
+ * where it was met. A one-argument listener still
293
+ * works; it hears them all — filter on `context.handling` for the
294
+ * request-failing ones alone. Without a hook (here or ambient) a
295
+ * failure that fails the request goes to `console.error`.
296
+ */
297
+ onError?: ServerErrorHook;
298
+ /**
299
+ * Embedded-render contract for hosts that own the document. When the
300
+ * shell contains no `</head>`, everything head-bound at first flush
301
+ * (resolved `useHead` winners, eager resources, tracked asset links,
302
+ * inline styles) is delivered here as one HTML string — prelude first —
303
+ * before the shell chunk is emitted, so the host can write its own
304
+ * `<head>` ahead of piping the stream. Post-shell head updates flow
305
+ * through the stream itself and apply in the browser. Not called when
306
+ * the shell has a `</head>` (splicing is automatic then).
307
+ */
308
+ onHead?: (head: string) => void;
309
+ /**
310
+ * The request's lifecycle. Aborting tears the render down exactly as a
311
+ * client disconnect does (`SSR_STREAM_ABANDONED`, `data.reason:
312
+ * "signal"`): in-flight reactive work is disposed, every async source
313
+ * still being pulled is returned, and nothing more is written to the
314
+ * sink. For the host whose transport cannot report a dead consumer
315
+ * through the sink or the readable view — a frame stream whose emission
316
+ * never touches the document writable, a platform whose response body
317
+ * is consumed by a proxy — this is the one teardown handle; pass
318
+ * `request.signal`. Idempotent with the sink and consumer paths: whichever
319
+ * fires first tears down, the rest are no-ops.
320
+ * Awaiting the render rejects with `signal.reason` when this signal aborts;
321
+ * the streaming forms stop writing and end cleanly — a close, not an
322
+ * error, since bytes are already out: `pipe` ends its sink, `pipeTo`
323
+ * closes its writable (after the writes already handed to it) and
324
+ * resolves, and `readable` closes. `onError` and `onCompleteAll` are not
325
+ * called (#4646).
326
+ */
327
+ signal?: AbortSignal;
328
+ }): {
329
+ /**
330
+ * Awaiting the stream resolves with the complete HTML once every boundary
331
+ * settles — the fully-settled-string form of the render (`const html =
332
+ * await renderToStream(...)`). Render errors route through `onError` and
333
+ * the promise resolves with whatever HTML the render produced. Signal
334
+ * cancellation rejects with `signal.reason`.
335
+ *
336
+ * Completion is this path's head-freeze point: the request event's
337
+ * `response` head (the request scope the render was started in) is
338
+ * committed right before the render's final dispose, so
339
+ * `httpStatus`/`httpHeader` declarations still live at completion survive
340
+ * into `createSSRResponse(html, event)` — which sees the already-committed
341
+ * stub and passes it through. The piped forms freeze at shell flush
342
+ * instead.
343
+ */
344
+ then<TResult1 = string, TResult2 = never>(onfulfilled?: ((html: string) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
345
+ pipe: (writable: {
346
+ write: (v: string) => void;
347
+ end: () => void;
348
+ }) => void;
349
+ pipeTo: (writable: WritableStream) => Promise<void>;
350
+ /**
351
+ * Lazy `ReadableStream<Uint8Array>` view of the render — hand it straight
352
+ * to `new Response(stream.readable)`. First access starts the render
353
+ * piping through an internal `TransformStream` (chunks are UTF-8 encoded
354
+ * bytes, the same as `pipeTo` writes) and the stream is cached, so
355
+ * repeated access returns the same instance. Like `pipe`/`pipeTo`, this
356
+ * consumes the render: use exactly one of the three — mixing distinct
357
+ * consumers (`readable` after `pipe`/`pipeTo`, or vice versa) throws an
358
+ * error naming the conflict.
359
+ */
360
+ readonly readable: ReadableStream<Uint8Array>;
361
+ };
362
+ export declare function HydrationScript(props: {
363
+ nonce?: CSPNonce;
364
+ eventNames?: string[];
365
+ }): JSX.Element;
366
+ export declare function ssrGroup<T extends () => any[]>(fn: T, n: number): T;
300
367
  /**
301
- * The canonical request event for HTTP handlers: the incoming `Request`, a
302
- * `locals` bag, and a `response` head stub the render writes to. `init`
303
- * spreads over the defaults so frameworks can extend the shape.
368
+ * The live-hole engine for one frame response. Constructed by the frame
369
+ * renderer (frame-sink) and published on the render context; `ssr()` and
370
+ * `resolveSSRNode` route content holes through `content()` while it is
371
+ * present. Bindings live in the sink's DR-2 ledger — same commit-driven
372
+ * sweeps, same equality gating, same end-of-response latch as watched slot
373
+ * args.
374
+ *
375
+ * Every state transition is commit-driven: the engine never chains its own
376
+ * promises, so it cannot amplify commits or starve the event loop — a
377
+ * pending re-evaluation simply waits for the next commit (async settles
378
+ * commit through the render core, and the response's end-latch sweep is
379
+ * always the last one).
304
380
  */
305
- export function createRequestEvent<T extends object = {}>(
306
- request: Request,
307
- init?: T
308
- ): RequestEvent & { response: ResponseStub } & T;
309
-
381
+ export declare function createLiveHoles(sink: any, scoped: any, settled: any, errorScope: any): {
382
+ suppressed: number;
383
+ sweeping: boolean;
384
+ parent: any;
385
+ gateHit: boolean;
386
+ sweptOwners: boolean;
387
+ scope: any;
388
+ visit: any;
389
+ dry: boolean;
390
+ /**
391
+ * The id of a positional slot call: at render time (and on a retry,
392
+ * which renders) the render-positional id the proxy minted, `given`,
393
+ * kept for the call's position; on a sweep, the id that position had —
394
+ * or, for a position no render reached, `prop#~<scope>.<n>` (the `~`
395
+ * keeps it apart from render ids and `$key` ids, whose alphabet has
396
+ * none). Outside every hole, `given` as it is.
397
+ */
398
+ slotId(prop: any, given: any): any;
399
+ /** A slot occurrence reached by the evaluation in progress; `forget` runs
400
+ * once a re-evaluation of its hole no longer reaches it. */
401
+ seen(id: any, forget: any): void;
402
+ /**
403
+ * Enter a nested hole's scope on the path that resolves it unminted (a
404
+ * sweep's interior, a suppressed window): the same scope a first render
405
+ * gives it inside `content()`. Returns the scope to restore, or
406
+ * undefined when none was entered.
407
+ */
408
+ nest(hole: any): any;
409
+ /**
410
+ * Intercept a thunk content hole: resolve it, and — when the evaluation
411
+ * proves re-runnable — mint an id, wrap the output in its marker pair,
412
+ * and open the ledger binding. Returns a string (sync resolve), a
413
+ * marker-wrapped `{ t, h, p }` template (NotReady escalation — markers
414
+ * ride the template so the retry's splice lands inside them), an
415
+ * UNMARKED string/template (latched: slot positions, impure
416
+ * evaluations), or null when interception is off for this evaluation.
417
+ */
418
+ content(hole: any): any;
419
+ /** The shared id counter — `ssr()` mints an attr address at injection
420
+ * time, before its capture completes. */
421
+ mint(): number;
422
+ /** Whether interception may arm at the current evaluation point —
423
+ * `ssr()` asks before opening an attr capture (the `data-lha`
424
+ * injection must not touch out-of-scope bytes, nor address an element
425
+ * nothing can change; content holes are gated inside `content()`
426
+ * itself). */
427
+ active(): boolean;
428
+ /**
429
+ * Register an element's attr-hole capture (built by `ssr()`'s in-tag
430
+ * scan): the tag's attribute area as alternating static strings and
431
+ * re-runnable parts (`{ f }` thunks, `{ g, i }` group positions). Sweeps
432
+ * rebuild the text, equality-gate against the baseline, and ship
433
+ * changes as an element-keyed `attr` chunk. Names that vanish between
434
+ * rebuilds ride an explicit `removed` list where the server holds the
435
+ * previous text; the client also matches the element to the whole
436
+ * text (the morph's rule), so a resume's re-emission — previous text
437
+ * known only as a digest, no list — removes them too.
438
+ */
439
+ attr(cap: any): void;
440
+ };
441
+ export declare function ssr(template: string[] | string, ...nodes: any[]): {
442
+ t: string;
443
+ };
444
+ export declare function ssrClassName(value: string | {
445
+ [k: string]: boolean;
446
+ } | Array<any>): string;
447
+ export declare function ssrStyle(value: string | {
448
+ [k: string]: string;
449
+ }): string;
450
+ export declare function ssrStyleProperty(name: string, value: any): string;
451
+ export declare function ssrStyleProperties(...entries: any[]): string;
452
+ export declare function ssrElement(name: string, props: any | any[] | (() => any | any[]), children: any, needsId: boolean, skip?: (key: string) => boolean, attrs?: string | (() => string)): {
453
+ t: string;
454
+ };
455
+ export declare function ssrElementAttribute(key: string, value: any): string;
456
+ export declare function ssrAttribute(key: string, value: any): string;
457
+ export declare function ssrHydrationKey(): string;
310
458
  /**
311
- * The status an outgoing redirect should use for a response head carrying
312
- * a `Location`: the stub's own status when it is a redirect status, 302
313
- * otherwise.
459
+ * A render's link handler (`setLinkClaim`): given an anchor's link-relevant
460
+ * attributes — `href`, and `target` / `rel` / `download` / `link` /
461
+ * `aria-current` when present, raw values as written — returns the extra
462
+ * attribute markup for the anchor, each attribute with its leading space
463
+ * (`" data-active"`, `' data-active aria-current="page"'`), or `""`.
464
+ * Synchronous and pure; the markup is the handler's own and is written
465
+ * verbatim.
466
+ * @internal
314
467
  */
315
- export function getExpectedRedirectStatus(response: ResponseStub): number;
316
-
468
+ export type LinkClaimHandler = (attrs: Readonly<Record<string, unknown>>) => string;
317
469
  /**
318
- * Flips a response stub to `committed` — the moment its head freezes on
319
- * the wire — and instruments the stub's `headers` mutating methods
320
- * (`set`/`append`/`delete`, patched in place; the `Headers` identity and
321
- * reads are untouched) so a post-commit write fails loudly instead of
322
- * silently missing the wire: it throws in the dev build and reports +
323
- * no-ops otherwise. Every head materialization path commits through here
324
- * (`createSSRResponse`, the server-function handler's commit seam);
325
- * integrations deriving their own heads should too.
470
+ * Compiler-emitted hole after a candidate anchor's attributes in SSR output:
471
+ * the render's link handler's markup for the anchor (`setLinkClaim`), or
472
+ * `""` when the render has no handler. An author-written `aria-current`
473
+ * wins — the handler is not consulted for that anchor. Not for hand-written
474
+ * code.
475
+ * @internal
476
+ */
477
+ export declare function ssrLinkClaim(attrs: Readonly<Record<string, unknown>>): string;
478
+ export declare function ssrSelectValues(): void;
479
+ export declare function resolveSSRSelectValues(html: any): any;
480
+ export declare function escape(s: any, attr?: boolean): any;
481
+ export declare function getHydrationKey(): string | undefined;
482
+ export declare function applyRef(r: ((element: any) => void) | ((element: any) => void)[], element: any): void;
483
+ export declare function generateHydrationScript(options?: {
484
+ nonce?: CSPNonce;
485
+ eventNames?: string[];
486
+ }): string;
487
+ export declare function resolveSSRNode(node: any, result?: any, top?: boolean, nested?: boolean): any;
488
+ export declare const RequestContext: unique symbol; /**
489
+ * Where a server-side failure was met, as the server error hook hears it.
326
490
  *
327
- * `allowLateLocation` is the stream path's documented exception: a
328
- * `Location` set after the shell flushed is still honored client-side
329
- * (stream completion appends a `window.location` script), so that one
330
- * write stays permitted there.
491
+ * `kind: "render"` — `fallback`: an `<Errored>` rendered its fallback;
492
+ * `client`: a `<Loading>` fragment rejected and the client re-renders the
493
+ * subtree; `failed`: nothing contained it and the request fails — including
494
+ * a synchronous throw out of `renderToString` or `renderToStream`'s first
495
+ * pass, reported before it reaches the caller;
496
+ * `serialize`: a hydration value would not serialize and the render went on
497
+ * without it (a render that passed `onError`). `kind: "server-function"` — `thrown`:
498
+ * the body threw; `channel`: a rejection or throw escaping through the
499
+ * result graph (a promise, an iterable, a stream) with the head already
500
+ * committed. `kind: "request"` (always `failed`): a failure that fails the
501
+ * request outside any render or server function the runtime reports — a
502
+ * middleware throw the framework's request handler catches (see
503
+ * `reportRequestFailure`). `boundary` is the hydration id the boundary records and
504
+ * findings use; `ownerPath` is where the error was THROWN — the component
505
+ * labels root-first up the owner chain it escaped, when the compiler emitted
506
+ * them — and `boundaryPath` where it was MET, the same labels up the
507
+ * boundary's chain (what broke, and what the user saw); `functionId`/`direct`
508
+ * name the server function and whether it was an in-process call during
509
+ * SSR; `event` the request, when the failure happened inside one.
331
510
  */
332
- export function commitResponseStub(
333
- stub: ResponseStub,
334
- options?: { allowLateLocation?: boolean }
335
- ): ResponseStub;
336
-
511
+ export interface ServerErrorContext extends Omit<ServerErrorSite, "event"> {
512
+ event?: RequestEvent;
513
+ }
337
514
  /**
338
- * Handler-lifecycle plumbing — a response's exit through the request
339
- * event's response-stub lifecycle: page results leave through
340
- * `createSSRResponse`, any other `Response` (a middleware early return, an
341
- * API result) leaves through `commitEventResponse`; application middleware
342
- * never calls this. Folds the event's stub onto the outgoing response —
343
- * `Set-Cookie` appends entry-by-entry alongside the response's own, other
344
- * stub headers fill gaps only (never the wire-protocol family the handlers
345
- * own, never `Content-Type`/`Content-Length` on a bodiless response), the
346
- * status is never taken from the stub — then commits the stub
347
- * (`commitResponseStub`: post-commit writes fail loudly). Responses with
348
- * immutable headers are rebuilt around merged copies.
515
+ * The server error hook (see `configureServerErrors`): every failure the
516
+ * server runtime handles or fails on, once per error object per `kind` per
517
+ * request (per render when no request is in scope — never once per
518
+ * process: an error object one request met and another meets again is
519
+ * heard by both), with where it was met. A direct server-function call that
520
+ * throws during SSR and the `<Errored>` that contains it are heard as both:
521
+ * `server-function` (the call failed), then `render` (the render fell back),
522
+ * so `kind: "render"` alone answers whether a render failed. Return the value the client should receive in
523
+ * place of the error — rendered into the fallback, serialized for
524
+ * hydration, sent as the RPC error — or nothing for the default policy (a
525
+ * generic `Error` outside the dev build, the error itself in it;
526
+ * `markSafeError` still passes through).
527
+ * A returned value is taken as intended client-facing content and is not
528
+ * sanitized again. Ignored for `handling: "failed"`, which has no wire, and
529
+ * once an earlier kind's sight gave one: every road carries the first.
349
530
  *
350
- * Idempotent at handler edges: an already-committed stub passes the
351
- * response through untouched, so a handler may apply this unconditionally
352
- * after its middleware chain unwinds — page responses from
353
- * `createSSRResponse` come back committed and do not double-fold.
531
+ * One road a mapping does not reach: a rejected async source's serialized
532
+ * rejection is encoded the moment the source rejects, ahead of the boundary
533
+ * that meets the failure, and carries the default policy's value there. The
534
+ * hydrating client renders from the boundary's record, which carries the
535
+ * mapping; no tick is added to the error path to make the two agree.
536
+ */
537
+ export type ServerErrorHook = (error: unknown, context: ServerErrorContext) => unknown | void;
538
+ export interface ServerErrorsConfig {
539
+ /** The hook, or `undefined` to clear it. */
540
+ onError?: ServerErrorHook;
541
+ }
542
+ /**
543
+ * Registers the ambient server error hook — the one call a server
544
+ * `init()` makes to see every failure the runtime handles in production:
545
+ * an `<Errored>` fallback rendered, a `<Loading>` fragment rejected, a
546
+ * server-function throw (HTTP dispatch or an in-process call during SSR),
547
+ * the failure that fails a request. Called once per error object per kind
548
+ * per request (per render outside one), at first sight, wherever the runtime
549
+ * met it; its return, when given, is the wire value (see
550
+ * `ServerErrorHook`). A per-request hook — `renderToStream`'s
551
+ * `onError`, the server-function handler's — overrides it for that
552
+ * request. Registered on `globalThis` under a registered symbol, so a
553
+ * bundled server build and an instrumented `--import`ed module share it.
354
554
  *
355
- * `event` defaults to the ambient `getRequestEvent()`.
555
+ * ```ts
556
+ * configureServerErrors({
557
+ * onError: (error, { kind, handling, boundary, functionId }) => {
558
+ * Sentry.captureException(error, {
559
+ * mechanism: { type: `solid.${kind}.${handling}`, handled: handling !== "failed" }
560
+ * });
561
+ * }
562
+ * });
563
+ * ```
356
564
  */
357
- export function commitEventResponse(response: Response, event?: RequestEvent): Response;
358
-
565
+ export declare function configureServerErrors(config: ServerErrorsConfig): void;
359
566
  /**
360
- * The cookie codec (the platform-gap primitives — see cookies.d.ts): ALL
361
- * of core's cookie surface. The blessed patterns are
362
- * `parseCookieHeader(event.request.headers.get("cookie"))` for reads and
363
- * `event.response.headers.append("set-cookie", serializeCookie(name,
364
- * value, options))` for writes.
567
+ * Reports a failure that fails a request outside any render or server
568
+ * function the runtime reports, such as a throw a framework's request
569
+ * handler catches from its middleware. The ambient server error hook hears
570
+ * it as `{ kind: "request", handling: "failed", event }`, once per error
571
+ * object per request, and its return is ignored, as for every `handling:
572
+ * "failed"`. A render failure is the render's: a synchronous throw out of
573
+ * `renderToString` or `renderToStream` was already heard as `kind:
574
+ * "render"` before the caller caught it, so reporting it here adds nothing.
575
+ * With no hook registered the failure goes to `console.error`, as a render
576
+ * that fails before its shell does. There is no per-request hook at this
577
+ * layer.
365
578
  */
366
- export { parseCookieHeader, serializeCookie } from "./cookies.js";
367
- export type { CookieOptions } from "./cookies.js";
368
-
579
+ export declare function reportRequestFailure(error: unknown, event: RequestEvent): void;
369
580
  /**
370
- * The flash cookie's isomorphic half and the codec-free server-function
371
- * layer (reference detection + the late-bound RPC seam) — mirrors of the
372
- * client entry's exports, so integration code reading them stays
373
- * universal. Declared through server-functions/shared.d.ts, the
374
- * declaration home published-types layouts ship.
581
+ * The current request event, when called on the server inside a request
582
+ * scope (established by `provideRequestEvent` from `@solidjs/web/storage`
583
+ * or by the framework). Undefined on the client and outside a request.
584
+ * Read it above `await` boundaries in partially-polyfilled environments.
375
585
  */
376
- export {
377
- clearFlashCookie,
378
- getServerFunctionMetadata,
379
- getServerFunctionRPC,
380
- hasFlashCookie,
381
- isServerFunction
382
- } from "./server-functions/shared.js";
383
- export type {
384
- ServerFunction,
385
- ServerFunctionMetadata,
386
- ServerFunctionRPC
387
- } from "./server-functions/shared.js";
388
-
389
- export interface SSRResponseOptions {
390
- /** Base head; the stub's status/headers win over it. */
391
- responseInit?: ResponseInit;
392
- /** Nonce carried by the post-flush `<script>` redirect fallback. */
393
- nonce?: string;
394
- /** Rewrites each outgoing HTML chunk (entry script injection, ...). */
395
- transformChunk?: (chunk: string) => string;
586
+ export declare function getRequestEvent(): RequestEvent | undefined;
587
+ /** A render's keyed server-to-client value channel (`getHydrationWriter`). */
588
+ export interface HydrationWriter {
589
+ /**
590
+ * Whether the render takes promises and async iterables (`renderToStream`).
591
+ * `renderToString` takes synchronous values only; `write` throws on an
592
+ * async one.
593
+ */
594
+ readonly async: boolean;
595
+ /**
596
+ * Serializes `value` for the client under `key`, readable there with
597
+ * `takeHydrationValue(key)`. Returns `false` without writing when `key` was
598
+ * already written by this render (the first write wins) or the render no
599
+ * longer takes values (a finished `renderToString`, a completed stream).
600
+ * `deferStream` holds the shell until a promise settles. Prefix keys with
601
+ * the library's own namespace (`"sq:"`); Solid's own entries are keyed by
602
+ * hydration id.
603
+ */
604
+ write(key: string, value: unknown, options?: {
605
+ deferStream?: boolean;
606
+ }): boolean;
396
607
  }
397
-
608
+ /** A keyed value taken from the hydration registry (`takeHydrationValue`). */
609
+ export type HydrationValue<T = unknown> = {
610
+ status: "resolved";
611
+ value: T;
612
+ } | {
613
+ status: "rejected";
614
+ error: unknown;
615
+ } | {
616
+ status: "pending";
617
+ promise: Promise<T>;
618
+ };
398
619
  /**
399
- * Derives the outgoing `Response` for an SSR render result, running the
400
- * response-head lifecycle against `event.response`: commit at shell flush,
401
- * pre-flush `Location` becomes a real redirect, post-flush `Location`
402
- * appends a client-side script redirect before the stream closes.
403
- * Synchronous for string results; resolves at shell flush for stream
404
- * results.
620
+ * The keyed server-to-client value channel of the render the caller belongs
621
+ * to — found through the caller's owner, else (no owner) through the request
622
+ * scope when exactly one render is open for that request. `undefined`
623
+ * outside any render and on the client. Never another request's render.
624
+ *
625
+ * Capture it where the render is known (component setup) to write from IO
626
+ * later. A write is not gated on `<NoHydration>`: read `isHydratable()` where
627
+ * the value is produced to decide. Read the value on the client with
628
+ * `takeHydrationValue(key)`.
629
+ *
630
+ * @example
631
+ * ```ts
632
+ * const writer = getHydrationWriter();
633
+ * if (writer && isHydratable()) writer.write("sq:" + hash, data);
634
+ * ```
405
635
  */
406
- export function createSSRResponse(
407
- result: string,
408
- event: RequestEvent | undefined,
409
- options?: SSRResponseOptions
410
- ): Response;
411
- export function createSSRResponse(
412
- result: { pipe(writable: { write: (v: string) => void; end: () => void }): void },
413
- event: RequestEvent | undefined,
414
- options?: SSRResponseOptions
415
- ): Promise<Response>;
416
-
636
+ export declare function getHydrationWriter(): HydrationWriter | undefined;
417
637
  /**
418
- * Fetch-style middleware: return a `Response` to answer the request, or
419
- * call `next()` (optionally with a substitute `Request`) to advance the
420
- * chain and observe/replace the eventual response.
638
+ * Sets the link handler of the render the caller belongs to — found through
639
+ * the caller's owner (component setup), else through the request scope when
640
+ * exactly one render is open for it — so every candidate anchor rendered
641
+ * from here on carries the handler's markup (`aria-current="page"`,
642
+ * `data-active`) in the server HTML. Returns `false` outside any render.
643
+ *
644
+ * Scoped to the render: concurrent renders never share a handler, and it is
645
+ * gone with the render. Set once per render, typically from a router's
646
+ * server render with its request's location; `undefined` clears it. Anchors
647
+ * serialized BEFORE the call (a document shell above the router) are not
648
+ * marked. Server components inline in the document render under the page's
649
+ * handler; a server component's own frame stream has none unless its render
650
+ * sets one.
651
+ *
652
+ * The first call with a handler writes the `links` hydration record once for
653
+ * the response (`hasServerLinkState()` on the client), the signal that the
654
+ * anchors' link state is the server's and can be trusted at hydration.
655
+ *
656
+ * @example
657
+ * ```ts
658
+ * // in <Router>'s server render
659
+ * setLinkClaim(attrs => matchLink(attrs, location) ? ' data-active aria-current="page"' : "");
660
+ * ```
661
+ * @internal
421
662
  */
422
- export type FetchMiddleware = (
423
- request: Request,
424
- next: (request?: Request) => Promise<Response>
425
- ) => Response | Promise<Response>;
426
-
663
+ export declare function setLinkClaim(handler: LinkClaimHandler | undefined): boolean;
427
664
  /**
428
- * Composes fetch-style middleware into one function of the same shape;
429
- * the terminal `next` dispatches to the actual handler. Runs in whatever
430
- * scope the caller established (`provideRequestEvent`), so
431
- * `getRequestEvent()` works exactly as in application code.
665
+ * Server: `false`. The client reads the `links` hydration record a render
666
+ * with a link handler wrote (`setLinkClaim`); see the client entry.
667
+ * @internal
432
668
  */
433
- export function composeMiddleware(
434
- middlewares: FetchMiddleware[]
435
- ): (
436
- request: Request,
437
- next: (request?: Request) => Response | Promise<Response>
438
- ) => Promise<Response>;
439
-
440
- export function untrack<T>(fn: () => T): T;
441
-
442
- // client-only APIs
443
-
444
- /** @deprecated not supported on the server side */
445
- export function style(
446
- node: Element,
447
- value: { [k: string]: string },
448
- prev?: { [k: string]: string }
449
- ): void;
450
-
451
- /** @deprecated not supported on the server side */
452
- export function insert<T>(
453
- parent: MountableElement,
454
- accessor: (() => T) | T,
455
- marker?: Node | null,
456
- init?: JSX.Element
457
- ): JSX.Element;
458
-
459
- /** @deprecated not supported on the server side */
460
- export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
461
-
462
- /** @deprecated not supported on the server side */
463
- export function delegateEvents(eventNames: string[]): void;
464
- /** @deprecated not supported on the server side */
465
- export function registerDelegatedRoot(root: MountableElement): void;
466
- /** @deprecated not supported on the server side */
467
- export function unregisterDelegatedRoot(root: MountableElement): void;
468
- /** @deprecated not supported on the server side */
469
- export function registerDelegatedContainer(
470
- container: MountableElement,
471
- owner?: MountableElement
472
- ): void;
473
- /** @deprecated not supported on the server side */
474
- export function unregisterDelegatedContainer(
475
- container: MountableElement,
476
- owner?: MountableElement
477
- ): void;
478
- /** @deprecated not supported on the server side */
479
- export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
480
- /** @deprecated not supported on the server side */
481
- export function dynamicProperty(props: unknown, key: string): unknown;
482
- /** @deprecated not supported on the server side */
483
- export function setAttribute(node: Element, name: string, value: string): void;
484
- /** @deprecated not supported on the server side */
485
- export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
486
-
669
+ export declare function hasServerLinkState(): boolean;
670
+ /** Server stub — the registry is the client's. See the client entry. */
671
+ export declare function takeHydrationValue<T = unknown>(_key: string): HydrationValue<T> | undefined;
487
672
  /**
488
- * Server no-op: element claims are a client-only concern, but consumers may
489
- * register isomorphically. Returns a no-op unregister function.
673
+ * The trace the current request belongs to — continued from the incoming
674
+ * W3C `traceparent` when there was one, originated by the runtime
675
+ * otherwise; in observe/dev builds, merged with the installed provider's
676
+ * answer (`OBSERVE.server.trace`). Same object for every read within the
677
+ * request, direct server-function calls included. For a render outside a
678
+ * request scope, the render's own trace, read within it (under its owner).
679
+ * `undefined` outside both, and on the client. Forward it downstream from a
680
+ * server function with `getTraceContext()?.entries.traceparent`.
490
681
  */
491
- export function registerElementClaim(handler: (element: Element) => void): () => void;
492
- /** Server no-op: returns `node` unchanged. Claims never fire during SSR. */
493
- export function claimElement<T extends Element>(node: T): T;
494
- /** Server no-op: returns `root` unchanged. Claims never fire during SSR. */
495
- export function claimElementTree<T extends Node>(root: T): T;
496
-
497
- /** @deprecated not supported on the server side */
498
- export function addEvent(node: Element, name: string, handler: () => void, delegate: boolean): void;
499
-
500
- /** @deprecated not supported on the server side */
501
- export function render(code: () => JSX.Element, element: MountableElement): () => void;
682
+ export declare function getTraceContext(): TraceContext | undefined;
683
+ /** A fresh, uncommitted response head. */
684
+ export declare function createResponseStub(): ResponseStub;
685
+ export declare function createRequestEvent<T extends object = {}>(request: Request, init?: T): RequestEvent & {
686
+ response: ResponseStub;
687
+ } & T;
688
+ export declare function commitResponseStub(stub: ResponseStub, options?: {
689
+ allowLateLocation?: boolean;
690
+ event?: RequestEvent;
691
+ }): ResponseStub;
692
+ export declare function getExpectedRedirectStatus(response: ResponseStub): number;
693
+ export declare function commitEventResponse(response: Response, event?: RequestEvent): Response;
694
+ export declare function createSSRResponse(result: string, event: RequestEvent | undefined, options?: SSRResponseOptions): Response;
695
+ export declare function createSSRResponse(result: {
696
+ pipe(writable: {
697
+ write: (v: string) => void;
698
+ end: () => void;
699
+ }): void;
700
+ }, event: RequestEvent | undefined, options?: SSRResponseOptions): Promise<Response>;
701
+ export declare function composeMiddleware(middlewares: FetchMiddleware[]): (request: Request, next: (request?: Request) => Response | Promise<Response>) => Promise<Response>;
502
702
  /**
503
- * @deprecated not supported on the server side
504
- * @param flag
505
- * - `undefined` — clone the template as-is (uses `cloneNode`).
506
- * - `1` — use `document.importNode` instead of `cloneNode`.
507
- * - `2` — the template html is wrapped; the outer tag is stripped at clone time.
703
+ * Options for `registerElementClaim` (see the client entry); inert on the server.
704
+ * @internal
508
705
  */
509
- export function template(html: string, flag?: 1 | 2): () => Element;
510
- /** @deprecated not supported on the server side */
511
- export function setProperty(node: Element, name: string, value: any): void;
512
- /** @deprecated not supported on the server side */
513
- export function className(node: Element, value: string): void;
514
- /** @deprecated not supported on the server side */
515
- export function assign(node: Element, props: any, skipChildren?: Boolean): void;
516
-
517
- /** @deprecated not supported on the server side */
518
- export function hydrate(
519
- fn: () => JSX.Element,
520
- node: MountableElement,
521
- options?: { renderId?: string; owner?: unknown }
522
- ): () => void;
523
-
524
- /** @deprecated not supported on the server side */
525
- export function getNextElement(template?: () => Element): Element;
526
- /** @deprecated not supported on the server side */
527
- export function getNextMatch(start: Node, elementName: string): Element;
528
- /** @deprecated not supported on the server side */
529
- export function getNextMarker(start: Node): [Node, Array<Node>];
530
- /** @deprecated not supported on the server side */
531
- export function runHydrationEvents(): void;
532
- /** @deprecated not supported on the server side */
533
- export function ref(
534
- fn: () => ((element: Element) => void) | ((element: Element) => void)[],
535
- element: Element
536
- ): void;
537
- /** @deprecated not supported on the server side */
538
- export function setStyleProperty(node: Element, name: string, value: any): void;
539
- /**
540
- * @internal See client.d.ts — head-management RFC policy: ambient CSS is
541
- * unmanaged; the head registry owns directly-mounted stylesheet lifecycle.
542
- * @deprecated not supported on the server side — register assets through the render context instead
706
+ export type ElementClaimOptions = {
707
+ /**
708
+ * Attribute names whose compiler-owned writes re-claim an already claimed
709
+ * element, as plain names (`href` covers `prop:href` and `xlink:href`).
710
+ * Defaults to `["href", "action"]`.
711
+ */
712
+ attributes?: readonly string[];
713
+ }; /**
714
+ * Server no-op: element claims are a client-only concern, but consumers may
715
+ * register isomorphically. Returns a no-op unregister function.
543
716
  */
544
- export function acquireAsset(descriptor: unknown): () => void;
717
+ export declare function registerElementClaim(handler: (element: Element) => void, options?: ElementClaimOptions): () => void;
718
+ export declare function claimElement<T extends Element>(node: T, owner?: Owner | null): T;
719
+ export declare function claimElementTree<T extends Node>(root: T): T;
720
+ /** Server: `fn()`. No event is dispatched during SSR, so there is no interaction to join. */
721
+ export declare function dispatchAsInteraction<T>(_e: Event, fn: () => T): T;
722
+ export { notSup as style, notSup as insert, notSup as spread, notSup as delegateEvents, notSup as registerDelegatedRoot, notSup as unregisterDelegatedRoot, notSup as registerDelegatedContainer, notSup as unregisterDelegatedContainer, notSup as getDelegatedRoot, notSup as dynamicProperty, notSup as setAttribute, notSup as setAttributeNS, notSup as addEvent, notSup as render, notSup as template, notSup as setProperty, notSup as setStatefulProperty, notSup as className, notSup as assign, notSup as hydrate, notSup as getNextElement, notSup as getNextMatch, notSup as getNextMarker, notSup as runHydrationEvents, notSup as ref, notSup as setStyleProperty, notSup as readShallow, notSup as acquireAsset };
723
+ declare function notSup(): void;