octane 0.2.11 → 0.2.13

package/dist/runtime.d.ts

@@ -12,10 +12,18 @@
  * Effects: three-phase pipeline (insertion sync → layout sync → passive post-paint).
  * Reconciliation: LIS-based keyed list inside forBlock (ported from Ripple's patchKeyedChildrenComplex).
  */
+import type { BindingHandle } from './dom-bindings.js';
+import { type BindingHandoff } from './dom-binding-handoff.js';
 import { EXTERNAL_HYDRATION_PROMISE, HYDRATION_RANGE_BOUNDARY } from './constants.js';
 import type { HydrateProps } from './hydration/types.js';
+import type { IndependentHydrateActivator } from './hydration/independent-island.js';
 import { validateNativeReadWitness, type NativeReadWitness } from './signals/native-read-collector.js';
 import { type NativeReadRetry } from './signals/native-read-retry.js';
+import { SignalCandidateFrame } from './signals/transition-candidate.js';
+import { setNativeAdoptionResolver } from './signals/read-protocol.js';
+import { type NativeAdoptionState } from './signals/native-read-seeds.js';
+export { documentSignalOwner, installStreamedSignalOwnerActivator, } from './signals/document-owner.js';
+import { type SignalOwner, type SignalRendererOwnerIdentity } from './signals/types.js';
 export { EXTERNAL_HYDRATION_PROMISE, HYDRATION_RANGE_BOUNDARY };
 export { validateNativeReadWitness };
 export type ComponentBody<P = any, E = any> = (props: P, scope: Scope, extra: E) => void;
@@ -160,6 +168,31 @@ interface ChildScope {
     key: symbol | string | number;
     scope: Scope;
 }
+interface SignalRetryNode {
+    children?: Map<unknown, SignalRetryNode>;
+    owner?: SignalRendererOwnerIdentity;
+}
+interface SignalRetryOwners {
+    paths: SignalRetryNode;
+    owners: Set<SignalRendererOwnerIdentity>;
+}
+/** @internal Compiler/runtime module-signal capability version 1. */
+export declare function enableSignalBindings(abi?: number, potentialOnly?: boolean): void;
+export { readNativeDomStyle, readNativeDomProps } from './signals/read-protocol.js';
+/**
+ * A style binding owns reads in a normal scheduled Block, but owns no DOM range.
+ * The enclosing template owns the host and its children. Reusing the native
+ * read driver keeps speculative subscriptions, errors, and adoption transactional.
+ * @internal
+ */
+export declare function nativeStyleBinding(owner: Scope, slotIndex: number, el: HTMLElement | SVGElement, value: any): void;
+interface NativeProjectionProps {
+    el: HTMLElement | SVGElement;
+    compute: () => Record<string, unknown> | null | undefined;
+    fields: readonly string[];
+}
+/** One scheduled native read owns every field of a compiler-proven projection. @internal */
+export declare function nativeProjectionBinding(owner: Scope, slotIndex: number, el: HTMLElement | SVGElement, compute: NativeProjectionProps['compute'], fields: readonly string[]): void;
 /** @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. */
@@ -178,6 +211,11 @@ type OutputHandler = (block: Block, value: unknown) => void;
 interface RootIdState {
     prefix: string;
     next: number;
+    /** Shared deterministic namespace for lazily used module-signal instances. */
+    signalState?: {
+        prefix: string;
+        next: number;
+    };
     /** Shared render ownership; descendants already carry this root-local record. */
     renderOwner?: RootRenderOwner;
     /** Exclusive end of an SSR-reserved deferred-boundary range. */
@@ -290,6 +328,17 @@ export interface Block extends Scope {
     inactive: boolean;
     /** Direct (own) context reads this render — drives memo invalidation alongside $$ctxReads. */
     $$ctxDirect: Map<Context<any>, any> | null;
+    /**
+     * The context epoch at which this block's $$ctxReads/$$ctxDirect
+     * entries were last known consistent with live context versions: sampled when
+     * renderBlock clears the maps (this render repopulates them at current
+     * versions) and re-stamped after a bailout verifies every recorded entry.
+     * While it equals the current epoch NO context anywhere has changed since, so
+     * the per-bail version scans are provably redundant. restampCtxDeps poisons it
+     * (-1) when it merges a stale version into this block's map, so a still-pending
+     * consumer refresh can never be masked by the fast path.
+     */
+    $$ctxDepsEpoch: number;
     /**
      * Armed for React's IMPLICIT same-element bailout (beginWork's
      * oldProps === newProps skip). Set at value-position component mounts
@@ -445,6 +494,11 @@ interface TransitionActionBatch {
     hooksPending: boolean;
     pendingHolds?: number;
     workComplete?: boolean;
+    /** Allocated only by a native write inside this Action. */
+    native?: SignalCandidateFrame;
+    nativeWake?: () => void;
+    nativeBlocks?: Set<Block>;
+    nativeBoundaries?: Map<TrySlot, TrackedThenable<any>>;
 }
 type TransitionMemoSwap = [kind: 0, hooks: Map<HookSlot, unknown>, slot: HookSlot, previous: unknown, next: unknown] | [kind: 1, cells: any[], base: number, previous: any[], next: any[]];
 interface WarmHarvestEntry {
@@ -469,6 +523,11 @@ interface RootTransitionHold {
 }
 interface RootRenderOwner {
     current: Block | null;
+    /** Shared document/account data owner; distinct from this root's presentation owner. */
+    signalOwner?: SignalOwner;
+    bindingLeases?: Set<BindingHandoff>;
+    preservePresentation?: boolean;
+    bindingContainer?: Node;
     adopt?: (block: Block) => void;
     retry: () => void;
     request: ((mode: 'urgent' | 'transition') => void) | null;
@@ -476,8 +535,12 @@ interface RootRenderOwner {
     wakeable: PromiseLike<unknown> | null;
     /** Lazily allocated only by adapters carrying metadata across fresh retry scopes. */
     retryKey: object | null;
+    /** Actual first-mount signal state retained only for the current retry episode. */
+    retrySignalOwners?: SignalRetryOwners;
     /** Only native suspended readers allocate a retry lease outside their discarded Scopes. */
     nativeRetry?: NativeReadRetry;
+    /** Only roots participating in a native candidate retain cancellation ownership. */
+    nativeTransitions?: Set<TransitionActionBatch>;
     transaction: RootRenderTransaction | null;
     /** Installed only when a single-origin transition suspends at this root. */
     transition?: RootTransitionHold;
@@ -499,6 +562,8 @@ interface RootRenderTransaction {
     aborted: boolean;
     rootRequest: boolean;
     hydrating?: boolean;
+    /** Collectively validated before a native candidate published canonical state. */
+    nativeAdmitted?: boolean;
 }
 /** @internal Opaque retry episode, without retaining an abandoned Scope. */
 export declare function getRootRenderRetryKey(scope: Scope, retryOnly?: boolean): object | null;
@@ -518,8 +583,14 @@ interface ParkedItem {
 }
 /** Animation class value: a class string, 'auto', 'none', or a per-type map. */
 type ViewTransitionClassValue = string | Record<string, string>;
+type ViewTransitionRef = ((instance: ViewTransitionInstance | null) => void | (() => void)) | {
+    current: ViewTransitionInstance | null;
+} | readonly ViewTransitionRef[] | null;
 export interface ViewTransitionProps {
     name?: string;
+    /** Create an element scope from one persistent host. Omitted boundaries inherit their scope. */
+    scope?: 'element';
+    ref?: ViewTransitionRef;
     enter?: ViewTransitionClassValue;
     exit?: ViewTransitionClassValue;
     update?: ViewTransitionClassValue;
@@ -552,9 +623,11 @@ export interface ViewTransitionProps {
 export declare class ViewTransitionPseudoElement {
     /** The pseudo-element selector, e.g. `::view-transition-new(hero)`. */
     readonly selector: string;
-    constructor(pseudo: string, name: string);
+    private readonly scope;
+    constructor(pseudo: string, name: string, scope?: Element);
     animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
-    getAnimations(): Animation[];
+    getAnimations(_options?: GetAnimationsOptions): Animation[];
+    getComputedStyle(): CSSStyleDeclaration;
 }
 /**
  * The instance handed to on* callbacks: the resolved view-transition-name plus
@@ -635,6 +708,8 @@ interface OffscreenCapture {
     suspenseCommits: Set<TrySlot> | undefined;
     /** Speculative renderer transactions are released only after commit or discard. */
     renderCleanups: Array<(discarded: boolean) => void> | undefined;
+    /** Only a structural binding lease records current-tree adoption receipts. */
+    presentations?: PresentationHydrationFrame[];
 }
 /** @internal Preserve the owning renderer's scheduler without racing a staged commit. */
 export declare function scheduleRenderCleanup(schedule: (callback: () => void) => void, receiver: unknown, cleanup: () => void, onDiscard?: () => void): void;
@@ -723,7 +798,7 @@ export declare function hasPendingWork(): boolean;
  */
 export declare function act<T>(fn: () => T | Promise<T>): Promise<T>;
 export declare function renderBlock(block: Block): void;
-export declare function componentSlotLite<P>(parentScope: Scope, slotKey: number, host: Node, comp: ComponentBody<P>, props: P, anchor?: Node): void;
+export declare function componentSlotLite<P>(parentScope: Scope, slotKey: number, host: Node, comp: ComponentBody<P>, props: P, anchor?: Node, invocationSite?: string): void;
 declare const SLOT_FLAG_TEARDOWN: number;
 /** @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;
@@ -874,6 +949,11 @@ export interface Context<T> {
      * changed value. Consumers record the version they read at; the memo bailout
      * (componentSlot) compares it so a context change forces a re-render through
      * the push-cascade even when props are shallow-equal. See useContextInternal.
+     * Every bump must move the shared context epoch too — call bumpContextEpoch
+     * adjacent to the write, or (for external bumpers like react-hosted mirrors)
+     * guarantee a root.render commit follows, whose renderResolved entry bumps
+     * it. The $$ctxDepsEpoch bail fast path treats an unmoved epoch as "nothing
+     * changed", so an unpaired bump strands consumers.
      */
     $$version: number;
 }
@@ -1058,6 +1138,12 @@ interface TrackedThenable<T = any> extends PromiseLike<T> {
     value?: T;
     reason?: any;
 }
+declare const HYDRATION_REJECTION_EXCEPTION: unique symbol;
+declare class HydrationRejectionException {
+    readonly reason: unknown;
+    readonly [HYDRATION_REJECTION_EXCEPTION] = true;
+    constructor(reason: unknown);
+}
 /** Compiler-owned direct use() creations consult their server-proven site outcome first. */
 export declare function seedOrCreate<T>(site: string, factory: () => T): T;
 /**
@@ -1160,7 +1246,129 @@ export declare function lazy<C extends ComponentBody<any>>(load: () => PromiseLi
     displayName?: string;
 };
 export declare function useId(slot?: symbol): string;
+interface LazyTemplateRecord {
+    html: string;
+    ns: 0 | 1 | 2 | 3;
+    frag: number;
+    parsed: Array<Node | null>;
+    /**
+     * Lazily computed adoption-root descriptor for PROD hydration's parse-free
+     * root check (see HydrationCapability.cloneLazy): 0 = not computed yet, a
+     * string = the root element's tag as written in `html`, 3 / 8 = a text /
+     * comment-anchor root (nodeType-only match). Declared in the `template()`
+     * literal so the record's hidden class never transitions.
+     */
+    root: string | 0 | 3 | 8;
+}
 export declare function template(html: string, ns?: number, frag?: number): Element;
+/**
+ * Lite component calls deliberately allocate no CompSlot/Block range owner,
+ * but hydration still adopts their server frame pair. Keep that pair in an
+ * ephemeral map for the one post-hydration compaction pass; the live lite
+ * scope only needs its end marker re-pointed if the pair is borrowed.
+ */
+interface HydratedLiteRange {
+    start: Comment;
+    end: Comment;
+}
+interface PendingHydrationClassWrite {
+    next: string | null;
+    absentIsEmpty: boolean;
+    useAttribute: boolean;
+    remove: boolean;
+}
+/**
+ * Root-local hydration state and the dynamic dispatch boundary for hydration-only
+ * code. The class is constructed only by hydrateRoot, so client-only bundles can
+ * discard its methods together with the marker/mismatch/seed helper graph.
+ */
+declare class HydrationCapability {
+    rootBlock: Block;
+    node: Node | null;
+    seeds: unknown[] | null;
+    depth: number;
+    seedCursor: number;
+    hasAdjacentRangePair: boolean;
+    private abandoned;
+    private readonly freshNodes;
+    private readonly unframedRootRanges;
+    /** Pairs discovered while matching an outer range; released with this hydration pass. */
+    private matchingCloses;
+    /** First unclaimed root sibling after a compiled root clone; undefined until known. */
+    private rootRemainder;
+    private rootCleanupBoundary;
+    readonly deferredActivities: Array<() => void>;
+    readonly liteRanges: WeakMap<Scope, HydratedLiteRange>;
+    readonly classWrites: Map<Element, PendingHydrationClassWrite>;
+    private readonly textWarnings;
+    /** Skip component-frame adoption until the declared container owner. */
+    passthroughRanges: boolean;
+    nativeAdoption?: NativeAdoptionState;
+    retryPresentation?: () => void;
+    presentation?: boolean;
+    constructor(rootBlock: Block, node: Node | null, seeds: unknown[] | null);
+    isActive(): boolean;
+    owns(block: Block): boolean;
+    suspend<T>(fn: () => T): T;
+    isOpen(node: Node | null): node is Comment;
+    isClose(node: Node | null): node is Comment;
+    close(open: Node): Comment;
+    resolveOpen(anchor: Node | null | undefined, domParent: Node): Comment | null;
+    markerState(node: Node): -1 | 0 | 1;
+    describe(node: Node | null): string;
+    warnStructural(loc: string | undefined, expected: string, actual: string): void;
+    recordTextMismatch(node: Text, loc: string | undefined, server: string | null): void;
+    flushTextWarnings(): void;
+    removeRange(start: Node, end: Node): void;
+    parseSeeds(raw: string): unknown[] | null;
+    isRejection(error: unknown): error is HydrationRejectionException;
+    rejectionFromSeed(seed: unknown): HydrationRejectionException | null;
+    seedOrCreate<T>(site: string, factory: () => T): T;
+    useSeed<T>(thenable: TrackedThenable<T>, state: TrackedThenable<any>[], index: number, replaceOnResume: boolean): T;
+    /** Mark a client-built hydration replacement (and its descendants) as fresh DOM. */
+    markFresh(node: Node): void;
+    isFresh(node: Node): boolean;
+    /** Keep a client-owned root anchor alive while stale server siblings are swept. */
+    protectRootAnchor(node: Node): void;
+    /** Bound an unframed third-party component root so its returned host can adopt it. */
+    wrapUnframedRoot(cursor: Node): readonly [Comment, Comment];
+    isUnframedRootRange(start: Node, end: Node): boolean;
+    /** Record the first node outside a root-owned range exactly once. */
+    claimRootRemainder(node: Node | null): void;
+    private freshClone;
+    private fragmentRemainder;
+    /**
+     * If a top-level cursor sits inside a server marker frame, return the first
+     * sibling after that OUTERMOST frame. A clone can execute in a lite/provider
+     * descendant while its DOM is still a direct child of the root container;
+     * `cursor.nextSibling` would then be only the descendant's close marker.
+     */
+    private framedRootRemainder;
+    /** Give up root adoption after an unframed return/fragment mismatch. */
+    abandonRoot(expected: string, actual: string, loc?: string): void;
+    clone<T extends Node>(template: T, loc?: string, partialStyles?: string): T;
+    /**
+     * PROD adoption entry for lazy compiler templates: the root check runs off
+     * the template SOURCE (lazyRootMatches), so the happy path never forces the
+     * parse — `adopt` resolves the parsed template on demand only on its cold
+     * paths (mismatch recovery, client-side builds mid-hydration, fragment root
+     * claims).
+     */
+    cloneLazy(lazy: LazyTemplateRecord, loc?: string): Node;
+    /** `template` is null only in prod lazy mode (then `lazy` is set) — every cold path resolves it. */
+    private adopt;
+    /** Remove server siblings left after the root's complete client shape was adopted. */
+    finishRoot(): void;
+    htext(el: Node, text: string, loc?: string): Text;
+    htextSwap(posNode: Node | null, text: string): Text;
+    sibling(node: Node, count: number): Node | null;
+    allowAttribute(el: Element, name: string, next: string | null): boolean;
+    allowClass(el: Element, next: string | null, absentIsEmpty?: boolean): boolean;
+    queueClass(el: Element, next: string | null, absentIsEmpty: boolean, useAttribute: boolean, remove: boolean): void;
+    flushClassWrites(): void;
+    applyStyle(el: HTMLElement | SVGElement, value: any, _prev: any, staticCss?: string, entries?: readonly unknown[]): boolean;
+    coalesce(): void;
+}
 export declare function clone<T extends Node>(node: T, loc?: string, partialStyles?: string): T;
 /**
  * Compiler-emitted for a multi-root template's mount: drain the cloned
@@ -1210,6 +1418,44 @@ export declare function htext(el: Node, value: unknown, seeded?: 1 | undefined):
  * `htext` (which handles the only-child fast path).
  */
 export declare function htextSwap(posNode: Node | null, value: unknown): Text;
+/** @internal Text holes in authored binding views retain an addressable range, including when empty. */
+export declare function bindingText(posNode: Node | null, value: unknown, marker: string): Text;
+interface PresentationHydrationFrame {
+    previous: PresentationHydrationFrame | null;
+    scope: Scope;
+    writes: Map<object, Map<string, () => void>>;
+    native: ReturnType<typeof setNativeAdoptionResolver>;
+    readToken: number;
+    witnessToken: number;
+    witnesses: Map<object, NativeReadWitness | null>;
+    completed: boolean;
+    lease: BindingHandoff;
+    revision?: number;
+    /** Installed only for structural receipts so ordinary commits do not retain the validator. */
+    current?: typeof currentPresentation;
+    hydration: HydrationCapability | null;
+}
+/** @internal Preserve the early presentation when an authored preparation throws. */
+export declare function presentationFailure(error: unknown): never;
+declare function currentPresentation(frame: PresentationHydrationFrame): boolean;
+/** @internal Only compiler-proven native views enter this publication boundary. */
+export declare function beginPresentationHydration(scope: Scope, id: string, supported?: boolean, structural?: boolean, conditionalRest?: boolean): PresentationHydrationFrame | null;
+/** @internal Restore the read frame even when preparation suspends or throws. */
+export declare function endPresentationHydration(frame: PresentationHydrationFrame | null, completed?: boolean): void;
+/** @internal Only authored host spreads retain generic host preparation. */
+export declare function presentationHostWrite<T>(writer: (...args: any[]) => T, ...args: any[]): T;
+/** @internal Compiler-selected writer seam; ordinary renderer setters stay unchanged. */
+export declare function presentationWrite<T>(writer: (...args: any[]) => T, kind: string, ...args: any[]): T;
+/** @internal Authored presentation ranges may not inherit an unrelated caller's boundary. */
+export declare function bindPresentationView<T extends Function>(view: T, id: string): T;
+/** @internal A lexical children body carries its authored invocation site across modules. */
+export declare function markBindingChildren<T extends Function>(body: T, site: string): T;
+/** @internal The existing renderer adopts only the current compiler-owned branch or child range. */
+export declare function presentationStructure(writer: (...args: any[]) => void, kind: 'if' | 'view', marker: string, ...args: any[]): void;
+/** @internal Keep historical class ownership beside the full renderer's composed class. */
+export declare function setBindingClass(element: Element, receipt: string, values: [unknown, unknown[]]): void;
+/** @internal Attribute-binding comparison ABI for the opt-in class receipt writer. */
+export declare function setBindingClassIfChanged(value: [unknown, unknown[]], previous: unknown, element: Element, receipt: string): unknown;
 /** Logical index-0 child: `node.firstChild` for both client and hydration. */
 export declare function child<T extends Node>(node: T): Node | null;
 /**
@@ -1219,6 +1465,15 @@ export declare function child<T extends Node>(node: T): Node | null;
  */
 export declare function sibling(node: Node, n?: number): Node | null;
 export declare function setText(node: Text, value: any): void;
+type DirectSignalAttributeKind = 'attr' | 'class' | 'booleanAttr' | 'ariaAttr' | 'stringData';
+/** @internal Compiler target for a direct signal/scalar text binding. */
+export declare function bindSignalText(scope: Scope, previous: unknown, position: Node, value: unknown, site: string, onlyChild?: boolean, seededText?: 1 | undefined, bindingMarker?: string, previousValue?: unknown): unknown;
+/** @internal Compiler target for a direct signal/scalar attribute binding. */
+export declare function bindSignalAttribute(scope: Scope, previous: unknown, element: Element, name: string, value: unknown, site: string, attributeKind?: DirectSignalAttributeKind): unknown;
+/** @internal Compiler target for a direct signal/scalar value binding. */
+export declare function bindSignalValue(scope: Scope, previous: unknown, element: Element, value: unknown, site: string): unknown;
+/** @internal Compiler target for a direct signal/scalar checked binding. */
+export declare function bindSignalChecked(scope: Scope, previous: unknown, element: Element, value: unknown, site: string): unknown;
 /**
  * Compact compiler binding ABI. Evaluate the authored value first, compare its
  * raw identity, then call the ordinary writer. Returning only after that writer
@@ -1461,6 +1716,10 @@ export declare function setClassName(el: Element, value: unknown): void;
 export declare function setClassAttr(el: Element, value: unknown): void;
 /** Whether a grouped style must compare its complete value during hydration. @internal */
 export declare function isHydratingStyle(): boolean;
+/** Intrinsic prototype used to guard completion of fresh style spread snapshots. @internal */
+export declare const styleObjectPrototype: Object;
+/** Whether a spread prefix and its fixed trailing declarations can be diffed separately. @internal */
+export declare function canSplitStyleProperties(): boolean;
 export declare function setStyle(el: HTMLElement | SVGElement, value: any, prev: any): void;
 /**
  * Update one dynamic declaration after a compiler-baked static style prefix.
@@ -1483,21 +1742,9 @@ type HostPropSource = readonly [
     value?: unknown,
     merge?: boolean
 ];
-/**
- * Resolve a spread-bearing compiled host's complete prop set before touching
- * the DOM. JSX spread merging is last-writer-wins, but aliases such as
- * className/class, htmlFor/for, and xlinkHref/xlink:href target one native
- * property. Canonical identities ensure a vanished earlier source cannot
- * remove an unchanged later winner, and hydration compares only the final
- * client value against the final server value.
- *
- * A synthesized scope-hash class (4th tuple flag) is not an authored later
- * writer: after identity last-writer-wins, it composes onto the winning class
- * instead of replacing a spread's class. An authored `class` beside a spread
- * stays last-writer-wins because its hash is baked into that authored value
- * and carries no merge flag.
- */
-export declare function setHostPropSources(el: Element, sources: readonly HostPropSource[], prev: Record<string, unknown> | undefined, scope: Scope, hasNestedChildren?: boolean): Record<string, unknown>;
+export declare function setHostPropSources(el: Element, sources: readonly HostPropSource[], prev: Record<string, unknown> | undefined, scope: Scope, hasNestedChildren?: boolean, readStyle?: (value: unknown) => unknown, deferControl?: boolean): Record<string, unknown>;
+/** @internal Compiler target for spread-bearing hosts containing direct signals. */
+export declare function bindSignalHostPropSources(scope: Scope, previous: unknown, element: Element, sources: readonly HostPropSource[], site: string, hasNestedChildren?: boolean, readStyle?: (value: unknown) => unknown): unknown;
 export declare function setSpread(el: Element, value: any, prev: any, mountScope?: Scope, skipDangerouslySetInnerHTML?: boolean, skipFormControls?: boolean): void;
 export declare function headBlock(scope: Scope, slot: number, key: string, tag: string, attrs: Record<string, any> | null, text: unknown): void;
 interface NamespaceHeadProps {
@@ -1676,6 +1923,8 @@ export interface ElementDescriptor<P = any> {
     key: any;
     ref: any;
     children: any;
+    /** @internal Compiler-stable component invocation identity. */
+    __octaneInvocationSite?: string;
 }
 export type OctaneNode = unknown;
 /**
@@ -1701,10 +1950,14 @@ export declare function nativeCreateScopedValue<P>(readElement: () => ElementDes
  *
  * @internal
  */
-export declare function createScopedElement<P>(type: ComponentBody<P> | string | typeof Fragment, props: P | undefined, readChildren: () => unknown): ElementDescriptor<P>;
+export declare function createScopedElement<P>(type: ComponentBody<P> | string | typeof Fragment, props: P | undefined, readChildren: () => unknown, invocationSite?: string): ElementDescriptor<P>;
 /** @internal Resolve native children in their represented render Scope. */
-export declare function nativeCreateScopedElement<P>(type: ComponentBody<P> | string | typeof Fragment, props: P | undefined, readChildren: () => unknown): ElementDescriptor<P>;
+export declare function nativeCreateScopedElement<P>(type: ComponentBody<P> | string | typeof Fragment, props: P | undefined, readChildren: () => unknown, invocationSite?: string): ElementDescriptor<P>;
 export declare function createElement<P>(type: ComponentBody<P> | string | typeof Fragment, props?: P, ...children: any[]): ElementDescriptor<P>;
+/** @internal Compiler-authored element descriptor with stable invocation identity. */
+export declare function createElementAt<P>(invocationSite: string, type: ComponentBody<P> | string | typeof Fragment, props?: P, ...children: any[]): ElementDescriptor<P>;
+/** @internal Compiler-owned positional children; omitted children allocate no rest array. */
+export declare function createElementFromConfig<P>(invocationSite: string | undefined, type: ComponentBody<P> | string | typeof Fragment, props: P | undefined, children?: any[]): ElementDescriptor<P>;
 /**
  * True for a createElement/JSX descriptor. Known descriptors, including unions,
  * retain their prop types; supply P to narrow an element-or-props union.
@@ -1731,9 +1984,9 @@ export declare const Children: {
     only<T>(children: T): T;
 };
 /** Generic component call site: reconcile any JavaScript return value. */
-export declare function componentSlot(parentScope: Scope, slotKey: number, domParent: Node, comp: ComponentBody | string, props: any, anchor?: Node | null, key?: any, singleRoot?: boolean | 2, inherit?: boolean, hasKey?: boolean): void;
+export declare function componentSlot(parentScope: Scope, slotKey: number, domParent: Node, comp: ComponentBody | string, props: any, anchor?: Node | null, key?: any, singleRoot?: boolean | 2, inherit?: boolean, hasKey?: boolean, invocationSite?: string): void;
 /** Compiler-proven `@{}` component call site: the body has no value return. */
-export declare function componentSlotVoid(parentScope: Scope, slotKey: number, domParent: Node, comp: ComponentBody | string, props: any, anchor?: Node | null, key?: any, singleRoot?: boolean | 2, inherit?: boolean, hasKey?: boolean): void;
+export declare function componentSlotVoid(parentScope: Scope, slotKey: number, domParent: Node, comp: ComponentBody | string, props: any, anchor?: Node | null, key?: any, singleRoot?: boolean | 2, inherit?: boolean, hasKey?: boolean, invocationSite?: string): void;
 export declare function positionalChildren(children: any[]): any[];
 export declare function hostComponent(scope: Scope, slot: number, tag: string, props: Record<string, any> | null, childrenBody?: ComponentBody | OctaneNode, anchor?: Node | null): Element;
 /**
@@ -1773,7 +2026,11 @@ export declare function compilerCacheImmutableArrayFilter(value: unknown, proper
 export declare function compilerCacheMappedArray(value: unknown, component: unknown): boolean;
 /** Shared compiler ABI: native-array eligibility query plus stable keyed map dispatch. */
 export declare function mapSlot(scopeOrItems: any, slotOrMethod: any, domParent?: Node, items?: any, method?: any, native?: boolean | ((...args: any[]) => any), callback?: (...args: any[]) => any, getKey?: (item: any, index: number) => any, itemBody?: (item: any, scope: Scope) => void, flags?: number, deps?: any[], anchor?: Node | null, ownEnd?: boolean | 1): boolean | void;
-export declare function childSlot(parentScope: Scope, slotKey: number, domParent: Node, value: unknown, anchor?: Node | null, ownEnd?: boolean, ownsHost?: Element, compactable?: boolean, includeKeyedSingle?: boolean, compiledMapBody?: (item: any, scope: Scope) => void, compiledMapKey?: (item: any, index: number) => any, compiledMapFlags?: number, compiledMapDeps?: any[], mappedFallback?: boolean): void;
+/** @internal Capability-routed renderable hole with targeted signal text updates. */
+export declare function bindSignalChild(parentScope: Scope, previous: unknown, slotKey: number, domParent: Node, value: unknown, _site: string, anchor?: Node | null, ownEnd?: boolean, ownsHost?: Element, compactable?: boolean, onlyChild?: boolean, bindingMarker?: string): unknown;
+/** @internal Address an ordinary renderable slot without narrowing its value semantics. */
+export declare function bindingChildSlot(parentScope: Scope, slotKey: number, domParent: Node, value: unknown, marker: string, anchor?: Node | null, ownEnd?: boolean): void;
+export declare function childSlot(parentScope: Scope, slotKey: number, domParent: Node, value: unknown, anchor?: Node | null, ownEnd?: boolean, ownsHost?: Element, compactable?: boolean, includeKeyedSingle?: boolean, compiledMapBody?: (item: any, scope: Scope) => void, compiledMapKey?: (item: any, index: number) => any, compiledMapFlags?: number, compiledMapDeps?: any[], mappedFallback?: boolean, bindingMarker?: string): void;
 export declare function textSlot(parentScope: Scope, slotKey: number, domParent: Node, value: unknown, anchor?: Node | null, ownEnd?: boolean, compactable?: boolean): void;
 export declare function textHole(parentScope: Scope, slotKey: number, domParent: Node, value: unknown, anchor?: Node | null, ownEnd?: boolean, compactable?: boolean): Text | null;
 /**
@@ -1832,6 +2089,8 @@ interface SuspenseHiddenDom {
 }
 declare function teardownTrySlot(state: TrySlot, detachDom: boolean): void;
 interface TrySlot {
+    /** Only an initial hydrated primary discarded by suspension needs transfer. */
+    retrySignalOwners?: SignalRetryOwners;
     __kind: 'trySlotSlot';
     __flags: typeof SLOT_FLAG_TEARDOWN;
     __teardown: typeof teardownTrySlot;
@@ -1898,6 +2157,8 @@ interface TrySlot {
      * scope teardown so we don't leak callbacks past the slot's lifetime.
      */
     transitionTimeoutId: any | null;
+    /** Native candidates own retry; a finite fallback still uses this boundary's lifetime. */
+    nativeTransition?: TransitionActionBatch;
     /**
      * Host refs detached when this boundary suspended (object refs set to null,
      * callback refs invoked with null). React treats ref attachment like a layout
@@ -2021,11 +2282,22 @@ export interface Root {
     unmount(): void;
 }
 export interface RootOptions {
+    /** Adopt fixed native early bindings only when their matching hydration capture commits. */
+    bindingLeases?: readonly BindingHandle[];
+    /**
+     * Shared document/account owner for module signals. Roots borrow this owner;
+     * unmounting a presentation root never retires shared data state.
+     */
+    signalOwner?: SignalOwner;
     /**
      * Caller-controlled useId prefix. createRoot composes it with an automatic
      * client-root namespace; hydrateRoot uses it verbatim to match server output.
      */
     identifierPrefix?: string;
+    /** @internal Compiler-owned starting useId slot for an independently hydrated range. */
+    identifierSeed?: number;
+    /** @internal Stable instance namespace for an independently hydrated root. */
+    signalInstancePrefix?: string;
     /**
      * React 19 parity, reporting only: called after an error boundary
      * (`@try`/`@catch` or `<ErrorBoundary>`) claims an error from this root's
@@ -2087,6 +2359,8 @@ export declare function __createVoidRoot(container: RootContainer, options?: Roo
  */
 export declare function hydrateRoot(container: RootContainer, element: ElementDescriptor, options?: RootOptions): Root;
 export declare function hydrateRoot(container: RootContainer, body: ComponentBody, props?: any, options?: RootOptions): Root;
+/** @internal Adapt a compiler-extracted body to the parent-free island loader contract. */
+export declare function createIndependentHydrateActivator(body: ComponentBody): IndependentHydrateActivator;
 /** React DOM `preload(href, {as, …})` — `<link rel="preload">`. */
 export declare function preload(href: string, options: {
     as: string;