@tanstack/redact 0.0.1

package/src/dom/features/forward-ref/stub.ts

@@ -0,0 +1,28 @@
+import { FiberTag, type Fiber } from '../../../core'
+import { REACT_FORWARD_REF_TYPE } from '../../../react'
+import { registerRenderer, registerTypeMatcher, renderFiber } from '../../reconcile'
+
+// Stub: ForwardRef feature disabled. `forwardRef(fn)` elements still render,
+// but the ref prop is NOT forwarded — the component is called as a plain
+// function with just props. React 19+ supports refs as normal props on
+// function components, so most apps can drop forwardRef entirely; this stub
+// preserves JSX compatibility while stripping the dispatcher save/restore
+// machinery.
+function renderForwardRefStub(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  const render = (fiber.type as any).render
+  const savedTag = fiber.tag
+  const savedType = fiber.type
+  fiber.type = render
+  fiber.tag = FiberTag.Function
+  try {
+    renderFiber(fiber, domParent, anchor)
+  } finally {
+    fiber.tag = savedTag
+    fiber.type = savedType
+  }
+}
+
+registerTypeMatcher((_type, marker) =>
+  marker === REACT_FORWARD_REF_TYPE ? FiberTag.ForwardRef : null,
+)
+registerRenderer(FiberTag.ForwardRef, renderForwardRefStub)

package/src/dom/features/hydration/full.ts

@@ -0,0 +1,345 @@
+import { FiberTag, type Fiber, type FiberRoot } from '../../../core'
+import { setProp } from '../../dom'
+import { findRoot } from '../../reconcile'
+
+// Re-export from event-replay so all hydration concerns live behind one
+// feature boundary — the plugin's stub swap strips drainReplayQueue too.
+export { drainReplayQueue } from '../../event-replay'
+
+const GUARD_WINDOW_MS = 3000
+
+/**
+ * Preserve the user's scroll position across hydration. If the user scrolled
+ * between SSR paint and hydrate (common in dev where JS takes seconds to
+ * load), libraries that wire scroll-restoration into a `useLayoutEffect`
+ * near the root (e.g. TanStack Router) will run during our synchronous
+ * hydrate and call `window.scrollTo(savedFromLastVisit)` — overwriting the
+ * user's fresh scroll. We install a short-lived wrapper around scrollTo that
+ * suppresses programmatic calls when a user-initiated scroll happened
+ * recently. Only runs in the hydration feature — the stub skips it.
+ */
+export function installHydrationScrollGuard(): void {
+  if (typeof window === 'undefined') return
+  const w = window as any
+  if (w.__tdomScrollGuardInstalled) return
+  w.__tdomScrollGuardInstalled = true
+  const guardStartedAt = performance.now()
+  let lastUserScrollAt = 0
+  let programmatic = 0
+  w.__tdomScrollLog = []
+  window.addEventListener(
+    'scroll',
+    () => {
+      if (programmatic === 0) {
+        lastUserScrollAt = performance.now()
+        w.__tdomScrollLog.push({ t: Math.round(lastUserScrollAt), ev: 'user-scroll', y: window.scrollY })
+      }
+    },
+    { capture: true, passive: true },
+  )
+  const origScrollTo = window.scrollTo.bind(window)
+  window.scrollTo = function (this: any, ...args: any[]) {
+    const now = performance.now()
+    const inGuardWindow = now - guardStartedAt < GUARD_WINDOW_MS
+    const userScrolledRecently = lastUserScrollAt > 0 && now - lastUserScrollAt < 1500
+    if (inGuardWindow && userScrolledRecently) {
+      w.__tdomScrollLog.push({
+        t: Math.round(now),
+        ev: 'suppressed',
+        args: JSON.stringify(args).slice(0, 80),
+        tSinceHydrate: Math.round(now - guardStartedAt),
+        tSinceUserScroll: Math.round(now - lastUserScrollAt),
+      })
+      return
+    }
+    w.__tdomScrollLog.push({
+      t: Math.round(now),
+      ev: 'allowed',
+      args: JSON.stringify(args).slice(0, 80),
+      tSinceHydrate: Math.round(now - guardStartedAt),
+      inGuard: inGuardWindow,
+      userScrolled: userScrolledRecently,
+    })
+    programmatic++
+    try {
+      return (origScrollTo as any).apply(this, args)
+    } finally {
+      queueMicrotask(() => {
+        programmatic = Math.max(0, programmatic - 1)
+      })
+    }
+  }
+}
+
+/**
+ * Hydration cursor: walks existing DOM children in document order so we can
+ * adopt them during fiber tree construction. One cursor per host parent.
+ *
+ * `endBefore` scopes the cursor to a subrange — used by rehydrateBoundary()
+ * so we only adopt DOM up to the closing `/$` marker for that boundary.
+ */
+export class HydrationCursor {
+  next: ChildNode | null
+  parent: Node
+  endBefore: ChildNode | null
+  constructor(parent: Node, start: ChildNode | null = null, endBefore: ChildNode | null = null) {
+    this.parent = parent
+    this.next = start ?? parent.firstChild
+    this.endBefore = endBefore
+  }
+  takeHostNode(): ChildNode | null {
+    while (this.next && this.next !== this.endBefore) {
+      const n = this.next
+      // Skip anything that isn't an element (1) or text (3):
+      // comments (8), doctype (10), processing instructions (7), cdata (4).
+      if (n.nodeType !== 1 && n.nodeType !== 3) {
+        this.next = n.nextSibling
+        continue
+      }
+      this.next = n.nextSibling
+      return n
+    }
+    return null
+  }
+  /**
+   * Position-insensitive lookup for head/html adoption. Scans forward past
+   * non-matching nodes without removing them, matching by tag AND the key
+   * attributes that identify head elements uniquely (rel/href for links,
+   * name/property for meta, src for script). Non-matching nodes stay in
+   * place so the SSR'd stylesheet/script order is preserved.
+   */
+  takeMatchingHeadElement(tag: string, props: Record<string, any>): ChildNode | null {
+    const target = tag.toLowerCase()
+    const keyAttrs = HEAD_KEY_ATTRS[target] ?? []
+    let scan = this.parent.firstChild
+    while (scan) {
+      if (
+        scan.nodeType === 1 &&
+        (scan as Element).tagName.toLowerCase() === target &&
+        headAttrsMatch(scan as Element, props, keyAttrs)
+      ) {
+        CLAIMED.add(scan)
+        return scan
+      }
+      scan = scan.nextSibling
+    }
+    return null
+  }
+  remaining(): ChildNode[] {
+    const out: ChildNode[] = []
+    let n = this.next
+    while (n && n !== this.endBefore) {
+      out.push(n)
+      n = n.nextSibling
+    }
+    return out
+  }
+}
+
+const hydrationCursors = new WeakMap<Fiber, HydrationCursor>()
+
+// Head elements that we match against server DOM by attribute signature.
+const HEAD_KEY_ATTRS: Record<string, ReadonlyArray<string>> = {
+  link: ['rel', 'href', 'sizes', 'type'],
+  meta: ['name', 'property', 'charset', 'http-equiv'],
+  script: ['src', 'type'],
+  style: [],
+  title: [],
+}
+
+// DOM elements already claimed by some fiber during this hydration pass.
+const CLAIMED = new WeakSet<Node>()
+
+function headAttrsMatch(
+  el: Element,
+  props: Record<string, any>,
+  keys: ReadonlyArray<string>,
+): boolean {
+  if (CLAIMED.has(el)) return false
+  if (keys.length === 0) return true
+  for (const k of keys) {
+    const propVal = props[k] ?? (k === 'http-equiv' ? props.httpEquiv : undefined)
+    const elVal = el.getAttribute(k)
+    // If neither defines it, skip this key; if one defines it, they must match.
+    if (propVal == null && elVal == null) continue
+    if (propVal == null || elVal == null) continue // tolerate missing on either side
+    if (String(propVal) !== elVal) return false
+  }
+  // At least one matching signal must be present.
+  return keys.some((k) => props[k] != null || el.hasAttribute(k))
+}
+
+export function beginHydration(root: FiberRoot): void {
+  root.hydrating = true
+  hydrationCursors.set(root.current, new HydrationCursor(root.container))
+}
+
+export function endHydration(root: FiberRoot): void {
+  root.hydrating = false
+  hydrationCursors.delete(root.current)
+}
+
+/**
+ * Inspect the current cursor position for a streaming-suspense boundary
+ * marker emitted by the server. Returns info + advances the cursor past the
+ * marker pair (start comment + fallback/real content + end comment).
+ */
+export interface BoundaryInfo {
+  kind: 'pending' | 'resolved'
+  id: number
+  startMark: Comment
+  endMark: Comment
+}
+
+export function tryConsumeBoundary(parent: Fiber): BoundaryInfo | null {
+  const cursor = hydrationCursors.get(findHostParent(parent))
+  if (!cursor) return null
+  const peek = cursor.next
+  if (!peek || peek.nodeType !== 8) return null
+  const data = (peek as Comment).data
+  const m = /^(\$\??)(\d+)$/.exec(data)
+  if (!m) return null
+  const kind = m[1] === '$?' ? 'pending' : 'resolved'
+  const id = Number(m[2])
+  const startMark = peek as Comment
+  // Advance past the start comment
+  cursor.next = startMark.nextSibling
+  // Locate end comment: closest <!--/$-->
+  let endMark: Comment | null = null
+  let scan = startMark.nextSibling
+  while (scan) {
+    if (scan.nodeType === 8 && (scan as Comment).data === '/$') {
+      endMark = scan as Comment
+      break
+    }
+    scan = scan.nextSibling
+  }
+  if (!endMark) return null
+  return { kind, id, startMark, endMark }
+}
+
+export function advanceCursorPast(parent: Fiber, node: Node): void {
+  const cursor = hydrationCursors.get(findHostParent(parent))
+  if (!cursor) return
+  cursor.next = node.nextSibling
+}
+
+export function getHydrationCursor(hostFiber: Fiber): HydrationCursor | undefined {
+  return hydrationCursors.get(hostFiber)
+}
+
+export function setHydrationCursor(hostFiber: Fiber, cursor: HydrationCursor): void {
+  hydrationCursors.set(hostFiber, cursor)
+}
+
+export function clearHydrationCursor(hostFiber: Fiber): void {
+  hydrationCursors.delete(hostFiber)
+}
+
+/**
+ * Try to adopt a DOM node for this host fiber. Returns true if adopted.
+ * Attaches existing attrs/children via separate hydrate pass.
+ */
+export function adoptHostDom(fiber: Fiber, parent: Fiber): boolean {
+  const hostParent = findHostParent(parent)
+  const cursor = hydrationCursors.get(hostParent)
+  if (!cursor) return false
+
+  const tag = (fiber.type as string).toLowerCase()
+  const parentEl = cursor.parent as Element
+  const parentTag =
+    parentEl.nodeType === 1 ? (parentEl as Element).tagName.toLowerCase() : ''
+  const isHeadish = parentTag === 'head' || parentTag === 'html'
+
+  let candidate: ChildNode | null
+  if (isHeadish) {
+    // Head/html children are position-insensitive — server may emit them in
+    // a different order than the React tree (React 19 head hoisting, etc.).
+    // Scan forward without removing non-matching nodes; match on attribute
+    // signature so we don't adopt the wrong <link> and clobber its props.
+    candidate = cursor.takeMatchingHeadElement(tag, fiber.pendingProps ?? {})
+  } else {
+    candidate = cursor.takeHostNode()
+  }
+
+  if (!candidate) {
+    // Client expected a host here but the cursor is exhausted — server gave
+    // fewer children than the client tree. Report the structural gap (React
+    // fires `onRecoverableError` for this exact case) and let the reconciler
+    // mount a fresh DOM for this fiber below.
+    // Exception: <head> children are position-insensitive; a missing match
+    // there means "server didn't hoist this one yet", which we silently mount.
+    if (!isHeadish) onMismatch(fiber, null)
+    return false
+  }
+
+  if (candidate.nodeType !== 1 || (candidate as Element).tagName.toLowerCase() !== tag) {
+    // mismatch — log and re-render fresh from this point
+    onMismatch(fiber, candidate)
+    return false
+  }
+  fiber.dom = candidate
+  // Apply props (attach events, sync IDL props). Don't re-set existing attrs.
+  const props = fiber.pendingProps ?? {}
+  const isSvg =
+    tag === 'svg' ||
+    ((candidate as Element).namespaceURI === 'http://www.w3.org/2000/svg' &&
+      tag !== 'foreignobject')
+  for (const k in props) {
+    if (k === 'children') continue
+    if (k[0] === 'o' && k[1] === 'n' && typeof props[k] === 'function') {
+      setProp(candidate as Element, k, props[k], undefined, isSvg)
+    }
+    // Non-event props: trust the server HTML, skip
+  }
+  // Set up child cursor for this host's children
+  hydrationCursors.set(fiber, new HydrationCursor(candidate))
+  return true
+}
+
+export function adoptTextDom(fiber: Fiber, parent: Fiber, text: string): boolean {
+  const cursor = hydrationCursors.get(findHostParent(parent))
+  if (!cursor) return false
+  const candidate = cursor.takeHostNode()
+  if (!candidate) return false
+  if (candidate.nodeType === 3) {
+    if ((candidate as Text).data !== text) {
+      ;(candidate as Text).data = text
+    }
+    fiber.dom = candidate
+    return true
+  }
+  onMismatch(fiber, candidate)
+  return false
+}
+
+export function findHostParent(fiber: Fiber): Fiber {
+  let f: Fiber | null = fiber
+  while (f) {
+    // A fiber explicitly holding a cursor acts as a boundary for hydration
+    // (e.g. Suspense with a scoped cursor during fallback/boundary hydration).
+    if (hydrationCursors.has(f)) return f
+    if (f.tag === FiberTag.Host || f.tag === FiberTag.Root || f.tag === FiberTag.Portal) {
+      return f
+    }
+    f = f.parent
+  }
+  throw new Error('No host parent found')
+}
+
+function onMismatch(fiber: Fiber, actualNode: ChildNode | null): void {
+  // For v1: log and exit hydration for this subtree. The normal reconciler
+  // will create a fresh DOM node below.
+  const root = findRoot(fiber)
+  if (root?.onRecoverableError) {
+    root.onRecoverableError(
+      new Error(
+        `Hydration mismatch: expected <${(fiber.type as string) ?? 'text'}> but found ${
+          actualNode ? (actualNode.nodeType === 1 ? (actualNode as Element).tagName : 'text') : 'nothing'
+        }.`,
+      ),
+    )
+  }
+  // Remove stale DOM if still there
+  if (actualNode && actualNode.parentNode) actualNode.parentNode.removeChild(actualNode)
+}

package/src/dom/features/hydration/index.ts

@@ -0,0 +1 @@
+export * from './full'

package/src/dom/features/hydration/stub.ts

@@ -0,0 +1,72 @@
+import type { Fiber, FiberRoot } from '../../../core'
+
+// Stub: Hydration feature disabled. Every adoption attempt returns "no match",
+// all cursor operations no-op, and `beginHydration` throws so `hydrateRoot`
+// fails loudly — apps that opt out of hydration should use `createRoot`.
+// The SSR walk-the-DOM machinery, streaming-boundary coordination, head
+// element matching, and the WeakMap of cursors per fiber are all stripped.
+
+export class HydrationCursor {
+  next: ChildNode | null = null
+  parent: Node
+  endBefore: ChildNode | null = null
+  constructor(parent?: Node, _s?: ChildNode | null, _e?: ChildNode | null) {
+    this.parent = parent as Node
+  }
+  takeHostNode(): ChildNode | null {
+    return null
+  }
+  takeMatchingHeadElement(): ChildNode | null {
+    return null
+  }
+  remaining(): ChildNode[] {
+    return []
+  }
+}
+
+export interface BoundaryInfo {
+  kind: 'pending' | 'resolved'
+  id: number
+  startMark: Comment
+  endMark: Comment
+}
+
+export function beginHydration(_root: FiberRoot): void {
+  throw new Error(
+    '`hydrateRoot` requires the `hydration` feature. ' +
+      'Enable it via @tanstack/redact/vite `features.hydration = true`, ' +
+      'or use `createRoot` for a SPA (no SSR hydration).',
+  )
+}
+
+export function endHydration(_root: FiberRoot): void {}
+
+export function tryConsumeBoundary(_parent: Fiber): BoundaryInfo | null {
+  return null
+}
+
+export function advanceCursorPast(_parent: Fiber, _node: Node): void {}
+
+export function getHydrationCursor(_hostFiber: Fiber): HydrationCursor | undefined {
+  return undefined
+}
+
+export function setHydrationCursor(_hostFiber: Fiber, _cursor: HydrationCursor): void {}
+
+export function clearHydrationCursor(_hostFiber: Fiber): void {}
+
+export function adoptHostDom(_fiber: Fiber, _parent: Fiber): boolean {
+  return false
+}
+
+export function adoptTextDom(_fiber: Fiber, _parent: Fiber, _text: string): boolean {
+  return false
+}
+
+export function findHostParent(fiber: Fiber): Fiber {
+  return fiber
+}
+
+export function installHydrationScrollGuard(): void {}
+
+export function drainReplayQueue(): void {}

package/src/dom/features/index.ts

@@ -0,0 +1,11 @@
+// Feature wiring. Each import is a side-effect import that triggers the
+// feature module's self-registration with the reconciler (renderer, type
+// matcher, element marker). A vite plugin can swap any entry to './stub'
+// to disable that feature in the emitted bundle.
+import './portal'
+import './context'
+import './suspense'
+import './memo'
+import './forward-ref'
+import './lazy'
+import './class'

package/src/dom/features/lazy/full.ts

@@ -0,0 +1,98 @@
+import { FiberTag, type Fiber } from '../../../core'
+import { REACT_LAZY_TYPE } from '../../../react'
+import {
+  registerRenderer,
+  registerTypeMatcher,
+  renderFiber,
+  scheduleUpdate,
+  isThenable,
+  handleSuspended,
+  getCurrentRoot,
+} from '../../reconcile'
+import {
+  getHydrationCursor,
+  setHydrationCursor,
+  findHostParent as findHydrationHost,
+} from '../hydration'
+
+function renderLazy(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  const { _payload, _init } = fiber.type as any
+  let resolved: any
+  try {
+    resolved = _init(_payload)
+  } catch (thenable: any) {
+    if (isThenable(thenable)) {
+      // During initial hydration, a lazy component inside an SSR-resolved
+      // Suspense boundary needs special handling: the SSR DOM for its
+      // resolved content is already in the page and our cursor is pointing
+      // at it. A normal `handleSuspended` would schedule the lazy's later
+      // re-render WITHOUT the hydration cursor — so when it eventually
+      // resolves, we'd create a fresh DOM copy next to the SSR one (visible
+      // as duplicate logos / buttons / sections inside the Suspense). Mirror
+      // the pattern in renderFunction: preserve the in-scope cursor on this
+      // fiber and flag it for deferred re-hydration, so rerenderFiber
+      // restores `root.hydrating = true` and the resolved render adopts the
+      // existing DOM instead of mounting a duplicate.
+      const root = getCurrentRoot()
+      if (root?.hydrating) {
+        const hostParent = findHydrationHost(fiber)
+        const inheritedCursor = getHydrationCursor(hostParent)
+        if (inheritedCursor) {
+          setHydrationCursor(fiber, inheritedCursor)
+        }
+        fiber.memoizedState = {
+          ...(fiber.memoizedState ?? {}),
+          _pendingHydration: true,
+        }
+        // Mark the nearest ancestor Suspense as "awaiting hydration-resume"
+        // so a post-hydration re-render of that Suspense doesn't accidentally
+        // flip into suspended+pending and mount a fallback atop the SSR
+        // content. Match-by-tag-name works whether Suspense is the full
+        // feature or stubbed to Fragment (the walk just never finds one).
+        let sus: Fiber | null = fiber.parent
+        while (sus && sus.tag !== FiberTag.Suspense) sus = sus.parent
+        if (sus && sus.memoizedState) {
+          ;(sus.memoizedState as any)._awaitingLazyHydration = true
+        }
+        thenable.then(
+          () => {
+            if (sus && sus.memoizedState) {
+              ;(sus.memoizedState as any)._awaitingLazyHydration = false
+            }
+            scheduleUpdate(fiber)
+          },
+          () => {
+            if (sus && sus.memoizedState) {
+              ;(sus.memoizedState as any)._awaitingLazyHydration = false
+            }
+            scheduleUpdate(fiber)
+          },
+        )
+        return
+      }
+      handleSuspended(fiber, thenable)
+      // reconcileChildren would be called here if we were rendering children,
+      // but Lazy delegates and has no children of its own.
+      return
+    }
+    throw thenable
+  }
+  const savedTag = fiber.tag
+  const savedType = fiber.type
+  fiber.type = resolved
+  fiber.tag =
+    typeof resolved === 'function'
+      ? resolved.prototype?.isReactComponent
+        ? FiberTag.Class
+        : FiberTag.Function
+      : FiberTag.Fragment
+  try {
+    renderFiber(fiber, domParent, anchor)
+  } finally {
+    fiber.tag = savedTag
+    fiber.type = savedType
+  }
+}
+
+registerTypeMatcher((_type, marker) => (marker === REACT_LAZY_TYPE ? FiberTag.Lazy : null))
+registerRenderer(FiberTag.Lazy, renderLazy)

package/src/dom/features/lazy/index.ts

@@ -0,0 +1 @@
+export * from './full'

package/src/dom/features/lazy/stub.ts

@@ -0,0 +1,45 @@
+import { FiberTag, type Fiber } from '../../../core'
+import { REACT_LAZY_TYPE } from '../../../react'
+import {
+  registerRenderer,
+  registerTypeMatcher,
+  renderFiber,
+  isThenable,
+  handleSuspended,
+} from '../../reconcile'
+
+// Stub: Lazy feature disabled. Lazy elements still resolve — sync if the
+// payload is ready, otherwise the thrown thenable goes through the default
+// `handleSuspended` capability (retry-on-settle). What's stripped: the
+// hydration-deferred-reveal pathway and the Suspense-awaiting coordination.
+function renderLazyStub(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  const { _payload, _init } = fiber.type as any
+  let resolved: any
+  try {
+    resolved = _init(_payload)
+  } catch (thrown: any) {
+    if (isThenable(thrown)) {
+      handleSuspended(fiber, thrown)
+      return
+    }
+    throw thrown
+  }
+  const savedTag = fiber.tag
+  const savedType = fiber.type
+  fiber.type = resolved
+  fiber.tag =
+    typeof resolved === 'function'
+      ? resolved.prototype?.isReactComponent
+        ? FiberTag.Class
+        : FiberTag.Function
+      : FiberTag.Fragment
+  try {
+    renderFiber(fiber, domParent, anchor)
+  } finally {
+    fiber.tag = savedTag
+    fiber.type = savedType
+  }
+}
+
+registerTypeMatcher((_type, marker) => (marker === REACT_LAZY_TYPE ? FiberTag.Lazy : null))
+registerRenderer(FiberTag.Lazy, renderLazyStub)

package/src/dom/features/memo/full.ts

@@ -0,0 +1,74 @@
+import { FiberTag, type Fiber } from '../../../core'
+import {
+  REACT_FORWARD_REF_TYPE,
+  REACT_MEMO_TYPE,
+  REACT_LAZY_TYPE,
+} from '../../../react'
+import {
+  registerRenderer,
+  registerTypeMatcher,
+  renderFiber,
+  getForceRerenderingFiber,
+} from '../../reconcile'
+
+function shallowEqual(a: any, b: any): boolean {
+  if (a === b) return true
+  if (!a || !b) return false
+  const ak = Object.keys(a)
+  const bk = Object.keys(b)
+  if (ak.length !== bk.length) return false
+  for (const k of ak) {
+    if (a[k] !== b[k]) return false
+  }
+  return true
+}
+
+function renderMemo(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  const { type, compare } = fiber.type as any
+  const props = fiber.pendingProps ?? {}
+  const prev = fiber.memoizedProps
+
+  // Memo's prop-equality gate guards PARENT-triggered rerenders. If this
+  // render is a STATE-triggered rerender of this exact fiber (hook update,
+  // useSyncExternalStore notification), props haven't changed by definition —
+  // bailing would swallow the state change and the subscriber never re-runs.
+  // rerenderFiber tags the fiber so we skip the gate here.
+  const bypassMemo = fiber === getForceRerenderingFiber()
+  const eq = !bypassMemo && prev && (compare ? compare(prev, props) : shallowEqual(prev, props))
+  if (eq) {
+    // Re-render children with previous output (already in tree)
+    return
+  }
+
+  // Determine the delegated tag based on the memoized type. `React.memo` can
+  // wrap plain functions, class components, OR other special types like
+  // `forwardRef`. Without the marker-based branch we'd mistreat
+  // `memo(forwardRef(...))` as a Fragment and render nothing.
+  let innerTag: FiberTag
+  if (typeof type === 'function') {
+    innerTag = type.prototype?.isReactComponent ? FiberTag.Class : FiberTag.Function
+  } else if (type && typeof type === 'object') {
+    const m = (type as any).$$typeof
+    if (m === REACT_FORWARD_REF_TYPE) innerTag = FiberTag.ForwardRef
+    else if (m === REACT_MEMO_TYPE) innerTag = FiberTag.Memo
+    else if (m === REACT_LAZY_TYPE) innerTag = FiberTag.Lazy
+    else innerTag = FiberTag.Fragment
+  } else {
+    innerTag = FiberTag.Fragment
+  }
+
+  // Swap tag and type for this render pass; this is a "delegating" render
+  const savedTag = fiber.tag
+  const savedType = fiber.type
+  fiber.tag = innerTag
+  fiber.type = type
+  try {
+    renderFiber(fiber, domParent, anchor)
+  } finally {
+    fiber.tag = savedTag
+    fiber.type = savedType
+  }
+}
+
+registerTypeMatcher((_type, marker) => (marker === REACT_MEMO_TYPE ? FiberTag.Memo : null))
+registerRenderer(FiberTag.Memo, renderMemo)

package/src/dom/features/memo/index.ts

@@ -0,0 +1 @@
+export * from './full'