octane 0.2.2 → 0.2.4

package/dist/component-flags.d.ts

@@ -1,6 +1,6 @@
 /** The component owns a load-bearing runtime/SSR boundary range. */
 export declare const COMPONENT_FLAG_BOUNDARY: number;
 /** Attach an immutable capability bitmask without retaining concrete component identities. */
-export declare function markComponentFlags<T extends Function>(component: T, flags: number, name: string): T;
+export declare function markComponentFlags<T extends Function>(component: T, flags: number, name: string, kind?: symbol): T;
 /** Test compiler/runtime capability bits on a component from any Octane runtime copy. */
 export declare function hasComponentFlags(component: unknown, flags: number): boolean;

package/dist/component-flags.js

@@ -1,9 +1,16 @@
 import { hasOwnProp } from "./has-own.js";
 const OCTANE_COMPONENT_FLAGS = /* @__PURE__ */ Symbol.for("octane.flags.component");
 const COMPONENT_FLAG_BOUNDARY = 1 << 0;
-function markComponentFlags(component, flags, name) {
+function markComponentFlags(component, flags, name, kind) {
   Object.defineProperty(component, OCTANE_COMPONENT_FLAGS, { value: flags });
   Object.defineProperty(component, "name", { value: name, configurable: true });
+  if (kind !== void 0) {
+    Object.defineProperty(component, kind, {
+      get() {
+        return this === component;
+      }
+    });
+  }
   return component;
 }
 function hasComponentFlags(component, flags) {

package/dist/css.d.ts

@@ -3,6 +3,13 @@
  * falsy drops out). Octane's `class`/`className` semantics at every apply site.
  */
 export declare function normalizeClass(value: unknown): string;
+/**
+ * Append a later class source onto an earlier one. Used when a synthesized
+ * scope hash must share the element with a spread's class instead of replacing
+ * it. Both sides go through `normalizeClass` so arrays / objects compose the
+ * same way they would as a lone `class` value.
+ */
+export declare function mergeClass(left: unknown, right: unknown): string;
 export declare function styleName(name: string): string;
 /** @internal Development-only React-style inline CSS diagnostics. */
 export declare function devWarnStyleProperty(name: string, value: unknown, server: boolean): void;

package/dist/css.js

@@ -20,6 +20,13 @@ function normalizeClass(value) {
   }
   return str;
 }
+function mergeClass(left, right) {
+  const a = normalizeClass(left);
+  const b = normalizeClass(right);
+  if (!a) return b;
+  if (!b) return a;
+  return a + " " + b;
+}
 import { hyphenateStyleName } from "./dom-tables.js";
 const styleNameCache = /* @__PURE__ */ new Map();
 function styleName(name) {
@@ -84,6 +91,7 @@ function devWarnStyleCoercion(name, value) {
 export {
   devWarnStyleCoercion,
   devWarnStyleProperty,
+  mergeClass,
   normalizeClass,
   styleName
 };

package/dist/dom-tables.js

@@ -398,6 +398,7 @@ for (const base of [
   "opacity",
   "order",
   "orphans",
+  "scale",
   "tabSize",
   "widows",
   "zIndex",
@@ -418,8 +419,13 @@ for (const base of [
   UNITLESS_STYLE_PROPS.add("moz" + c);
   UNITLESS_STYLE_PROPS.add("o" + c);
 }
+const unitlessStylePropCache = /* @__PURE__ */ new Map();
 function isUnitlessStyleProp(name) {
-  return UNITLESS_STYLE_PROPS.has(name.replaceAll("-", "").toLowerCase());
+  const cached = unitlessStylePropCache.get(name);
+  if (cached !== void 0) return cached;
+  const result = UNITLESS_STYLE_PROPS.has(name.replaceAll("-", "").toLowerCase());
+  unitlessStylePropCache.set(name, result);
+  return result;
 }
 function cssStyleValue(name, value) {
   if (typeof value === "number" && value !== 0 && name.charCodeAt(0) !== 45 && !isUnitlessStyleProp(name)) {
@@ -428,6 +434,7 @@ function cssStyleValue(name, value) {
   return typeof value === "string" ? value.trim() : "" + value;
 }
 function hyphenateStyleName(name) {
+  if (name === "cssFloat") return "float";
   if (name.charCodeAt(0) === 45) return name;
   let hasUpper = false;
   for (let i = 0; i < name.length; i++) {

package/dist/error-codes.client.generated.d.ts

@@ -26,7 +26,6 @@ type ClientErrorArguments = {
     25: [];
     26: [unknown];
     27: [];
-    28: [];
     29: [];
     46: [unknown, unknown];
     49: [];
@@ -38,6 +37,9 @@ type ClientErrorArguments = {
     55: [];
     56: [];
     58: [];
+    61: [];
+    62: [];
+    63: [];
 };
 export declare function formatClientError<Code extends keyof ClientErrorArguments>(code: Code, ...args: ClientErrorArguments[Code]): string;
 export {};

package/dist/error-codes.client.generated.js

@@ -129,8 +129,6 @@ function formatClientError(code, ...args) {
           "A hosted foreign-context request escaped its renderer-region owner; the owning bridge is gone or declined it.",
           args
         );
-      case 28:
-        return formatDevErrorMessage("Target container is not a DOM element.", args);
       case 29:
         return formatDevErrorMessage("Cannot update an unmounted root.", args);
       case 46:
@@ -177,6 +175,21 @@ function formatClientError(code, ...args) {
         );
       case 58:
         return formatDevErrorMessage("Unsupported native-read compiler/runtime version.", args);
+      case 61:
+        return formatDevErrorMessage(
+          "Hydration mismatch: the server-rendered text differed from the client; the text was updated to the client value.",
+          args
+        );
+      case 62:
+        return formatDevErrorMessage(
+          "Hydration mismatch: the server rendered extra children in a text element; the stale children were discarded.",
+          args
+        );
+      case 63:
+        return formatDevErrorMessage(
+          "Target container is not a DOM element. Pass an Element, Document, or DocumentFragment. If document.body is null after document hydration, update the existing document root or render a document shell containing <body>.",
+          args
+        );
       default:
         return formatUnknownDevErrorMessage(code);
     }

package/dist/error-codes.server.generated.d.ts

@@ -30,6 +30,7 @@ type ServerErrorArguments = {
     57: [];
     58: [];
     59: [unknown];
+    60: [];
 };
 export declare function formatServerError<Code extends keyof ServerErrorArguments>(code: Code, ...args: ServerErrorArguments[Code]): string;
 export {};

package/dist/error-codes.server.generated.js

@@ -125,6 +125,11 @@ function formatServerError(code, ...args) {
         return formatDevErrorMessage("Unsupported native-read compiler/runtime version.", args);
       case 59:
         return formatDevErrorMessage("%s requires an active server component.", args);
+      case 60:
+        return formatDevErrorMessage(
+          "A component suspended without a Suspense boundary during synchronous server rendering. Use prerender() or a streaming renderer to await it.",
+          args
+        );
       default:
         return formatUnknownDevErrorMessage(code);
     }

package/dist/event-names.d.ts

@@ -0,0 +1 @@
+export function isDelegatedEventProp(name: string): boolean;

package/dist/event-names.js

@@ -0,0 +1,15 @@
+const names = "Abort AnimationEnd AnimationIteration AnimationStart AuxClick BeforeInput BeforeToggle Blur Cancel CanPlay CanPlayThrough Change Click Close CompositionEnd CompositionStart CompositionUpdate ContextMenu Copy Cut DoubleClick Drag DragEnd DragEnter DragExit DragLeave DragOver DragStart Drop DurationChange Emptied Encrypted Ended Error Focus GotPointerCapture Input Invalid KeyDown KeyPress KeyUp Load LoadedData LoadedMetadata LoadStart LostPointerCapture MouseDown MouseEnter MouseLeave MouseMove MouseOut MouseOver MouseUp Paste Pause Play Playing PointerCancel PointerDown PointerEnter PointerLeave PointerMove PointerOut PointerOver PointerUp Progress RateChange Reset Resize Scroll ScrollEnd Seeked Seeking Select Stalled Submit Suspend TimeUpdate Toggle TouchCancel TouchEnd TouchMove TouchStart TransitionCancel TransitionEnd TransitionRun TransitionStart VolumeChange Waiting Wheel";
+let delegatedEventProps;
+function isDelegatedEventProp(name) {
+  if (delegatedEventProps === void 0) {
+    delegatedEventProps = /* @__PURE__ */ new Set();
+    for (const event of names.split(" ")) {
+      delegatedEventProps.add("on" + event);
+      delegatedEventProps.add("on" + event + "Capture");
+    }
+  }
+  return delegatedEventProps.has(name);
+}
+export {
+  isDelegatedEventProp
+};

package/dist/html-tree-validation.d.ts

@@ -1,34 +1,17 @@
-/**
- * HTML parser-repair rules used by DEV client and SSR nesting diagnostics.
- *
- * This is intentionally narrower than the full HTML content model: it only
- * lists placements the browser repairs while parsing serialized HTML, because
- * those repairs can change the DOM before hydration. Adapted from Svelte's
- * html-tree-validation module, which Ripple also uses.
- *
- * Copyright (c) 2016-2025 Svelte Contributors
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-/** Return a diagnostic when `childTag` causes an ancestor to be repaired. */
-export declare function invalidHtmlNestingWithAncestor(childTag: string, ancestors: string[], childLocation?: string, ancestorLocation?: string): string | null;
-/** Return a diagnostic when `childTag` causes its direct parent to be repaired. */
-export declare function invalidHtmlNestingWithParent(childTag: string, parentTag: string, childLocation?: string, parentLocation?: string): string | null;
-/** Return a diagnostic when visible or whitespace text cannot remain under its parent. */
-export declare function invalidHtmlTextNesting(text: string, parentTag: string, parentLocation?: string): string | null;
+export declare function invalidHtmlNestingWithAncestor(
+	childTag: string,
+	ancestors: string[],
+	childLocation?: string,
+	ancestorLocation?: string,
+): string | null;
+export declare function invalidHtmlNestingWithParent(
+	childTag: string,
+	parentTag: string,
+	childLocation?: string,
+	parentLocation?: string,
+): string | null;
+export declare function invalidHtmlTextNesting(
+	text: string,
+	parentTag: string,
+	parentLocation?: string,
+): string | null;

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 export { version } from './version.js';
+export type * from './public-types.js';
+export { StrictMode, unstable_batchedUpdates } from './compatibility.js';
 export { initializeHydrationEventCapture } from './hydration/event-capture.js';
 export { attachBehaviorRoot } from './behavior-root.js';
 export type * from './behavior-root.js';
 export { createSubSlot, subSlot, type SubSlot, type SlotlessSubSlot, type SubSlotOptions, } from './sub-slot.js';
-export { createRoot, hydrateRoot, flushSync, act, type Root, type RootOptions, useState, useLinkedState, type LinkedStatePrevious, type LinkedStateOptions, useReducer, useEffect, useLayoutEffect, useInsertionEffect, useMemo, useCallback, useRef, useId, useImperativeHandle, useEffectEvent, useSyncExternalStore, useDeferredValue, useTransition, useActionState, useFormStatus, useOptimistic, useDebugValue, type FormStatus, startTransition, requestFormReset, memo, lazy, preload, preinit, preloadModule, preinitModule, preconnect, prefetchDNS, createContext, use, useContext, type Context, type ForeignHostContext, Suspense, ErrorBoundary, Hydrate, Activity, Activity as unstable_Activity, ViewTransition, addTransitionType, ViewTransition as unstable_ViewTransition, addTransitionType as unstable_addTransitionType, ViewTransitionPseudoElement, type ViewTransitionProps, type ViewTransitionInstance, Fragment, createPortal, type PortalDescriptor, createElement, cloneElement, isValidElement, isChildrenBlock, Children, type ElementDescriptor, type ComponentBody, type OctaneNode, TsrxErrorBoundary, __useStateWithGetter, __useLinkedStateWithGetter, __useReducerWithGetter, __createVoidRoot, bindRendererRegionOwner, EXTERNAL_HYDRATION_PROMISE, HYDRATION_RANGE_BOUNDARY, createHostContextRequest, __vtSeen, template, clone, drainFrag, bag0, bag1, bag2, bag3, bag4, bag5, bag6, bag7, bag8, bag9, bag10, bag11, bag12, bag13, bag14, bag15, bag16, bagOf, evt0, evt0u, evt1, evt1u, evt2, evt2u, evtN, evtNu, setEventHandler, devEventListener, devHtmlNesting, htext, htextSwap, child, sibling, setText, setScriptText, setHTML, setDangerouslySetInnerHTML, setDangerouslySetInnerHTMLSources, markDangerouslySetInnerHTMLChildren, setAttribute, setStringData, setBooleanAttribute, setAriaAttribute, setClassName, setClassAttr, normalizeClass, setStyle, setStyleProperty, setSpread, snapshotSpread, setHostPropSources, queueNativeChangeDiagnostic, queueFormAuthoringDiagnostic, markNativeChangeDiagnosticStatic, setFormAction, setValue, setFormControlSources, setChecked, setCheckedCheckable, setSelectValue, setDefaultValue, setDefaultValueUncontrolled, setDefaultChecked, setAutoFocus, attachRef, queueRefAttach, queueRefDetach, replaceRef, queueOwnRefDetach, injectStyle, headBlock, stylesheetResource, styleResource, scriptResource, namespaceHead, namespaceHeadElement, delegateEvents, delegateCaptureEvents, fastForBlock, fastKeyedForBlock, fastMapSlot, forBlock, keyedForBlock, mapSlot, ifBlock, errorBlock, tryBlock, switchBlock, activityBlock, componentSlot, componentSlotVoid, componentSlotLite, compilerCacheArray, compilerCacheImmutableArrayFilter, compilerCacheMappedArray, compilerCacheContext, compilerOwnsContextProvider, markSingleRoot, markSingleRoot as __s, markChildrenBlock, descriptorChildren, createScopedValue, createScopedElement, childSlot, positionalChildren, textSlot, textHole, childTextHole, hostComponent, renderBlock, portal, hookSlots, withSlot, useBatch, seedOrCreate, warmMemo, warmChild, puMiss, puTake0, puTake1, puTake2, puTake3, puTake4, puPub, provideContext, mountFragmentRef, FragmentInstance, hmr, HMR, hasPendingWork, type Scope, type Block, drainPassiveEffects, setIsOctaneActEnvironment, resetFloatResourceState, setTransitionFallbackTimeout, getTransitionFallbackTimeout, } from './runtime.js';
+export { createRoot, hydrateRoot, flushSync, act, type Root, type RootContainer, type RootOptions, useState, useLinkedState, type LinkedStatePrevious, type LinkedStateOptions, useReducer, useEffect, useLayoutEffect, useInsertionEffect, useMemo, useCallback, useRef, useId, useImperativeHandle, useEffectEvent, useSyncExternalStore, useDeferredValue, useTransition, useActionState, useActionState as useFormState, useFormStatus, useOptimistic, useDebugValue, type FormStatus, startTransition, requestFormReset, memo, lazy, preload, preinit, preloadModule, preinitModule, preconnect, prefetchDNS, createContext, use, useContext, type Context, type ForeignHostContext, Suspense, ErrorBoundary, Hydrate, Activity, Activity as unstable_Activity, ViewTransition, addTransitionType, ViewTransition as unstable_ViewTransition, addTransitionType as unstable_addTransitionType, ViewTransitionPseudoElement, type ViewTransitionProps, type ViewTransitionInstance, Fragment, createPortal, type PortalDescriptor, createElement, cloneElement, isValidElement, isChildrenBlock, descriptorChildren, Children, type ElementDescriptor, type ComponentBody, type OctaneNode, TsrxErrorBoundary, __useStateWithGetter, __useLinkedStateWithGetter, __useReducerWithGetter, __createVoidRoot, bindRendererRegionOwner, EXTERNAL_HYDRATION_PROMISE, HYDRATION_RANGE_BOUNDARY, createHostContextRequest, __vtSeen, template, clone, drainFrag, bag0, bag1, bag2, bag3, bag4, bag5, bag6, bag7, bag8, bag9, bag10, bag11, bag12, bag13, bag14, bag15, bag16, bagOf, evt0, evt0u, evt1, evt1u, evt2, evt2u, evtN, evtNu, setEventHandler, devEventListener, devHtmlNesting, htext, htextSwap, child, sibling, setText, setScriptText, setHTML, setDangerouslySetInnerHTML, setDangerouslySetInnerHTMLSources, markDangerouslySetInnerHTMLChildren, setAttribute, setStringData, setBooleanAttribute, setAriaAttribute, setClassName, setClassAttr, normalizeClass, setStyle, setStyleProperty, setSpread, snapshotSpread, setHostPropSources, queueNativeChangeDiagnostic, queueFormAuthoringDiagnostic, markNativeChangeDiagnosticStatic, setFormAction, setValue, setFormControlSources, setChecked, setCheckedCheckable, setSelectValue, setDefaultValue, setDefaultValueUncontrolled, setDefaultChecked, setAutoFocus, attachRef, queueRefAttach, queueRefDetach, replaceRef, queueOwnRefDetach, injectStyle, headBlock, stylesheetResource, styleResource, scriptResource, namespaceHead, namespaceHeadElement, delegateEvents, delegateCaptureEvents, fastForBlock, fastKeyedForBlock, fastMapSlot, forBlock, keyedForBlock, mapSlot, ifBlock, errorBlock, tryBlock, switchBlock, activityBlock, componentSlot, componentSlotVoid, componentSlotLite, compilerCacheArray, compilerCacheImmutableArrayFilter, compilerCacheMappedArray, compilerCacheContext, compilerOwnsContextProvider, markSingleRoot, markWarm, markSingleRoot as __s, markChildrenBlock, createScopedValue, createScopedElement, childSlot, positionalChildren, textSlot, textHole, childTextHole, hostComponent, renderBlock, portal, hookSlots, withSlot, manualHook, invokeManualHook, useBatch, seedOrCreate, warmMemo, warmChild, puMiss, puTake0, puTake1, puTake2, puTake3, puTake4, puPub, provideContext, mountFragmentRef, FragmentInstance, hmr, HMR, hasPendingWork, type Scope, type Block, drainPassiveEffects, setIsOctaneActEnvironment, resetFloatResourceState, setTransitionFallbackTimeout, getTransitionFallbackTimeout, } from './runtime.js';
 export type { HydrateOptions, HydrateProps, HydrateWhen, HydrationInteractionEvent, HydrationInteractionEvents, HydrationPrefetchContext, HydrationPrefetchFunction, HydrationPrefetchStrategy, HydrationPrefetchWaitReason, HydrationStrategy, HydrationWhen, } from './hydration/types.js';
 export { __serverRpc } from './server-rpc-client.js';
 export { __methodDep } from './method-dep.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 import { version } from "./version.js";
+import { StrictMode, unstable_batchedUpdates } from "./compatibility.js";
 import { initializeHydrationEventCapture } from "./hydration/event-capture.js";
 import { attachBehaviorRoot } from "./behavior-root.js";
 import {
@@ -26,6 +27,7 @@ import {
   useDeferredValue,
   useTransition,
   useActionState,
+  useActionState as useActionState2,
   useFormStatus,
   useOptimistic,
   useDebugValue,
@@ -58,6 +60,7 @@ import {
   cloneElement,
   isValidElement,
   isChildrenBlock,
+  descriptorChildren,
   Children,
   TsrxErrorBoundary,
   __useStateWithGetter,
@@ -170,9 +173,9 @@ import {
   compilerCacheContext,
   compilerOwnsContextProvider,
   markSingleRoot,
+  markWarm,
   markSingleRoot as markSingleRoot2,
   markChildrenBlock,
-  descriptorChildren,
   createScopedValue,
   createScopedElement,
   childSlot,
@@ -185,6 +188,8 @@ import {
   portal,
   hookSlots,
   withSlot,
+  manualHook,
+  invokeManualHook,
   useBatch,
   seedOrCreate,
   warmMemo,
@@ -220,6 +225,7 @@ export {
   HMR,
   HYDRATION_RANGE_BOUNDARY,
   Hydrate,
+  StrictMode,
   Suspense,
   TsrxErrorBoundary,
   ViewTransition,
@@ -310,15 +316,18 @@ export {
   ifBlock,
   initializeHydrationEventCapture,
   injectStyle,
+  invokeManualHook,
   isChildrenBlock,
   isValidElement,
   keyedForBlock,
   lazy,
+  manualHook,
   mapSlot,
   markChildrenBlock,
   markDangerouslySetInnerHTMLChildren,
   markNativeChangeDiagnosticStatic,
   markSingleRoot,
+  markWarm,
   memo,
   mountFragmentRef,
   namespaceHead,
@@ -393,6 +402,7 @@ export {
   Activity2 as unstable_Activity,
   ViewTransition2 as unstable_ViewTransition,
   addTransitionType2 as unstable_addTransitionType,
+  unstable_batchedUpdates,
   use,
   useActionState,
   useBatch,
@@ -402,6 +412,7 @@ export {
   useDeferredValue,
   useEffect,
   useEffectEvent,
+  useActionState2 as useFormState,
   useFormStatus,
   useId,
   useImperativeHandle,

package/dist/jsx-runtime.d.ts

@@ -53,6 +53,10 @@ import type { ElementDescriptor, FragmentInstance } from './index.js';
  */
 export interface OctaneElement<P = any> extends ElementDescriptor<P> {}
 
+export interface CSSProperties extends React.CSSProperties {
+	cssFloat?: React.CSSProperties['float'];
+}
+
 export type ClassValue =
 	| string
 	| number
@@ -135,7 +139,7 @@ type Transformed<P, T> = Omit<P, ReactSyntheticProps | 'className' | 'style' | '
 		className?: ClassValue;
 		for?: string;
 		xmlns?: string;
-		style?: string | React.CSSProperties;
+		style?: string | CSSProperties;
 		children?: unknown;
 	};
 
@@ -177,6 +181,7 @@ declare namespace Octane {
 	interface FieldsetHTMLAttributes<T> extends Transformed<React.FieldsetHTMLAttributes<T>, T> {}
 	interface FormHTMLAttributes<T> extends Transformed<React.FormHTMLAttributes<T>, T> {}
 	interface HTMLAttributes<T> extends Transformed<React.HTMLAttributes<T>, T> {}
+	interface AllHTMLAttributes<T> extends Transformed<React.AllHTMLAttributes<T>, T> {}
 	interface HtmlHTMLAttributes<T> extends Transformed<React.HtmlHTMLAttributes<T>, T> {}
 	interface IframeHTMLAttributes<T> extends Transformed<React.IframeHTMLAttributes<T>, T> {}
 	interface ImgHTMLAttributes<T> extends Transformed<React.ImgHTMLAttributes<T>, T> {}

package/dist/public-types.d.ts

@@ -0,0 +1,188 @@
+/** React-shaped type names describing Octane values and native DOM events. */
+import type * as React from 'react';
+import type { Octane } from './jsx-runtime.js';
+import type { Activity, Context, ElementDescriptor, OctaneNode, PortalDescriptor, Suspense } from './runtime.js';
+export type { JSX, Octane, OctaneElement, ClassValue, CSSProperties } from './jsx-runtime.js';
+/** Migration alias. New Octane code should use OctaneNode. */
+export type ReactNode = OctaneNode;
+export type ReactElement<P = any, T extends ElementDescriptor<P>['type'] = ElementDescriptor<P>['type']> = ElementDescriptor<P> & {
+    type: T;
+};
+export type ReactPortal = PortalDescriptor;
+export type FunctionComponentElement<P> = ReactElement<P, FunctionComponent<P>>;
+export type DOMElement<P, T extends Element> = ReactElement<P, string> & {
+    ref?: Ref<T>;
+};
+export type DetailedReactHTMLElement<P extends HTMLAttributes<T>, T extends HTMLElement> = DOMElement<P, T>;
+export type ReactHTMLElement<T extends HTMLElement> = DetailedReactHTMLElement<AllHTMLAttributes<T>, T>;
+export type ReactSVGElement = DOMElement<SVGAttributes<SVGElement>, SVGElement>;
+export type Key = Octane.Key;
+export type Ref<T> = Octane.Ref<T>;
+export type RefCallback<T> = React.RefCallback<T>;
+export interface RefObject<T> {
+    current: T;
+}
+export interface MutableRefObject<T> {
+    current: T;
+}
+export type Attributes = Octane.Attributes;
+export type RefAttributes<T> = Octane.RefAttributes<T>;
+export type PropsWithChildren<P = unknown> = P & {
+    children?: OctaneNode;
+};
+export type PropsWithoutRef<P> = P extends unknown ? 'ref' extends keyof P ? Omit<P, 'ref'> : P : P;
+export type PropsWithRef<P> = P;
+export type SetStateAction<S> = S | ((previous: S) => S);
+export type Dispatch<A> = (value: A) => void;
+export type DispatchWithoutAction = () => void;
+export type DependencyList = readonly unknown[];
+export type EffectCallback = () => void | (() => void);
+export type Destructor = () => void;
+export type Reducer<S, A> = (state: S, action: A) => S;
+export type ReducerWithoutAction<S> = (state: S) => S;
+export type ReducerState<R extends Reducer<any, any>> = R extends Reducer<infer S, any> ? S : never;
+export type ReducerAction<R extends Reducer<any, any>> = R extends Reducer<any, infer A> ? A : never;
+export type ReducerStateWithoutAction<R extends ReducerWithoutAction<any>> = R extends ReducerWithoutAction<infer S> ? S : never;
+export interface FunctionComponent<P = {}> {
+    (props: P): OctaneNode;
+    displayName?: string;
+}
+export type FC<P = {}> = FunctionComponent<P>;
+export type ComponentType<P = {}> = FunctionComponent<P>;
+/** Octane boundary and memo wrappers are callable components, without React branding. */
+export type ExoticComponent<P = {}> = FunctionComponent<P>;
+export type NamedExoticComponent<P = {}> = FunctionComponent<P>;
+export type MemoExoticComponent<T extends ComponentType<any>> = FunctionComponent<ComponentProps<T>> & {
+    readonly type: T;
+};
+export type LazyExoticComponent<T extends ComponentType<any>> = FunctionComponent<ComponentProps<T>>;
+export type JSXElementConstructor<P> = (props: P, ...args: any[]) => OctaneNode;
+export type ElementType<P = any, Tag extends keyof Octane.JSX.IntrinsicElements = keyof Octane.JSX.IntrinsicElements> = {
+    [K in Tag]: P extends Octane.JSX.IntrinsicElements[K] ? K : never;
+}[Tag] | ComponentType<P>;
+export type ComponentProps<T extends keyof Octane.JSX.IntrinsicElements | JSXElementConstructor<any>> = T extends JSXElementConstructor<infer P> ? P : T extends keyof Octane.JSX.IntrinsicElements ? Octane.JSX.IntrinsicElements[T] : never;
+export type ComponentPropsWithRef<T extends ElementType> = ComponentProps<T>;
+export type ComponentPropsWithoutRef<T extends ElementType> = PropsWithoutRef<ComponentProps<T>>;
+export type CustomComponentPropsWithRef<T extends ComponentType<any>> = ComponentProps<T>;
+export type ComponentRef<T extends ElementType> = ComponentProps<T> extends {
+    ref?: Ref<infer Instance>;
+} ? Instance : never;
+export type ElementRef<T extends ElementType> = ComponentRef<T>;
+export type ContextType<C extends Context<any>> = C extends Context<infer T> ? T : never;
+export type Provider<T> = Context<T>['Provider'];
+export interface ProviderProps<T> {
+    value: T;
+    children?: OctaneNode;
+}
+export type SuspenseProps = Parameters<typeof Suspense>[0];
+export type ActivityProps = Parameters<typeof Activity>[0];
+export interface StrictModeProps {
+    children?: OctaneNode;
+}
+export type AriaAttributes = React.AriaAttributes;
+export type AriaRole = React.AriaRole;
+export type HTMLInputTypeAttribute = React.HTMLInputTypeAttribute;
+export type HTMLAttributeReferrerPolicy = React.HTMLAttributeReferrerPolicy;
+export type HTMLAttributeAnchorTarget = React.HTMLAttributeAnchorTarget;
+export type Booleanish = boolean | 'true' | 'false';
+export type CrossOrigin = '' | 'anonymous' | 'use-credentials' | undefined;
+export type DetailedHTMLProps<E, T> = Octane.DetailedHTMLProps<E, T>;
+export type HTMLProps<T> = Octane.DetailedHTMLProps<Octane.AllHTMLAttributes<T>, T>;
+export type SVGProps<T> = Octane.SVGProps<T>;
+export type SVGLineElementAttributes<T> = Octane.SVGLineElementAttributes<T>;
+export type SVGTextElementAttributes<T> = Octane.SVGTextElementAttributes<T>;
+/** The currentTarget is the host whose listener is currently being invoked. */
+export type NativeEvent<T = Element, E extends Event = Event> = E & {
+    currentTarget: T & EventTarget;
+};
+export type EventHandler<E extends Event> = {
+    bivarianceHack(event: E): void;
+}['bivarianceHack'];
+export type AnchorHTMLAttributes<T> = Octane.AnchorHTMLAttributes<T>;
+export type AreaHTMLAttributes<T> = Octane.AreaHTMLAttributes<T>;
+export type AudioHTMLAttributes<T> = Octane.AudioHTMLAttributes<T>;
+export type BaseHTMLAttributes<T> = Octane.BaseHTMLAttributes<T>;
+export type BlockquoteHTMLAttributes<T> = Octane.BlockquoteHTMLAttributes<T>;
+export type ButtonHTMLAttributes<T> = Octane.ButtonHTMLAttributes<T>;
+export type CanvasHTMLAttributes<T> = Octane.CanvasHTMLAttributes<T>;
+export type ColHTMLAttributes<T> = Octane.ColHTMLAttributes<T>;
+export type ColgroupHTMLAttributes<T> = Octane.ColgroupHTMLAttributes<T>;
+export type DataHTMLAttributes<T> = Octane.DataHTMLAttributes<T>;
+export type DelHTMLAttributes<T> = Octane.DelHTMLAttributes<T>;
+export type DetailsHTMLAttributes<T> = Octane.DetailsHTMLAttributes<T>;
+export type DialogHTMLAttributes<T> = Octane.DialogHTMLAttributes<T>;
+export type EmbedHTMLAttributes<T> = Octane.EmbedHTMLAttributes<T>;
+export type FieldsetHTMLAttributes<T> = Octane.FieldsetHTMLAttributes<T>;
+export type FormHTMLAttributes<T> = Octane.FormHTMLAttributes<T>;
+export type HTMLAttributes<T> = Octane.HTMLAttributes<T>;
+export type AllHTMLAttributes<T> = Octane.AllHTMLAttributes<T>;
+export type HtmlHTMLAttributes<T> = Octane.HtmlHTMLAttributes<T>;
+export type IframeHTMLAttributes<T> = Octane.IframeHTMLAttributes<T>;
+export type ImgHTMLAttributes<T> = Octane.ImgHTMLAttributes<T>;
+export type InputHTMLAttributes<T> = Octane.InputHTMLAttributes<T>;
+export type InsHTMLAttributes<T> = Octane.InsHTMLAttributes<T>;
+export type KeygenHTMLAttributes<T> = Octane.KeygenHTMLAttributes<T>;
+export type LabelHTMLAttributes<T> = Octane.LabelHTMLAttributes<T>;
+export type LiHTMLAttributes<T> = Octane.LiHTMLAttributes<T>;
+export type LinkHTMLAttributes<T> = Octane.LinkHTMLAttributes<T>;
+export type MapHTMLAttributes<T> = Octane.MapHTMLAttributes<T>;
+export type MenuHTMLAttributes<T> = Octane.MenuHTMLAttributes<T>;
+export type MetaHTMLAttributes<T> = Octane.MetaHTMLAttributes<T>;
+export type MeterHTMLAttributes<T> = Octane.MeterHTMLAttributes<T>;
+export type ObjectHTMLAttributes<T> = Octane.ObjectHTMLAttributes<T>;
+export type OlHTMLAttributes<T> = Octane.OlHTMLAttributes<T>;
+export type OptgroupHTMLAttributes<T> = Octane.OptgroupHTMLAttributes<T>;
+export type OptionHTMLAttributes<T> = Octane.OptionHTMLAttributes<T>;
+export type OutputHTMLAttributes<T> = Octane.OutputHTMLAttributes<T>;
+export type ParamHTMLAttributes<T> = Octane.ParamHTMLAttributes<T>;
+export type ProgressHTMLAttributes<T> = Octane.ProgressHTMLAttributes<T>;
+export type QuoteHTMLAttributes<T> = Octane.QuoteHTMLAttributes<T>;
+export type SVGAttributes<T> = Octane.SVGAttributes<T>;
+export type ScriptHTMLAttributes<T> = Octane.ScriptHTMLAttributes<T>;
+export type SelectHTMLAttributes<T> = Octane.SelectHTMLAttributes<T>;
+export type SlotHTMLAttributes<T> = Octane.SlotHTMLAttributes<T>;
+export type SourceHTMLAttributes<T> = Octane.SourceHTMLAttributes<T>;
+export type StyleHTMLAttributes<T> = Octane.StyleHTMLAttributes<T>;
+export type TableHTMLAttributes<T> = Octane.TableHTMLAttributes<T>;
+export type TdHTMLAttributes<T> = Octane.TdHTMLAttributes<T>;
+export type TextareaHTMLAttributes<T> = Octane.TextareaHTMLAttributes<T>;
+export type ThHTMLAttributes<T> = Octane.ThHTMLAttributes<T>;
+export type TimeHTMLAttributes<T> = Octane.TimeHTMLAttributes<T>;
+export type TrackHTMLAttributes<T> = Octane.TrackHTMLAttributes<T>;
+export type VideoHTMLAttributes<T> = Octane.VideoHTMLAttributes<T>;
+export type WebViewHTMLAttributes<T> = Octane.WebViewHTMLAttributes<T>;
+export type ClipboardEvent<T = Element> = NativeEvent<T, globalThis.ClipboardEvent>;
+export type ClipboardEventHandler<T = Element> = EventHandler<ClipboardEvent<T>>;
+export type CompositionEvent<T = Element> = NativeEvent<T, globalThis.CompositionEvent>;
+export type CompositionEventHandler<T = Element> = EventHandler<CompositionEvent<T>>;
+export type DragEvent<T = Element> = NativeEvent<T, globalThis.DragEvent>;
+export type DragEventHandler<T = Element> = EventHandler<DragEvent<T>>;
+export type FocusEvent<T = Element> = NativeEvent<T, globalThis.FocusEvent>;
+export type FocusEventHandler<T = Element> = EventHandler<FocusEvent<T>>;
+export type FormEvent<T = Element> = NativeEvent<T, globalThis.Event>;
+export type FormEventHandler<T = Element> = EventHandler<FormEvent<T>>;
+export type ChangeEvent<T = Element> = NativeEvent<T, globalThis.Event>;
+export type ChangeEventHandler<T = Element> = EventHandler<ChangeEvent<T>>;
+export type InputEvent<T = Element> = NativeEvent<T, globalThis.InputEvent>;
+export type InputEventHandler<T = Element> = EventHandler<InputEvent<T>>;
+export type InvalidEvent<T = Element> = NativeEvent<T, globalThis.Event>;
+export type InvalidEventHandler<T = Element> = EventHandler<InvalidEvent<T>>;
+export type KeyboardEvent<T = Element> = NativeEvent<T, globalThis.KeyboardEvent>;
+export type KeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent<T>>;
+export type MouseEvent<T = Element> = NativeEvent<T, globalThis.MouseEvent>;
+export type MouseEventHandler<T = Element> = EventHandler<MouseEvent<T>>;
+export type TouchEvent<T = Element> = NativeEvent<T, globalThis.TouchEvent>;
+export type TouchEventHandler<T = Element> = EventHandler<TouchEvent<T>>;
+export type PointerEvent<T = Element> = NativeEvent<T, globalThis.PointerEvent>;
+export type PointerEventHandler<T = Element> = EventHandler<PointerEvent<T>>;
+export type UIEvent<T = Element> = NativeEvent<T, globalThis.UIEvent>;
+export type UIEventHandler<T = Element> = EventHandler<UIEvent<T>>;
+export type WheelEvent<T = Element> = NativeEvent<T, globalThis.WheelEvent>;
+export type WheelEventHandler<T = Element> = EventHandler<WheelEvent<T>>;
+export type AnimationEvent<T = Element> = NativeEvent<T, globalThis.AnimationEvent>;
+export type AnimationEventHandler<T = Element> = EventHandler<AnimationEvent<T>>;
+export type TransitionEvent<T = Element> = NativeEvent<T, globalThis.TransitionEvent>;
+export type TransitionEventHandler<T = Element> = EventHandler<TransitionEvent<T>>;
+export type ToggleEvent<T = Element> = NativeEvent<T, globalThis.Event>;
+export type ToggleEventHandler<T = Element> = EventHandler<ToggleEvent<T>>;
+export type DOMAttributes<T> = Pick<Octane.HTMLAttributes<T>, Extract<keyof Octane.HTMLAttributes<T>, `on${string}`> | 'children' | 'dangerouslySetInnerHTML'>;