octane 0.2.2 → 0.2.3

package/dist/runtime.server.d.ts

@@ -43,6 +43,7 @@ type ServerComponent = (props: any, scope: SSRScope, extra?: any) => string;
  * authored component type and trust the build for the server shape.
  */
 export type ServerEntryComponent = ServerComponent | ((props: any) => unknown);
+export type ServerRenderNode = ServerEntryComponent | ElementDescriptor | Iterable<unknown> | PromiseLike<unknown> | Context<unknown> | string | number | bigint | boolean | null | undefined;
 /** @internal Enable invocation collection before an opted-in module renders. */
 export declare function enableNativeReadCollection(abi?: number): void;
 /** @internal Compiler/runtime native-read capability version 1. */
@@ -130,6 +131,8 @@ export declare const Children: {
     only<T>(children: T): T;
 };
 export declare function createPortal(body: unknown, target: unknown, props?: any): unknown;
+/** @internal Brand the final serialized output of a compiled server body. */
+export declare function ssrHtml(html: string): string;
 export declare function escapeHtml(v: unknown): string;
 export declare function escapeAttr(v: unknown): string;
 /** A dynamic text hole. null/false/undefined render as empty (React parity). */
@@ -151,6 +154,10 @@ export declare function ssrTextPre(v: unknown): string;
  */
 export declare function ssrChild(v: unknown, scope: SSRScope): string;
 export declare function ssrChildText(v: unknown, scope: SSRScope): string;
+/** @internal First-child renderable hole in a newline-eating HTML element. */
+export declare function ssrChildTextPre(v: unknown, scope: SSRScope): string;
+/** @internal First renderable child when static output has no shielding markers. */
+export declare function ssrChildPre(v: unknown, scope: SSRScope): string;
 /**
  * Wrap a control-flow branch / for-item's HTML in hydration block markers
  * (`<!--[-->` … `<!--]-->`), so a future client hydrate cursor can find the
@@ -335,7 +342,8 @@ export declare const Hydrate: ServerComponent;
  * branch's inner `ssrBlock`, so the client's `<Suspense>` (componentSlot →
  * tryBlock) adopts it byte-for-byte. A descendant `use(thenable)` that hasn't
  * resolved throws `SSR_SUSPENSE` → the `fallback` renders for this pass and
- * render()'s loop awaits + re-renders; a real error rethrows to an outer boundary.
+ * render()'s loop awaits + re-renders. A render error publishes the fallback,
+ * reports onError, and leaves the boundary ready for a fresh client render.
  */
 export declare const Suspense: (props: {
     fallback?: unknown;
@@ -474,7 +482,9 @@ export declare function warmChild(comp: any, props: any): void;
  */
 export declare function lazy<C>(load: () => PromiseLike<{
     default: C;
-} | C>): C;
+} | C>): C & {
+    displayName?: string;
+};
 export declare function useState<T = undefined>(): [
     T | undefined,
     (next: T | undefined | ((value: T | undefined) => T | undefined)) => void,
@@ -526,12 +536,21 @@ export declare function useActionState<S>(_action: unknown, initialState: S): [S
 export interface FormStatus {
     pending: boolean;
     data: FormData | null;
-    method: string;
+    method: string | null;
     action: ((formData: FormData) => unknown) | string | null;
 }
 export declare function useFormStatus(): FormStatus;
 export declare function useOptimistic<S, V = S>(state: S): [S, (value: V) => void];
-export declare function memo<P>(component: P): P;
+export declare function memo<C extends (...args: any[]) => any>(component: C): C & {
+    readonly type: C;
+    displayName?: string;
+};
+/** @internal Keep a copied static descriptor from warming an unrelated wrapper. */
+export declare function markWarm<T extends Function>(component: T, plan: unknown): T;
+/** @internal Invoke a provider that owns the trailing hook-slot ABI. */
+export declare function invokeManualHook<T>(fn: (...args: any[]) => T, receiver: unknown, args: IArguments): T;
+/** @internal Adapt an expression provider that owns the trailing hook-slot ABI. */
+export declare function manualHook<F extends (...args: any[]) => any>(fn: F, name?: string): F;
 export declare function withSlot<T>(sym: symbol, fn: (...a: any[]) => T, ...args: any[]): T;
 export declare function startTransition(fn: () => void | Promise<unknown>): void;
 export declare function flushSync<T>(fn: () => T): T;
@@ -641,6 +660,11 @@ type SuspenseOutcome = SuspenseResult & {
     thenable: PromiseLike<unknown>;
 };
 type ResolvedMap = Map<string, SuspenseOutcome> & {
+    /** Recoverable buffered-boundary errors are reported once across async retries. */
+    bufferedErrors?: Map<string, {
+        error: unknown;
+        reported: boolean;
+    }>;
     /** Undefined for externally hosted passes whose request lifetime is not owned here. */
     resourceOptions?: RenderOptions | null;
     /** Optional renderer resources; allocated only by a participating adapter. */
@@ -699,7 +723,7 @@ export declare function getServerRenderResourceContext(): ServerRenderResourceCo
  * for SSG / any place that wants fully-resolved HTML with no client fallback.
  * This is the buffered, await-everything behaviour of the old `render()`.
  */
-export declare function prerender(entryComponent: ServerEntryComponent, props?: any, options?: RenderOptions): Promise<RenderResult>;
+export declare function prerender(entryComponent: ServerRenderNode, props?: any, options?: RenderOptions): Promise<RenderResult>;
 /**
  * Stream variant of {@link prerender}, mirroring React's `prerenderToNodeStream`
  * semantics: the promise resolves only after the await-everything render fully
@@ -711,7 +735,7 @@ export declare function prerender(entryComponent: ServerEntryComponent, props?:
  * `headChannel: 'separate'` has no channel to land in here and is ignored
  * (the head folds), with a development diagnostic.
  */
-export declare function prerenderToNodeStream(entryComponent: ServerEntryComponent, props?: any, options?: RenderOptions): Promise<{
+export declare function prerenderToNodeStream(entryComponent: ServerRenderNode, props?: any, options?: RenderOptions): Promise<{
     prelude: import('node:stream').Readable;
 }>;
 /** @internal hosted-host ABI. Opaque outside octane/react/server. */
@@ -753,17 +777,17 @@ export declare function renderHostedAttempt(session: HostedServerSession, compon
 /**
  * React `react-dom/server` `renderToString` — a SINGLE synchronous pass, no
  * awaiting. A Suspense boundary that suspends renders its fallback (the inline
- * `@try`/`@pending` arm); a bare `use(thenable)` with no enclosing boundary ends
- * the render early (its partial output is returned). Synchronously-resolved
+ * `@try`/`@pending` arm); a bare `use(thenable)` with no enclosing boundary throws
+ * instead of returning an incomplete document. Synchronously-resolved
  * `use()` in the shell still seeds. Use `prerender` when you need the data awaited.
  */
-export declare function renderToString(entryComponent: ServerEntryComponent, props?: any, options?: RenderOptions): RenderResult;
+export declare function renderToString(entryComponent: ServerRenderNode, props?: any, options?: RenderOptions): RenderResult;
 /**
  * React `react-dom/server` `renderToStaticMarkup` — a single synchronous pass
  * producing clean, NON-hydratable HTML: no `<!--[-->`/`<!--]-->` block markers,
  * no head-adoption markers, no suspense seed script. For static pages / email.
  */
-export declare function renderToStaticMarkup(entryComponent: ServerEntryComponent, props?: any, options?: RenderOptions): RenderResult;
+export declare function renderToStaticMarkup(entryComponent: ServerRenderNode, props?: any, options?: RenderOptions): RenderResult;
 /**
  * Compiled `@try` / JSX `<Suspense>` boundary. `siteKey` is the compiler's
  * source-position hash; combined with the frame path + per-frame occurrence it
@@ -773,12 +797,13 @@ export declare function renderToStaticMarkup(entryComponent: ServerEntryComponen
  *   suspend, @pending  → ssrBlock(ssrBlock(pendingHtml))
  *   suspend, no arm    → ssrBlock('')
  *   error, @catch      → ssrBlock(ssrBlock(catchHtml))
- *   error, no @catch   → rethrow (buffered) / stream fallback for client recovery
+ *   error, no @catch   → rethrow for authored buffered @try; JSX Suspense and
+ *                       streamed boundaries publish fallback for client recovery
  * In streaming mode a suspended boundary additionally carries the
  * `<template data-oct-b>` sentinel, and a REGISTERED boundary keeps returning
  * its pending form (content ships via its segment).
  */
-export declare function ssrTry(scope: SSRScope, siteKey: string, tryFn: (arg: unknown, scope: SSRScope) => string, pendFn: ((arg: unknown, scope: SSRScope) => string) | null, catchFn: ((err: unknown, scope: SSRScope, reset: () => void) => string) | null, namespace?: 'html' | 'svg' | 'mathml', propagateSuspense?: boolean): string;
+export declare function ssrTry(scope: SSRScope, siteKey: string, tryFn: (arg: unknown, scope: SSRScope) => string, pendFn: ((arg: unknown, scope: SSRScope) => string) | null, catchFn: ((err: unknown, scope: SSRScope, reset: () => void) => string) | null, namespace?: 'html' | 'svg' | 'mathml', propagateSuspense?: boolean, recoverErrors?: boolean): string;
 /**
  * A live source of externally-produced HTML (typically framework data
  * `<script>` tags materializing as loaders settle) merged natively into a
@@ -849,7 +874,7 @@ export interface StreamOptions extends RenderOptions {
  * `onAllReady` once every boundary has streamed. Octane signature convention:
  * `(Component, props?, options?)`.
  */
-export declare function renderToPipeableStream(entryComponent: ServerEntryComponent, props?: any, options?: StreamOptions): {
+export declare function renderToPipeableStream(entryComponent: ServerRenderNode, props?: any, options?: StreamOptions): {
     pipe: <T extends {
         write(chunk: string): unknown;
         end(): unknown;
@@ -863,7 +888,7 @@ export declare function renderToPipeableStream(entryComponent: ServerEntryCompon
  * accepted under consumer backpressure. A consumer that pauses pulling also
  * pauses `allReady`; read concurrently when waiting for it.
  */
-export declare function renderToReadableStream(entryComponent: ServerEntryComponent, props?: any, options?: StreamOptions): Promise<ReadableStream<Uint8Array> & {
+export declare function renderToReadableStream(entryComponent: ServerRenderNode, props?: any, options?: StreamOptions): Promise<ReadableStream<Uint8Array> & {
     allReady: Promise<void>;
 }>;
 /** React DOM `preload(href, {as, …})`. */