@appsent-co/react-native-watchos 0.1.0

package/src/components/Picker.tsx

@@ -0,0 +1,39 @@
+import { createElement } from 'react';
+
+import type { CommonProps } from '../types';
+import { useEventHandler } from '../useEventHandler';
+import { useModifiers } from '../useModifiers';
+
+export interface PickerOption {
+  /// Stable tag passed to `onSelectionChange` and matched against `selection`.
+  value: string;
+  /// Human-readable text shown in the picker UI.
+  label: string;
+}
+
+export interface PickerProps extends CommonProps {
+  /// Picker label, shown next to the selection on watchOS.
+  label: string;
+  /// Currently selected option's `value`. Controlled — JS owns the truth.
+  selection: string;
+  /// Choices rendered inside the picker. Passed as a prop array rather
+  /// than children so the JSON tree stays flat — SwiftUI's tag-based
+  /// child model doesn't translate cleanly through the bridge.
+  options: PickerOption[];
+  /// Fires when the user picks a different option, with the new `value`.
+  onSelectionChange?: (value: string) => void;
+}
+
+/// SwiftUI `Picker`. Options live as a prop array — each is rendered as a
+/// tagged `Text` row in the native picker.
+export function Picker(props: PickerProps) {
+  const { onSelectionChange, ...rest } = props;
+  const onSelectionChangeId = useEventHandler<string>(onSelectionChange);
+  const { modifiers, children } = useModifiers(rest.modifiers, rest.children);
+  return createElement('Picker', {
+    ...rest,
+    onSelectionChange: onSelectionChangeId,
+    modifiers,
+    children,
+  });
+}

package/src/components/ProgressView.tsx

@@ -0,0 +1,19 @@
+import { createNativeView } from '../createNativeView';
+
+export interface ProgressViewProps {
+  /// Current progress (typically 0…`total`). When omitted, renders the
+  /// indeterminate spinner.
+  value?: number;
+  /// Upper bound of `value`. Defaults to `1` (use `value` as a fraction).
+  total?: number;
+  /// Progress style. Defaults to `'automatic'` (SwiftUI picks per context).
+  style?: 'linear' | 'circular' | 'automatic';
+  /// Accent color. Same string format as other color props: named system
+  /// colors (`'red'`, `'accent'`, …) or hex (`'#ff8800'`, `'#ff8800ff'`).
+  tint?: string;
+}
+
+/// SwiftUI `ProgressView`. Omit `value` for the indeterminate spinner; pass
+/// `value` (0…`total`) for a determinate bar or ring. Pair with `style`
+/// and/or `tint` for explicit control over appearance.
+export const ProgressView = createNativeView<ProgressViewProps>('ProgressView');

package/src/components/RadialGradient.tsx

@@ -0,0 +1,12 @@
+import { createNativeView } from '../createNativeView';
+import type { UnitPoint } from './LinearGradient';
+
+export interface RadialGradientProps {
+  colors: string[];
+  center: UnitPoint;
+  startRadius: number;
+  endRadius: number;
+}
+
+export const RadialGradient =
+  createNativeView<RadialGradientProps>('RadialGradient');

package/src/components/Rectangle.tsx

@@ -0,0 +1,3 @@
+import { createNativeView } from '../createNativeView';
+
+export const Rectangle = createNativeView<object>('Rectangle');

package/src/components/RoundedRectangle.tsx

@@ -0,0 +1,11 @@
+import { createNativeView } from '../createNativeView';
+
+export interface RoundedRectangleProps {
+  /// Corner radius in points. Required.
+  cornerRadius: number;
+  /// Corner curve style. Defaults to `'continuous'` (Apple's squircle).
+  style?: 'circular' | 'continuous';
+}
+
+export const RoundedRectangle =
+  createNativeView<RoundedRectangleProps>('RoundedRectangle');

package/src/components/ScrollView.tsx

@@ -0,0 +1,10 @@
+import { createNativeView } from '../createNativeView';
+
+export interface ScrollViewProps {
+  /// Which scroll axes to enable. Defaults to `'vertical'`.
+  axes?: 'vertical' | 'horizontal' | 'both';
+  /// Whether to display the scroll indicators. Defaults to `true`.
+  showsIndicators?: boolean;
+}
+
+export const ScrollView = createNativeView<ScrollViewProps>('ScrollView');

package/src/components/ScrollViewReader.tsx

@@ -0,0 +1,3 @@
+import { createNativeView } from '../createNativeView';
+
+export const ScrollViewReader = createNativeView<object>('ScrollViewReader');

package/src/components/Section.tsx

@@ -0,0 +1,37 @@
+import { createElement, type FC, type ReactNode } from 'react';
+
+import type { CommonProps } from '../types';
+import { useModifiers } from '../useModifiers';
+
+export interface SectionProps {}
+
+interface SectionHeaderProps extends CommonProps {
+  children?: ReactNode;
+}
+
+interface SectionFooterProps extends CommonProps {
+  children?: ReactNode;
+}
+
+/// Sentinel child of `<Section>`. Its contents are routed into SwiftUI's
+/// `header:` slot. Outside a `Section` it falls back to rendering its
+/// children inline (graceful degradation, not an intended use).
+const Header: FC<SectionHeaderProps> = (props) =>
+  createElement('SectionHeader', props);
+Header.displayName = 'Section.Header';
+
+/// Sentinel child of `<Section>` — routes into SwiftUI's `footer:` slot.
+const Footer: FC<SectionFooterProps> = (props) =>
+  createElement('SectionFooter', props);
+Footer.displayName = 'Section.Footer';
+
+const SectionFn: FC<SectionProps & CommonProps> = (props) => {
+  const { modifiers, children } = useModifiers(props.modifiers, props.children);
+  return createElement('Section', { ...props, modifiers, children });
+};
+SectionFn.displayName = 'Section';
+
+/// SwiftUI `Section`. Place inside a `<List>` to group rows. Optionally
+/// nest a single `<Section.Header>` and/or `<Section.Footer>` directly
+/// under it; remaining children become the section's rows.
+export const Section = Object.assign(SectionFn, { Header, Footer });

package/src/components/SecureField.tsx

@@ -0,0 +1,30 @@
+import { createElement } from 'react';
+
+import type { CommonProps } from '../types';
+import { useEventHandler } from '../useEventHandler';
+import { useModifiers } from '../useModifiers';
+
+export interface SecureFieldProps extends CommonProps {
+  /// Prompt shown while the field is empty.
+  placeholder: string;
+  /// Current text. Controlled — JS owns the truth, the native side
+  /// mirrors it locally for instant feedback while typing.
+  value: string;
+  /// Fires as the user types, with the new text.
+  onChange?: (value: string) => void;
+}
+
+/// SwiftUI `SecureField`. Same shape as `TextField` but the glyphs are
+/// masked. No label children — wrap with `<HStack>` + `<Text>` for a
+/// caption.
+export function SecureField(props: SecureFieldProps) {
+  const { onChange, ...rest } = props;
+  const onChangeId = useEventHandler<string>(onChange);
+  const { modifiers, children } = useModifiers(rest.modifiers, rest.children);
+  return createElement('SecureField', {
+    ...rest,
+    onChange: onChangeId,
+    modifiers,
+    children,
+  });
+}

package/src/components/ShareLink.tsx

@@ -0,0 +1,18 @@
+import { createNativeView } from '../createNativeView';
+
+export interface ShareLinkProps {
+  /// The string payload presented to the share sheet. Wrap URLs or other
+  /// content as a string — only `String` items are supported on watchOS.
+  item: string;
+  /// Optional subject hint (used by Mail, Messages, etc.).
+  subject?: string;
+  /// Optional message hint shown alongside the item.
+  message?: string;
+  /// Shortcut for `ShareLink("title", item: ...)` — when set, children
+  /// are ignored and SwiftUI renders its default label with this title.
+  title?: string;
+}
+
+/// SwiftUI `ShareLink`. Presents the system share sheet for a string
+/// item. Children become the label when `title` is not provided.
+export const ShareLink = createNativeView<ShareLinkProps>('ShareLink');

package/src/components/Slider.tsx

@@ -0,0 +1,32 @@
+import { createElement } from 'react';
+
+import type { CommonProps } from '../types';
+import { useEventHandler } from '../useEventHandler';
+import { useModifiers } from '../useModifiers';
+
+export interface SliderProps extends CommonProps {
+  /// Current value. Controlled — JS owns the truth.
+  value: number;
+  /// Inclusive minimum. Defaults to 0.
+  min?: number;
+  /// Inclusive maximum. Defaults to 1.
+  max?: number;
+  /// Optional snapping increment. Continuous when omitted.
+  step?: number;
+  /// Fires while dragging with the new value.
+  onChange?: (value: number) => void;
+}
+
+/// SwiftUI `Slider`. No label children — labels are not commonly used on
+/// watchOS sliders. Wrap with `<HStack>` + `<Text>` for a caption.
+export function Slider(props: SliderProps) {
+  const { onChange, ...rest } = props;
+  const onChangeId = useEventHandler<number>(onChange);
+  const { modifiers, children } = useModifiers(rest.modifiers, rest.children);
+  return createElement('Slider', {
+    ...rest,
+    onChange: onChangeId,
+    modifiers,
+    children,
+  });
+}

package/src/components/Spacer.tsx

@@ -0,0 +1,8 @@
+import { createNativeView } from '../createNativeView';
+
+export interface SpacerProps {
+  /// Optional minimum length the spacer will take, in points.
+  minLength?: number;
+}
+
+export const Spacer = createNativeView<SpacerProps>('Spacer');

package/src/components/Stepper.tsx

@@ -0,0 +1,35 @@
+import { createElement } from 'react';
+
+import type { CommonProps } from '../types';
+import { useEventHandler } from '../useEventHandler';
+import { useModifiers } from '../useModifiers';
+
+export interface StepperProps extends CommonProps {
+  /// Label rendered alongside the +/- controls.
+  label: string;
+  /// Current value. Controlled — JS owns the truth.
+  value: number;
+  /// Inclusive minimum. When both `minimum` and `maximum` are present
+  /// the value is clamped to that range; otherwise it is unbounded.
+  minimum?: number;
+  /// Inclusive maximum. See `minimum`.
+  maximum?: number;
+  /// Increment per tap. Defaults to 1 on the native side.
+  step?: number;
+  /// Fires when the user taps +/- with the new value.
+  onChange?: (value: number) => void;
+}
+
+/// SwiftUI `Stepper`. No children — the label is provided via the
+/// `label` prop (matches SwiftUI's `Stepper(_:value:in:step:)` overload).
+export function Stepper(props: StepperProps) {
+  const { onChange, ...rest } = props;
+  const onChangeId = useEventHandler<number>(onChange);
+  const { modifiers, children } = useModifiers(rest.modifiers, rest.children);
+  return createElement('Stepper', {
+    ...rest,
+    onChange: onChangeId,
+    modifiers,
+    children,
+  });
+}

package/src/components/TabView.tsx

@@ -0,0 +1,39 @@
+import { createElement } from 'react';
+
+import type { CommonProps } from '../types';
+import { useEventHandler } from '../useEventHandler';
+import { useModifiers } from '../useModifiers';
+
+export interface TabViewProps extends CommonProps {
+  /// Currently selected tab. Matched against each child's `tabTag` prop.
+  /// When omitted, defaults to the first child's `tabTag` (or its index
+  /// position if none was set).
+  selection?: string;
+  /// Fires when the user pages to a different tab via swipe / Digital
+  /// Crown. JS should mirror the new tag back to `selection`.
+  onSelectionChange?: (tag: string) => void;
+  /// Tab navigation style. Defaults to `'page'` (the watchOS norm — swipe
+  /// or crown to page between tabs). `'automatic'` lets SwiftUI pick.
+  style?: 'page' | 'automatic';
+}
+
+/// SwiftUI `TabView` with watchOS-style paged navigation. Each child
+/// declares a string `tabTag` prop; `selection` matches one of those tags.
+///
+/// ```tsx
+/// <TabView selection={tab} onSelectionChange={setTab}>
+///   <VStack tabTag="rooms"> … </VStack>
+///   <VStack tabTag="schedule"> … </VStack>
+/// </TabView>
+/// ```
+export function TabView(props: TabViewProps) {
+  const { onSelectionChange, ...rest } = props;
+  const onSelectionChangeId = useEventHandler<string>(onSelectionChange);
+  const { modifiers, children } = useModifiers(rest.modifiers, rest.children);
+  return createElement('TabView', {
+    ...rest,
+    onSelectionChange: onSelectionChangeId,
+    modifiers,
+    children,
+  });
+}

package/src/components/Text.tsx

@@ -0,0 +1,16 @@
+import { createElement } from 'react';
+
+import type { CommonProps } from '../types';
+import { useModifiers } from '../useModifiers';
+
+export interface TextProps extends CommonProps {
+  children?: string | number | (string | number)[];
+}
+
+/// SwiftUI `Text`. Children must be strings (or numbers, coerced) — the
+/// native side concatenates rawText children into a single styled `Text`.
+/// Style via the `modifiers` prop (`foregroundColor`, `font`, …).
+export function Text(props: TextProps) {
+  const { modifiers, children } = useModifiers(props.modifiers, props.children);
+  return createElement('Text', { ...props, modifiers, children });
+}

package/src/components/TextField.tsx

@@ -0,0 +1,30 @@
+import { createElement } from 'react';
+
+import type { CommonProps } from '../types';
+import { useEventHandler } from '../useEventHandler';
+import { useModifiers } from '../useModifiers';
+
+export interface TextFieldProps extends CommonProps {
+  /// Prompt shown while the field is empty.
+  placeholder: string;
+  /// Current text. Controlled — JS owns the truth, the native side
+  /// mirrors it locally for instant feedback while typing.
+  value: string;
+  /// Fires as the user types, with the new text.
+  onChange?: (value: string) => void;
+}
+
+/// SwiftUI `TextField`. No label children — labels are not commonly
+/// used on watchOS text fields. Wrap with `<HStack>` + `<Text>` for a
+/// caption.
+export function TextField(props: TextFieldProps) {
+  const { onChange, ...rest } = props;
+  const onChangeId = useEventHandler<string>(onChange);
+  const { modifiers, children } = useModifiers(rest.modifiers, rest.children);
+  return createElement('TextField', {
+    ...rest,
+    onChange: onChangeId,
+    modifiers,
+    children,
+  });
+}

package/src/components/TimelineView.tsx

@@ -0,0 +1,13 @@
+import { createNativeView } from '../createNativeView';
+
+export type TimelineSchedule =
+  | { kind: 'everyMinute' }
+  | { kind: 'periodic'; from?: number; by: number }
+  | { kind: 'animation'; minimumInterval?: number; paused?: boolean }
+  | { kind: 'explicit'; dates: number[] };
+
+export interface TimelineViewProps {
+  schedule: TimelineSchedule;
+}
+
+export const TimelineView = createNativeView<TimelineViewProps>('TimelineView');

package/src/components/Toggle.tsx

@@ -0,0 +1,26 @@
+import { createElement } from 'react';
+
+import type { CommonProps } from '../types';
+import { useEventHandler } from '../useEventHandler';
+import { useModifiers } from '../useModifiers';
+
+export interface ToggleProps extends CommonProps {
+  /// Current on/off state. The control is controlled — JS owns the
+  /// truth, the native side mirrors it locally for instant feedback.
+  value: boolean;
+  /// Fires when the user flips the toggle, with the new value.
+  onChange?: (value: boolean) => void;
+}
+
+/// SwiftUI `Toggle`. Children become the toggle's label.
+export function Toggle(props: ToggleProps) {
+  const { onChange, ...rest } = props;
+  const onChangeId = useEventHandler<boolean>(onChange);
+  const { modifiers, children } = useModifiers(rest.modifiers, rest.children);
+  return createElement('Toggle', {
+    ...rest,
+    onChange: onChangeId,
+    modifiers,
+    children,
+  });
+}

package/src/components/VStack.tsx

@@ -0,0 +1,10 @@
+import { createNativeView } from '../createNativeView';
+
+export interface VStackProps {
+  /// Horizontal alignment of children. Defaults to `'center'`.
+  alignment?: 'leading' | 'center' | 'trailing';
+  /// Distance between children. Defaults to the system spacing.
+  spacing?: number;
+}
+
+export const VStack = createNativeView<VStackProps>('VStack');

package/src/components/ViewThatFits.tsx

@@ -0,0 +1,7 @@
+import { createNativeView } from '../createNativeView';
+
+export type ViewThatFitsProps = {
+  axes?: 'horizontal' | 'vertical' | 'both';
+};
+
+export const ViewThatFits = createNativeView<ViewThatFitsProps>('ViewThatFits');

package/src/components/ZStack.tsx

@@ -0,0 +1,18 @@
+import { createNativeView } from '../createNativeView';
+
+export interface ZStackProps {
+  /// Where to anchor children that are smaller than the stack frame.
+  /// Defaults to `'center'`.
+  alignment?:
+    | 'leading'
+    | 'trailing'
+    | 'top'
+    | 'bottom'
+    | 'center'
+    | 'topLeading'
+    | 'topTrailing'
+    | 'bottomLeading'
+    | 'bottomTrailing';
+}
+
+export const ZStack = createNativeView<ZStackProps>('ZStack');

package/src/createHostConfig.ts

@@ -0,0 +1,223 @@
+// HostConfig for the C++ shadow-tree renderer. Every callback that mutates
+// the tree forwards directly to a JSI host function on `globalThis.__RNW_UI`.
+// Instances are opaque integer tags — the same model Fabric uses for its
+// native nodes — so the JS side never holds a parallel tree.
+//
+// We deliberately don't import `HostConfig` from `react-reconciler`. The
+// generic signature drifts every minor version (0.28 → 0.29 → 0.32 each
+// rearranged params) and chasing those changes adds no value here. The
+// reconciler only ever calls the methods below positionally.
+
+type Tag = number;
+type Container = object; // inert sentinel — the C++ side owns the root list
+// Type is the SwiftUI view name passed as-is through the C++ shadow
+// tree to the Swift `RNWViewRegistry`. Any string is valid here — an
+// unregistered view falls back to EmptyView on the Swift side rather
+// than failing at the reconciler boundary.
+type Type = string;
+type Props = Record<string, unknown>;
+
+interface UIManager {
+  createNode(type: Type, props: Props): Tag;
+  createTextNode(text: string): Tag;
+  updateNodeProps(tag: Tag, newProps: Props): void;
+  updateTextNode(tag: Tag, text: string): void;
+  appendChild(parent: Tag, child: Tag): void;
+  insertBefore(parent: Tag, child: Tag, before: Tag): void;
+  removeChild(parent: Tag, child: Tag): void;
+  appendToRoot(child: Tag): void;
+  removeFromRoot(child: Tag): void;
+  clearRoot(): void;
+  completeRoot(): void;
+}
+
+// `globalThis.__RNW_UI` is installed by RNWHermesHost when the runtime
+// boots. If the JS side imports the renderer before the host is wired
+// (e.g. unit tests under Node), throw with a clear message.
+function ui(): UIManager {
+  const g = globalThis as unknown as { __RNW_UI?: UIManager };
+  if (!g.__RNW_UI) {
+    throw new Error(
+      '@appsent-co/react-native-watchos: __RNW_UI host object is not installed. ' +
+        'This renderer only runs inside the watchOS Hermes runtime.'
+    );
+  }
+  return g.__RNW_UI;
+}
+
+// `setTimeout`/`clearTimeout` aren't in the project's `lib` (ESNext only),
+// so reference them off `globalThis` to dodge the missing global types.
+const g = globalThis as unknown as {
+  setTimeout: (cb: () => void, ms?: number) => number;
+  clearTimeout: (id: number) => void;
+};
+
+// react-reconciler 0.32 (React 19) splits the old `getCurrentEventPriority`
+// into get/set/resolve. Lanes are bitmasks, matching the constants exported
+// from react-reconciler/constants:
+//   NoEventPriority = 0, DiscreteEventPriority = 2,
+//   ContinuousEventPriority = 8, DefaultEventPriority = 32.
+// We don't dispatch real events on watchOS yet, so a single module-level
+// slot is enough. resolveUpdatePriority is the function requestUpdateLane
+// invokes at render time; returning undefined here is what produced the
+// "undefined is not a function" crash in requestUpdateLane.
+const NoEventPriority = 0;
+const DefaultEventPriority = 32;
+let currentUpdatePriority: number = NoEventPriority;
+
+export function createHostConfig(): Record<string, unknown> {
+  return {
+    supportsMutation: true,
+    supportsPersistence: false,
+    isPrimaryRenderer: true,
+    supportsHydration: false,
+
+    createInstance(type: Type, props: Props): Tag {
+      return ui().createNode(type, props);
+    },
+    createTextInstance(text: string): Tag {
+      return ui().createTextNode(text);
+    },
+
+    appendInitialChild(parent: Tag, child: Tag) {
+      ui().appendChild(parent, child);
+    },
+    appendChild(parent: Tag, child: Tag) {
+      ui().appendChild(parent, child);
+    },
+    appendChildToContainer(_container: Container, child: Tag) {
+      ui().appendToRoot(child);
+    },
+
+    insertBefore(parent: Tag, child: Tag, before: Tag) {
+      ui().insertBefore(parent, child, before);
+    },
+    insertInContainerBefore(_container: Container, child: Tag, _before: Tag) {
+      // No real "before" semantics on root; treat as append for MVP.
+      ui().appendToRoot(child);
+    },
+
+    removeChild(parent: Tag, child: Tag) {
+      ui().removeChild(parent, child);
+    },
+    removeChildFromContainer(_container: Container, child: Tag) {
+      ui().removeFromRoot(child);
+    },
+
+    clearContainer(_container: Container) {
+      ui().clearRoot();
+    },
+
+    // react-reconciler 0.32 dropped `prepareUpdate` and removed the
+    // `updatePayload` arg from `commitUpdate`. Signature is now
+    // `(instance, type, oldProps, newProps, internalHandle)`. Keeping the
+    // old 5-arg `(tag, payload, type, oldProps, newProps)` shape silently
+    // swaps oldProps↔newProps and every re-render forwards the *previous*
+    // props to native — useState/setInterval appear to fire but never
+    // change the screen.
+    commitUpdate(tag: Tag, _type: Type, _oldProps: Props, newProps: Props) {
+      ui().updateNodeProps(tag, newProps);
+    },
+    commitTextUpdate(tag: Tag, _oldText: string, newText: string) {
+      ui().updateTextNode(tag, newText);
+    },
+
+    finalizeInitialChildren(): boolean {
+      return false;
+    },
+    shouldSetTextContent(): boolean {
+      return false;
+    },
+
+    getRootHostContext() {
+      return {};
+    },
+    getChildHostContext() {
+      return {};
+    },
+    getPublicInstance(tag: Tag): Tag {
+      return tag;
+    },
+
+    prepareForCommit(): null {
+      return null;
+    },
+    resetAfterCommit(_container: Container) {
+      ui().completeRoot();
+    },
+
+    preparePortalMount() {
+      // unused
+    },
+
+    now: Date.now,
+    scheduleTimeout: g.setTimeout,
+    cancelTimeout: g.clearTimeout,
+    noTimeout: -1,
+
+    // Priority APIs (react-reconciler 0.32). requestUpdateLane calls
+    // resolveUpdatePriority synchronously on every state update; if it's
+    // missing the reconciler crashes with "undefined is not a function"
+    // before ever reaching the host methods above.
+    getCurrentUpdatePriority(): number {
+      return currentUpdatePriority;
+    },
+    setCurrentUpdatePriority(priority: number) {
+      currentUpdatePriority = priority;
+    },
+    resolveUpdatePriority(): number {
+      return currentUpdatePriority !== NoEventPriority
+        ? currentUpdatePriority
+        : DefaultEventPriority;
+    },
+    shouldAttemptEagerTransition(): boolean {
+      return false;
+    },
+
+    // Suspense-on-commit hooks. Called during render/commit even when the
+    // tree contains no <Suspense>, so they must exist. We don't suspend.
+    maySuspendCommit(): boolean {
+      return false;
+    },
+    preloadInstance(): boolean {
+      return true;
+    },
+    startSuspendingCommit() {},
+    suspendInstance() {},
+    waitForCommitToBeReady(): null {
+      return null;
+    },
+
+    // Form/transition plumbing. HostTransitionContext is read via
+    // readContext() inside useFormState etc.; the reconciler also writes
+    // to its `_currentValue`/`_currentValue2` slots, so it must be a real
+    // object. NotPendingTransition is the sentinel stored in those slots
+    // when no transition is active — any stable reference works.
+    NotPendingTransition: null,
+    HostTransitionContext: {
+      $$typeof: Symbol.for('react.context'),
+      Provider: null,
+      Consumer: null,
+      _currentValue: null,
+      _currentValue2: null,
+      _threadCount: 0,
+      _defaultValue: null,
+      _globalName: null,
+    },
+    resetFormInstance() {},
+
+    // No-ops below — required by the HostConfig contract but irrelevant
+    // for a non-interactive, non-suspense renderer.
+    commitMount() {},
+    detachDeletedInstance() {},
+    getInstanceFromNode() {
+      return null;
+    },
+    beforeActiveInstanceBlur() {},
+    afterActiveInstanceBlur() {},
+    prepareScopeUpdate() {},
+    getInstanceFromScope() {
+      return null;
+    },
+  };
+}