@adea-ai/ui 0.123.0 → 0.124.0

package/dist/r/src/components/layout/split-layout/resize-controller-core.tsx

@@ -0,0 +1,66 @@
+import Resizable from '@corvu/resizable'
+import { type Accessor, type JSX } from 'solid-js'
+import {
+  listLeaves,
+  MIN_SPLIT_RATIO,
+  MAX_SPLIT_RATIO,
+  type SplitLayoutBranch,
+  type SplitLayoutLeaf,
+} from './model'
+
+export type SplitLayoutResizeControllerProps<L extends SplitLayoutLeaf> = {
+  branch: Accessor<SplitLayoutBranch<L>>
+  rect: Accessor<JSX.CSSProperties>
+  domId: (id: string) => string
+  root: () => HTMLDivElement | undefined
+  labelForSeparator?: (branch: SplitLayoutBranch<L>) => string
+  onResize: (splitId: string, ratio: number) => void
+}
+
+/** Corvu stays behind the first real split while the pane owners remain mounted. */
+export default function SplitLayoutResizeController<L extends SplitLayoutLeaf>(
+  props: SplitLayoutResizeControllerProps<L>
+) {
+  const id = () => props.branch().id
+  return (
+    <Resizable
+      orientation={props.branch().direction === 'row' ? 'horizontal' : 'vertical'}
+      sizes={[props.branch().ratio, 1 - props.branch().ratio]}
+      keyboardDelta={0.05}
+      onSizesChange={(sizes) => {
+        // Corvu also reports panel registration/unregistration while
+        // mounting or disposing a controller. Those incomplete or
+        // hidden-host sizes are not user resize intent.
+        const root = props.root()
+        if (!root?.isConnected || root.getClientRects().length === 0) return
+        if (
+          sizes.length !== 2 ||
+          sizes.some((size) => !Number.isFinite(size)) ||
+          Math.abs(sizes[0]! + sizes[1]! - 1) > 0.000001
+        )
+          return
+        if (sizes[0] !== undefined && Math.abs(sizes[0] - props.branch().ratio) > 0.000001)
+          props.onResize(id(), sizes[0])
+      }}
+      style={props.rect()}
+      class="pointer-events-none absolute flex min-h-0 min-w-0 data-[orientation=vertical]:flex-col"
+    >
+      <Resizable.Panel minSize={MIN_SPLIT_RATIO} maxSize={MAX_SPLIT_RATIO} aria-hidden="true" />
+      <Resizable.Handle
+        aria-label={
+          props.labelForSeparator?.(props.branch()) ??
+          (props.branch().direction === 'row' ? 'Resize pane columns' : 'Resize pane rows')
+        }
+        aria-orientation={props.branch().direction === 'row' ? 'vertical' : 'horizontal'}
+        aria-controls={listLeaves(props.branch())
+          .map((leaf) => props.domId(leaf.id))
+          .join(' ')}
+        aria-valuemin={10}
+        aria-valuemax={90}
+        aria-valuenow={Math.round(props.branch().ratio * 100)}
+        class="pointer-events-auto relative w-px shrink-0 bg-border after:absolute after:inset-y-0 after:-inset-x-1 after:w-3 focus-visible:bg-primary focus-visible:outline-none hover:bg-primary data-[orientation=vertical]:h-px data-[orientation=vertical]:w-full data-[orientation=vertical]:after:inset-x-0 data-[orientation=vertical]:after:-inset-y-1 data-[orientation=vertical]:after:h-3 data-[orientation=vertical]:after:w-full"
+      />
+      <Resizable.Panel minSize={MIN_SPLIT_RATIO} maxSize={MAX_SPLIT_RATIO} aria-hidden="true" />
+    </Resizable>
+  )
+}

package/dist/r/src/components/layout/split-layout/resize-controller-retry-2.tsx

@@ -0,0 +1,2 @@
+/** Independent module entrypoint to recover from a cached failed primary core import. */
+export { default } from './resize-controller-core-retry'

package/dist/r/src/components/layout/split-layout/resize-controller-retry.tsx

@@ -0,0 +1 @@
+export { default } from './resize-controller-core'

package/dist/r/src/components/layout/split-layout/resize-controller.tsx

@@ -0,0 +1 @@
+export { default } from './resize-controller-core'

package/dist/r/src/components/layout/split-layout/split-layout.tsx

@@ -1,17 +1,21 @@
-import Resizable from '@corvu/resizable'
 import {
   For,
-  createMemo,
+  createEffect,
   createComputed,
+  createMemo,
   createUniqueId,
   createSignal,
+  onMount,
   onCleanup,
   on,
+  Show,
   type Accessor,
   type JSX,
 } from 'solid-js'
+import { Dynamic } from 'solid-js/web'
 import { X, GripVertical } from 'lucide-solid'
 import { ActionButton } from '../../composites/action-button'
+import { Button } from '../../ui/button'
 import { cn } from '../../../lib/utils'
 import { computeLayoutFrames, type LayoutRect } from './geometry'
 import { paneDropIntent, type PaneDropIntent } from './drop'
@@ -21,12 +25,16 @@ const DRAG_PREVIEW_MAX_WIDTH = 384
 const DRAG_PREVIEW_MAX_HEIGHT = 256
 import {
   listLeaves,
-  MIN_SPLIT_RATIO,
-  MAX_SPLIT_RATIO,
   type SplitLayoutBranch,
   type SplitLayoutLeaf,
   type SplitLayoutState,
 } from './model'
+import type { SplitLayoutResizeControllerProps } from './resize-controller-core'
+
+type ResizeController<L extends SplitLayoutLeaf> = (
+  props: SplitLayoutResizeControllerProps<L>
+) => JSX.Element
+type ResizeControllerState<L extends SplitLayoutLeaf> = ResizeController<L> | false | 'error'
 
 export type SplitLayoutProps<L extends SplitLayoutLeaf> = {
   state: SplitLayoutState<L>
@@ -59,6 +67,16 @@ function rectStyle(rect: LayoutRect): JSX.CSSProperties {
     height: `${rect.height * 100}%`,
   }
 }
+function separatorPlaceholderStyle(branch: SplitLayoutBranch, rect: LayoutRect): JSX.CSSProperties {
+  const horizontal = branch.direction === 'row'
+  return {
+    left: `${(rect.x + (horizontal ? rect.width * branch.ratio : 0)) * 100}%`,
+    top: `${(rect.y + (horizontal ? 0 : rect.height * branch.ratio)) * 100}%`,
+    width: horizontal ? '1px' : `${rect.width * 100}%`,
+    height: horizontal ? `${rect.height * 100}%` : '1px',
+    transform: horizontal ? 'translateX(-50%)' : 'translateY(-50%)',
+  }
+}
 function dragPreviewPlaceholder(source: HTMLElement, message: string) {
   const placeholder = document.createElement('div')
   placeholder.className = cn(
@@ -171,14 +189,40 @@ function cloneDragPreviewNode(source: Node): Node | undefined {
 export function SplitLayout<L extends SplitLayoutLeaf>(props: SplitLayoutProps<L>) {
   let root: HTMLDivElement | undefined
   let pendingFrame: number | undefined
+  let disposed = false
+  let resizeLoadGeneration = 0
+  let retryWithAlternateImport = false
+  let alternateImportAttempts = 0
+  let focusHandleAfterRetry = false
+  let focusRecoveryButtonAfterError = false
+  let focusRestoreEpoch = 0
+  let focusEpoch = 0
+  let pendingFocusFrame: number | undefined
   const refs = new Map<string, HTMLElement>()
   const domIds = new Map<string, string>()
   const prefix = createUniqueId()
+  const resizeReloadWarningId = `${prefix}-resize-reload-warning`
   let nextDomId = 0
   let nextDragId = 0
   let dragPreview: HTMLElement | undefined
   const [drag, setDrag] = createSignal<{ id: string; token: string }>()
   const [drop, setDrop] = createSignal<{ id: string; intent: PaneDropIntent }>()
+  const [resizeController, setResizeController] = createSignal<ResizeControllerState<L>>()
+  const cancelPendingFocusRestore = () => {
+    if (pendingFocusFrame !== undefined) cancelAnimationFrame(pendingFocusFrame)
+    pendingFocusFrame = undefined
+  }
+  const trackFocusChange = (event: FocusEvent) => {
+    if (event.target === document.body) return
+    focusEpoch += 1
+    focusHandleAfterRetry = false
+    focusRecoveryButtonAfterError = false
+    cancelPendingFocusRestore()
+  }
+  onMount(() => {
+    document.addEventListener('focusin', trackFocusChange)
+    onCleanup(() => document.removeEventListener('focusin', trackFocusChange))
+  })
   const clearDrag = () => {
     setDrag(undefined)
     setDrop(undefined)
@@ -221,6 +265,79 @@ export function SplitLayout<L extends SplitLayoutLeaf>(props: SplitLayoutProps<L
       frame.node.kind === 'split' ? [frame.node] : []
     )
   )
+  createEffect(() => {
+    if (branches().length === 0) {
+      resizeLoadGeneration += 1
+      focusHandleAfterRetry = false
+      focusRecoveryButtonAfterError = false
+      cancelPendingFocusRestore()
+      // Keep a loaded controller so a later split does not re-import a facade
+      // that may have failed before recovery. Clear only transient UI state.
+      if (resizeController() === false || resizeController() === 'error')
+        setResizeController(undefined)
+      return
+    }
+    if (resizeController() !== undefined) return
+    const retry = retryWithAlternateImport
+    const generation = ++resizeLoadGeneration
+    setResizeController(false)
+    const controllerImport = retry
+      ? alternateImportAttempts++ === 0
+        ? import('./resize-controller-retry')
+        : import('./resize-controller-retry-2')
+      : import('./resize-controller')
+    void controllerImport.then(
+      ({ default: Controller }) => {
+        if (disposed || generation !== resizeLoadGeneration || branches().length === 0) return
+        const shouldFocusHandle = focusHandleAfterRetry && focusEpoch === focusRestoreEpoch
+        focusHandleAfterRetry = false
+        focusRecoveryButtonAfterError = false
+        retryWithAlternateImport = false
+        alternateImportAttempts = 0
+        setResizeController(() => Controller)
+        if (shouldFocusHandle)
+          pendingFocusFrame = requestAnimationFrame(() => {
+            pendingFocusFrame = undefined
+            if (
+              disposed ||
+              generation !== resizeLoadGeneration ||
+              branches().length === 0 ||
+              focusEpoch !== focusRestoreEpoch
+            )
+              return
+            const currentFocus = root?.ownerDocument.activeElement
+            if (currentFocus && currentFocus !== root?.ownerDocument.body && currentFocus !== root)
+              return
+            root?.querySelector<HTMLElement>('[data-corvu-resizable-handle]')?.focus({
+              preventScroll: true,
+            })
+          })
+      },
+      () => {
+        // A rejected dynamic import can remain cached under its specifier.
+        // The next split must start from the alternate module entry as well.
+        retryWithAlternateImport = true
+        if (!disposed && generation === resizeLoadGeneration && branches().length > 0) {
+          setResizeController('error')
+          const shouldFocusRetry = focusRecoveryButtonAfterError && focusEpoch === focusRestoreEpoch
+          if (shouldFocusRetry)
+            pendingFocusFrame = requestAnimationFrame(() => {
+              pendingFocusFrame = undefined
+              if (
+                disposed ||
+                generation !== resizeLoadGeneration ||
+                branches().length === 0 ||
+                focusEpoch !== focusRestoreEpoch
+              )
+                return
+              root?.querySelector<HTMLButtonElement>('[data-resize-retry]')?.focus({
+                preventScroll: true,
+              })
+            })
+        }
+      }
+    )
+  })
   createComputed(() => {
     const current = drag()
     if (current && (!props.onMove || !leafMap().has(current.id))) clearDrag()
@@ -288,6 +405,10 @@ export function SplitLayout<L extends SplitLayoutLeaf>(props: SplitLayoutProps<L
     )
   )
   onCleanup(() => {
+    disposed = true
+    focusHandleAfterRetry = false
+    focusRecoveryButtonAfterError = false
+    cancelPendingFocusRestore()
     if (pendingFrame !== undefined) cancelAnimationFrame(pendingFrame)
     clearDrag()
     refs.clear()
@@ -452,62 +573,89 @@ export function SplitLayout<L extends SplitLayoutLeaf>(props: SplitLayoutProps<L
         }}
       </For>
       <span class="sr-only" role="status">
-        {dropLabel()}
+        {dropLabel() ||
+          (resizeController() === 'error'
+            ? alternateImportAttempts >= 2
+              ? 'Resize controls did not load after repeated attempts. Reloading may discard unsaved pane content.'
+              : 'Resize controls did not load.'
+            : '')}
       </span>
       <For each={branches().map((branch) => branch.id)}>
         {(id) => {
           const initial = branchMap().get(id)!
           const branch: Accessor<SplitLayoutBranch<L>> = () => branchMap().get(id) ?? initial
+          const rect = () => frames().get(id)?.rect ?? { x: 0, y: 0, width: 0, height: 0 }
           return (
-            <Resizable
-              orientation={branch().direction === 'row' ? 'horizontal' : 'vertical'}
-              sizes={[branch().ratio, 1 - branch().ratio]}
-              keyboardDelta={0.05}
-              onSizesChange={(sizes) => {
-                // Corvu also reports panel registration/unregistration while
-                // mounting or disposing a controller. Those incomplete or
-                // hidden-host sizes are not user resize intent.
-                if (!root?.isConnected || root.getClientRects().length === 0) return
-                if (
-                  sizes.length !== 2 ||
-                  sizes.some((size) => !Number.isFinite(size)) ||
-                  Math.abs(sizes[0]! + sizes[1]! - 1) > 0.000001
-                )
-                  return
-                if (sizes[0] !== undefined && Math.abs(sizes[0] - branch().ratio) > 0.000001)
-                  props.onResize(id, sizes[0])
-              }}
-              style={rectStyle(frames().get(id)?.rect ?? { x: 0, y: 0, width: 0, height: 0 })}
-              class="pointer-events-none absolute flex min-h-0 min-w-0 data-[orientation=vertical]:flex-col"
+            <Show
+              when={typeof resizeController() === 'function'}
+              fallback={
+                <div
+                  role="separator"
+                  aria-label={
+                    props.labelForSeparator?.(branch()) ??
+                    (branch().direction === 'row' ? 'Resize pane columns' : 'Resize pane rows')
+                  }
+                  aria-orientation={branch().direction === 'row' ? 'vertical' : 'horizontal'}
+                  aria-controls={listLeaves(branch())
+                    .map((leaf) => domId(leaf.id))
+                    .join(' ')}
+                  aria-valuemin={10}
+                  aria-valuemax={90}
+                  aria-valuenow={Math.round(branch().ratio * 100)}
+                  aria-disabled="true"
+                  tabIndex={-1}
+                  data-direction={branch().direction}
+                  style={separatorPlaceholderStyle(branch(), rect())}
+                  class="pointer-events-none absolute bg-border"
+                />
+              }
             >
-              <Resizable.Panel
-                minSize={MIN_SPLIT_RATIO}
-                maxSize={MAX_SPLIT_RATIO}
-                aria-hidden="true"
-              />
-              <Resizable.Handle
-                aria-label={
-                  props.labelForSeparator?.(branch()) ??
-                  (branch().direction === 'row' ? 'Resize pane columns' : 'Resize pane rows')
-                }
-                aria-orientation={branch().direction === 'row' ? 'vertical' : 'horizontal'}
-                aria-controls={listLeaves(branch())
-                  .map((leaf) => domId(leaf.id))
-                  .join(' ')}
-                aria-valuemin={10}
-                aria-valuemax={90}
-                aria-valuenow={Math.round(branch().ratio * 100)}
-                class="pointer-events-auto relative w-px shrink-0 bg-border after:absolute after:inset-y-0 after:-inset-x-1 after:w-3 focus-visible:bg-primary focus-visible:outline-none hover:bg-primary data-[orientation=vertical]:h-px data-[orientation=vertical]:w-full data-[orientation=vertical]:after:inset-x-0 data-[orientation=vertical]:after:-inset-y-1 data-[orientation=vertical]:after:h-3 data-[orientation=vertical]:after:w-full"
-              />
-              <Resizable.Panel
-                minSize={MIN_SPLIT_RATIO}
-                maxSize={MAX_SPLIT_RATIO}
-                aria-hidden="true"
+              <Dynamic
+                component={resizeController() as ResizeController<L>}
+                branch={branch}
+                rect={() => rectStyle(rect())}
+                domId={domId}
+                root={() => root}
+                labelForSeparator={props.labelForSeparator}
+                onResize={props.onResize}
               />
-            </Resizable>
+            </Show>
           )
         }}
       </For>
+      {resizeController() === 'error' ? (
+        <div class="absolute top-2 right-2 z-(--z-menu) flex max-w-sm flex-col items-end gap-2">
+          {alternateImportAttempts >= 2 ? (
+            <p
+              id={resizeReloadWarningId}
+              role="alert"
+              class="rounded-md border bg-background p-2 text-sm shadow-md"
+            >
+              Reloading may discard unsaved pane content.
+            </p>
+          ) : null}
+          <Button
+            variant="outline"
+            size="sm"
+            data-resize-retry
+            aria-describedby={alternateImportAttempts >= 2 ? resizeReloadWarningId : undefined}
+            onClick={(event) => {
+              if (alternateImportAttempts >= 2) {
+                window.location.reload()
+                return
+              }
+              const ownsFocus = document.activeElement === event.currentTarget
+              focusHandleAfterRetry = ownsFocus
+              focusRecoveryButtonAfterError = ownsFocus
+              focusRestoreEpoch = focusEpoch
+              retryWithAlternateImport = true
+              setResizeController(undefined)
+            }}
+          >
+            {alternateImportAttempts >= 2 ? 'Reload page to retry resizing' : 'Retry pane resizing'}
+          </Button>
+        </div>
+      ) : null}
     </div>
   )
 }

package/dist/r/src/components/theme/index.ts

@@ -11,11 +11,14 @@ export {
   ThemeProvider,
   defaultThemeSelection,
   inlineScriptLiteral,
+  localStoragePersistence,
   resolvedDensity,
   themeScript,
+  useOptionalTheme,
   useTheme,
   type ThemeContextValue,
   type ThemeDensity,
+  type ThemePersistence,
   type ThemeProviderProps,
   type ThemeSelection,
 } from './theme-provider'

package/dist/r/src/components/theme/theme-context.ts

@@ -0,0 +1,43 @@
+import { createContext, useContext, type Context } from 'solid-js'
+import type { ThemeContextValue } from './theme-state'
+
+/**
+ * Where the context object lives: on the global, under a registered symbol.
+ *
+ * A context is an object identity, and a bundle can legitimately load this module
+ * twice — a dev graph where a relative import and a package subpath are distinct
+ * module records, or two copies of the package at different versions. Each copy
+ * would then call `createContext` and own its own object; a provider from one and a
+ * `useOptionalTheme()` from the other would never meet, and the second would return
+ * `undefined` as though no provider were mounted. `Symbol.for` is shared across
+ * every copy in a realm, so they all find the one context the first created.
+ *
+ * Both copies must agree on its shape. The context value only ever grows, which is
+ * why a newer provider under an older reader is safe and the reverse is a missing
+ * member, not a mismatch.
+ */
+const CONTEXT_KEY = Symbol.for('adea.ui.theme')
+
+type ContextHost = { [CONTEXT_KEY]?: Context<ThemeContextValue | undefined> }
+
+export function themeContext(): Context<ThemeContextValue | undefined> {
+  const host = globalThis as ContextHost
+  return (host[CONTEXT_KEY] ??= createContext<ThemeContextValue>())
+}
+
+export function useTheme(): ThemeContextValue {
+  const value = useContext(themeContext())
+  if (!value) throw new Error('useTheme must be called inside a <ThemeProvider>.')
+  return value
+}
+
+/**
+ * The theme context, or `undefined` outside a `ThemeProvider`.
+ *
+ * For a component that can run both ways — a shared control rendered in a harness,
+ * a story, or a host that has not mounted a provider — and would rather degrade
+ * than throw.
+ */
+export function useOptionalTheme(): ThemeContextValue | undefined {
+  return useContext(themeContext())
+}

package/dist/r/src/components/theme/theme-document.ts

@@ -0,0 +1,168 @@
+import {
+  applyAppearanceFontSettings,
+  normalizeAppearanceEditorFontSettings,
+} from '../../lib/appearance-font-settings'
+import {
+  accentVariables,
+  themeCssVariables,
+  type ThemeAppearance,
+  type ThemeVariant,
+} from '../../lib/themes'
+import { resolvedDensity, type ThemeSelection } from './theme-state'
+
+/**
+ * The document half of the theme provider: the single writer of `<html>`.
+ *
+ * Written against the few members of an element it uses, so the rules can be tested
+ * on a stand-in and the provider's effect stays a one-line call.
+ */
+export type ThemeRoot = Pick<
+  HTMLElement,
+  'classList' | 'dataset' | 'style' | 'removeAttribute' | 'setAttribute'
+>
+
+export type ThemeDocumentState = {
+  /** What the document shows: the committed selection, or a preview laid over it. */
+  selection: ThemeSelection
+  appearance: ThemeAppearance
+  variant: ThemeVariant
+}
+
+export type ThemeDocumentOptions = {
+  /**
+   * Rewrites the custom properties just before they are written: the variant's
+   * roles with the accent laid over them. It sees every property of the pass and
+   * must return the full map; a name it drops is not written.
+   */
+  transformTokens?: (tokens: Record<string, string>) => Record<string, string>
+}
+
+/**
+ * The custom properties a state paints: the variant's roles, with the accent
+ * selection laid over them, then `transformTokens`.
+ *
+ * The accent is applied *here* rather than left to the `[data-accent]` blocks in
+ * `theme.css`, because the properties are written inline and an inline declaration
+ * outranks every stylesheet selector however specific it is. The blocks still exist
+ * and are still correct — they are what styles the window before this runs — but
+ * they cannot win from here, so leaving the accent to them meant the attribute was
+ * set, the rules were present, and nothing changed on screen.
+ */
+export function themeDocumentTokens(
+  state: ThemeDocumentState,
+  options: ThemeDocumentOptions = {}
+): { tokens: Record<string, string>; accented: boolean } {
+  const properties = { ...themeCssVariables(state.variant) }
+  const accent = accentVariables(state.selection.accent, state.appearance, state.selection)
+  if (accent) Object.assign(properties, accent)
+  return {
+    tokens: options.transformTokens ? options.transformTokens(properties) : properties,
+    accented: accent !== undefined,
+  }
+}
+
+/**
+ * Write a state onto a root and report which custom properties it owns.
+ *
+ * Pass the previous call's return as `previous` and any palette property that pass
+ * wrote and this one does not is removed. For the catalogue the two sets are the
+ * same, so nothing is ever removed; it matters for a host variant that carries
+ * `tokens` the catalogue does not, which would otherwise stay inline, beating the
+ * stylesheet, after the user switched away from it.
+ */
+export function applyThemeToRoot(
+  root: ThemeRoot,
+  state: ThemeDocumentState,
+  options: ThemeDocumentOptions = {},
+  previous?: ReadonlySet<string>
+): ReadonlySet<string> {
+  const { tokens, accented } = themeDocumentTokens(state, options)
+
+  for (const [name, value] of Object.entries(tokens)) {
+    root.style.setProperty(name, value)
+  }
+  if (previous) {
+    for (const name of previous) {
+      if (!(name in tokens)) root.style.removeProperty(name)
+    }
+  }
+
+  root.classList.toggle('dark', state.appearance === 'dark')
+  root.dataset['theme'] = state.variant.id
+  root.dataset['appearance'] = state.appearance
+  root.style.colorScheme = state.appearance
+
+  if (!accented) root.removeAttribute('data-accent')
+  else root.dataset['accent'] = state.selection.accent
+
+  applyAppearanceFontSettings(
+    root,
+    normalizeAppearanceEditorFontSettings(state.selection.fonts, state.selection.font).settings
+  )
+
+  // Density is a pure token shift, so unlike the colour axes there is nothing to
+  // compute: the attribute selects a block in `theme.css`. It is applied here for
+  // the same reason as the others — this is the one place that knows what the
+  // current selection is, and it is the only writer of these attributes.
+  if (resolvedDensity(state.selection) === 'comfortable') root.removeAttribute('data-density')
+  else root.dataset['density'] = resolvedDensity(state.selection)
+
+  return new Set(Object.keys(tokens))
+}
+
+/** What {@link applyWithoutTransitions} needs of a document. */
+export type TransitionDocument = {
+  head: { appendChild(node: unknown): unknown }
+  createElement(tag: 'style'): {
+    textContent: string | null
+    offsetHeight?: number
+    remove(): void
+  }
+}
+
+/**
+ * Run `apply` with every CSS transition switched off for the frame that carries
+ * it, so a theme switch cannot animate page-wide.
+ *
+ * Without this, flipping the custom properties on `<html>` starts a transition on
+ * every element that declares one, and each fades from the old palette to the new
+ * over its own duration: a theme change that looks like a rendering fault. The
+ * rule is removed two frames later, after the browser has committed the new styles
+ * with transitions off, and `restore` runs it early (the provider calls it when it
+ * is disposed mid-switch).
+ *
+ * `schedule` is the frame source; it defaults to `requestAnimationFrame` and falls
+ * back to running at once where there is none, which leaves transitions on rather
+ * than off.
+ */
+export function applyWithoutTransitions(
+  doc: TransitionDocument,
+  apply: () => void,
+  schedule: (callback: () => void) => void = defaultSchedule
+): () => void {
+  const style = doc.createElement('style')
+  style.textContent = '*{transition:none !important}'
+  doc.head.appendChild(style)
+  // Reading a layout property forces the browser to commit the rule before the
+  // properties change; without it the two can be batched into one style recalc.
+  void style.offsetHeight
+  let removed = false
+  const restore = () => {
+    if (removed) return
+    removed = true
+    style.remove()
+  }
+  try {
+    apply()
+  } catch (error) {
+    restore()
+    throw error
+  }
+  schedule(() => schedule(restore))
+  return restore
+}
+
+function defaultSchedule(callback: () => void): void {
+  if (typeof requestAnimationFrame === 'function') requestAnimationFrame(callback)
+  else callback()
+}