@unrulysystems/native-motion 0.1.0-alpha.0

package/src/native/motion/motionViewController.ts

@@ -0,0 +1,3180 @@
+// Motion.View's brain (specs/M2.2-BUILD-PACKET.md §pinned semantics): validate → resolve → diff →
+// driver commands, factored OUT of the React component so the behavioral checks drive it
+// deterministically against the manual-stepping driver (no React timing in the verification path —
+// the same pure-interior/thin-binding split the core uses). The component wrapper owns only React
+// concerns (hook driver, animated style, prop plumbing); everything semantic lives here and calls
+// core's exported pipeline — no forked resolution logic (REQ-API-017 is the seam this reuses).
+
+import {
+  InvalidTransitionError,
+  validateTransition,
+  assertTargetShape,
+  captureTransition,
+  describeValue,
+  getDefaultTransition,
+  hostCapabilities,
+  DiscreteHostBaseError,
+  InvalidTargetError,
+  isAuto,
+  isDiscreteKeyword,
+  parseColor,
+  parseValue,
+  isLengthTarget,
+  resolveLengthToPx,
+  resolveStartValue,
+  springKeyframeCountRefusal,
+  targetShapeRefusal,
+  transformColor,
+  validateTarget,
+  validateTargetRefusal,
+  type DriverCommand,
+  type ElementHandle,
+  type HostCapabilities,
+  type LengthLayoutContext,
+  type MeasureResolveContextError,
+  type PositionalLengthAxis,
+  type PropTarget,
+  type PropTargetTo,
+  type PropTransition,
+  type ResolvedValue,
+  type RGBA,
+  type Target,
+  type Transition,
+  TARGET_PROPERTY_KEYS,
+} from '@unrulysystems/native-motion-core'
+import { rewritePathCommands, seedPathRotationKey } from './pathTransition'
+import {
+  isNativeMeasureLengthKey,
+  isNativeViewMotionProp,
+  NATIVE_PROPERTY_TRANSITION_OPTIONS,
+  nativeMountTargetValueKind,
+} from './shippedSurface'
+import { TRANSFORM_KEY_NAMES } from './mappedKeys'
+import { keyframeTimingRefusal } from './keyframeTiming'
+
+const TRANSFORM_KEY_SET = new Set<string>(TRANSFORM_KEY_NAMES)
+const TRANSITION_MAP_KEYS = new Set<string>(['default', 'layout', ...TARGET_PROPERTY_KEYS])
+/** Instant property transition for reduced-motion / static / skip paths (pin type:false analog). */
+const INSTANT_TRANSITION: Transition = Object.freeze({ type: 'tween', duration: 0 })
+import {
+  captureBoundedArray,
+  capturedArrayDescription,
+  isRepeatFoldRefusal,
+  resolveTransitionForKey,
+} from '@unrulysystems/native-motion-core/internal-driver'
+import type { WorkletDriverBinding } from '../driver/workletDriver'
+import { IDENTITY_DECLARATIVE_LANE_COMMAND } from './identityValueChannelLaneMarker'
+import { projectColorSequence } from './colorProjection'
+import { projectDiscreteStep } from './discreteProjection'
+
+export interface MotionViewProps {
+  // First-paint state (REQ-API-010): a Target overlays the start values; `false` mounts already AT
+  // the resolved `animate` with no entrance animation; omitted → style/host-base start values.
+  readonly initial?: Target | false | undefined
+  readonly animate: Target
+  readonly transition?: Transition | undefined
+  // Static style passthrough consulted for start values (REQ-API-011). L1: numeric values plus
+  // color strings for rgba-typed keys; the style-merge policy stays a flagged §7 call.
+  readonly style?: Readonly<Record<string, number | string>>
+  // FLAG 5a (REQ-API-020): keys registered STATIC — at their style/host-base start value with no
+  // target and no entrance command — because an external lane drives them (the drag axis through
+  // the driver's write lane). The initial-only-key rule generalized; a key already covered by
+  // animate/initial registers through its normal path and this list is a no-op for it.
+  readonly staticKeys?: readonly string[]
+  /** Internal host identity used solely for element-owned validation diagnostics. */
+  readonly componentId?: MotionComponentId
+}
+
+export type MotionComponentId = '<Motion.View>' | '<Motion.Text>' | '<Motion.Image>'
+
+// L1 (specs/L1-BUILD-PACKET.md §semantics 4): the endpoint-sync port the wrapper provides. Invoked
+// with the CURRENT endpoints at every command entry (mount and each color retarget), BEFORE the
+// driver command is issued, so the animated style's endpoint shared values are never stale when a
+// fresh progress lands — one sync path, no lazily-reconciled state.
+export interface MotionViewControllerHooks {
+  readonly onColorEndpoints?: (key: string, sequence: readonly RGBA[]) => void
+  // T23 B2b: the discrete lane's endpoint publication — the [from, to] keyword pair the animated
+  // style projects through (the onColorEndpoints mirror; primitive-only payload for the crossing).
+  readonly onDiscreteEndpoints?: (key: string, pair: readonly [string, string]) => void
+  // The component's severity channel (review major 42): the R8-F1 spring/keyframe-array compat refusal
+  // for INDIRECT consumers (a gesture/label array riding the element-transition fallback reaches the
+  // controller here, past its supplying gate) is reported + the property dropped in production, thrown
+  // in development. A direct controller consumer defaults to development (the loud law).
+  readonly severity?: NativeSeverity
+  readonly report?: (error: Error) => void
+  // REQ-API-035: live MotionConfig policy box (the wrapper mutates `.current` each render so a
+  // late AccessibilityInfo "user" resolution and isStatic/skipAnimations updates reach the
+  // next command without recreating the controller).
+  readonly motionPolicyBox?: {
+    current: { readonly shouldReduceMotion: boolean; readonly skipAnimations: boolean }
+  }
+  // REQ-VALUETYPE-013: live layout context for measure-resolving %/auto/simple calc length targets.
+  // Wrapper updates `.current` from parent/viewport/content onLayout; missing required fields fail loud.
+  readonly lengthLayoutContextBox?: { current: LengthLayoutContext }
+}
+
+export interface MotionViewController {
+  // Validate + resolve + seed the element and issue the mount command (one `start`, O(1)); throws
+  // InvalidTargetError on a bad target BEFORE any driver mutation (fail-closed, REQ-API-013).
+  mount(): ElementHandle
+  // Diff the RESOLVED next target against the current one; issue ONE `retarget` carrying only the
+  // changed keys, or NO command when nothing changed (unrelated re-render discipline). The return
+  // reports whether any driver command was emitted so lifecycle gates can settle a zero-delta exit
+  // synchronously instead of waiting for an onAllSettled edge that cannot occur.
+  update(next: {
+    readonly animate: Target
+    readonly transition?: Transition | undefined
+    /**
+     * Internal variant-lane execution edge. Motion restarts an element-wise equal keyframe
+     * target when its authored variant label changes, while ordinary equal-target updates
+     * remain no-ops. Scalars are deliberately unaffected.
+     */
+    readonly restartEqualKeyframes?: boolean | undefined
+    // AnimatePresence's one removal-boundary snapshot. Only null-first targets consume it; ordinary
+    // updates keep reading the driver's current value at their own command boundary.
+    readonly removalValues?: Readonly<Record<string, ResolvedValue>> | undefined
+    /**
+     * Deferred-length pending queue scope (review-1785219035198-7rbpy5):
+     * - `'partial'` (default): gesture/label slices — never treat key absence as abandonment
+     * - `'full'`: declarative animate snapshot (host prop) — keys absent from animate are abandoned
+     */
+    readonly animateScope?: 'partial' | 'full'
+    /**
+     * Internal — the deferred flush's own re-entry (review 356417a77aec): the flush resolves
+     * auto targets against the measure it just seeded, so the retarget invalidation must not
+     * drop that fresh measure. Only flushDeferredLengthMeasures sets this.
+     */
+    readonly skipAutoMeasureInvalidation?: boolean
+    /**
+     * T21 (REQ-API-053) — the orchestration-computed per-child start delay (seconds; negative
+     * = elapsed-time offset). Applied as the per-key DEFAULT under any authored delay (the
+     * pin's `{ delay, ...getValueTransition }` spread, visual-element-target.ts:87-90). Set
+     * only by the variant tree's label-application lane; finite or the update fails loud.
+     */
+    readonly orchestrationDelaySeconds?: number | undefined
+  }): boolean
+  /**
+   * First-mount element-box measures (auto, x/y %): keys registered at host base while
+   * onLayout was pending. Call after autoWidth/autoHeight land so deferred targets command
+   * without violating the fixed-at-mount key set (REQ-VALUETYPE-013).
+   */
+  /**
+   * Flush pending measure-resolved keys. Optional `held` excludes gesture-held keys so mid-hold
+   * onLayout does not retarget protected keys (review-1785230277710-lhz6ub).
+   */
+  flushDeferredLengthMeasures(held?: ReadonlySet<string>): boolean
+  /**
+   * Re-seed settled auto-resting AND relative-resting keys to their freshly measured values
+   * (reviews ae0a42832d85 + 7cec8ad963d8): an auto-rest key releases to the intrinsic layout at
+   * settle so content drift shows up in onLayout directly; an initial-only relative rest
+   * (%/calc/vw/vh) re-resolves its kept form against the changed element box / parent /
+   * viewport. Both re-seed INSTANT (never an animation — the element already tracks the
+   * measure). Keys mid-animation are skipped. Returns whether any re-seed commanded.
+   */
+  remeasureAutoRests(): boolean
+  /**
+   * Rebuild deferred-length pending from a declarative animate snapshot without issuing
+   * driver commands or re-running keyframe/element-transition compatibility (label full
+   * projection after per-label updates — review-1785226634574-2gxseb).
+   */
+  syncDeferredLengthPending(next: {
+    readonly animate: Target
+    readonly animateScope?: 'partial' | 'full'
+  }): void
+  // The projected rgba() string a color key currently renders (L1, specs/L1-BUILD-PACKET.md
+  // §semantics 3): the SAME projectColor seam the animated style binds, evaluated at the driver's
+  // live progress — the deterministic observable the checks drive.
+  currentColor(key: string): string
+  // The discrete deterministic observable (T23 B2b): the keyword displayed at the live progress,
+  // through the SAME projectDiscreteStep seam the animated style binds.
+  currentDiscrete(key: string): string
+  /**
+   * T23 B3 (pin visual-element-target.ts:159-168): JUMP-apply the latest target's transitionEnd
+   * values — instantly, never animated. Every key must be mounted (fixed-at-mount law); each
+   * family jumps on its own lane (numeric INSTANT retarget; discrete/color settled re-seed +
+   * INSTANT progress start on an EQUAL pair, which projects the jumped value at any progress) and
+   * moves its diff base so a later identical animate target is a no-op.
+   */
+  applyTransitionEnd(target: Readonly<Record<string, unknown>>): void
+  // T23 C: project the driver marshal's raw committed record (progress lanes) to the public
+  // latest-values record the onUpdate callback receives. Pure JS; shares the currentColor /
+  // currentDiscrete projection seams.
+  projectLatestValues(
+    raw: Readonly<Record<string, number>>,
+  ): Readonly<Record<string, string | number>>
+  // Immutable removal-boundary snapshot for Presence (REQ-PRESENCE-020). Reads every registered
+  // property's actual committed host value; colors are projected to the string currently displayed.
+  committedValues(keys: readonly string[]): Readonly<Record<string, ResolvedValue>>
+  /** Fresh pin-shaped maps for functional animation definitions. */
+  variantValueState(): {
+    readonly current: Readonly<Record<string, ResolvedValue>>
+    readonly velocity: Readonly<Record<string, number>>
+  }
+  // Deactivate before release (REQ-DRIVER-020 window-shrink).
+  unmount(): void
+}
+
+// The native host declaration, built from the registry so it can never drift from membership — the
+// same construction the conformance scenarios use.
+const NATIVE_HOST: HostCapabilities = hostCapabilities('native', ['universal', 'native-extension'])
+
+// The single validation entry the wrapper AND the controller share, so fail-loud ordering can never
+// fork: an invalid/unknown/off-host key throws core's InvalidTargetError (REQ-API-013/014) BEFORE any
+// other wrapper concern (review cycle 2: a scope guard running first swallowed the pipeline error).
+// The property lane's full transition law (r9 major 762e9d0a4c77): core executability PLUS
+// this lane's executable option set — an option the lane cannot execute (velocity) fails loud on a
+// direct consumer instead of riding along inert (G-INV-8). Transition maps resolve to the actual
+// mounted property keys before this lane-specific option check; core still validates every map branch.
+function validatePropertyLaneTransition(
+  transition: Transition | undefined,
+  componentId: MotionComponentId,
+  propertyKeys: readonly string[] = ['__root__'],
+): void {
+  validateTransition(transition, { componentId })
+  if (transition === undefined) return
+  if (
+    Reflect.ownKeys(transition).some(
+      (key) => typeof key === 'string' && TRANSITION_MAP_KEYS.has(key),
+    )
+  ) {
+    const selectedKeys = propertyKeys.length === 0 ? ['__root__'] : propertyKeys
+    for (const key of new Set(selectedKeys)) {
+      validatePropertyLaneTransition(resolveTransitionForKey(transition, key), componentId)
+    }
+    return
+  }
+  for (const option of Reflect.ownKeys(transition)) {
+    if (typeof option !== 'string' || TRANSITION_MAP_KEYS.has(option)) continue // core's closed-schema validator already rejects symbols
+    const value = (transition as Record<string, unknown>)[option]
+    if (value === undefined) continue // explicitly-undefined reads as absent (core semantics)
+    if (!NATIVE_PROPERTY_TRANSITION_OPTIONS.has(option)) {
+      throw new InvalidTransitionError(
+        componentId,
+        option,
+        value,
+        `not executable by the property lane (it drives: ` +
+          `${NATIVE_PROPERTY_TRANSITION_OPTIONS.options.join(', ')}) — a silently inert ` +
+          'option is refused (G-INV-8, shippedSurface.ts)',
+      )
+    }
+  }
+  for (const mapKey of Reflect.ownKeys(transition)) {
+    if (typeof mapKey !== 'string' || !TRANSITION_MAP_KEYS.has(mapKey)) continue
+    const bag = (transition as Record<string, unknown>)[mapKey]
+    if (typeof bag !== 'object' || bag === null || Array.isArray(bag)) continue
+    for (const option of Reflect.ownKeys(bag)) {
+      if (typeof option !== 'string' || option === 'inherit' || TRANSITION_MAP_KEYS.has(option))
+        continue
+      const value = (bag as Record<string, unknown>)[option]
+      if (value === undefined || NATIVE_PROPERTY_TRANSITION_OPTIONS.has(option)) continue
+      throw new InvalidTransitionError(
+        componentId,
+        option,
+        value,
+        'not executable by the property lane (it drives: ' +
+          NATIVE_PROPERTY_TRANSITION_OPTIONS.options.join(', ') +
+          ') — a silently inert option is refused (G-INV-8, shippedSurface.ts)',
+      )
+    }
+  }
+}
+
+export function validateAgainstNativeHost(
+  target: Readonly<Record<string, unknown>>,
+  componentId: MotionComponentId = '<Motion.View>',
+): void {
+  validateTarget(target, NATIVE_HOST, { componentId })
+}
+
+// Capture the per-call transition ONCE and validate the SNAPSHOT (review majors 51/61): a malformed
+// non-object shape (null is never absence) is refused on the RAW, an object is CAPTURED then validated —
+// so the values the driver commands run are EXACTLY the values validation saw. A malicious accessor
+// (`duration` 0.2 to validation, -1 after) cannot show validation one value and the command another; the
+// getter is read exactly once. `undefined` is absence (rides the default). Returns the frozen snapshot.
+function captureAndValidateTransition(
+  raw: Transition | undefined,
+  componentId: MotionComponentId,
+  propertyKeys: readonly string[] = ['__root__'],
+): Transition | undefined {
+  if (raw === undefined) return undefined
+  // A CHEAP shape gate that reads NO option value (review majors 61/63): a primitive, null, array, or
+  // prototype-carrying object like `Date` retains the TYPED refusal — capturing it would launder an array
+  // / `Date` into an empty `{}`. Then capture the option values EXACTLY ONCE and validate the SNAPSHOT as
+  // the single truth: the getter is read once (the capture), the snapshot is what validation AND every
+  // command see, and the null-proto capture keeps an own `__proto__` as an own key so it reaches the
+  // snapshot validator. A second-read-throwing/stateful-but-legal object is materialized once, not reread.
+  const proto = typeof raw === 'object' && raw !== null ? Object.getPrototypeOf(raw) : undefined
+  if (
+    typeof raw !== 'object' ||
+    raw === null ||
+    Array.isArray(raw) ||
+    (proto !== Object.prototype && proto !== null)
+  ) {
+    throw new InvalidTransitionError(
+      componentId,
+      '(transition)',
+      raw,
+      'a transition must be a plain object of transition options — a primitive, array, or ' +
+        'prototype-carrying object is refused (REQ-API-013; a malformed config never coerces to default)',
+    )
+  }
+  const snapshot = captureTransition(raw)
+  validatePropertyLaneTransition(snapshot, componentId, propertyKeys)
+  return snapshot
+}
+
+// L1 (specs/L1-BUILD-PACKET.md): rgba-typed keys animate by scalar progress through the numeric
+// driver seam (REQ-DRIVER-014 unchanged); everything else stays numeric fast-tier. The registry is
+// the single classification source — the same table the web engine's disposition rides.
+function isColorKey(key: string): boolean {
+  return nativeMountTargetValueKind(key) === 'color'
+}
+
+// T23 B2b: discrete-typed keys (display/visibility) ride the color lane's [0,100] progress
+// convention with a projected KEYWORD (a step or a constant, per REQ-VALUETYPE-015's two paths)
+// — same single classification source.
+function isDiscreteKey(key: string): boolean {
+  return nativeMountTargetValueKind(key) === 'discrete'
+}
+
+// Positional length keys that Motion measure-resolves (DOMKeyframesResolver positionalValues).
+// The ONE authority is shippedSurface's NATIVE_MEASURE_LENGTH_KEYS — the variants gate reads the
+// same set, so it never admits a length string this lane cannot execute (review b3c3dd6b431a).
+function isPositionalLengthKey(key: string): key is PositionalLengthAxis {
+  return isNativeMeasureLengthKey(key)
+}
+
+function isMeasureResolvedLengthString(value: unknown): value is string {
+  if (typeof value !== 'string') return false
+  // Total verdict predicate — never bare catch over parseLengthTarget (unexpected faults propagate
+  // from resolveLengthToPx / parseLengthTarget throw path elsewhere).
+  return isLengthTarget(value)
+}
+
+// Trim-insensitive auto detection over a scalar or ANY keyframe element (review 356417a77aec):
+// " AUTO " parses as auto, so the retarget re-measure and the unconstrained-paint detector must
+// recognize it too — and a keyframe array re-measures when any element is auto.
+function containsAutoLengthTarget(value: unknown): boolean {
+  if (typeof value === 'string') return isAuto(value)
+  return (
+    Array.isArray(value) && value.some((element) => typeof element === 'string' && isAuto(element))
+  )
+}
+
+// Mount-refused keys drop out of a later update/sync target (review 39c6a3e7ee90): the mount's
+// severity-channel report is the one notice; subsequent applications of the same refused
+// property are refused through the same law rather than crashing the fixed-at-mount invariant.
+function dropMountRefusedKeys(target: Target, mountRefusedKeys: ReadonlySet<string>): Target {
+  if (mountRefusedKeys.size === 0) return target
+  const kept: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(target as Record<string, unknown>)) {
+    if (!mountRefusedKeys.has(key)) kept[key] = value
+  }
+  return kept as Target
+}
+
+// The FINAL resting form of a target (review 1578a42974bc): only a final AUTO keyframe rests at
+// auto — an auto MIDDLE keyframe ([0,'auto',100]) is a measurement episode whose resting form is
+// the numeric final value, and a % origin-only settle is a % measure episode. Auto-rest tracking
+// (release + drift re-seed) reads this, never the broader "contains an auto" measure test.
+function restsAtAutoForm(value: unknown): boolean {
+  if (typeof value === 'string') return isAuto(value)
+  if (Array.isArray(value) && value.length > 0) {
+    const last = value[value.length - 1]
+    return typeof last === 'string' && isAuto(last)
+  }
+  return false
+}
+
+// A scalar RELATIVE measure form (review 7cec8ad963d8): %/calc/vw/vh — everything the measure
+// lane resolves except auto (auto owns its own rest lane). Initial-only relative settles keep
+// these forms so a later element/parent/viewport change re-measures them.
+function isRelativeLengthForm(value: unknown): value is string {
+  return typeof value === 'string' && !isAuto(value) && isLengthTarget(value)
+}
+
+// The FINAL element of a target rests at a RELATIVE measure form (review 26cc511b0927): a
+// scalar relative string, or a keyframe array whose last keyframe is one.
+function restsAtRelativeForm(value: unknown): boolean {
+  if (typeof value === 'string') return isRelativeLengthForm(value)
+  if (Array.isArray(value) && value.length > 0) {
+    const last = value[value.length - 1]
+    return typeof last === 'string' && isRelativeLengthForm(last)
+  }
+  return false
+}
+
+// Element-wise identity of two keyframe arrays (the AUTHORED shape, not the resolved values) —
+// a context-only re-resolution presents the same raw array (review 26cc511b0927).
+function sameRawKeyframes(a: unknown, b: unknown): boolean {
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false
+  for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false
+  return true
+}
+
+// L1 scope + R13 value-breadth (REQ-VALUETYPE-013): numeric OR measure-resolved length string.
+// Measure-required forms resolve through layout context; bare unitless/px strings parse to numbers.
+function numericValue(
+  key: string,
+  value: unknown,
+  layoutContext: LengthLayoutContext = {},
+): number {
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw new Error(`L1 scope: target '${key}' is non-finite ${value}`)
+    }
+    return value
+  }
+  if (
+    typeof value === 'string' &&
+    isPositionalLengthKey(key) &&
+    isMeasureResolvedLengthString(value)
+  ) {
+    return resolveLengthToPx(value, key, layoutContext)
+  }
+  throw new Error(
+    `L1 scope: target '${key}' is ${JSON.stringify(value)}; only numeric values or measure-resolved ` +
+      'length strings (%/auto/simple calc/px) are driven for non-color keys (REQ-VALUETYPE-013).',
+  )
+}
+
+/**
+ * Cross-bundle safe: class identity can diverge between core source/dist and the consumer.
+ * Match on name + reason field rather than `instanceof`.
+ */
+function measureResolveContextReason(error: unknown): string | null {
+  if (!(error instanceof Error)) return null
+  if (error.name !== 'MeasureResolveContextError') return null
+  const reason = (error as { reason?: unknown }).reason
+  return typeof reason === 'string' ? reason : null
+}
+
+/**
+ * Typed / shape refusals that own the severity boundary. Unexpected dependency faults
+ * (non-Error throws, non-boundary Errors) always propagate — never message-regex classification.
+ */
+function isMeasureResolveBoundaryError(error: unknown): error is Error {
+  if (measureResolveContextReason(error) !== null) return true
+  if (!(error instanceof Error)) return false
+  // L1 shape refusals are constructed only in this module with a fixed prefix.
+  return (
+    error.message.startsWith('L1 scope: target ') || error.message.startsWith('L1 scope: keyframe ')
+  )
+}
+
+/** Element-box measures (auto, x/y %) arrive from onLayout after first mount — defer, never drop key. */
+function isDeferrableElementMeasureError(error: unknown): error is MeasureResolveContextError {
+  return measureResolveContextReason(error) === 'missing-element-measure'
+}
+
+/**
+ * The tri-state origin resolution (review 763d6bcb0194): a production-refused NONDEFERRABLE
+ * origin and an element-measure deferral must never share one null — the refused property is
+ * dropped (one report, fired exactly once HERE), a deferred origin waits for the element box.
+ */
+type OriginResolution =
+  | { readonly kind: 'resolved'; readonly value: number }
+  | { readonly kind: 'deferred' }
+  | { readonly kind: 'refused' }
+
+function resolveNumericKeyVerdict(
+  key: string,
+  value: unknown,
+  layoutContext: LengthLayoutContext,
+  severity: 'development' | 'production',
+  report: (error: Error) => void,
+): OriginResolution {
+  try {
+    return { kind: 'resolved', value: numericValue(key, value, layoutContext) }
+  } catch (error) {
+    if (isDeferrableElementMeasureError(error)) return { kind: 'deferred' }
+    if (!isMeasureResolveBoundaryError(error)) throw error
+    if (severity === 'development') throw error
+    report(error)
+    return { kind: 'refused' }
+  }
+}
+
+/**
+ * Resolve one numeric target under severity (major a41d97e260cb): missing layout context for
+ * parent/%/viewport reports+drops in production; development throws. Element-measure misses
+ * return null with `defer` so the host can register the key and flush after onLayout.
+ */
+function resolveNumericKeyWithSeverity(
+  key: string,
+  value: unknown,
+  layoutContext: LengthLayoutContext,
+  severity: 'development' | 'production',
+  report: (error: Error) => void,
+): number | null {
+  try {
+    return numericValue(key, value, layoutContext)
+  } catch (error) {
+    if (isDeferrableElementMeasureError(error)) {
+      // First-mount path: host registers the key and flushes after onLayout supplies auto sizes.
+      return null
+    }
+    if (!isMeasureResolveBoundaryError(error)) throw error
+    if (severity === 'development') throw error
+    report(error)
+    return null
+  }
+}
+
+// L1 typed entry gate (packet §semantics 6): a color endpoint must be a string core's parseColor
+// accepts. Core validation already rejects wrong-primitive values (InvalidTargetError names the
+// key — observed in the RED run); this gate wraps the PARSE failure with the key context.
+function colorValue(key: string, value: unknown): RGBA {
+  if (typeof value !== 'string') {
+    throw new Error(
+      `L1: color target '${key}' is ${JSON.stringify(value)}; an rgba-typed key takes a color ` +
+        'string (specs/L1-BUILD-PACKET.md §semantics 6).',
+    )
+  }
+  // No parse catch (M3 r8 major b9eb82c0d429): every colorValue call site runs POST-gate,
+  // where core validation already proved the string parses — a throw here is a dependency
+  // fault or a core/L1 skew bug and must propagate loud, never be re-wrapped.
+  return parseColor(value)
+}
+
+// The driver's internal progress convention for non-numeric values (REQ-SPRING-013): a color prop
+// registers at PROGRESS_START and animates to PROGRESS_END; projection divides by PROGRESS_END.
+const PROGRESS_START = 0
+const PROGRESS_END = 100
+
+// A RAW color TARGET value (R8 M2, review major 35): a scalar color string → its RGBA, OR a color
+// keyframe ARRAY → its parsed RGBA sequence with a null-FIRST element kept as `null` (from-current,
+// R8-F2 — substituted by the caller's live color in buildColorSequence). Core validation already
+// proved a same-value-type array whose only legal null is index 0.
+type ColorTarget = RGBA | readonly (RGBA | null)[]
+function colorTargetValue(key: string, value: unknown): ColorTarget {
+  if (Array.isArray(value)) {
+    return value.map((element, index) => {
+      if (element === null) return null // legal ONLY at index 0 (validated upstream); seeded from live
+      if (typeof element !== 'string') {
+        throw new Error(
+          `L1: color keyframe '${key}[${index}]' is ${JSON.stringify(element)}; a color keyframe ` +
+            'is a color string (REQ-API-033 / specs/L1-BUILD-PACKET.md §semantics 6).',
+        )
+      }
+      return parseColor(element)
+    })
+  }
+  return colorValue(key, value)
+}
+
+// The color TARGETS of a target (raw scalar RGBA or a keyframe RGBA sequence), each through the gate.
+function resolveColors(target: Target): Record<string, ColorTarget> {
+  const resolved: Record<string, ColorTarget> = {}
+  for (const key of Object.keys(target)) {
+    if (!isColorKey(key)) continue
+    resolved[key] = colorTargetValue(key, (target as Record<string, unknown>)[key])
+  }
+  return resolved
+}
+
+function isColorArrayTarget(target: ColorTarget): target is readonly (RGBA | null)[] {
+  return Array.isArray(target)
+}
+
+// The typed entry gate for a discrete target (T23 B2b): a SINGLE keyword string of the discrete
+// FAMILY. isDiscreteKeyword pre-guards the parse (a letters-only string can never throw in
+// parseValue), and the family verdict catches keywords other families own ('auto', named colors).
+// Keyframe ARRAYS are not chartered for discrete keys — refuse loud, never a silent scalar pick.
+function discreteValue(key: string, value: unknown): string {
+  if (Array.isArray(value)) {
+    throw new Error(
+      `T23: discrete keyframe arrays are not implemented — '${key}' takes a single keyword ` +
+        'target (scalar display/visibility only).',
+    )
+  }
+  if (
+    typeof value !== 'string' ||
+    !isDiscreteKeyword(value) ||
+    parseValue(value).kind !== 'discrete'
+  ) {
+    throw new Error(
+      `T23: discrete target '${key}' is ${JSON.stringify(value)}; a display/visibility target ` +
+        "is a single CSS keyword string (e.g. 'flex'/'none'/'visible'/'hidden').",
+    )
+  }
+  return value
+}
+
+// The discrete TARGETS of a target, each through the gate (the resolveColors mirror).
+function resolveDiscretes(target: Target): Record<string, string> {
+  const resolved: Record<string, string> = {}
+  for (const key of Object.keys(target)) {
+    if (!isDiscreteKey(key)) continue
+    resolved[key] = discreteValue(key, (target as Record<string, unknown>)[key])
+  }
+  return resolved
+}
+
+// Build the live RGBA SEQUENCE the driver's progress maps through (major 35): a SCALAR color target is
+// the from-current 2-color `[fromColor, target]` (the sealed scalar-color lane); a color ARRAY is its
+// parsed sequence with a null-FIRST element substituted by `fromColor` (R8-F2 from-current).
+function buildColorSequence(target: ColorTarget, fromColor: RGBA): readonly RGBA[] {
+  if (!isColorArrayTarget(target)) return [fromColor, target]
+  return target.map((element) => element ?? fromColor)
+}
+
+// The evenly-spaced numeric PROGRESS keyframe array for an N-color sequence (major 35): [0, …, 100]
+// with N points, so the shipped keyframe generator owns offsets/per-segment easing/duration while the
+// projector maps progress → the color segment. N ≥ 2 (a color target is ≥2 keyframes).
+function colorProgressArray(n: number): readonly number[] {
+  return Array.from({ length: n }, (_, i) => (i / (n - 1)) * PROGRESS_END)
+}
+
+// The SETTLED color of a color target — where the key rests once the animation completes (the LAST
+// keyframe; a scalar rests at itself). Used to register a constant color (initial={false} / initial-
+// only). The last element is non-null (validation guarantees a null only at index 0).
+function settledColor(key: string, target: ColorTarget): RGBA {
+  if (!isColorArrayTarget(target)) return target
+  const last = target[target.length - 1]
+  if (last === null || last === undefined) {
+    throw new Error(`color keyframe array '${key}' has no final color (REQ-API-033).`)
+  }
+  return last
+}
+
+// The canonical string of a WHOLE color target — the diff base for the M2.2 no-op invariant (review
+// major 37). A scalar is its rgba() projection; an ARRAY is EVERY keyframe joined (a null-first element,
+// from-current R8-F2, is its own marker), so two sequences that share endpoints but differ in a MIDDLE
+// keyframe (red→green→blue vs red→yellow→blue) canonicalize DIFFERENTLY and correctly re-command — the
+// old settled-color-only diff wrongly treated them as equal and continued the stale trajectory.
+const FROM_CURRENT_MARKER = '~from-current~'
+function colorTargetCanonical(target: ColorTarget): string {
+  if (!isColorArrayTarget(target)) return transformColor(target)
+  return target
+    .map((element) => (element === null ? FROM_CURRENT_MARKER : transformColor(element)))
+    .join('|')
+}
+
+// A validated ANIMATE target value: a scalar number OR a numeric keyframe ARRAY (REQ-API-033, R8 M2).
+// Core validation already proved a well-formed same-value-type keyframe array (length ≥2, null only at
+// index 0); this gate rides it into the numeric lane and fails loud on any other shape (a unit string
+// stays the flagged L1 stretch). Distinct from `numericValue` (start/from values, scalar-only).
+function numericTargetValue(
+  key: string,
+  value: unknown,
+  layoutContext: LengthLayoutContext = {},
+): number | PropTargetTo {
+  if (typeof value === 'number') return value
+  // Materialize the array ONCE into a frozen snapshot (review major 30): the driver + `current` diff
+  // base then hold the single truth, never aliasing caller memory a later mutation/accessor would skew.
+  if (Array.isArray(value)) {
+    const elements = value.map((element, index) => {
+      if (element === null && index === 0) return null
+      if (typeof element === 'number') return element
+      if (
+        typeof element === 'string' &&
+        isPositionalLengthKey(key) &&
+        isMeasureResolvedLengthString(element)
+      ) {
+        return resolveLengthToPx(element, key, layoutContext)
+      }
+      throw new Error(
+        `L1 scope: keyframe '${key}[${index}]' is ${JSON.stringify(element)}; only numeric or ` +
+          'measure-resolved length values are driven (REQ-VALUETYPE-013).',
+      )
+    })
+    return Object.freeze(elements) as PropTargetTo
+  }
+  if (
+    typeof value === 'string' &&
+    isPositionalLengthKey(key) &&
+    isMeasureResolvedLengthString(value)
+  ) {
+    return resolveLengthToPx(value, key, layoutContext)
+  }
+  throw new Error(
+    `L1 scope: target '${key}' is ${JSON.stringify(value)}; only a numeric value, measure-resolved ` +
+      'length string, or numeric keyframe array is driven for non-color keys (REQ-VALUETYPE-013).',
+  )
+}
+
+// Resolve a validated ANIMATE target for the numeric lane: scalars pass through, a numeric keyframe
+// array rides as its PropTargetTo; color keys are EXCLUDED (they ride the progress convention).
+// Element-measure misses (auto / x|y %) go to `deferred` so mount can register the key and flush
+// after onLayout — never drop from the fixed-at-mount key set.
+function resolveAnimateTargets(
+  target: Target,
+  layoutContext: LengthLayoutContext = {},
+  severity: 'development' | 'production' = 'development',
+  report: (error: Error) => void = (): void => {},
+): {
+  readonly resolved: Record<string, number | PropTargetTo>
+  readonly deferred: Record<string, unknown>
+} {
+  const resolved: Record<string, number | PropTargetTo> = {}
+  const deferred: Record<string, unknown> = {}
+  for (const key of Object.keys(target)) {
+    if (isColorKey(key) || isDiscreteKey(key)) continue
+    const raw = (target as Record<string, unknown>)[key]
+    try {
+      resolved[key] = numericTargetValue(key, raw, layoutContext)
+    } catch (error) {
+      if (isDeferrableElementMeasureError(error)) {
+        deferred[key] = raw
+        continue
+      }
+      if (!isMeasureResolveBoundaryError(error)) throw error
+      if (severity === 'development') throw error
+      report(error)
+    }
+  }
+  return { resolved, deferred }
+}
+
+/** Host-base numeric seed when a measure-required animate target is deferred to first onLayout. */
+function deferredRegistrationSeed(
+  key: string,
+  style: MotionViewProps['style'],
+  layoutContext: LengthLayoutContext,
+  severity: 'development' | 'production',
+  report: (error: Error) => void,
+): number {
+  const start = resolveStartValue(key, style !== undefined ? { style } : {})
+  if (typeof start === 'number' && Number.isFinite(start)) return start
+  if (
+    typeof start === 'string' &&
+    isPositionalLengthKey(key) &&
+    isMeasureResolvedLengthString(start)
+  ) {
+    try {
+      return resolveLengthToPx(start, key, layoutContext)
+    } catch (error) {
+      if (isDeferrableElementMeasureError(error)) return 0
+      if (!isMeasureResolveBoundaryError(error)) throw error
+      if (severity === 'development') throw error
+      report(error)
+      return 0
+    }
+  }
+  return 0
+}
+
+type PendingDeferredLengthTarget = Readonly<{
+  /** Raw animate endpoint; resolved only after the element box exists. Absent on an
+   *  initial-only pending origin (review 73044cc0e1bd) until an update pairs one. */
+  to?: unknown
+  /** Raw first-mount origin when it too requires the element box. */
+  from?: unknown
+  /** The deferring application's OWN transition (review 93aeec05a9a8): R7 law (b) submits
+   *  label applications separately — ownership stays per entry, so a later application can
+   *  never overwrite an earlier one's transition. An explicit null means the deferring
+   *  application authored NO transition and owns the DEFAULT (review 7d395c90c954) —
+   *  absence of a transition is an ownership state, never "retain the prior application's".
+   *  Absent → the mount fallback. */
+  transition?: Transition | null
+}>
+
+type PendingDeferredLengthTargets = Record<string, PendingDeferredLengthTarget>
+
+function deferredTargetsFrom(target: Record<string, unknown>): PendingDeferredLengthTargets {
+  const pending: PendingDeferredLengthTargets = {}
+  for (const [key, to] of Object.entries(target)) pending[key] = { to }
+  return pending
+}
+
+// A transition object with at least one DEFINED option (review major 38): Motion treats an empty `{}`
+// (and one whose every value is explicitly `undefined`) as NO transition — defaults apply — so it must
+// not suppress the count-aware per-prop default. An explicitly-undefined option reads as absent (the R6
+// option law), so it does not count as "defined".
+function hasDefinedTransition(transition: Transition | undefined): boolean {
+  if (transition === undefined) return false
+  return Reflect.ownKeys(transition).some(
+    (key) => typeof key === 'string' && (transition as Record<string, unknown>)[key] !== undefined,
+  )
+}
+
+// transition-default-selection F6: the pin's `isTransitionDefined` exempts EXACTLY these
+// orchestration keys (motion-dom@12.42.2 utils/is-transition-defined.ts:4-29) — a flat bag whose
+// every defined field is one of them is NOT a defined transition, so `animateMotionValue` merges
+// the per-key default UNDER it (motion-value.ts:68-70 → utils/default-transitions.ts:35-48). The
+// flat arm of perPropTransition is that pin seam and takes the pin's full list;
+// TRANSITION_ORCHESTRATION_KEYS below stays the map branch's own (narrower) executable check.
+const TRANSITION_DEFINED_EXEMPT_KEYS = new Set([
+  'when',
+  'delay',
+  'delayChildren',
+  'staggerChildren',
+  'staggerDirection',
+  'repeat',
+  'repeatType',
+  'repeatDelay',
+  'from',
+  'elapsed',
+])
+
+/**
+ * Seed the T21 orchestration-computed delay as the per-key DEFAULT (REQ-API-053). Pin law
+ * (visual-element-target.ts:87-90): every value transition is `{ delay, ...getValueTransition }`
+ * — the computed delay applies wherever no delay is authored, and an authored delay at any
+ * altitude replaces it. Flat bags seed at the root; map bags seed each REPLACING property/
+ * `default` entry plus the root, so core resolveTransitionForKey's key → default → root
+ * precedence carries the default to unmapped keys; `inherit: true` entries are left alone
+ * (the merged root supplies the default at the correct precedence). The `layout` entry is
+ * NEVER seeded — orchestration is a property-lane concern and the layout builder owns its
+ * own delay consumption.
+ */
+// alloc-ok: lifecycle-edge — runs once per orchestrated update, never per frame.
+function seedOrchestrationDelay(
+  transition: Transition | undefined,
+  delaySeconds: number,
+): Transition {
+  if (!Number.isFinite(delaySeconds)) {
+    throw new Error(
+      `motionViewController: orchestrationDelaySeconds must be finite, got ${String(delaySeconds)} ` +
+        '— the upstream per-child resolver is broken (internal invariant, REQ-API-053)',
+    )
+  }
+  // The seed is written LAST so an own explicit `delay: undefined` (ABSENT under the R6 option
+  // law) cannot re-erase it via spread order (review r1 major 3).
+  const seedFlat = (bag: Transition): Transition =>
+    (bag as { delay?: number }).delay !== undefined
+      ? bag
+      : (Object.freeze({ ...bag, delay: delaySeconds }) as Transition)
+  if (transition === undefined) return Object.freeze({ delay: delaySeconds }) as Transition
+  if (!hasTransitionMap(transition)) return seedFlat(transition)
+  const seeded: Record<string, unknown> = {}
+  for (const key of Reflect.ownKeys(transition)) {
+    if (typeof key !== 'string') continue
+    const value = (transition as Record<string, unknown>)[key]
+    // An `inherit: true` entry is NEVER pre-seeded (review r1 major 3): resolveTransitionForKey
+    // merges root-under-child for it, so the seeded ROOT already supplies the computed default
+    // at the lowest precedence — pre-seeding the child would sit the computed delay ABOVE the
+    // root's AUTHORED delay in that merge. Replacing entries (no inherit) drop the root, so
+    // they take the seed directly, reproducing the pin's `{ delay, ...getValueTransition }`.
+    seeded[key] =
+      key !== 'layout' &&
+      TRANSITION_MAP_KEYS.has(key) &&
+      typeof value === 'object' &&
+      value !== null &&
+      (value as { inherit?: boolean }).inherit !== true
+        ? seedFlat(value as Transition)
+        : value
+  }
+  return seedFlat(seeded as Transition)
+}
+
+const TRANSITION_ORCHESTRATION_KEYS = new Set(['delay', 'repeat', 'repeatType', 'repeatDelay'])
+
+function hasExecutableTransition(transition: Transition | undefined): boolean {
+  if (transition === undefined) return false
+  for (const key of Reflect.ownKeys(transition)) {
+    if (
+      typeof key === 'string' &&
+      (transition as Record<string, unknown>)[key] !== undefined &&
+      !TRANSITION_ORCHESTRATION_KEYS.has(key)
+    )
+      return true
+  }
+  return false
+}
+
+function definedTransitionFields(transition: Transition): Transition {
+  const defined: Record<string, unknown> = {}
+  for (const key of Reflect.ownKeys(transition)) {
+    if (typeof key !== 'string') continue
+    const value = (transition as Record<string, unknown>)[key]
+    if (value !== undefined) defined[key] = value
+  }
+  return defined as Transition
+}
+
+function transitionForProperty(
+  transition: Transition | undefined,
+  key: string,
+): Transition | undefined {
+  if (transition === undefined) return undefined
+  if (
+    !Reflect.ownKeys(transition).some(
+      (mapKey) => typeof mapKey === 'string' && TRANSITION_MAP_KEYS.has(mapKey),
+    )
+  )
+    return transition
+  return resolveTransitionForKey(transition, key)
+}
+
+function effectiveTransitionForProperty(
+  key: string,
+  to: number | PropTargetTo,
+  transition: Transition | undefined,
+): PropTransition | undefined {
+  const selected = transitionForProperty(transition, key)
+  if (selected === undefined || hasExecutableTransition(selected)) return selected
+  // Motion's `isTransitionDefined` ignores orchestration-only fields, then merges the property's
+  // count-aware default into the remaining delay/repeat options. This is the native-side equivalent
+  // for a map branch such as `x: { delay: 0.2 }` or `x: {}`; forwarding that sparse bag as a complete
+  // transition would make the driver choose its generic spring for every property.
+  const defaults = getDefaultTransition(key, Array.isArray(to) ? to : [null, to])
+  return { ...defaults, ...definedTransitionFields(selected) } as PropTransition
+}
+
+function hasTransitionMap(transition: Transition): boolean {
+  return Reflect.ownKeys(transition).some(
+    (mapKey) => typeof mapKey === 'string' && TRANSITION_MAP_KEYS.has(mapKey),
+  )
+}
+
+// The per-prop transition for an animate value (R8 M2, consult agent-2026-07-19-e715fd): ONLY a
+// keyframe ARRAY with NO defined command-level transition carries a per-prop default — the count-aware
+// getDefaultTransition (a 2-kf transform → spring, >2 → 800ms keyframes). A scalar, or an array under a
+// DEFINED command-level transition, uses the command-level transition (returns undefined). An empty
+// `{}` is NOT a defined transition (major 38). The drivers read `target.transition ?? command.transition`.
+// REQ-API-035: reducedMotion skips transform (positional) keys; skipAnimations/isStatic skip all keys.
+function perPropTransition(
+  key: string,
+  to: number | PropTargetTo,
+  commandTransition: Transition | undefined,
+  motionPolicy?: { readonly shouldReduceMotion?: boolean; readonly skipAnimations?: boolean },
+): PropTransition | undefined {
+  if (motionPolicy?.skipAnimations === true) return INSTANT_TRANSITION
+  if (motionPolicy?.shouldReduceMotion === true && TRANSFORM_KEY_SET.has(key)) {
+    return INSTANT_TRANSITION
+  }
+  if (commandTransition !== undefined && hasTransitionMap(commandTransition)) {
+    return effectiveTransitionForProperty(key, to, commandTransition)
+  }
+  if (typeof to === 'number') {
+    // transition-default-selection F6 (REQ-SPRING-012, flat arm): the pin's `isTransitionDefined`
+    // exempts the orchestration keys (TRANSITION_DEFINED_EXEMPT_KEYS), so a flat bag whose every
+    // defined field is orchestration-only is NOT a defined transition — the per-key count-aware
+    // default merges UNDER the bag (the pin's `{ ...getDefaultTransition(...), ...valueTransition }`,
+    // motion-dom@12.42.2 motion-value.ts:68-70), the same shape effectiveTransitionForProperty
+    // already produces for a sparse MAP branch. An absent or fieldless (`{}`) bag keeps the
+    // command-level ride unchanged (the R8 M2 scalar law); a bag with ANY defined non-exempt field
+    // is defined and rides the command transition to the driver (an ease-only bag resolves there —
+    // the drivers' timing lane routes a defined typeless bag carrying an ease spelling).
+    if (commandTransition === undefined) return undefined
+    const defined = definedTransitionFields(commandTransition)
+    const definedKeys = Reflect.ownKeys(defined)
+    if (definedKeys.length === 0) return undefined
+    if (
+      definedKeys.some(
+        (definedKey) =>
+          typeof definedKey === 'string' && !TRANSITION_DEFINED_EXEMPT_KEYS.has(definedKey),
+      )
+    )
+      return undefined
+    return { ...getDefaultTransition(key, [null, to]), ...defined } as PropTransition
+  }
+  if (hasDefinedTransition(commandTransition)) return undefined
+  return getDefaultTransition(key, to)
+}
+
+// Filter the R8-F1-incompatible keyframe arrays from an animate target BEFORE any resolve/register/seed/
+// command (review majors 36 + 42): a keyframe array (numeric OR color — a color array's progress
+// keyframes carry the same count) whose command-level transition is an EXPLICIT spring interpolates
+// exactly two keyframes; a longer array is refused HERE. Running up-front makes the whole mount/update
+// ATOMIC (major 36: a rejection mutates nothing) AND routes INDIRECT consumers through the severity
+// boundary (major 42: a gesture/label array riding the element-transition fallback reaches the
+// controller past its supplying gate) — production reports + drops the property (siblings survive),
+// development throws (the direct-consumer loud law). The per-prop default is never a spring for a
+// refusable count, so the command transition is the sole trigger.
+function filterStartCompat(
+  animate: Target,
+  commandTransition: Transition | undefined,
+  severity: NativeSeverity,
+  report: (error: Error) => void,
+  componentId: MotionComponentId,
+): Target {
+  if (!hasDefinedTransition(commandTransition)) return animate
+  const kept: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(animate)) {
+    const effectiveTransition = transitionForProperty(commandTransition, key)
+    let refusal: Error | null = null
+    if (effectiveTransition?.type === 'spring' && Array.isArray(value)) {
+      const springRefusal = springKeyframeCountRefusal(value.length)
+      if (springRefusal !== null) refusal = springRefusal
+    }
+    if (refusal === null)
+      refusal = keyframeTimingRefusal(componentId, key, value, effectiveTransition)
+    if (refusal !== null) {
+      if (severity === 'development') throw refusal
+      report(refusal)
+      continue // production: refuse the property, valid siblings survive
+    }
+    kept[key] = value
+  }
+  return kept as Target
+}
+
+// Value equality for the update diff (M2.2 no-op invariant): scalars by ===, keyframe arrays by
+// element-wise equality so a new-but-EQUAL array on an unrelated re-render issues NO command.
+function sameTargetValue(a: number | PropTargetTo, b: number | PropTargetTo): boolean {
+  if (typeof a === 'number' || typeof b === 'number') return a === b
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false
+  return true
+}
+
+// The SETTLED value of an animate target — where the element rests once the animation completes. A
+// scalar rests at itself; a keyframe array rests at its LAST keyframe (validation guarantees a non-null
+// numeric final element). Used for the `initial={false}` sentinel (mount AT the settled state).
+function settledTargetValue(key: string, value: number | PropTargetTo): number {
+  if (typeof value === 'number') return value
+  const last = value[value.length - 1]
+  if (typeof last !== 'number') {
+    throw new Error(`keyframe array target '${key}' has no numeric final value (REQ-API-033).`)
+  }
+  return last
+}
+
+export type NativeSeverity = 'development' | 'production'
+
+// The omitted-animate mount target: one frozen instance so every static MotionView shares it and
+// the controller's resolved-value diffing sees a stable identity.
+export const EMPTY_TARGET: Target = Object.freeze({})
+
+function animatePropRefusal(error: unknown, componentId: MotionComponentId): Error {
+  // Caught values are untrusted, including Error instances with hostile prototype or message
+  // accessors. Re-wrapping through the total formatter keeps the severity boundary owned.
+  return new InvalidTargetError(
+    componentId,
+    '(target)',
+    describeValue(error),
+    'malformed animate target (REQ-API-013)',
+  )
+}
+
+// The component's animate-prop boundary (round 9 major 31 + U7h): omitted (undefined) animate
+// AND a boolean animate are the empty static target. Boolean is the pin's parse-skip
+// (`typeof prop === "boolean"`) — accepted and inert, not a disable switch. `??` silently
+// converted an explicit `animate={null}` into a static mount that the web entry rejects as a
+// typed failure; null stays loud. Runs in the RENDER body on every render, so a malformed
+// shape arriving on an UPDATE fails here too, before it can reach Object.keys inside the
+// update planner (raw TypeError) or any driver mutation. Development throws; production
+// reports the typed error and refuses the whole target (static view).
+export function resolveAnimateProp(
+  animate: Target | boolean | undefined,
+  severity: NativeSeverity,
+  report: (error: Error) => void,
+  componentId: MotionComponentId,
+): Target {
+  // U7h (REQ-API-057): pin animation-state.ts skips `typeof prop === "boolean"` — accepted
+  // and inert. Not the initial={false} sentinel and not a disable switch. null stays loud.
+  if (animate === undefined || typeof animate === 'boolean') return EMPTY_TARGET
+  try {
+    assertTargetShape(animate, { componentId })
+  } catch (error) {
+    const refusal = animatePropRefusal(error, componentId)
+    if (severity === 'development') throw refusal
+    report(refusal)
+    return EMPTY_TARGET
+  }
+  return animate
+}
+
+// Per-key severity validation — the web shim's validateWithSeverity mirrored natively (review
+// round 6; the ratified severity law is ONE policy across engines): development throws through
+// core's validator untouched; production validates PER KEY, reports each offender through the
+// error channel, and refuses it — the remaining keys proceed.
+// One key's FULL boundary check: core validation plus the L1 value-shape gate (review round 7
+// major a6139e22 — `x: '10px'` passes core validation but is a rung-level value failure; the
+// boundary must catch it BEFORE any driver/controller mutation, on both severity lanes).
+function keyBoundaryRefusal(
+  key: string,
+  value: unknown,
+  allowArrays: boolean,
+  commandTransition: Transition | undefined,
+  componentId: MotionComponentId,
+): Error | null {
+  const effectiveTransition = transitionForProperty(commandTransition, key)
+  // RETURN-shaped (M3 r8 major b9eb82c0d429): the returned refusal is boundary/validator-
+  // made by construction; anything THROWN through core validation (a polluted parse
+  // dependency) propagates untouched — no catch exists on this path.
+  // A keyframe ARRAY is only an ANIMATE target (REQ-API-033); `initial`/`from` are a SINGLE start
+  // value, so an array there is refused AT the boundary (review major 34) — never left to escape as
+  // an uncaught resolveNumeric throw downstream.
+  if (!allowArrays && Array.isArray(value)) {
+    return new Error(
+      `'${key}' takes a single start value, not a keyframe array — a keyframe array is an ANIMATE ` +
+        'target only (REQ-API-010/011/033).',
+    )
+  }
+  const coreRefusal = validateTargetRefusal({ [key]: value } as Target, NATIVE_HOST, {
+    componentId,
+  })
+  if (coreRefusal !== null) return coreRefusal
+  // R8-F1 through the SEVERITY boundary (review major 41): a keyframe array whose command-level
+  // transition is an EXPLICIT spring interpolates exactly two keyframes — a longer array is refused
+  // HERE (per-key: production reports + drops this key, valid siblings survive; development throws)
+  // instead of escaping as an uncaught throw from the controller's atomicity preflight. An
+  // omitted/empty or non-spring transition routes the array through the keyframes generator (no
+  // refusal); the per-prop default is never a spring for a >2 count. Applies to numeric AND color
+  // arrays (a color array's progress keyframes carry the same count).
+  if (
+    Array.isArray(value) &&
+    hasDefinedTransition(effectiveTransition) &&
+    effectiveTransition?.type === 'spring'
+  ) {
+    const springRefusal = springKeyframeCountRefusal(value.length)
+    if (springRefusal !== null) return springRefusal
+  }
+  // R8 M2-B (REQ-API-033 law d): validate keyframe timing before any family-specific early return.
+  // Exact-count `times` override even offsets; other shape-valid counts fall back. Missing segment
+  // easings are linear and extras are ignored. Scalar targets still refuse keyframe-only timing as
+  // inert. Applies to numeric AND color arrays (color progress keyframes carry the same count).
+  const timingRefusal = keyframeTimingRefusal(componentId, key, value, effectiveTransition)
+  if (timingRefusal !== null) return timingRefusal
+  if (key === 'transitionEnd') {
+    // T23 B3: a settle-JUMP sub-target, not a driven value key. Core validateTarget deep-validated
+    // its shape and every sub-value; the native boundary destructures it into the settle lane
+    // (MotionView), and applyTransitionEnd re-gates each sub-value on its own family at jump time.
+    return null
+  }
+  if (isColorKey(key)) {
+    // A color keyframe ARRAY is core-validated above (same-value-type, length ≥2, null only at index 0
+    // for from-current) and driven by the R8 M2 color lane (major 35, projectColorSequence); the
+    // `initial`/`from` scalar lane already refused arrays at the top (allowArrays gate).
+    if (Array.isArray(value)) return null
+    if (typeof value !== 'string') {
+      return new Error(
+        `L1: color target '${key}' is ${JSON.stringify(value)}; an rgba-typed key takes a color ` +
+          'string (specs/L1-BUILD-PACKET.md §semantics 6).',
+      )
+    }
+    return null
+  }
+  if (isDiscreteKey(key)) {
+    // T23 B2b: a single keyword string of the discrete family; arrays are not chartered. The
+    // same verdict discreteValue throws — RETURN-shaped here so production reports + drops.
+    if (Array.isArray(value)) {
+      return new Error(
+        `T23: discrete keyframe arrays are not implemented — '${key}' takes a single keyword ` +
+          'target (scalar display/visibility only).',
+      )
+    }
+    if (
+      typeof value !== 'string' ||
+      !isDiscreteKeyword(value) ||
+      parseValue(value).kind !== 'discrete'
+    ) {
+      return new Error(
+        `T23: discrete target '${key}' is ${JSON.stringify(value)}; a display/visibility target ` +
+          "is a single CSS keyword string (e.g. 'flex'/'none'/'visible'/'hidden').",
+      )
+    }
+    return null
+  }
+  // A numeric keyframe ARRAY is core-validated above (REQ-API-033) and driven by the R8 M2 numeric
+  // keyframe lane; a scalar number passes; measure-resolved length strings pass for positional keys
+  // (REQ-VALUETYPE-013); anything else stays refused.
+  if (typeof value === 'number' || Array.isArray(value)) return null
+  if (
+    typeof value === 'string' &&
+    isPositionalLengthKey(key) &&
+    isMeasureResolvedLengthString(value)
+  ) {
+    return null
+  }
+  return new Error(
+    `L1 scope: target '${key}' is ${JSON.stringify(value)}; only a numeric value, measure-resolved ` +
+      'length string (%/auto/simple calc/px), or numeric keyframe array is driven for non-color keys ' +
+      '(REQ-VALUETYPE-013).',
+  )
+}
+
+function checkKeyAtBoundary(
+  key: string,
+  value: unknown,
+  allowArrays: boolean,
+  commandTransition: Transition | undefined,
+  componentId: MotionComponentId,
+): void {
+  const refusal = keyBoundaryRefusal(key, value, allowArrays, commandTransition, componentId)
+  if (refusal !== null) throw refusal
+}
+
+export function gateTargetWithSeverity(
+  target: Target,
+  severity: NativeSeverity,
+  report: (error: Error) => void,
+  // Whether a keyframe ARRAY is a legal value here: the ANIMATE lane accepts arrays (REQ-API-033); the
+  // `initial` lane is scalar-only (a single start value) and refuses them AT the boundary (major 34).
+  allowArrays = true,
+  // The command-level transition (major 41): its type drives the R8-F1 spring/keyframe-array
+  // compatibility refusal per key, so an incompatible array is reported + dropped under severity here
+  // instead of throwing uncaught from the controller. Absent for the `initial` lane (arrays refused).
+  commandTransition: Transition | undefined = undefined,
+  componentId: MotionComponentId = '<Motion.View>',
+): Target {
+  return gateTargetWithSeverityResult(
+    target,
+    severity,
+    report,
+    allowArrays,
+    commandTransition,
+    componentId,
+  ).target
+}
+
+export interface GatedTargetWithSeverity {
+  /** The immutable target snapshot that passed the per-property severity gate. */
+  readonly target: Target
+  /** Keys supplied to the gate before per-property refusals; derived from the same snapshot. */
+  readonly attemptedKeys: readonly string[]
+}
+
+// The richer form lets a supplying boundary distinguish an absent fallback consumer from one whose
+// every property was already refused. It is deliberately derived from the same captured target as the
+// returned target: examining the caller's object again would recreate the validated/dispatched split.
+export function gateTargetWithSeverityResult(
+  target: Target,
+  severity: NativeSeverity,
+  report: (error: Error) => void,
+  allowArrays = true,
+  commandTransition: Transition | undefined = undefined,
+  componentId: MotionComponentId = '<Motion.View>',
+): GatedTargetWithSeverity {
+  // Whole-target shape gate (round 9 major 31): a malformed non-object target (null, primitive,
+  // array) is ONE typed failure and the WHOLE target is refused — there are no per-key survivors
+  // of a shapeless target. Without this, Object.keys/entries silently coerced numbers and
+  // booleans to the empty target and raw-TypeErrored on null, so native mounted a static view
+  // for inputs the web entry rejects (REQ-API-013/014, one severity policy across engines).
+  const shapeRefusal = targetShapeRefusal(target, { componentId })
+  if (shapeRefusal !== null) {
+    if (severity === 'development') throw shapeRefusal
+    report(shapeRefusal)
+    return { target: {} as Target, attemptedKeys: [] }
+  }
+  // Materialize each keyframe array member ONCE, before validation (review major 30 / web major 23):
+  // an accessor-backed array read during validation and re-read on forward could substitute the
+  // accepted value; the single frozen snapshot is the ONE truth validation AND forwarding (and the
+  // controller's `current` diff base) see. A null-prototype accumulator keeps an own '__proto__' key
+  // from vanishing to the legacy setter (major 24 parity); non-array members pass through.
+  const captured = captureTargetArrays(target)
+  if (captured.refusal !== null) {
+    if (severity === 'development') throw captured.refusal
+    report(captured.refusal)
+    return { target: {} as Target, attemptedKeys: [] }
+  }
+  const snapshot = captured.target
+  const attemptedKeys = Object.freeze(Object.keys(snapshot))
+  if (severity === 'development') {
+    validateAgainstNativeHost(snapshot, componentId)
+    for (const [key, value] of Object.entries(snapshot)) {
+      checkKeyAtBoundary(key, value, allowArrays, commandTransition, componentId)
+    }
+    return { target: snapshot, attemptedKeys }
+  }
+  // RETURN-shaped per key (M3 r8 major b9eb82c0d429): only the boundary's OWN refusals are
+  // reported and dropped; a dependency fault thrown through core validation keeps its
+  // exact identity — no catch exists here.
+  const kept: Record<string, unknown> = Object.create(null)
+  for (const [key, value] of Object.entries(snapshot)) {
+    const refusal = keyBoundaryRefusal(key, value, allowArrays, commandTransition, componentId)
+    if (refusal !== null) {
+      report(refusal)
+      continue
+    }
+    kept[key] = value
+  }
+  return { target: kept as Target, attemptedKeys }
+}
+
+// Materialize a validated-shape target's keyframe array members ONCE into frozen snapshots (review
+// major 30). A null-prototype accumulator is own-property-safe: an own enumerable '__proto__' key
+// lands as data instead of vanishing to the legacy prototype setter (major 24 parity), so it reaches
+// the capability gate. The shared bounded capture reads each caller array length and own index once;
+// scalars pass through.
+export function materializeTargetArrays(
+  target: Target,
+  componentId: MotionComponentId = '<Motion.View>',
+): Target {
+  const captured = captureTargetArrays(target, componentId)
+  if (captured.refusal !== null) throw captured.refusal
+  return captured.target
+}
+
+function captureTargetArrays(
+  target: Target,
+  componentId: MotionComponentId = '<Motion.View>',
+): {
+  readonly target: Target
+  readonly refusal: InvalidTargetError | null
+} {
+  const snapshot: Record<string, unknown> = Object.create(null)
+  for (const key of Object.keys(target)) {
+    const value = (target as Record<string, unknown>)[key]
+    if (!Array.isArray(value)) {
+      snapshot[key] = value
+      continue
+    }
+    const capture = captureBoundedArray(value)
+    if (capture.kind !== 'captured') {
+      return {
+        target: {} as Target,
+        refusal: new InvalidTargetError(
+          componentId,
+          key,
+          capturedArrayDescription(capture),
+          'keyframe arrays must have a safe bounded length (REQ-API-033)',
+        ),
+      }
+    }
+    snapshot[key] = capture.values
+  }
+  return { target: snapshot as Target, refusal: null }
+}
+
+// VENDORED motion-prop predicate — framer-motion's `isValidMotionProp` (the pinned oracle's
+// own denial surface, review round 7 major f10c6c8a: a hand-maintained subset forwarded
+// Motion-valid capabilities like dragConstraints). Vendored rather than imported so the native
+// bundle never pulls motion/react; `motionPropOracle.canary.test.ts` compares this predicate
+// against the REAL isValidMotionProp and fails on drift. The declared public props
+// (initial/animate/exit/transition/style/onAnimationComplete/children) are destructured before
+// the gate and never reach it.
+export function isPinnedMotionProp(key: string): boolean {
+  return isNativeViewMotionProp(key)
+}
+
+// The extra denial the native surface adds beyond motion's predicate: capabilities this repo
+// declares on the WEB ViewProps but has not pulled natively. EMPTY since FLAG 5a pulled
+// dragSnapPoints into the native surface; the mechanism stays for the next web-ahead capability.
+const NATIVE_DEFERRED_EXTRAS = new Set<string>()
+
+/** Deferred drag/pan family names cited by residual Campaign 1 (REQ-API-024). */
+export function isDeferredDragFamilyProp(key: string): boolean {
+  // R15 D5 (REQ-API-046): _dragX/_dragY SHIPPED — never deferred.
+  // R15 D6 (REQ-API-047): onPan* SHIPPED — never deferred.
+  if (key === 'dragOriginEvent') return true
+  // R15 D4 (REQ-API-044): onDirectionLock + dragDirectionLock SHIPPED — never deferred.
+  // R15 D5 (REQ-API-045): dragMomentum / dragTransition / dragSnapToOrigin SHIPPED — never deferred.
+  // Shipped drag surface is destructured before this gate; remaining drag* rest props are deferred.
+  // R15 D1 (REQ-API-041): dragPropagation SHIPPED (destructured + root lock) — never deferred.
+  // R15 D3 (REQ-API-043): dragControls + dragListener SHIPPED — never deferred.
+  if (
+    key.startsWith('drag') &&
+    key !== 'draggable' &&
+    key !== 'dragPropagation' &&
+    key !== 'dragControls' &&
+    key !== 'dragListener' &&
+    key !== 'dragDirectionLock' &&
+    key !== 'dragMomentum' &&
+    key !== 'dragTransition' &&
+    key !== 'dragSnapToOrigin'
+  )
+    return true
+  return false
+}
+
+export function gateDeferredViewProps(
+  rest: Record<string, unknown>,
+  severity: NativeSeverity,
+  report: (error: Error) => void,
+  componentId: MotionComponentId = '<Motion.View>',
+): Record<string, unknown> {
+  const forwarded: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(rest)) {
+    if (value === undefined) continue
+    if (isPinnedMotionProp(key) || NATIVE_DEFERRED_EXTRAS.has(key)) {
+      const dragFamily = isDeferredDragFamilyProp(key)
+      const error = new Error(
+        dragFamily
+          ? `${componentId}: "${key}" is a deferred drag-family capability (REQ-API-024) — ` +
+              'refused until its shipping campaign lands; never a silent free-drag substitute.'
+          : `${componentId}: "${key}" is a motion capability outside the ratified native surface — it fails ` +
+              'loudly on every engine until its own rung lands (REQ-API-006; BRIEF Decisions).',
+      )
+      if (severity === 'development') throw error
+      report(error)
+      continue
+    }
+    forwarded[key] = value
+  }
+  return forwarded
+}
+
+// The optional-animate growth rule (review round 5): a STATIC mount (no keys at all) accepting
+// its first keyed `animate` is valid Motion — the wrapper REMOUNTS its internals with the new
+// key set (new element registration; starts resolve from the current static visuals). Growing
+// a NON-empty mounted set stays the ratified L1 fixed-at-mount deferral: the update guard
+// throws loud, recorded as a Motion divergence until the dynamic-key rung.
+export type MotionViewUpdatePlan = 'update' | 'grow-from-empty'
+
+export function planMotionViewUpdate(
+  mountedKeys: readonly string[],
+  animate: Target,
+): MotionViewUpdatePlan {
+  if (mountedKeys.length === 0 && Object.keys(animate).length > 0) return 'grow-from-empty'
+  return 'update'
+}
+
+export function createMotionViewController(
+  binding: WorkletDriverBinding,
+  props: MotionViewProps,
+  hooks: MotionViewControllerHooks = {},
+): MotionViewController {
+  let handle: ElementHandle | null = null
+  let unmounted = false
+  // The severity channel for the R8-F1 compat filter (major 42): a direct consumer defaults to the
+  // development loud law; the component threads its ambient severity + reporter.
+  const severity: NativeSeverity = hooks.severity ?? 'development'
+  const report = hooks.report ?? ((): void => {})
+  const componentId = props.componentId ?? '<Motion.View>'
+  // A driver command can REFUSE from BELOW the boundary, and the boundary cannot pre-empt it: the
+  // fold re-measures its iteration from the LIVE value, so a `repeat` that validation certified and
+  // that `start` accepted can be refused at a retarget (T18-a round-7 review MAJOR). Left unhandled
+  // that surfaced as an uncaught `InvalidTransitionError` from inside a React lifecycle — on BOTH
+  // severity lanes, including production, whose entire purpose is that it reports instead.
+  //
+  // The ratified severity law owns this outcome and already says what it is (see `keyBoundaryRefusal`
+  // above): development throws typed and untouched; production reports each offender through the
+  // error channel and refuses it, while the REMAINING KEYS PROCEED. The last clause is why a refused
+  // command is re-issued per key rather than dropped whole — the driver commits a retarget
+  // atomically, so a multi-key refusal applied nothing at all and the survivors would otherwise be
+  // punished for sharing a command with an offender.
+  //
+  // Only the fold's own refusal is routed here. Anything else is a different fault and propagates.
+  // The recognition is STRUCTURAL and single-sourced in core: class identity cannot cross to the UI
+  // runtime, so `instanceof` was decidable on the reference backend only and this router silently
+  // stopped firing on the backend that ships (T18-a round-9 review BLOCKING 1).
+  const isFoldRefusal = isRepeatFoldRefusal
+  // A fold refusal is only reachable when the author asked for a fold — no resolved default injects
+  // `repeat` — so this is the exact predicate for "this command could be refused from below".
+  const transitionCarriesFold = (transition: unknown): boolean =>
+    typeof transition === 'object' &&
+    transition !== null &&
+    (transition as { repeat?: unknown }).repeat !== undefined
+  const commandCarriesFold = (command: Extract<DriverCommand, { targets: unknown }>): boolean => {
+    if (transitionCarriesFold(command.transition)) return true
+    if (command.kind === 'retarget' && command.targetTransitions !== undefined) {
+      for (const key of Object.keys(command.targetTransitions)) {
+        if (transitionCarriesFold(command.targetTransitions[key])) return true
+      }
+    }
+    if (command.kind !== 'start') return false
+    // A start resolves its transition PER PROP (keyframe-count-aware defaults), so the fold can
+    // live on a target rather than on the command.
+    for (const key of Object.keys(command.targets)) {
+      if (transitionCarriesFold(command.targets[key]!.transition)) return true
+    }
+    return false
+  }
+  // The identity-channel lane marker for the adapter binding (REQ-API-061): the declarative
+  // update lane (MotionView's animateScope-carrying update) keeps a timed trajectory on the exact
+  // identity, while an unmarked gesture-state/presence retarget of the same shape takes the
+  // host-resolved carrier commit. Set per update()/mount() call; read once per issued command.
+  let commandLaneIsDeclarative = false
+  const issueCommand = (h: ElementHandle, command: DriverCommand): void => {
+    const commands = rewritePathCommands(command, () => binding.driver.committed(h))
+    try {
+      for (const next of commands) {
+        binding.driver.command(
+          h,
+          commandLaneIsDeclarative
+            ? (Object.assign(next, {
+                [IDENTITY_DECLARATIVE_LANE_COMMAND]: true,
+              }) as DriverCommand)
+            : next,
+        )
+      }
+    } catch (error) {
+      if (!isFoldRefusal(error) || severity === 'development') throw error
+      report(error)
+    }
+  }
+  // Only the target-bearing commands can carry a fold; `stop` has nothing to refuse.
+  const commandThroughSeverity = (
+    h: ElementHandle,
+    command: Extract<DriverCommand, { targets: unknown }>,
+  ): void => {
+    const keys = Object.keys(command.targets)
+    // A raw DriverCommand has one command-level transition slot, so a map cannot represent distinct
+    // scalar retarget timings there. Resolve it at this controller boundary: starts keep one atomic
+    // command by placing the selected flat bag in each target slot; scalar retargets become one flat
+    // command per selected bag. The concrete drivers and the shared prepared boundary therefore never
+    // receive a map, while every key still follows the same resolver used by mount/layout validation.
+    if (hasTransitionMap(command.transition)) {
+      if (command.kind === 'retarget') {
+        const selectedTransitions = keys.map((key) => ({
+          key,
+          selectedTransition: effectiveTransitionForProperty(
+            key,
+            command.targets[key]!,
+            command.transition,
+          ),
+          selectedAuthoredTransition: transitionForProperty(command.transition, key) ?? {},
+        }))
+        if (
+          severity === 'development' &&
+          selectedTransitions.some(({ selectedTransition }) =>
+            transitionCarriesFold(selectedTransition),
+          )
+        ) {
+          // Keep every mapped property in one prepared command on the loud lane. The backend
+          // preflight then sees the whole retarget before mutating any shared value; sequentially
+          // issuing mapped keys would commit an early key before a later fold refusal (review major
+          // n4wse8).
+          const targetTransitions: Record<string, PropTransition> = {}
+          for (const {
+            key,
+            selectedTransition,
+            selectedAuthoredTransition,
+          } of selectedTransitions) {
+            targetTransitions[key] = selectedTransition ?? selectedAuthoredTransition
+          }
+          commandThroughSeverity(h, {
+            ...command,
+            transition: {},
+            targetTransitions,
+          } as Extract<DriverCommand, { targets: unknown }>)
+          return
+        }
+        for (const { key, selectedTransition, selectedAuthoredTransition } of selectedTransitions) {
+          commandThroughSeverity(h, {
+            ...command,
+            targets: { [key]: command.targets[key]! },
+            transition: selectedAuthoredTransition,
+            ...(selectedTransition === undefined
+              ? {}
+              : { targetTransitions: { [key]: selectedTransition } }),
+          } as Extract<DriverCommand, { targets: unknown }>)
+        }
+        return
+      }
+      const targets: Record<string, PropTarget> = {}
+      for (const key of keys) {
+        const target = command.targets[key]!
+        const targetTransition = target.transition
+        const selectedTransition =
+          targetTransition === undefined
+            ? effectiveTransitionForProperty(key, target.to, command.transition)
+            : hasTransitionMap(targetTransition as Transition)
+              ? effectiveTransitionForProperty(key, target.to, targetTransition as Transition)
+              : undefined
+        targets[key] = {
+          ...target,
+          ...(targetTransition === undefined
+            ? selectedTransition === undefined
+              ? {}
+              : { transition: selectedTransition }
+            : hasTransitionMap(targetTransition as Transition)
+              ? selectedTransition === undefined
+                ? {}
+                : { transition: selectedTransition }
+              : {}),
+        }
+      }
+      commandThroughSeverity(h, {
+        ...command,
+        targets,
+        transition: {},
+      } as Extract<DriverCommand, { targets: unknown }>)
+      return
+    }
+    // Development keeps the command whole: the typed throw IS the law there, and nothing degrades.
+    // Production splits a FOLD-bearing multi-key command into per-key commands BEFORE issuing it.
+    // Splitting REACTIVELY — issue, catch, re-issue per key — cannot work on the backend that
+    // ships: it crosses commands to the UI runtime through a fire-and-forget schedule, so a refusal
+    // never returns to this caller as a throw and the healthy keys went down with the offender
+    // (T18-a round-9 review BLOCKING 2). Splitting up front works on BOTH lanes because each key
+    // becomes its own atomic command, and it costs nothing on the common path: a command with no
+    // authored fold cannot be refused, so it keeps the single crossing (REQ-DRIVER-013).
+    if (severity === 'development' || keys.length <= 1 || !commandCarriesFold(command)) {
+      issueCommand(h, command)
+      return
+    }
+    let fault: unknown = null
+    for (const key of keys) {
+      try {
+        issueCommand(h, { ...command, targets: { [key]: command.targets[key]! } } as DriverCommand)
+      } catch (error) {
+        // A non-fold fault is a real defect and stays loud — but it is raised AFTER every other key
+        // has had its command. Aborting the split mid-loop would leave it half-applied, which is
+        // the shape the split exists to avoid. First fault wins (round-9 review MINOR).
+        if (fault === null) fault = error
+      }
+    }
+    if (fault !== null) throw fault
+  }
+  const motionPolicyOf = (): {
+    readonly shouldReduceMotion: boolean
+    readonly skipAnimations: boolean
+  } =>
+    hooks.motionPolicyBox?.current ?? {
+      shouldReduceMotion: false,
+      skipAnimations: false,
+    }
+  const lengthLayoutOf = (): LengthLayoutContext => hooks.lengthLayoutContextBox?.current ?? {}
+  // Diff bases for update() — tracking RESOLVED values (not prop identity) is what makes an
+  // unrelated re-render a guaranteed no-op (M2.2 §semantics 3). Numeric keys diff on the resolved
+  // number; color keys diff on the CANONICAL rgba() projection of the target (L1 §semantics),
+  // so '#f00' vs 'rgb(255,0,0)' never issues a spurious command.
+  let current: Record<string, number | PropTargetTo> = {}
+  let activeRemovalValues: Readonly<Record<string, ResolvedValue>> | undefined
+  const handedOffRemovalKeys = new Set<string>()
+  // The color diff base (review major 37): the canonical of the WHOLE declared color target per key —
+  // scalar rgba() or the full keyframe sequence — so a changed MIDDLE keyframe re-commands.
+  const currentColorCanonical: Record<string, string> = {}
+  // Live color SEQUENCE per rgba-typed key (L1 §semantics 3/4; R8 M2 color keyframe arrays, major 35):
+  // the RGBA sequence the driver's progress maps through (a scalar color is a 2-element [from, to]).
+  // Every mutation flows through seed() — state first, wrapper port second, driver command last — so
+  // the animated style's endpoint shareds can never lag a fresh progress (no getter/mutator skew).
+  const colors: Record<string, readonly RGBA[]> = {}
+  // Live discrete PAIR + diff base per discrete-typed key (T23 B2b, the color-lane mirror): the
+  // [from, to] keyword pair the driver's progress RESOLVES through — by whichever of
+  // REQ-VALUETYPE-015's two paths the pair takes, the mixVisibility step or the zero-slot target
+  // constant, which reads no progress at all. The diff base is the declared
+  // target keyword (scalar-only lane). Every mutation flows through seedDiscrete — state first,
+  // wrapper port second, driver command last (no getter/mutator skew).
+  const discretes: Record<string, readonly [string, string]> = {}
+  const currentDiscreteCanonical: Record<string, string> = {}
+  // The fixed-at-mount key set (review major 52): the controller's OWN record of every registered key,
+  // independent of the driver's `committed` map. An update proves EVERY changed key is a member BEFORE
+  // any command — a scalar retarget to an unmounted key must not ride behind an already-committed array
+  // start (atomicity), and membership can't rely on `committed` alone (a not-yet-stepped key is absent).
+  const registeredKeys = new Set<string>()
+  // Mount-refused keys (reviews 763d6bcb0194 + 39c6a3e7ee90): a key whose origin/seed refused
+  // through the severity channel at mount is TERMINAL for this mount's life — it never
+  // registers (fixed-at-mount key set), so any later update naming it must be dropped through
+  // the same severity law instead of crashing on the fixed-key invariant. The mount report is
+  // the one notice; subsequent applications of the same refused property drop silently.
+  const mountRefusedKeys = new Set<string>()
+  // Keys whose CURRENT resting target is an auto form (review ae0a42832d85): once the auto
+  // animation settles, MotionView releases these to the intrinsic layout, and
+  // remeasureAutoRests re-seeds their committed measure when content drifts — the next animate
+  // edge then originates from the drifted content, never a stale number.
+  const autoRestKeys = new Set<string>()
+  // Keys whose CURRENT resting value came from an authored RELATIVE measure form and have NO
+  // animate target owning their re-measure (initial-only %/calc/vw/vh rests, review
+  // 7cec8ad963d8): the form is kept verbatim so remeasureAutoRests re-resolves it against a
+  // changed element box / parent / viewport and INSTANT re-seeds.
+  const relativeRestForms = new Map<string, string>()
+  // The last AUTHORED array form each key commanded (review 26cc511b0927): an identical raw
+  // array whose RESOLUTION changed means a context edge, never an authored replacement — the
+  // array's resting final value retargets instead of replaying the sequence.
+  const lastCommandedRawKeyframes = new Map<string, readonly unknown[]>()
+  // Element-box endpoints (auto / x|y %) remain paired until onLayout. A first-mount `initial`
+  // or authored style origin may require the same measurement as its animate endpoint; retaining
+  // only `to` would manufacture a 0-origin instead of issuing the measured endpoint pair.
+  let pendingDeferredAnimate: PendingDeferredLengthTargets | null = null
+  let pendingDeferredTransition: Transition | undefined
+  // Mount-deferred flush under initial={false} settles instantly (REQ-API-010). Post-mount
+  // deferred flushes keep the command transition (review residual over-fix major).
+  let mountDeferredNeedsInstantFlush = false
+  function registerElement(registered: Record<string, number>): ElementHandle {
+    for (const key of Object.keys(registered)) registeredKeys.add(key)
+    return binding.driver.register(registered)
+  }
+
+  function requireHandle(): ElementHandle {
+    if (handle === null) {
+      throw new Error('MotionView controller used before mount(): mount the component first.')
+    }
+    return handle
+  }
+
+  // FLAG 5a staticKeys: register each not-yet-registered static key at its resolved start value
+  // (REQ-API-011's rule — style wins, else the documented host base). Mutates the registration
+  // map BEFORE driver.register so the element is born with the key; never adds a target. An
+  // rgba-typed static key (r4 major 18: a gesture-only color) registers SETTLED at its start
+  // color — from = to, progress at PROGRESS_END, the same constant-projection shape as an
+  // initial-only color — so a later retarget re-seeds through the existing update color lane.
+  function addStaticKeys(registered: Record<string, number>): void {
+    for (const key of props.staticKeys ?? []) {
+      if (key in registered) continue
+      if (isDiscreteKey(key)) {
+        // Settled at the start keyword (style-provided). A missing start is the severity-gated
+        // discreteStartKeyword refusal (T23 B2a2): dev throws, production reports + skips the key.
+        const startKeyword = discreteStartKeyword(key)
+        if (startKeyword === null) continue
+        seedDiscrete(key, startKeyword, [startKeyword, startKeyword])
+        registered[key] = PROGRESS_END
+        continue
+      }
+      const start = resolveStartValue(key, props.style !== undefined ? { style: props.style } : {})
+      if (isColorKey(key)) {
+        const startColor = colorValue(key, start)
+        seed(key, startColor, [startColor, startColor]) // settled: from = to (constant projection)
+        registered[key] = PROGRESS_END
+        continue
+      }
+      const n = resolveNumericKeyWithSeverity(key, start, lengthLayoutOf(), severity, report)
+      if (n !== null) registered[key] = n
+    }
+  }
+
+  // Seed a color key's live SEQUENCE (length ≥2; a scalar color is [from, to]) plus its DIFF BASE. The
+  // diff base is the canonical of the DECLARED target (the whole sequence, major 37 — not just the
+  // settled color); the wrapper port receives the live RGBA sequence so the animated-style worklet
+  // projects through it (projectColorSequence). One mutation path — no getter/mutator skew.
+  function seed(key: string, declaredTarget: ColorTarget, sequence: readonly RGBA[]): void {
+    colors[key] = sequence
+    currentColorCanonical[key] = colorTargetCanonical(declaredTarget)
+    if (hooks.onColorEndpoints !== undefined) hooks.onColorEndpoints(key, sequence)
+  }
+
+  // T23 B2a2 (severity law): a discrete animate/static key with NO authored start — core's
+  // TYPED host-base refusal (the default diverges across engines) — is an authoring error
+  // owned by this boundary: development throws core's error; production reports it once and
+  // the key is refused WHOLE (no seed, no registration, no target — the numeric refused-seed
+  // posture). Non-discrete host-base refusals (unknown/complex keys) stay loud on every
+  // severity.
+  function discreteStartKeyword(key: string): string | null {
+    try {
+      return discreteValue(
+        key,
+        resolveStartValue(key, props.style !== undefined ? { style: props.style } : {}),
+      )
+    } catch (error) {
+      if (!(error instanceof DiscreteHostBaseError)) throw error
+      if (severity === 'development') throw error
+      report(error)
+      // TERMINAL for the key at this mount (the numeric refused-seed law): the update lane
+      // skips it silently — one report, never a fixed-key throw on a later retarget.
+      mountRefusedKeys.add(key)
+      return null
+    }
+  }
+
+  // Seed a discrete key's live [from, to] pair plus its DIFF BASE (the declared target keyword) —
+  // the seed() mirror; the wrapper port receives the pair so the animated-style worklet projects
+  // through it (projectDiscreteStep). One mutation path — no getter/mutator skew.
+  function seedDiscrete(
+    key: string,
+    declaredTarget: string,
+    pair: readonly [string, string],
+  ): void {
+    discretes[key] = pair
+    currentDiscreteCanonical[key] = declaredTarget
+    if (hooks.onDiscreteEndpoints !== undefined) hooks.onDiscreteEndpoints(key, pair)
+  }
+
+  return {
+    mount() {
+      commandLaneIsDeclarative = false
+      // Fail-closed ordering (REQ-API-013): every target validates BEFORE the driver sees anything.
+      // The transition validates through the same boundary (r7 major 41b089c8c0af) — the
+      // component pre-gates with severity; a direct controller consumer gets the loud law,
+      // including this lane's OWN vocabulary (r9 major 762e9d0a4c77: the property lane rebases
+      // delay and never reads velocity — the component hands it the selected projection).
+      // Capture + validate the transition ONCE (review major 61): a DIRECT controller consumer's raw
+      // accessor-backed transition would otherwise be read by validation and RE-read by the filter,
+      // per-prop defaults, and the command — the validated value must be the one the command runs.
+      // Materialize the animate arrays ONCE, then validate the SNAPSHOT (review major 60 — the mount
+      // analog of major 30): the shape gate is a top-level check that reads no array element, so a
+      // frozen snapshot is the ONE truth validation, filtering, resolution, and forwarding all see; a
+      // direct consumer's accessor-backed array cannot pass validation with one value and forward another.
+      const animateShapeRefusal = targetShapeRefusal(props.animate, { componentId })
+      if (animateShapeRefusal !== null) throw animateShapeRefusal
+      const transition = captureAndValidateTransition(
+        props.transition,
+        componentId,
+        Object.keys(props.animate),
+      )
+      const animateSnapshot = materializeTargetArrays(props.animate, componentId)
+      validateAgainstNativeHost(animateSnapshot, componentId)
+      if (props.initial !== false && props.initial !== undefined) {
+        validateAgainstNativeHost(props.initial, componentId)
+      }
+      // Filter R8-F1-incompatible arrays under severity FIRST (major 42): an indirect consumer's array
+      // riding an explicit-spring element transition is reported + dropped (production) or throws
+      // (development) before any mutation, so the rest of the mount is atomic and the property is
+      // refused rather than throwing uncaught downstream.
+      const compatAnimate = filterStartCompat(
+        animateSnapshot,
+        transition,
+        severity,
+        report,
+        componentId,
+      )
+      const layoutCtx = lengthLayoutOf()
+      const { resolved: animate, deferred: deferredAnimate } = resolveAnimateTargets(
+        compatAnimate,
+        layoutCtx,
+        severity,
+        report,
+      )
+      // The mount's authored array forms seed the context-vs-authored discriminator (review
+      // 26cc511b0927): a later context-only re-resolution of the SAME array is a responsive
+      // retarget, not a sequence restart.
+      for (const key of Object.keys(animate)) {
+        const raw = (compatAnimate as Record<string, unknown>)[key]
+        if (Array.isArray(raw)) lastCommandedRawKeyframes.set(key, raw)
+      }
+      const animateColors = resolveColors(compatAnimate)
+      const animateDiscretes = resolveDiscretes(compatAnimate)
+      if (Object.keys(deferredAnimate).length > 0) {
+        pendingDeferredAnimate = deferredTargetsFrom(deferredAnimate)
+        pendingDeferredTransition = transition
+        mountDeferredNeedsInstantFlush = props.initial === false
+      }
+
+      if (props.initial === false) {
+        // REQ-API-010 sentinel: first painted frame IS the settled animate state — register at the
+        // animate values, no entrance command, element idle. A keyframe array rests at its LAST
+        // keyframe (settledTargetValue). A color registers at PROGRESS_END with from = to: the
+        // projection is constant at the target color.
+        const registered: Record<string, number> = {}
+        for (const key of Object.keys(animate)) {
+          registered[key] = settledTargetValue(key, animate[key]!)
+        }
+        // Element-measure deferred keys still join the fixed-at-mount set at host base; flush
+        // after onLayout retargets them to the measured settle without re-registering. A REFUSED
+        // seed base (e.g. a missing-parent % style) never fabricates a zero registration —
+        // one report at the verdict, key left unregistered (review 763d6bcb0194). The refusal is
+        // TERMINAL for the key at this mount (review 39c6a3e7ee90): it leaves pending AND the
+        // diff base too — a leftover pending would let the post-onLayout flush re-enter update()
+        // and throw the fixed-key invariant OUTSIDE the severity channel.
+        const refusedSeedKeys: string[] = []
+        for (const key of Object.keys(deferredAnimate)) {
+          if (!(key in registered)) {
+            const seedVerdict = resolveNumericKeyVerdict(
+              key,
+              resolveStartValue(key, props.style !== undefined ? { style: props.style } : {}),
+              layoutCtx,
+              severity,
+              report,
+            )
+            if (seedVerdict.kind === 'refused') {
+              refusedSeedKeys.push(key)
+              mountRefusedKeys.add(key)
+              continue
+            }
+            registered[key] =
+              seedVerdict.kind === 'resolved'
+                ? seedVerdict.value
+                : deferredRegistrationSeed(key, props.style, layoutCtx, severity, report)
+          }
+        }
+        if (refusedSeedKeys.length > 0 && pendingDeferredAnimate !== null) {
+          const retained: PendingDeferredLengthTargets = {}
+          for (const key of Object.keys(pendingDeferredAnimate)) {
+            if (!refusedSeedKeys.includes(key)) retained[key] = pendingDeferredAnimate[key]!
+          }
+          pendingDeferredAnimate = Object.keys(retained).length === 0 ? null : retained
+          if (pendingDeferredAnimate === null) {
+            pendingDeferredTransition = undefined
+            mountDeferredNeedsInstantFlush = false
+          }
+        }
+        for (const key of Object.keys(animateColors)) {
+          const target = animateColors[key]!
+          const settled = settledColor(key, target)
+          // initial=false: rest AT the settled color, constant projection (from = to). The DIFF BASE is
+          // the DECLARED target (the whole array), not the settled scalar (review major 43) — else an
+          // unchanged re-render diffs its full-sequence canonical against a settled-only base and wrongly
+          // restarts, violating both the settled-mount rule and the no-command invariant.
+          seed(key, target, [settled, settled])
+          registered[key] = PROGRESS_END
+        }
+        // initial={false} discrete keys rest AT the settled target keyword (constant projection).
+        for (const key of Object.keys(animateDiscretes)) {
+          const keyword = animateDiscretes[key]!
+          seedDiscrete(key, keyword, [keyword, keyword])
+          registered[key] = PROGRESS_END
+        }
+        addStaticKeys(registered)
+        seedPathRotationKey(registered, transition)
+        handle = registerElement(registered)
+        current = { ...animate }
+        for (const key of Object.keys(deferredAnimate)) {
+          // A refused seed never enters the diff base either (review 39c6a3e7ee90).
+          if (!(key in current) && !refusedSeedKeys.includes(key)) current[key] = registered[key]!
+        }
+        return handle
+      }
+
+      // Start values per key (REQ-API-010/011): an `initial` target value wins, else the style
+      // value, else the documented host base — the latter two via core's resolveStartValue. Color
+      // start values resolve identically, then parse through the typed entry gate.
+      // Start values per key (REQ-API-010/011): an `initial` target value wins, else the style
+      // value, else the documented host base — the latter two via core's resolveStartValue. Color
+      // start values resolve identically, then parse through the typed entry gate. Every origin
+      // resolves through the tri-state verdict ONCE per mount (review 763d6bcb0194): a refusal
+      // reports exactly once, and the same verdict is reused everywhere below — never re-reported.
+      const initialVerdicts = new Map<string, OriginResolution>()
+      const initial: Record<string, number> = {}
+      // (initial === false returned above; here initial is a Target or undefined.)
+      if (props.initial !== undefined) {
+        for (const key of Object.keys(props.initial as Record<string, unknown>)) {
+          if (isColorKey(key) || isDiscreteKey(key)) continue
+          const verdict = resolveNumericKeyVerdict(
+            key,
+            (props.initial as Record<string, unknown>)[key],
+            layoutCtx,
+            severity,
+            report,
+          )
+          initialVerdicts.set(key, verdict)
+          if (verdict.kind === 'resolved') initial[key] = verdict.value
+        }
+      }
+      const initialColors = props.initial === undefined ? {} : resolveColors(props.initial)
+      const initialDiscretes =
+        props.initial === undefined ? {} : resolveDiscretes(props.initial as Target)
+      const from: Record<string, number> = {}
+      const mountDeferredPairs: PendingDeferredLengthTargets = {
+        ...pendingDeferredAnimate,
+      }
+      const rawStartValue = (key: string): unknown => {
+        if (props.initial !== undefined && props.initial !== false && key in props.initial) {
+          return (props.initial as Record<string, unknown>)[key]!
+        }
+        return resolveStartValue(key, props.style !== undefined ? { style: props.style } : {})
+      }
+      for (const key of Object.keys(animate)) {
+        if (key in initial) {
+          from[key] = initial[key]!
+        } else {
+          const rawStart = rawStartValue(key)
+          const verdict =
+            initialVerdicts.get(key) ??
+            resolveNumericKeyVerdict(key, rawStart, layoutCtx, severity, report)
+          if (verdict.kind === 'resolved') {
+            from[key] = verdict.value
+          } else if (verdict.kind === 'deferred') {
+            // Do not start a resolved target from a synthetic 0 when initial/style needs the
+            // element box. The deferred flush resolves and commands both endpoints together.
+            mountDeferredPairs[key] = {
+              to: (compatAnimate as Record<string, unknown>)[key]!,
+              from: rawStart,
+            }
+            delete animate[key]
+          } else {
+            // Refused (review 763d6bcb0194): the report fired once, at the verdict — drop the
+            // property entirely: never a fabricated-zero registration, never a pending measure.
+            // Terminal for this mount (review 39c6a3e7ee90): later updates drop it silently.
+            mountRefusedKeys.add(key)
+            delete animate[key]
+          }
+        }
+      }
+      // Initial-ONLY unresolved origins (review 73044cc0e1bd): a first-mount initial key no
+      // animate target names — the label-form topology initial="open" with
+      // variants.open.height="auto" mounts with an EMPTY animate — must still join the fixed
+      // mount key set (a temporary seed registration) with its raw origin held as a pending
+      // endpoint, or a later label update meets an unmounted key. Origins already refused
+      // through the severity channel by the initial verdict stay refused (never resurrected).
+      // (initial === false returned above; here initial is a Target or undefined.)
+      if (props.initial !== undefined) {
+        for (const key of Object.keys(props.initial as Record<string, unknown>)) {
+          if (isColorKey(key) || isDiscreteKey(key)) continue
+          if (key in mountDeferredPairs) continue // animate loop already paired this origin
+          if (key in initial) continue // resolved origin — the initial-only registration owns it
+          const rawStart = (props.initial as Record<string, unknown>)[key]
+          const verdict = initialVerdicts.get(key)!
+          if (verdict.kind === 'deferred') {
+            mountDeferredPairs[key] = { from: rawStart }
+          }
+          // Refused: the initial verdict already threw (development) or reported once
+          // (production) — leave it refused, never registered.
+        }
+      }
+      // Deferred element-measure keys: register at the authored origin when available, otherwise a
+      // temporary seed. A paired origin waits for onLayout with its target and never becomes 0→0.
+      // A REFUSED origin (e.g. a missing-parent % style base) drops the pair entirely — one
+      // report at the verdict, no fabricated-zero registration, no pending measure (review
+      // 763d6bcb0194).
+      for (const key of Object.keys(mountDeferredPairs)) {
+        if (key in from) continue
+        const pair = mountDeferredPairs[key]!
+        if (pair.from === undefined && key in initial) {
+          from[key] = initial[key]!
+          continue
+        }
+        const rawStart = pair.from ?? rawStartValue(key)
+        const verdict =
+          initialVerdicts.get(key) ??
+          resolveNumericKeyVerdict(key, rawStart, layoutCtx, severity, report)
+        if (verdict.kind === 'resolved') {
+          from[key] = verdict.value
+        } else if (verdict.kind === 'deferred') {
+          // A target deferred before this loop still needs its authored unresolved origin
+          // retained. Pair it now instead of letting the later flush retarget from the 0 seed.
+          mountDeferredPairs[key] = { ...pair, from: rawStart }
+          from[key] = deferredRegistrationSeed(key, props.style, layoutCtx, severity, report)
+        } else {
+          mountRefusedKeys.add(key)
+          delete mountDeferredPairs[key]
+        }
+      }
+      pendingDeferredAnimate =
+        Object.keys(mountDeferredPairs).length === 0 ? null : mountDeferredPairs
+      if (pendingDeferredAnimate !== null && pendingDeferredTransition === undefined) {
+        // review 818eba29da3a: the animate endpoint may have RESOLVED while only the authored
+        // initial/style origin deferred — the measured first animation still rides the
+        // AUTHORED mount transition, never a defaulted {}.
+        pendingDeferredTransition = transition
+      }
+      const registered: Record<string, number> = { ...from }
+      const targets: Record<string, PropTarget> = {}
+      for (const key of Object.keys(animate)) {
+        const to = animate[key]!
+        // An omitted-transition keyframe ARRAY carries its count-aware per-prop default; a scalar (or an
+        // array under an explicit command-level transition) rides the command-level transition (R8 M2).
+        const perProp = perPropTransition(key, to, transition, motionPolicyOf())
+        targets[key] = {
+          to,
+          from: from[key]!,
+          ...(perProp !== undefined ? { transition: perProp } : {}),
+        }
+      }
+      // Initial-ONLY keys (review round 4 major 9 — the optional-animate surface): first paint
+      // must honor `initial` exactly like the web entry, so the key registers at its initial
+      // value with NO target — a static value until a later animate retargets it. An initial-only
+      // RELATIVE form joins the relative-rest lane (review 7cec8ad963d8): no animate target owns
+      // its re-measure, so a later context change re-resolves and re-seeds it here.
+      for (const key of Object.keys(initial)) {
+        if (!(key in targets)) {
+          registered[key] = initial[key]!
+          const rawInitial = (props.initial as Record<string, unknown>)[key]
+          if (isRelativeLengthForm(rawInitial)) relativeRestForms.set(key, rawInitial)
+        }
+      }
+      // BUILD the color targets + collect the endpoint seeds WITHOUT mutating (major 36 atomicity): the
+      // seeds apply only AFTER the whole target set pre-validates, so a rejected mount mutates nothing.
+      const pendingSeeds: {
+        key: string
+        declaredTarget: ColorTarget
+        sequence: readonly RGBA[]
+      }[] = []
+      for (const key of Object.keys(animateColors)) {
+        const target = animateColors[key]!
+        const fromColor: RGBA =
+          key in initialColors
+            ? settledColor(key, initialColors[key]!) // initial is scalar-only ⇒ the start color
+            : colorValue(
+                key,
+                resolveStartValue(key, props.style !== undefined ? { style: props.style } : {}),
+              )
+        pendingSeeds.push({
+          key,
+          declaredTarget: target,
+          sequence: buildColorSequence(target, fromColor),
+        })
+        registered[key] = PROGRESS_START
+        // A color ARRAY drives a numeric PROGRESS keyframe array [0…100] (per-prop count-aware default,
+        // R8 M2 major 35); a scalar color rides the sealed 0→100 progress under the command transition.
+        if (isColorArrayTarget(target)) {
+          const progressTo = colorProgressArray(target.length)
+          const perProp = perPropTransition(key, progressTo, transition, motionPolicyOf())
+          targets[key] = {
+            to: progressTo,
+            from: PROGRESS_START,
+            ...(perProp !== undefined ? { transition: perProp } : {}),
+          }
+        } else {
+          const perProp = perPropTransition(key, PROGRESS_END, transition, motionPolicyOf())
+          targets[key] = {
+            to: PROGRESS_END,
+            from: PROGRESS_START,
+            ...(perProp !== undefined ? { transition: perProp } : {}),
+          }
+        }
+      }
+      // Initial-only COLOR keys register settled at the initial color (from = to: the
+      // projection is constant), the same shape as the initial={false} sentinel.
+      for (const key of Object.keys(initialColors)) {
+        if (!(key in targets)) {
+          const settled = settledColor(key, initialColors[key]!) // initial is scalar-only
+          pendingSeeds.push({ key, declaredTarget: settled, sequence: [settled, settled] })
+          registered[key] = PROGRESS_END
+        }
+      }
+      // BUILD the discrete targets + pair seeds WITHOUT mutating (the color block's major-36
+      // atomicity): the start keyword is initial's, else style's, else the LOUD host-base refusal
+      // (T23 B2a — the discrete default diverges across engines). There is no pair-legality probe:
+      // since H3 every keyword pair is legal, and core's mixDiscrete answers all of them.
+      const pendingDiscreteSeeds: {
+        key: string
+        declaredTarget: string
+        pair: readonly [string, string]
+      }[] = []
+      for (const key of Object.keys(animateDiscretes)) {
+        const target = animateDiscretes[key]!
+        const fromKeyword: string | null =
+          key in initialDiscretes ? initialDiscretes[key]! : discreteStartKeyword(key)
+        if (fromKeyword === null) continue
+        const pair: readonly [string, string] = [fromKeyword, target]
+        pendingDiscreteSeeds.push({
+          key,
+          declaredTarget: target,
+          pair,
+        })
+        registered[key] = PROGRESS_START
+        // A scalar keyword rides the sealed 0→100 progress under the command transition (the
+        // scalar-color shape; discrete keyframe arrays are refused upstream).
+        const perProp = perPropTransition(key, PROGRESS_END, transition, motionPolicyOf())
+        targets[key] = {
+          to: PROGRESS_END,
+          from: PROGRESS_START,
+          ...(perProp !== undefined ? { transition: perProp } : {}),
+        }
+      }
+      // Initial-only DISCRETE keys register settled at the initial keyword (constant projection).
+      for (const key of Object.keys(initialDiscretes)) {
+        if (!(key in targets)) {
+          const keyword = initialDiscretes[key]!
+          pendingDiscreteSeeds.push({ key, declaredTarget: keyword, pair: [keyword, keyword] })
+          registered[key] = PROGRESS_END
+        }
+      }
+      // R8-F1-incompatible arrays were filtered up-front (compatAnimate) so `targets` holds none — the
+      // build → commit order below leaks no registration/endpoint on a refusal (major 36 atomicity).
+      for (const { key, declaredTarget, sequence } of pendingSeeds)
+        seed(key, declaredTarget, sequence)
+      for (const { key, declaredTarget, pair } of pendingDiscreteSeeds)
+        seedDiscrete(key, declaredTarget, pair)
+      addStaticKeys(registered)
+      seedPathRotationKey(registered, transition)
+      handle = registerElement(registered)
+      // An initial-only mount has nothing to animate — no command, element idle at first paint.
+      if (Object.keys(targets).length > 0) {
+        commandThroughSeverity(handle, {
+          kind: 'start',
+          targets,
+          transition: transition ?? {},
+        })
+      }
+      current = { ...animate }
+      for (const key of Object.keys(mountDeferredPairs)) {
+        if (!(key in current)) current[key] = registered[key]!
+      }
+      return handle
+    },
+
+    flushDeferredLengthMeasures(held) {
+      if (pendingDeferredAnimate === null || handle === null) return false
+      const pendingAll = pendingDeferredAnimate
+      const retainHeld: PendingDeferredLengthTargets = {}
+      // Flush commands are PARTITIONED by transition ownership (review 93aeec05a9a8): each
+      // pending entry rides its deferring application's OWN transition (the mount fallback
+      // covers unstamped mount pairs; the instant latch still wins while set). Keys sharing
+      // one transition share one command.
+      const flushTargetGroups = new Map<Transition | undefined, Record<string, unknown>>()
+      const startGroups = new Map<
+        Transition | undefined,
+        { targets: Record<string, PropTarget>; resolved: Record<string, number | PropTargetTo> }
+      >()
+      // Origin-only initial pendings that resolved this flush — settled INSTANT (review
+      // 2bd345e800ff), never through the application transition.
+      const settleTargets: Record<string, number> = {}
+      const effectiveTransitionOf = (
+        pending: PendingDeferredLengthTarget,
+      ): Transition | undefined =>
+        mountDeferredNeedsInstantFlush
+          ? INSTANT_TRANSITION
+          : pending.transition === null
+            ? undefined // explicit default ownership (review 7d395c90c954)
+            : (pending.transition ?? pendingDeferredTransition)
+      const layoutContext = lengthLayoutOf()
+      for (const key of Object.keys(pendingAll)) {
+        const pending = pendingAll[key]!
+        if (held !== undefined && held.has(key)) {
+          retainHeld[key] = pending
+          continue
+        }
+        // An origin-only pending (initial-only key, review 73044cc0e1bd) holds while its origin
+        // still needs the element box — and SETTLES the registration to the measured origin the
+        // moment it resolves (review 2bd345e800ff): INSTANT, never an entrance animation — the
+        // authored application transition is not an entrance for an initial-only key.
+        if (pending.to === undefined) {
+          try {
+            const measured = numericValue(key, pending.from, layoutContext)
+            settleTargets[key] = measured
+          } catch (error) {
+            if (isDeferrableElementMeasureError(error)) {
+              retainHeld[key] = pending
+              continue
+            }
+            if (!isMeasureResolveBoundaryError(error)) throw error
+            if (severity === 'development') throw error
+            report(error)
+            // A refused origin at flush: dropped with the report, never retained as pending.
+          }
+          continue
+        }
+        const transition = effectiveTransitionOf(pending)
+        if (pending.from === undefined) {
+          const group = flushTargetGroups.get(transition) ?? {}
+          group[key] = pending.to
+          flushTargetGroups.set(transition, group)
+          continue
+        }
+        try {
+          const to = numericTargetValue(key, pending.to, layoutContext)
+          const from =
+            pending.from === undefined
+              ? binding.driver.committed(handle)[key]
+              : numericValue(key, pending.from, layoutContext)
+          if (from === undefined) {
+            throw new Error(
+              `L1: cannot flush deferred '${key}': it was not registered on this MotionView controller.`,
+            )
+          }
+          const perProp = perPropTransition(key, to, transition, motionPolicyOf())
+          let group = startGroups.get(transition)
+          if (group === undefined) {
+            group = { targets: {}, resolved: {} }
+            startGroups.set(transition, group)
+          }
+          group.targets[key] = {
+            to,
+            from,
+            ...(perProp === undefined ? {} : { transition: perProp }),
+          }
+          group.resolved[key] = to
+        } catch (error) {
+          if (isDeferrableElementMeasureError(error)) {
+            retainHeld[key] = pending
+            continue
+          }
+          if (!isMeasureResolveBoundaryError(error)) throw error
+          if (severity === 'development') throw error
+          report(error)
+        }
+      }
+      if (
+        startGroups.size === 0 &&
+        flushTargetGroups.size === 0 &&
+        Object.keys(settleTargets).length === 0
+      ) {
+        pendingDeferredAnimate = Object.keys(retainHeld).length === 0 ? null : retainHeld
+        if (pendingDeferredAnimate === null) {
+          pendingDeferredTransition = undefined
+          mountDeferredNeedsInstantFlush = false
+        }
+        // Everything still held — keep pending; do not clear mount instant latch.
+        return false
+      }
+      // Origin-only settles ride ONE instant retarget — the measured registration, never an
+      // entrance (review 2bd345e800ff). The settle rests at auto ONLY when its origin IS a
+      // dimension auto (review 1578a42974bc); a RELATIVE origin-only settle keeps its authored
+      // relative form in the relative-rest lane instead (review 7cec8ad963d8) — never the auto
+      // lane — so a later context change re-measures it.
+      if (Object.keys(settleTargets).length > 0) {
+        for (const key of Object.keys(settleTargets)) {
+          const pendingFrom = pendingAll[key]?.from
+          if ((key === 'width' || key === 'height') && restsAtAutoForm(pendingFrom)) {
+            autoRestKeys.add(key)
+            relativeRestForms.delete(key)
+          } else if (isRelativeLengthForm(pendingFrom)) {
+            autoRestKeys.delete(key)
+            relativeRestForms.set(key, pendingFrom)
+          } else {
+            autoRestKeys.delete(key)
+            relativeRestForms.delete(key)
+          }
+        }
+        commandThroughSeverity(handle, {
+          kind: 'retarget',
+          targets: settleTargets,
+          transition: INSTANT_TRANSITION,
+        })
+        current = { ...current, ...settleTargets }
+      }
+      for (const [transition, group] of startGroups) {
+        for (const key of Object.keys(group.targets)) {
+          const pendingTo = pendingAll[key]?.to
+          if (restsAtAutoForm(pendingTo)) autoRestKeys.add(key)
+          else autoRestKeys.delete(key)
+          // The flush's start lane commands the array too (review 551ba4344486): record the
+          // authored keyframes so a later context-only re-resolution of the SAME array reads as
+          // a responsive final-value retarget, never a first-keyframe replay. A non-array
+          // pending takes the key out of array authorship (same law as the update lane).
+          if (Array.isArray(pendingTo)) lastCommandedRawKeyframes.set(key, pendingTo)
+          else lastCommandedRawKeyframes.delete(key)
+        }
+        commandThroughSeverity(handle, {
+          kind: 'start',
+          targets: group.targets,
+          transition: transition ?? {},
+        })
+        current = { ...current, ...group.resolved }
+      }
+      pendingDeferredAnimate = Object.keys(retainHeld).length === 0 ? null : retainHeld
+      if (pendingDeferredAnimate === null) {
+        pendingDeferredTransition = undefined
+        mountDeferredNeedsInstantFlush = false
+      }
+      let commanded = startGroups.size > 0 || Object.keys(settleTargets).length > 0
+      for (const [transition, flushTarget] of flushTargetGroups) {
+        commanded =
+          this.update({
+            animate: flushTarget as Target,
+            animateScope: 'partial',
+            // This re-entry resolves auto against the measure the flush just seeded — the
+            // retarget invalidation must not drop it back into the deferred lane (review
+            // 356417a77aec).
+            skipAutoMeasureInvalidation: true,
+            ...(transition === undefined ? {} : { transition }),
+          }) || commanded
+      }
+      return commanded
+    },
+
+    remeasureAutoRests() {
+      if (handle === null || (autoRestKeys.size === 0 && relativeRestForms.size === 0)) {
+        return false
+      }
+      const layoutContext = lengthLayoutOf()
+      const reseed: Record<string, number> = {}
+      for (const key of autoRestKeys) {
+        // A key mid-animation keeps its course — the drift re-seed applies only at rest.
+        const active = binding.propertyStateFor?.(handle, key)?.active.value === true
+        if (active) continue
+        try {
+          const measured = resolveLengthToPx('auto', key as PositionalLengthAxis, layoutContext)
+          if (current[key] !== measured) reseed[key] = measured
+        } catch (error) {
+          if (isDeferrableElementMeasureError(error)) continue
+          if (!isMeasureResolveBoundaryError(error)) throw error
+          if (severity === 'development') throw error
+          report(error)
+        }
+      }
+      // The relative-rest lane (review 7cec8ad963d8): initial-only %/calc/vw/vh forms re-resolve
+      // against the changed element box / parent / viewport and INSTANT re-seed.
+      for (const [key, rawForm] of relativeRestForms) {
+        const active = binding.propertyStateFor?.(handle, key)?.active.value === true
+        if (active) continue
+        try {
+          const measured = numericValue(key, rawForm, layoutContext)
+          if (current[key] !== measured) reseed[key] = measured
+        } catch (error) {
+          if (isDeferrableElementMeasureError(error)) continue
+          if (!isMeasureResolveBoundaryError(error)) throw error
+          if (severity === 'development') throw error
+          report(error)
+        }
+      }
+      if (Object.keys(reseed).length === 0) return false
+      commandThroughSeverity(handle, {
+        kind: 'retarget',
+        targets: reseed,
+        transition: INSTANT_TRANSITION,
+      })
+      current = { ...current, ...reseed }
+      return true
+    },
+
+    syncDeferredLengthPending(next) {
+      commandLaneIsDeclarative = next.animateScope !== undefined
+      // Pending-only: no filterStartCompat against element keyframe timing, no driver commands.
+      // Label full projection uses this after per-label updates (major 210b429d9557).
+      if (handle === null) {
+        throw new Error('MotionView controller used before mount(): mount the component first.')
+      }
+      const animateShapeRefusal = targetShapeRefusal(next.animate, { componentId })
+      if (animateShapeRefusal !== null) throw animateShapeRefusal
+      const animateSnapshot = materializeTargetArrays(next.animate, componentId)
+      validateAgainstNativeHost(animateSnapshot, componentId)
+      // Mount-refused keys are terminal for this mount (review 39c6a3e7ee90): the sync must not
+      // rebuild pending for them either.
+      const animateEffective = dropMountRefusedKeys(animateSnapshot, mountRefusedKeys)
+      const { deferred: stillDeferred } = resolveAnimateTargets(
+        animateEffective,
+        lengthLayoutOf(),
+        severity,
+        report,
+      )
+      const animateScope = next.animateScope ?? 'partial'
+      if (animateScope === 'full') {
+        const nextPending: PendingDeferredLengthTargets = {}
+        for (const key of Object.keys(stillDeferred)) {
+          nextPending[key] = { ...pendingDeferredAnimate?.[key], to: stillDeferred[key] }
+        }
+        // Origin pairs (review 73044cc0e1bd): a projection key holding a pending measured
+        // origin keeps its pair — the full-projection abandon law applies to keys the
+        // projection OMITS, never to origins it still names. The pair is SPREAD, never
+        // reconstructed (review 759cc100e882): the per-label update stamped its OWN transition
+        // on the entry, and the full sync must not launder it back to the mount fallback.
+        for (const key of Object.keys(animateEffective as Target)) {
+          if (key in stillDeferred) continue
+          const prior = pendingDeferredAnimate?.[key]
+          if (prior?.from !== undefined) {
+            nextPending[key] = {
+              ...prior,
+              to: (animateEffective as Record<string, unknown>)[key],
+            }
+          }
+        }
+        pendingDeferredAnimate = Object.keys(nextPending).length === 0 ? null : nextPending
+        if (pendingDeferredAnimate === null) {
+          pendingDeferredTransition = undefined
+          mountDeferredNeedsInstantFlush = false
+        }
+        // Do not clear mountDeferredNeedsInstantFlush otherwise — re-sync before first
+        // onLayout must preserve the mount initial:false instant latch
+        // (review-1785230277710-lhz6ub).
+      } else {
+        const nextPending: PendingDeferredLengthTargets = { ...pendingDeferredAnimate }
+        for (const key of Object.keys(animateEffective as Target)) {
+          if (key in stillDeferred) {
+            nextPending[key] = { ...pendingDeferredAnimate?.[key], to: stillDeferred[key] }
+          } else {
+            const prior = pendingDeferredAnimate?.[key]
+            if (prior?.from !== undefined) {
+              // Spread preserves the stamped transition (review 759cc100e882) — the per-label
+              // application's own transition rides into the flush, not the mount fallback.
+              nextPending[key] = {
+                ...prior,
+                to: (animateEffective as Record<string, unknown>)[key],
+              }
+            } else delete nextPending[key]
+          }
+        }
+        pendingDeferredAnimate = Object.keys(nextPending).length === 0 ? null : nextPending
+        if (pendingDeferredAnimate === null) {
+          pendingDeferredTransition = undefined
+          mountDeferredNeedsInstantFlush = false
+        }
+      }
+    },
+
+    update(next) {
+      commandLaneIsDeclarative = next.animateScope !== undefined
+      const h = requireHandle()
+      if (next.removalValues !== activeRemovalValues) {
+        activeRemovalValues = next.removalValues
+        handedOffRemovalKeys.clear()
+      }
+      // CAPTURE + validate the transition ONCE (review majors 51/61): this update reads its transition
+      // for the R8-F1 filter, per-prop defaults, AND up to THREE driver commands (array start, scalar
+      // retarget, color start) that each re-capture. The frozen snapshot is what validation AND every
+      // command see — a malicious accessor cannot skew the lanes/drivers or slip an unvalidated value.
+      // Materialize the animate arrays ONCE, then validate the SNAPSHOT (review major 60): shape gate
+      // first (no element read), then one frozen snapshot for validation, filtering, resolution, and the
+      // diff base — a direct consumer's accessor-backed array can't validate one value and forward another.
+      const animateShapeRefusal = targetShapeRefusal(next.animate, { componentId })
+      if (animateShapeRefusal !== null) throw animateShapeRefusal
+      const authoredTransition = captureAndValidateTransition(
+        next.transition,
+        componentId,
+        Object.keys(next.animate),
+      )
+      // T21 (REQ-API-053): the orchestration-computed delay seeds the VALIDATED snapshot as the
+      // per-key default — authored delays at every altitude win by the seeding spread, and the
+      // downstream lanes (flat command transition, map selection, count-aware default merge)
+      // execute it through the shipped T18-b delay machinery unchanged.
+      const transition =
+        next.orchestrationDelaySeconds === undefined
+          ? authoredTransition
+          : seedOrchestrationDelay(authoredTransition, next.orchestrationDelaySeconds)
+      const animateSnapshot = materializeTargetArrays(next.animate, componentId)
+      validateAgainstNativeHost(animateSnapshot, componentId)
+      // Filter R8-F1-incompatible arrays under severity FIRST (major 42): an indirect consumer (a
+      // gesture retarget batch riding the element-transition fallback) reaches update() past its
+      // supplying gate — report + drop the property (production) or throw (development) before any diff.
+      // Mount-refused keys are terminal for this mount (review 39c6a3e7ee90): they drop out of
+      // every lane here instead of crashing the fixed-at-mount invariant on a later update.
+      const compatAnimate = dropMountRefusedKeys(
+        filterStartCompat(animateSnapshot, transition, severity, report, componentId),
+        mountRefusedKeys,
+      )
+      // numeric→auto / auto→auto retarget re-measure (review 356417a77aec): a cached auto
+      // measure is STALE the moment an auto target arrives for that dimension — it may have
+      // been seeded from a constraint episode (numeric onLayout) or from content that since
+      // changed. Dropping it re-enters the deferred lane so the host drops the painted
+      // constraint and re-measures UNCONSTRAINED content; the flush then commands the fresh
+      // measure. The deferred flush's own re-entry opts out — it resolves auto against the
+      // measure it just seeded, and the pending queue was already drained before re-entry.
+      if (next.skipAutoMeasureInvalidation !== true && hooks.lengthLayoutContextBox !== undefined) {
+        const autoBox = hooks.lengthLayoutContextBox
+        let nextBox: LengthLayoutContext | null = null
+        for (const key of Object.keys(compatAnimate)) {
+          if (key !== 'width' && key !== 'height') continue
+          if (!containsAutoLengthTarget((compatAnimate as Record<string, unknown>)[key])) continue
+          if (containsAutoLengthTarget(pendingDeferredAnimate?.[key]?.to)) continue
+          if (nextBox === null) nextBox = { ...autoBox.current }
+          if (key === 'width') {
+            const { autoWidth: _dropped, ...rest } = nextBox
+            nextBox = rest
+          } else {
+            const { autoHeight: _dropped, ...rest } = nextBox
+            nextBox = rest
+          }
+        }
+        if (nextBox !== null) autoBox.current = nextBox
+      }
+      const { resolved, deferred: stillDeferred } = resolveAnimateTargets(
+        compatAnimate,
+        lengthLayoutOf(),
+        severity,
+        report,
+      )
+      // Pending-origin pairing (review 73044cc0e1bd): an incoming RESOLVED key whose pending
+      // entry holds a measured origin (an initial-only mount pending, or a paired mount
+      // origin) never retargets from the temporary 0 seed. An origin that measures NOW starts
+      // the pair immediately; one still needing the element box pairs into pending and waits
+      // for the flush. A boundary-refused origin is reported and dropped (production) — the
+      // target then rides the ordinary scalar lane.
+      const deferredPairKeys = new Set<string>()
+      const pairedStarts: Record<string, PropTarget> = {}
+      for (const key of Object.keys(resolved)) {
+        if (key in stillDeferred) continue
+        const prior = pendingDeferredAnimate?.[key]
+        if (prior?.from === undefined) continue
+        try {
+          const from = numericValue(key, prior.from, lengthLayoutOf())
+          const to = resolved[key]!
+          const perProp = perPropTransition(key, to, transition, motionPolicyOf())
+          pairedStarts[key] = {
+            to,
+            from,
+            ...(perProp === undefined ? {} : { transition: perProp }),
+          }
+        } catch (error) {
+          if (isDeferrableElementMeasureError(error)) {
+            deferredPairKeys.add(key)
+            continue
+          }
+          if (!isMeasureResolveBoundaryError(error)) throw error
+          if (severity === 'development') throw error
+          report(error)
+        }
+      }
+      // Deferred pending queue (majors 9044e8b70004 + 7c3a91e2b0d4):
+      // - supersession: keys resolved in this update leave pending
+      // - stillDeferred keys re-enter / stay
+      // - partial updates (gesture/label): absence does NOT abandon other pending keys
+      // - full declarative animate: rebuild from stillDeferred only (absent = abandoned)
+      // Mount seeds pending; flush drains it. Transition OWNERSHIP is per entry (review
+      // 93aeec05a9a8): this update's transition stamps only the keys IT defers or pairs —
+      // and an update with NO authored transition stamps the explicit default (review
+      // 7d395c90c954): supersession always transfers ownership, never retains the prior
+      // application's transition.
+      const stampTransition = (pair: PendingDeferredLengthTarget): PendingDeferredLengthTarget =>
+        transition === undefined ? { ...pair, transition: null } : { ...pair, transition }
+      const animateScope = next.animateScope ?? 'partial'
+      if (animateScope === 'full') {
+        const nextPending: PendingDeferredLengthTargets = {}
+        for (const key of Object.keys(stillDeferred)) {
+          nextPending[key] = stampTransition({
+            ...pendingDeferredAnimate?.[key],
+            to: stillDeferred[key],
+          })
+        }
+        for (const key of deferredPairKeys) {
+          nextPending[key] = stampTransition({
+            to: (compatAnimate as Record<string, unknown>)[key],
+            from: pendingDeferredAnimate![key]!.from,
+          })
+        }
+        pendingDeferredAnimate = Object.keys(nextPending).length === 0 ? null : nextPending
+        // Re-defer with a commanding update is post-mount — clear mount instant latch (and a
+        // supersession / empty full snapshot drains pending without flush — same latch end).
+        mountDeferredNeedsInstantFlush = false
+      } else {
+        const nextPending: PendingDeferredLengthTargets = {
+          ...pendingDeferredAnimate,
+        }
+        for (const key of Object.keys(compatAnimate)) {
+          if (key in stillDeferred) {
+            nextPending[key] = stampTransition({
+              ...pendingDeferredAnimate?.[key],
+              to: stillDeferred[key],
+            })
+          } else if (deferredPairKeys.has(key)) {
+            nextPending[key] = stampTransition({
+              to: (compatAnimate as Record<string, unknown>)[key],
+              from: pendingDeferredAnimate![key]!.from,
+            })
+          } else delete nextPending[key]
+        }
+        pendingDeferredAnimate = Object.keys(nextPending).length === 0 ? null : nextPending
+        if (pendingDeferredAnimate === null) {
+          pendingDeferredTransition = undefined
+          mountDeferredNeedsInstantFlush = false
+        }
+      }
+      const resolvedColors = resolveColors(compatAnimate)
+      const resolvedDiscretes = resolveDiscretes(compatAnimate)
+      // Diff RESOLVED values (M2.2 no-op invariant): scalars by ===, keyframe arrays ELEMENT-WISE
+      // (sameTargetValue) so a new-but-equal array on an unrelated re-render issues no command.
+      // Only changed keys ride a command (unlisted keys hold, REQ-API-002/012). A changed SCALAR
+      // RETARGETS (velocity-continuous); a changed ARRAY re-STARTS — retarget is scalar-only, and a
+      // keyframe array is an absolute sequence Motion restarts on change (R8 M2).
+      const changedScalars: Record<string, number> = {}
+      const changedArrayKeys: string[] = []
+      // Context-only re-resolutions of an unchanged authored array: retarget the resting final
+      // value instead of restarting (review 26cc511b0927) — filled by the array plan below.
+      const responsiveFinalRetargets: Record<string, number> = {}
+      for (const key of Object.keys(resolved)) {
+        // Paired keys never ride the ordinary lanes: a deferred pair waits for the flush, an
+        // already-measurable pair starts below from its measured origin — never the 0 seed.
+        if (deferredPairKeys.has(key) || key in pairedStarts) continue
+        const value = resolved[key]!
+        const prev = current[key]
+        // A removal episode is an execution edge, even when the declarative null-first target is
+        // unchanged: it must restart from the one captured removal origin rather than continue an
+        // older generator/velocity that presence is not measuring (REQ-PRESENCE-020).
+        const removalHandoff =
+          next.removalValues !== undefined &&
+          Array.isArray(value) &&
+          value[0] === null &&
+          !handedOffRemovalKeys.has(key)
+        const equalKeyframeReplay = next.restartEqualKeyframes === true && Array.isArray(value)
+        if (
+          prev !== undefined &&
+          sameTargetValue(prev, value) &&
+          !removalHandoff &&
+          !equalKeyframeReplay
+        )
+          continue
+        if (typeof value === 'number') changedScalars[key] = value
+        else changedArrayKeys.push(key)
+      }
+      // Discrete diff base is the declared keyword (scalar-only lane): unchanged keyword ⇒ no
+      // command (the no-op re-render discipline).
+      const changedDiscreteKeys = Object.keys(resolvedDiscretes).filter(
+        (key) => currentDiscreteCanonical[key] !== resolvedDiscretes[key],
+      )
+      const changedColorKeys = Object.keys(resolvedColors).filter(
+        // Diff the WHOLE declared target canonical (major 37): a changed MIDDLE keyframe re-commands
+        // even when the endpoints match. The no-op invariant still holds — an unrelated re-render
+        // passing the same color/array canonicalizes identically ⇒ no command.
+        (key) => {
+          const target = resolvedColors[key]!
+          return (
+            (next.restartEqualKeyframes === true && isColorArrayTarget(target)) ||
+            currentColorCanonical[key] !== colorTargetCanonical(target) ||
+            (next.removalValues !== undefined &&
+              isColorArrayTarget(target) &&
+              target[0] === null &&
+              !handedOffRemovalKeys.has(key))
+          )
+        },
+      )
+      if (
+        Object.keys(changedScalars).length === 0 &&
+        changedArrayKeys.length === 0 &&
+        changedColorKeys.length === 0 &&
+        changedDiscreteKeys.length === 0 &&
+        Object.keys(pairedStarts).length === 0 &&
+        Object.keys(responsiveFinalRetargets).length === 0
+      )
+        return false
+      // (`transition` — the per-call transition, r9 major c7de6fd1030b; captured once above, major 51.)
+      // The live committed value of a key, or a LOUD refusal if the key was never mounted (major 39:
+      // the array lane silently invented 0 for an unmounted key; the animated set is fixed at mount).
+      let committed: Readonly<Record<string, number>> | undefined
+      const committedValueOf = (key: string): number => {
+        committed ??= binding.driver.committed(h)
+        const value = committed[key]
+        if (value === undefined) {
+          throw new Error(
+            `L1: cannot update '${key}': it was not mounted on this element (the animated key set ` +
+              'is fixed at mount, REQ-API-002/012).',
+          )
+        }
+        return value
+      }
+      const numericFromCurrent = (key: string): number => {
+        if (next.removalValues === undefined) return committedValueOf(key)
+        const value = next.removalValues[key]
+        if (typeof value !== 'number') {
+          throw new Error(
+            `presence removal snapshot '${key}' must be numeric for a null-first numeric target ` +
+              `(received ${typeof value}; REQ-PRESENCE-020).`,
+          )
+        }
+        return value
+      }
+      const colorFromCurrent = (key: string, live: readonly RGBA[]): RGBA => {
+        if (next.removalValues === undefined) {
+          return parseColor(projectColorSequence(live, committedValueOf(key)))
+        }
+        const value = next.removalValues[key]
+        if (typeof value !== 'string') {
+          throw new Error(
+            `presence removal snapshot '${key}' must be a color string for a null-first color target ` +
+              `(received ${typeof value}; REQ-PRESENCE-020).`,
+          )
+        }
+        return parseColor(value)
+      }
+      // BUILD every plan purely, up front, so the whole update is ATOMIC (major 36): the numeric-array
+      // start + the color start are the driver's only FALLIBLE commands (an R8-F1 >2-keyframe explicit
+      // spring). Pre-validating them BEFORE any command/seed means a rejection mutates NOTHING — no
+      // scalar retarget, no endpoint seed, no `current` skew. A keyframe array re-STARTS (retarget is
+      // scalar-only) from the live committed value: continuity for a null-first array; a non-null-first
+      // array's tick-0 is keyframes[0] regardless. EXCEPTION (review 26cc511b0927): the SAME authored
+      // array re-resolving against changed context is a responsive remeasure, not a replacement —
+      // its resting final value RETARGETS (scalar lane, no first-keyframe replay).
+      const arrayTargets: Record<string, PropTarget> = {}
+      for (const key of changedArrayKeys) {
+        const to = resolved[key]! as PropTargetTo
+        const raw = (compatAnimate as Record<string, unknown>)[key]
+        const lastRaw = lastCommandedRawKeyframes.get(key)
+        // The removal handoff takes precedence over the responsive-retarget shortcut (review
+        // f48c90b9ad72): the SAME already-commanded null-first relative array as the exit target
+        // must restart from the captured REQ-PRESENCE-020 drop-time origin — never continue the
+        // older live flight presence is not measuring.
+        const removalHandoff =
+          next.removalValues !== undefined &&
+          Array.isArray(raw) &&
+          raw[0] === null &&
+          !handedOffRemovalKeys.has(key)
+        if (
+          !removalHandoff &&
+          next.restartEqualKeyframes !== true &&
+          lastRaw !== undefined &&
+          sameRawKeyframes(lastRaw, raw) &&
+          Array.isArray(raw) &&
+          restsAtRelativeForm(raw) &&
+          Array.isArray(to) &&
+          typeof to[to.length - 1] === 'number'
+        ) {
+          responsiveFinalRetargets[key] = to[to.length - 1] as number
+          lastCommandedRawKeyframes.set(key, raw)
+          continue
+        }
+        const from =
+          Array.isArray(to) && to[0] === null ? numericFromCurrent(key) : committedValueOf(key)
+        const perProp = perPropTransition(key, to, transition, motionPolicyOf())
+        arrayTargets[key] = { to, from, ...(perProp !== undefined ? { transition: perProp } : {}) }
+        if (Array.isArray(raw)) lastCommandedRawKeyframes.set(key, raw)
+      }
+      // L1 §semantics 5, oracle-faithful: re-seed from the CURRENT DISPLAYED color (C0 — the
+      // handoff frame is byte-continuous) through the live sequence and restart progress 0→100.
+      // Velocity is not transferable across endpoint pairs for mixed values — motion's own mixed-value
+      // interrupts restart the same way. Projection clamps/rounds overshot RGBA before it becomes the
+      // next committed origin, so interruption starts from exactly the frame React Native displayed.
+      const colorTargets: Record<string, PropTarget> = {}
+      const pendingColorSeeds: {
+        key: string
+        declaredTarget: ColorTarget
+        sequence: readonly RGBA[]
+      }[] = []
+      // The discrete mirror (T23 B2b): re-seed from the keyword DISPLAYED at the live progress
+      // (projectDiscreteStep — the same seam the animated style binds) and restart 0→100.
+      const discreteTargets: Record<string, PropTarget> = {}
+      const pendingDiscreteSeeds: {
+        key: string
+        declaredTarget: string
+        pair: readonly [string, string]
+      }[] = []
+      for (const key of changedDiscreteKeys) {
+        const live = discretes[key]
+        if (live === undefined) {
+          // A mount-refused discrete start (T23 B2a2) is terminal for the key: the one
+          // report fired at mount; retargets skip silently (the numeric refused-seed law).
+          if (mountRefusedKeys.has(key)) continue
+          throw new Error(`T23: discrete '${key}' has no registered pair on this element.`)
+        }
+        const target = resolvedDiscretes[key]!
+        const liveKeyword = projectDiscreteStep(live[0], live[1], committedValueOf(key))
+        const pair: readonly [string, string] = [liveKeyword, target]
+        pendingDiscreteSeeds.push({
+          key,
+          declaredTarget: target,
+          pair,
+        })
+        const perProp = perPropTransition(key, PROGRESS_END, transition, motionPolicyOf())
+        discreteTargets[key] = {
+          to: PROGRESS_END,
+          from: PROGRESS_START,
+          ...(perProp !== undefined ? { transition: perProp } : {}),
+        }
+      }
+      for (const key of changedColorKeys) {
+        const live = colors[key]
+        if (live === undefined) {
+          throw new Error(`L1: color '${key}' has no registered sequence on this element.`)
+        }
+        const target = resolvedColors[key]!
+        const nullFirst = isColorArrayTarget(target) && target[0] === null
+        const liveColor = nullFirst
+          ? colorFromCurrent(key, live)
+          : parseColor(projectColorSequence(live, committedValueOf(key)))
+        pendingColorSeeds.push({
+          key,
+          declaredTarget: target,
+          sequence: buildColorSequence(target, liveColor),
+        })
+        if (isColorArrayTarget(target)) {
+          const progressTo = colorProgressArray(target.length)
+          const perProp = perPropTransition(key, progressTo, transition, motionPolicyOf())
+          colorTargets[key] = {
+            to: progressTo,
+            from: PROGRESS_START,
+            ...(perProp !== undefined ? { transition: perProp } : {}),
+          }
+        } else {
+          // Mirror mount: scalar colors must carry perPropTransition so skipAnimations/isStatic
+          // force INSTANT on retarget (REQ-API-035 law (d); review r2 major 4). Pre-fix this
+          // branch emitted bare {to, from} and the color start rode the command-level timed tween.
+          const perProp = perPropTransition(key, PROGRESS_END, transition, motionPolicyOf())
+          colorTargets[key] = {
+            to: PROGRESS_END,
+            from: PROGRESS_START,
+            ...(perProp !== undefined ? { transition: perProp } : {}),
+          }
+        }
+      }
+      // Every changed SCALAR key must be MOUNTED too, proven BEFORE any command (review major 52): the
+      // array/color lanes proved their keys in the build phase above (committedValueOf), but an unmounted
+      // scalar was previously left to the driver's retarget — which threw AFTER the array start had
+      // already committed (non-atomic). The fixed-at-mount set is the authority (a mounted-but-unstepped
+      // key is absent from `committed`, so `committed` alone can't decide membership).
+      for (const key of Object.keys(changedScalars)) {
+        if (!registeredKeys.has(key)) {
+          throw new Error(
+            `L1: cannot update '${key}': it was not mounted on this element (the animated key set ` +
+              'is fixed at mount, REQ-API-002/012).',
+          )
+        }
+      }
+      // R8-F1-incompatible arrays were filtered up-front (compatAnimate) so neither arrayTargets nor
+      // colorTargets can hold one — every command below is infallible (major 36 atomicity).
+      // COMMIT: the color seeds publish before the color start.
+      // REQ-API-035: retarget carries a single command-level transition (no per-key slot). Split the
+      // batch when reducedMotion applies so transform keys force INSTANT while non-transforms keep the
+      // timed transition (review r1 major 2: every(TRANSFORM) left mixed batches fully animated).
+      // skipAnimations / isStatic force INSTANT on every key.
+      const scalarKeys = Object.keys(changedScalars)
+      const livePolicy = motionPolicyOf()
+      const baseRetargetTransition = transition ?? {}
+      // Paired starts carry their measured origin explicitly (review 73044cc0e1bd) — they join
+      // the start command rather than retargeting from the temporary seed.
+      const startTargets: Record<string, PropTarget> = { ...pairedStarts, ...arrayTargets }
+      if (Object.keys(startTargets).length > 0) {
+        commandThroughSeverity(h, {
+          kind: 'start',
+          targets: startTargets,
+          transition: transition ?? {},
+        })
+      }
+      // Responsive remeasure (review 26cc511b0927): the SAME authored array re-resolved against
+      // changed context — retarget the resting final value, never a sequence restart from the
+      // first keyframe. The retarget rides the SAME livePolicy law as the scalar lane (review
+      // 5c9810960d1a): skipAnimations/isStatic force INSTANT everywhere; shouldReduceMotion
+      // forces INSTANT on transform keys and keeps the timed transition elsewhere.
+      const responsiveKeys = Object.keys(responsiveFinalRetargets)
+      if (responsiveKeys.length > 0) {
+        if (livePolicy.skipAnimations) {
+          commandThroughSeverity(h, {
+            kind: 'retarget',
+            targets: responsiveFinalRetargets,
+            transition: INSTANT_TRANSITION,
+          })
+        } else if (livePolicy.shouldReduceMotion) {
+          const transformTargets: Record<string, number> = {}
+          const nonTransformTargets: Record<string, number> = {}
+          for (const key of responsiveKeys) {
+            if (TRANSFORM_KEY_SET.has(key)) transformTargets[key] = responsiveFinalRetargets[key]!
+            else nonTransformTargets[key] = responsiveFinalRetargets[key]!
+          }
+          if (Object.keys(transformTargets).length > 0) {
+            commandThroughSeverity(h, {
+              kind: 'retarget',
+              targets: transformTargets,
+              transition: INSTANT_TRANSITION,
+            })
+          }
+          if (Object.keys(nonTransformTargets).length > 0) {
+            commandThroughSeverity(h, {
+              kind: 'retarget',
+              targets: nonTransformTargets,
+              transition: baseRetargetTransition,
+            })
+          }
+        } else {
+          commandThroughSeverity(h, {
+            kind: 'retarget',
+            targets: responsiveFinalRetargets,
+            transition: baseRetargetTransition,
+          })
+        }
+      }
+      if (scalarKeys.length > 0) {
+        if (livePolicy.skipAnimations) {
+          commandThroughSeverity(h, {
+            kind: 'retarget',
+            targets: changedScalars,
+            transition: INSTANT_TRANSITION,
+          })
+        } else if (livePolicy.shouldReduceMotion) {
+          const transformTargets: Record<string, number> = {}
+          const nonTransformTargets: Record<string, number> = {}
+          for (const key of scalarKeys) {
+            if (TRANSFORM_KEY_SET.has(key)) transformTargets[key] = changedScalars[key]!
+            else nonTransformTargets[key] = changedScalars[key]!
+          }
+          if (Object.keys(transformTargets).length > 0) {
+            commandThroughSeverity(h, {
+              kind: 'retarget',
+              targets: transformTargets,
+              transition: INSTANT_TRANSITION,
+            })
+          }
+          if (Object.keys(nonTransformTargets).length > 0) {
+            commandThroughSeverity(h, {
+              kind: 'retarget',
+              targets: nonTransformTargets,
+              transition: baseRetargetTransition,
+            })
+          }
+        } else {
+          commandThroughSeverity(h, {
+            kind: 'retarget',
+            targets: changedScalars,
+            transition: baseRetargetTransition,
+          })
+        }
+      }
+      if (Object.keys(colorTargets).length > 0 || Object.keys(discreteTargets).length > 0) {
+        for (const { key, declaredTarget, sequence } of pendingColorSeeds) {
+          seed(key, declaredTarget, sequence)
+        }
+        for (const { key, declaredTarget, pair } of pendingDiscreteSeeds) {
+          seedDiscrete(key, declaredTarget, pair)
+        }
+        // REQ-API-035: skipAnimations/isStatic force INSTANT on every key — the color start's
+        // command-level transition is the fallback when a target omits per-prop (drivers read
+        // target.transition ?? command.transition). Per-prop already covers array colors via
+        // perPropTransition above; under skipAnimations the command slot is INSTANT too so no
+        // color key can fall back to a timed tween (review r2 major 4).
+        commandThroughSeverity(h, {
+          kind: 'start',
+          targets: { ...colorTargets, ...discreteTargets },
+          transition: livePolicy.skipAnimations ? INSTANT_TRANSITION : (transition ?? {}),
+        })
+      }
+      if (next.removalValues !== undefined) {
+        for (const key of changedArrayKeys) {
+          const target = resolved[key]
+          if (Array.isArray(target) && target[0] === null) handedOffRemovalKeys.add(key)
+        }
+        for (const key of changedColorKeys) {
+          const target = resolvedColors[key]
+          if (target !== undefined && isColorArrayTarget(target) && target[0] === null) {
+            handedOffRemovalKeys.add(key)
+          }
+        }
+      }
+      // The diff base records COMMANDED values only: a deferred pair (review 73044cc0e1bd) is
+      // not applied yet — the flush publishes its `current` when it commands the pair.
+      // Resting-form membership (review 1578a42974bc): a key rests at auto only when its FINAL
+      // authored keyframe is auto — an auto MIDDLE keyframe is a measurement episode, not the
+      // resting form. remeasureAutoRests re-seeds the released keys on content drift so the next
+      // edge originates from the drifted content, never a stale measure. A commanded key leaves
+      // the initial-only relative-rest lane too (review 7cec8ad963d8): its owning animate target
+      // re-resolves it through the ordinary update lane.
+      for (const key of Object.keys(startTargets)) {
+        if (restsAtAutoForm((compatAnimate as Record<string, unknown>)[key])) {
+          autoRestKeys.add(key)
+        } else {
+          autoRestKeys.delete(key)
+        }
+        relativeRestForms.delete(key)
+        // Non-array authority took the key (review b327265f3dc5): a later identical array is a
+        // NEW authored episode (restart), never a context-only re-resolution of the old one.
+        if (!Array.isArray((compatAnimate as Record<string, unknown>)[key])) {
+          lastCommandedRawKeyframes.delete(key)
+        }
+      }
+      for (const key of scalarKeys) {
+        if (restsAtAutoForm((compatAnimate as Record<string, unknown>)[key])) {
+          autoRestKeys.add(key)
+        } else {
+          autoRestKeys.delete(key)
+        }
+        relativeRestForms.delete(key)
+        lastCommandedRawKeyframes.delete(key)
+      }
+      const nextCurrent = { ...current }
+      for (const key of Object.keys(resolved)) {
+        if (!deferredPairKeys.has(key)) nextCurrent[key] = resolved[key]!
+      }
+      current = nextCurrent
+      return true
+    },
+
+    applyTransitionEnd(target) {
+      const h = requireHandle()
+      // BUILD every jump first (the major-36 atomicity shape): a refused key mutates nothing.
+      const numericJumps: Record<string, number> = {}
+      const discreteJumps: { key: string; keyword: string }[] = []
+      const colorJumps: { key: string; color: RGBA }[] = []
+      for (const key of Object.keys(target)) {
+        if (!registeredKeys.has(key)) {
+          throw new Error(
+            `T23: cannot apply transitionEnd '${key}': it was not mounted on this element ` +
+              '(the animated key set is fixed at mount, REQ-API-002/012).',
+          )
+        }
+        const value = target[key]
+        if (isDiscreteKey(key)) {
+          discreteJumps.push({ key, keyword: discreteValue(key, value) })
+        } else if (isColorKey(key)) {
+          colorJumps.push({ key, color: colorValue(key, value) })
+        } else {
+          const resolved = numericTargetValue(key, value, lengthLayoutOf())
+          if (typeof resolved !== 'number') {
+            throw new Error(
+              `T23: transitionEnd '${key}' must jump to a single numeric value ` +
+                '(keyframe arrays cannot jump).',
+            )
+          }
+          numericJumps[key] = resolved
+        }
+      }
+      // COMMIT: progress lanes re-seed settled (constant projection at the jumped value) and
+      // start INSTANT at PROGRESS_END; numerics ride one INSTANT retarget. Diff bases move so
+      // a later identical animate is a no-op.
+      const progressTargets: Record<string, PropTarget> = {}
+      for (const { key, keyword } of discreteJumps) {
+        seedDiscrete(key, keyword, [keyword, keyword])
+        progressTargets[key] = { to: PROGRESS_END, from: PROGRESS_END }
+      }
+      for (const { key, color } of colorJumps) {
+        seed(key, color, [color, color])
+        progressTargets[key] = { to: PROGRESS_END, from: PROGRESS_END }
+      }
+      if (Object.keys(progressTargets).length > 0) {
+        commandThroughSeverity(h, {
+          kind: 'start',
+          targets: progressTargets,
+          transition: INSTANT_TRANSITION,
+        })
+      }
+      if (Object.keys(numericJumps).length > 0) {
+        commandThroughSeverity(h, {
+          kind: 'retarget',
+          targets: numericJumps,
+          transition: INSTANT_TRANSITION,
+        })
+        current = { ...current, ...numericJumps }
+      }
+    },
+
+    currentColor(key: string): string {
+      // The deterministic observable of L1 §semantics 3: the SAME projectColorSequence seam the
+      // animated style binds, evaluated at the driver's live progress (major 35 — projects THROUGH
+      // the sequence; a scalar color is the 2-element endpoint case).
+      const h = requireHandle()
+      const c = colors[key]
+      if (c === undefined) {
+        throw new Error(
+          `L1: '${key}' is not a color key mounted on this element (specs/L1-BUILD-PACKET.md).`,
+        )
+      }
+      const progress = binding.driver.committed(h)[key]
+      if (progress === undefined) {
+        throw new Error(`L1: color '${key}' has no registered driver prop on this element.`)
+      }
+      return projectColorSequence(c, progress)
+    },
+
+    currentDiscrete(key: string): string {
+      // The discrete deterministic observable (T23 B2b): the SAME projectDiscreteStep seam the
+      // animated style binds, evaluated at the driver's live progress.
+      const h = requireHandle()
+      const pair = discretes[key]
+      if (pair === undefined) {
+        throw new Error(`T23: '${key}' is not a discrete key mounted on this element.`)
+      }
+      const progress = binding.driver.committed(h)[key]
+      if (progress === undefined) {
+        throw new Error(`T23: discrete '${key}' has no registered driver prop on this element.`)
+      }
+      return projectDiscreteStep(pair[0], pair[1], progress)
+    },
+
+    projectLatestValues(raw) {
+      // T23 C: the onUpdate projection — the driver marshal crosses the RAW committed record
+      // (numerics as-is; color/discrete lanes as [0,100] progress). Project each progress lane
+      // through the SAME seam its observable binds (currentColor / currentDiscrete — one truth
+      // per family); numeric keys pass through untouched. Pure JS, no UI crossing: the record
+      // already crossed with the marshal.
+      const out: Record<string, string | number> = {}
+      for (const key of Object.keys(raw)) {
+        const value = raw[key]!
+        const colorSequence = colors[key]
+        if (colorSequence !== undefined) {
+          out[key] = projectColorSequence(colorSequence, value)
+          continue
+        }
+        const pair = discretes[key]
+        if (pair !== undefined) {
+          out[key] = projectDiscreteStep(pair[0], pair[1], value)
+          continue
+        }
+        out[key] = value
+      }
+      return out
+    },
+
+    committedValues(keys) {
+      const committed = binding.driver.committed(requireHandle())
+      const snapshot: Record<string, ResolvedValue> = {}
+      for (const key of keys) {
+        if (!registeredKeys.has(key)) {
+          throw new Error(
+            `cannot snapshot committed '${key}': it was not registered on this MotionView controller.`,
+          )
+        }
+        const color = colors[key]
+        if (color !== undefined) {
+          const progress = committed[key]
+          if (progress === undefined) {
+            throw new Error(`L1: color '${key}' has no registered driver prop on this element.`)
+          }
+          snapshot[key] = projectColorSequence(color, progress)
+          continue
+        }
+        const pair = discretes[key]
+        if (pair !== undefined) {
+          const progress = committed[key]
+          if (progress === undefined) {
+            throw new Error(`T23: discrete '${key}' has no registered driver prop on this element.`)
+          }
+          snapshot[key] = projectDiscreteStep(pair[0], pair[1], progress)
+          continue
+        }
+        const value = committed[key]
+        if (value === undefined) {
+          throw new Error(
+            `cannot snapshot committed '${key}': it is registered on the MotionView controller ` +
+              'but absent from the driver.',
+          )
+        }
+        snapshot[key] = value
+      }
+      return Object.freeze(snapshot)
+    },
+
+    variantValueState() {
+      if (unmounted) {
+        throw new Error('MotionView controller cannot read variant value state after unmount().')
+      }
+      const h = requireHandle()
+      const current: Record<string, ResolvedValue> = {}
+      const velocity: Record<string, number> = {}
+      for (const key of registeredKeys) {
+        const live = binding.driver.liveFor(h, key)
+        const color = colors[key]
+        if (color !== undefined) {
+          current[key] = projectColorSequence(color, live.value)
+          velocity[key] = 0
+          continue
+        }
+        const pair = discretes[key]
+        if (pair !== undefined) {
+          current[key] = projectDiscreteStep(pair[0], pair[1], live.value)
+          velocity[key] = 0
+          continue
+        }
+        current[key] = live.value
+        velocity[key] = live.velocity
+      }
+      return { current: Object.freeze(current), velocity: Object.freeze(velocity) }
+    },
+
+    unmount() {
+      binding.driver.setActive(requireHandle(), false)
+      unmounted = true
+    },
+  }
+}
+
+// Re-exported so the checks screen asserts the exact error class the pipeline throws.
+export { InvalidTargetError }