@unrulysystems/native-motion 0.1.0-alpha.0

package/src/native/motion/identityValueChannelControllerAdapter.ts

@@ -0,0 +1,2043 @@
+import {
+  delayGenerator,
+  keyframesGenerator,
+  ManualClock,
+  resolveSpringGenerator,
+  timingGenerator,
+  toDelayMs,
+  toKeyframesConfig,
+  toSpringConfig,
+  type Animation,
+  type DriverCommand,
+  type ElementHandle,
+  type Generator,
+  type GeneratorFactory,
+  type MotionValue,
+  type Transition,
+} from '@unrulysystems/native-motion-core'
+import {
+  createExternalAnimationLedger,
+  createMotionValueDriverPort,
+  initialExternalAnimationLedgerState,
+  instantFinalKeyframe,
+  isDirectPublicNumericMotionValue,
+  isDurationZeroInstantTransition,
+  isTimingLaneTransition,
+  toTimingLaneConfig,
+  type TransportedSampleProgressEntry,
+  type TransportedSampleProgressState,
+  type TransportedSampleProgressWriter,
+  type TransportedSampleIrreversibleSubphase,
+} from '@unrulysystems/native-motion-core/internal-driver'
+
+import {
+  identityValueChannelDriverIdForBinding,
+  type WorkletDriverBinding,
+} from '../driver/workletDriver'
+import {
+  createDriverValueChannelIdentityRegistry,
+  type DriverValueChannelIdentityRegistry,
+  type DriverValueChannelIdentityRegistryRecord,
+  type DriverValueChannelSinkRegistration,
+  type DriverValueChannelState,
+} from './driverValueChannel'
+import {
+  advanceGlobalTargetBatch,
+  channelMailboxTransferStatusHandler,
+  channelMailboxTransferStatusValidator,
+  completeIdentityGlobalValueChannelExecution,
+  constructGlobalTargetBatchFromPostListenerMotionValueSlot,
+  createIdentityGlobalValueChannelHostOperationController,
+  drainChannelMailboxTurnEnvelope,
+  IdentityGlobalValueChannelInvariantError,
+  produceIdentityGlobalValueChannelSealedEmptyBatch,
+  sealChannelMailboxTurnEnvelope,
+  type ChannelMailboxDrainRuntime,
+  type ChannelMailboxDrainState,
+  type ChannelMailboxEntry,
+  type ChannelMailboxTurnEnvelope,
+  type GlobalTargetBatchRegistryState,
+  type IdentityGlobalValueChannelExternalAnimationRuntime,
+  type IdentityGlobalValueChannelHostOperationController,
+  type IdentityGlobalValueChannelHostOperationObservation,
+  type IdentityGlobalValueChannelIdentityState,
+  type IdentityGlobalValueChannelPublicControlState,
+  type IdentityGlobalValueChannelRuntimeState,
+  type TargetBatchDependencyEventKind,
+  type ValueChannel,
+} from './valueChannel'
+import type { IdentityValueChannelControllerElementReconciliationPlan } from './identityValueChannelControllerReconciliation'
+import { IDENTITY_DECLARATIVE_LANE_COMMAND } from './identityValueChannelLaneMarker'
+import {
+  identityChannelEligibleBoundStyleSnapshot,
+  type MotionViewAuthoredStyleMountPreparation,
+} from './styleValueBinding'
+
+/**
+ * Mount-known public-value bindings for one MotionView controller. The adapter attaches these
+ * exact objects when the controller registers its element, before that controller can issue a
+ * target command.
+ */
+export interface IdentityValueChannelControllerElementBinding {
+  readonly ownerDriverId: number
+  readonly ownerGeneration: number
+  readonly stylePreparation: MotionViewAuthoredStyleMountPreparation
+  readonly delegate: WorkletDriverBinding
+}
+
+declare const identityValueChannelElementAdapterBrand: unique symbol
+
+/** Opaque wrapper created only by the shared runtime; callers cannot forge a plain binding. */
+export interface IdentityValueChannelControllerElementAdapter extends IdentityValueChannelControllerElementBinding {
+  readonly [identityValueChannelElementAdapterBrand]: true
+  readonly binding: WorkletDriverBinding
+}
+
+export interface IdentityValueChannelMountedElementObservation {
+  readonly adapter: IdentityValueChannelControllerElementAdapter
+  readonly handle: ElementHandle
+  readonly sinkRegistrations: readonly DriverValueChannelSinkRegistration[]
+  readonly delegateCommittedValues: Readonly<Record<string, number>>
+}
+
+export interface IdentityValueChannelIdentityObservation {
+  readonly record: DriverValueChannelIdentityRegistryRecord<number>
+  readonly host: IdentityGlobalValueChannelHostOperationObservation
+  readonly publicControlSlot: IdentityGlobalValueChannelPublicControlState | null
+}
+
+export type IdentityValueChannelControllerOrderedEdge =
+  | {
+      readonly kind: 'LISTENER_STACK_COMPLETED'
+      readonly sequence: number
+      readonly batchId: number
+    }
+  | {
+      readonly kind: 'TARGET_BATCH_DEPENDENCY_APPENDED'
+      readonly sequence: number
+      readonly batchId: number
+      readonly dependencyId: number
+    }
+  | {
+      readonly kind: 'ASYNCHRONOUS_COMPLETION_DRAINED'
+      readonly sequence: number
+      readonly batchId: number
+      readonly dependencyId: number
+    }
+
+export interface IdentityValueChannelCarrierDelivery {
+  readonly batchId: number
+  readonly carrierId: number
+  readonly authoredIndex: number
+  readonly identityId: number
+  readonly key: string
+  readonly taskSequence: number
+}
+
+export interface IdentityValueChannelElementDelivery {
+  readonly batchId: number
+  readonly ownerDriverId: number
+  readonly ownerGeneration: number
+}
+
+/**
+ * Private production observability. Every record is the adapter's live canonical record or an
+ * immutable envelope/delivery emitted by the real command path; this surface never accepts a
+ * caller-authored capture, slot, dependency event, or scenario result.
+ */
+export interface IdentityValueChannelControllerRuntimeObservation {
+  readonly identities: readonly IdentityValueChannelIdentityObservation[]
+  readonly mountedElements: readonly IdentityValueChannelMountedElementObservation[]
+  readonly runtimeState: IdentityGlobalValueChannelRuntimeState
+  readonly targetBatchState: GlobalTargetBatchRegistryState
+  readonly orderedEdges: readonly IdentityValueChannelControllerOrderedEdge[]
+  readonly closedMailboxTurns: readonly ChannelMailboxTurnEnvelope[]
+  readonly carrierDeliveries: readonly IdentityValueChannelCarrierDelivery[]
+  readonly elementDeliveries: readonly IdentityValueChannelElementDelivery[]
+}
+
+/**
+ * Shared JS-global target/value-channel authority used by every concrete MotionView controller
+ * binding in one channel. Controller commands and public MotionValue callbacks are the only
+ * mutation entrances; test code can drive frames and replay a real emitted envelope, but cannot
+ * manufacture the controller's internal batch/capture protocol.
+ */
+export interface IdentityValueChannelControllerRuntime {
+  bindingForElement(
+    options: IdentityValueChannelControllerElementBinding,
+  ): IdentityValueChannelControllerElementAdapter
+  advanceFrame(elapsedMs: number): void
+  drainNextMailboxTurn(): void
+  replayMailboxTurn(envelope: ChannelMailboxTurnEnvelope): void
+  runReadyAggregateReactions(): void
+  observe(): IdentityValueChannelControllerRuntimeObservation
+}
+
+export interface CreateIdentityValueChannelControllerRuntimeOptions {
+  readonly channel: ValueChannel
+  readonly identityRegistry: DriverValueChannelIdentityRegistry<number>
+}
+
+export interface AttachIdentityValueChannelControllerElementOptions {
+  readonly channel: ValueChannel
+  readonly stylePreparation: MotionViewAuthoredStyleMountPreparation
+  readonly resolvedStyleValues: Readonly<Record<string, number | string>>
+  readonly delegate: WorkletDriverBinding
+}
+
+export interface ReconcileIdentityValueChannelControllerElementOptions {
+  readonly channel: ValueChannel
+  readonly handle: ElementHandle
+  readonly delegate: WorkletDriverBinding
+  readonly controllerBinding: WorkletDriverBinding
+  readonly adapter: IdentityValueChannelControllerElementAdapter | null
+  readonly plan: IdentityValueChannelControllerElementReconciliationPlan
+}
+
+export type IdentityValueChannelControllerAdapterOperation =
+  | 'CREATE_IDENTITY_VALUE_CHANNEL_CONTROLLER_RUNTIME'
+  | 'RECONCILE_IDENTITY_VALUE_CHANNEL_CONTROLLER_ELEMENT'
+
+export const IDENTITY_VALUE_CHANNEL_CONTROLLER_ADAPTER_UNIMPLEMENTED =
+  'NATIVE_MOTION_IDENTITY_VALUE_CHANNEL_CONTROLLER_ADAPTER_UNIMPLEMENTED' as const
+
+export const IDENTITY_VALUE_CHANNEL_CONTROLLER_ADAPTER_INVARIANT =
+  'NATIVE_MOTION_IDENTITY_VALUE_CHANNEL_CONTROLLER_ADAPTER_INVARIANT' as const
+
+export type IdentityValueChannelControllerAdapterInvariant = 'UNREGISTERED_WORKLET_DRIVER_BINDING'
+
+export class IdentityValueChannelControllerAdapterInvariantError extends Error {
+  readonly code = IDENTITY_VALUE_CHANNEL_CONTROLLER_ADAPTER_INVARIANT
+  readonly invariant: IdentityValueChannelControllerAdapterInvariant
+
+  constructor(invariant: IdentityValueChannelControllerAdapterInvariant) {
+    super(
+      `native-motion: identity value-channel controller adapter invariant '${invariant}' failed`,
+    )
+    this.name = 'IdentityValueChannelControllerAdapterInvariantError'
+    this.invariant = invariant
+  }
+}
+
+/** Typed fail-closed boundary for behavior deliberately absent from the RED scaffold. */
+export class IdentityValueChannelControllerAdapterUnimplementedError extends Error {
+  readonly code = IDENTITY_VALUE_CHANNEL_CONTROLLER_ADAPTER_UNIMPLEMENTED
+  readonly operation: IdentityValueChannelControllerAdapterOperation
+
+  constructor(operation: IdentityValueChannelControllerAdapterOperation) {
+    super(
+      `native-motion: identity value-channel controller adapter operation '${operation}' is ` +
+        'unimplemented (REQ-VALUE-015, REQ-DRIVER-034, REQ-API-061)',
+    )
+    this.name = 'IdentityValueChannelControllerAdapterUnimplementedError'
+    this.operation = operation
+  }
+}
+
+// ——— Runtime implementation (REQ-VALUE-015, REQ-DRIVER-034, REQ-API-061) ———
+// The shared JS-global authority: every concrete MotionView controller binding on one channel
+// resolves exact direct-public numeric identities into ONE canonical registry record, host
+// operation controller, and target-batch protocol per value. Controller commands and public
+// MotionValue callbacks are the only mutation entrances; frames, drains, replays, and reactions
+// are driven through the runtime surface below.
+
+interface IdentityValueChannelExecutionRecord {
+  readonly executionId: number
+  readonly controlId: number
+  readonly valueCompletionSequence: number
+  readonly lifecycleCallbackId: number
+  readonly directOperationEpoch: number
+  readonly executionLease: number
+  readonly owner: IdentityValueChannelElementAuthority
+  generator: Generator
+  handle: Animation
+  elapsedMs: number
+  done: boolean
+  stopped: boolean
+}
+
+interface IdentityValueChannelIdentityAuthority {
+  readonly identityId: number
+  readonly channelId: number
+  readonly record: DriverValueChannelIdentityRegistryRecord<number>
+  readonly controller: IdentityGlobalValueChannelHostOperationController
+  readonly slotByExecutionId: Map<number, IdentityGlobalValueChannelPublicControlState>
+  readonly executions: IdentityValueChannelExecutionRecord[]
+  readonly unsubscribeChangeLane: () => void
+  attachedSinkCount: number
+}
+
+interface IdentityValueChannelElementAuthority {
+  readonly adapter: IdentityValueChannelControllerElementAdapter
+  readonly delegate: WorkletDriverBinding
+  readonly ownerDriverId: number
+  readonly ownerGeneration: number
+  readonly eligibleKeys: readonly string[]
+  readonly resolvedStyleValues: Readonly<Record<string, number>>
+  readonly identityBindings: Map<string, IdentityValueChannelIdentityAuthority>
+  /**
+   * Identity keys a forwarded start/retarget made command-owned on the delegate. The driver's
+   * dual-authority law refuses a second write lane for them for the rest of the flight's life,
+   * so every adapter-originated delegate write skips them once the delegate proves it enforces
+   * that law (rigs without the guard keep receiving the writes their traces pin).
+   */
+  readonly commandOwnedKeys: Set<string>
+  /** Set on the delegate's first observed dual-authority write refusal; owned writes then skip. */
+  delegateRefusesOwnedWrites: boolean
+  handle: ElementHandle | null
+  frameValuesListener: ((values: Readonly<Record<string, number>>) => void) | null
+  /**
+   * False until the mount commit's synchronous block yields. Mount-phase entrance commands keep
+   * the timed trajectory class; only a settled element's host-resolved retargets commit their
+   * carrier synchronously (the carrier keyed to the host's own returned controls).
+   */
+  mountSettled: boolean
+}
+
+/**
+ * The reconcile entry's backchannel into a runtime's element/identity authorities. Only
+ * `createIdentityValueChannelControllerRuntime` registers here, so a caller cannot manufacture
+ * element authority through the public runtime surface.
+ */
+interface IdentityValueChannelControllerRuntimeInternals {
+  findElementByAdapter(
+    adapter: IdentityValueChannelControllerElementAdapter,
+  ): IdentityValueChannelElementAuthority | null
+  ensureElement(options: {
+    readonly adapter: IdentityValueChannelControllerElementAdapter
+    readonly delegate: WorkletDriverBinding
+    readonly ownerDriverId: number
+    readonly ownerGeneration: number
+    readonly handle: ElementHandle
+  }): IdentityValueChannelElementAuthority
+  detachIdentityValue(
+    element: IdentityValueChannelElementAuthority,
+    key: string,
+    value: MotionValue<number>,
+    spliceRegistry: boolean,
+  ): DriverValueChannelSinkRegistration | null
+  attachIdentityValue(
+    element: IdentityValueChannelElementAuthority,
+    key: string,
+    value: MotionValue<number>,
+    currentValue: number,
+    previous: {
+      readonly previousValue: MotionValue<number>
+      readonly previousSink: DriverValueChannelSinkRegistration
+    } | null,
+  ): void
+}
+
+const controllerRuntimeInternals = new WeakMap<
+  IdentityValueChannelControllerRuntime,
+  IdentityValueChannelControllerRuntimeInternals
+>()
+
+/** Every element authority by its branded adapter, for the mount-commit notification seam. */
+const elementByAdapter = new WeakMap<
+  IdentityValueChannelControllerElementAdapter,
+  IdentityValueChannelElementAuthority
+>()
+
+/**
+ * MotionView's first insertion effect of every commit reports it here: render-phase entrance
+ * commands (the mount block) keep their timed trajectory class, while everything after the
+ * boundary follows the settled carrier law. Idempotent per element.
+ */
+export function notifyIdentityValueChannelControllerMountCommit(
+  adapter: IdentityValueChannelControllerElementAdapter,
+): void {
+  const element = elementByAdapter.get(adapter)
+  if (element !== undefined) element.mountSettled = true
+}
+
+/** Whether a forwarded command owns the element's property for the rest of its flight's life. */
+function delegateOwnsKey(element: IdentityValueChannelElementAuthority, key: string): boolean {
+  return element.commandOwnedKeys.has(key)
+}
+
+const DUAL_AUTHORITY_WRITE_REFUSAL = 'cannot write bound value'
+
+/**
+ * The one adapter-originated delegate write lane. Command-owned keys ride it unless the
+ * delegate proves it enforces the dual-authority refusal — then they stay with the flight.
+ */
+function writeDelegateValues(
+  element: IdentityValueChannelElementAuthority,
+  values: Readonly<Record<string, number>>,
+): void {
+  if (element.handle === null || element.delegate.isDisposed()) return
+  const writable: Record<string, number> = {}
+  const owned: Record<string, number> = {}
+  for (const [key, value] of Object.entries(values)) {
+    if (delegateOwnsKey(element, key)) owned[key] = value
+    else writable[key] = value
+  }
+  if (Object.keys(writable).length > 0) {
+    element.delegate.driver.write(element.handle, writable, undefined, 'bound-value-retarget')
+  }
+  if (element.delegateRefusesOwnedWrites || Object.keys(owned).length === 0) return
+  try {
+    element.delegate.driver.write(element.handle, owned, undefined, 'bound-value-retarget')
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith(DUAL_AUTHORITY_WRITE_REFUSAL)) {
+      element.delegateRefusesOwnedWrites = true
+      return
+    }
+    throw error
+  }
+}
+
+/**
+ * The empty mount snapshot for a reconcile-time attach whose mount had no eligible identity. Only
+ * the reconcile entrance constructs it; eligibility itself always comes from the plan's edges.
+ */
+const EMPTY_MOUNT_STYLE_PREPARATION = {
+  boundStyleValues: {},
+  resolvedBoundStyleValues: {},
+  staticStyleValues: {},
+} as unknown as MotionViewAuthoredStyleMountPreparation
+
+/** The value's @internal lifecycle emitter (motion-value.ts), the same seam the graph uses. */
+function emitIdentityValueEvent(
+  value: MotionValue<number>,
+  event: 'animationStart' | 'animationComplete',
+): void {
+  const emitter = value as Partial<{
+    emitEvent: (emitted: 'animationStart' | 'animationComplete') => void
+  }>
+  emitter.emitEvent?.(event)
+}
+
+function isInstantIdentityTransition(transition: Transition): boolean {
+  return transition.type === false || isDurationZeroInstantTransition(transition)
+}
+
+/** One trajectory factory for a scalar/keyframe target, mirroring the drivers' lane selection. */
+function identityTrajectoryFactory(
+  target: number | readonly (number | null)[],
+  transition: Transition,
+): GeneratorFactory {
+  const delayMs = toDelayMs(transition)
+  const base: GeneratorFactory =
+    typeof target !== 'number'
+      ? keyframesGenerator(target, toKeyframesConfig(transition))
+      : transition.type === 'tween' || isTimingLaneTransition(transition)
+        ? timingGenerator(target, toTimingLaneConfig(transition))
+        : resolveSpringGenerator(target, toSpringConfig(transition))
+  return (seed) => (delayMs > 0 ? delayGenerator(base(seed), delayMs) : base(seed))
+}
+
+class IdentityValueChannelDrainProgressWriter implements TransportedSampleProgressWriter {
+  #state: TransportedSampleProgressState = {
+    activeEntry: null,
+    lastIrreversibleSubphase: null,
+    deliveredWriteWatermark: 0,
+    deliveredEventWatermark: 0,
+    retentionFinalization: 'pending',
+  }
+
+  beginEntry(entry: TransportedSampleProgressEntry): void {
+    this.#state = { ...this.#state, activeEntry: entry }
+  }
+
+  markIrreversibleSubphase(subphase: TransportedSampleIrreversibleSubphase): void {
+    this.#state = { ...this.#state, lastIrreversibleSubphase: subphase }
+  }
+
+  finalizeDeliveredWriteWatermarkAndRetention(
+    _channelId: number,
+    deliveredWriteWatermark: number,
+  ): void {
+    this.#state = {
+      ...this.#state,
+      deliveredWriteWatermark,
+      retentionFinalization: 'finalized',
+    }
+  }
+
+  finalizeDeliveredEventWatermarkAndRetention(
+    _channelId: number,
+    deliveredEventWatermark: number,
+  ): void {
+    this.#state = {
+      ...this.#state,
+      deliveredEventWatermark,
+      retentionFinalization: 'finalized',
+    }
+  }
+
+  clearEntry(): void {
+    this.#state = { ...this.#state, activeEntry: null, lastIrreversibleSubphase: null }
+  }
+
+  observe(): TransportedSampleProgressState {
+    return this.#state
+  }
+}
+
+function freshIdentityValueChannelDrainState(): ChannelMailboxDrainState {
+  return {
+    acceptedDrainIds: [],
+    completedPositions: [],
+    appliedEntryIds: [],
+    deliveredWriteWatermarks: [],
+    successfulTailCount: 0,
+    abortCount: 0,
+    abortPrefixReadyResolutionCount: 0,
+    retentionFinalizationCount: 0,
+  }
+}
+
+function resolveIdentityTarget(
+  command: DriverCommand & { readonly targets: object },
+  key: string,
+): {
+  readonly target: number | readonly (number | null)[]
+  readonly transition: Transition
+} {
+  if (command.kind === 'start') {
+    const targets = command.targets as Readonly<
+      Record<
+        string,
+        { readonly to: number | readonly (number | null)[]; readonly transition?: unknown }
+      >
+    >
+    const propTarget = targets[key]!
+    return {
+      target: propTarget.to,
+      transition: (propTarget.transition ?? command.transition) as Transition,
+    }
+  }
+  const retarget = command as Extract<DriverCommand, { readonly kind: 'retarget' }>
+  return {
+    target: (retarget.targets as Readonly<Record<string, number>>)[key]!,
+    transition: (retarget.targetTransitions?.[key] ?? retarget.transition) as Transition,
+  }
+}
+
+function partitionIdentityCommandKeys(
+  identityBindings: ReadonlyMap<string, unknown>,
+  targets: Readonly<Record<string, unknown>>,
+): { readonly identityKeys: string[]; readonly restKeys: string[] } {
+  const identityKeys: string[] = []
+  const restKeys: string[] = []
+  for (const key of Object.keys(targets)) {
+    if (identityBindings.has(key)) identityKeys.push(key)
+    else restKeys.push(key)
+  }
+  return { identityKeys, restKeys }
+}
+
+const unexpectedIdentityMailboxEntry = (): void => undefined
+
+/** Host frames never stage a transfer status; reaching one is a caller defect, fail closed. */
+const unexpectedIdentityTransferStatus = (): never => {
+  throw new IdentityGlobalValueChannelInvariantError('identity-unknown')
+}
+
+/** The one JS-global identity runtime for an exact public ValueChannel graph. */
+export function createIdentityValueChannelControllerRuntime(
+  options: CreateIdentityValueChannelControllerRuntimeOptions,
+): IdentityValueChannelControllerRuntime {
+  const { channel, identityRegistry } = options
+
+  // Monotonic id allocators; every sequence the tests pin is > 0 and order-consistent.
+  let nextIdentityId = 1
+  let nextChannelId = 1
+  let nextJsRecordId = 1
+  let nextUiRecordId = 1
+  let nextSinkId = 1
+  let nextExecutionId = 1
+  let nextControlId = 1
+  let nextValueCompletionSequence = 1
+  let nextCaptureId = 1
+  let nextDependencyId = 1
+  let nextCarrierId = 1
+  let nextCallbackId = 1
+  let nextBatchCreationSequence = 1
+  let nextExecutionCreationSequence = 1
+  let nextCommandSequence = 1
+  let nextDirectOperationEpoch = 1
+  let nextExecutionLease = 1
+  let nextWriteSequence = 1
+  let nextDependencyEventSequence = 1
+  let nextEdgeSequence = 1
+  let frameTimeMs = 0
+  let changeLaneSuppressionDepth = 0
+
+  const identities: IdentityValueChannelIdentityAuthority[] = []
+  const elements: IdentityValueChannelElementAuthority[] = []
+  const mountedElements: IdentityValueChannelElementAuthority[] = []
+  const lifecycleCallbacks = new Map<number, () => void>()
+  const transitionCallbacks = new Map<number, (value: number) => void>()
+  const carrierValues = new Map<number, number>()
+  const orderedEdges: IdentityValueChannelControllerOrderedEdge[] = []
+  const closedMailboxTurns: ChannelMailboxTurnEnvelope[] = []
+  const carrierDeliveries: IdentityValueChannelCarrierDelivery[] = []
+  const recordedCarrierDeliveryIds = new Set<number>()
+  const elementDeliveries: IdentityValueChannelElementDelivery[] = []
+  let mailboxDrainCursor = 0
+  let targetBatchState: GlobalTargetBatchRegistryState = {
+    batches: [],
+    nextBatchId: 1,
+    nextAggregateReactionSequence: 1,
+    readyBatchIdsByMailboxDrain: [],
+  }
+  let drainState: ChannelMailboxDrainState = freshIdentityValueChannelDrainState()
+  let replayDrainState: ChannelMailboxDrainState = freshIdentityValueChannelDrainState()
+
+  const runtime: IdentityGlobalValueChannelExternalAnimationRuntime = {
+    channel,
+    state: {
+      identities: [],
+      frameBuffers: {
+        executionCapacity: 4,
+        taskCapacity: 8,
+        completionCapacity: 4,
+        envelopeEntryCapacity: 16,
+        liveGrowthCount: 0,
+      },
+      pendingJsFrame: null,
+      nextMailboxDrainId: 1,
+      disposedOwnerDriverIds: [],
+    },
+    callbacks: {
+      publishChange: () => undefined,
+      markDerivedDirty: () => undefined,
+      invokeTransitionCallback(callbackId, _identityId, value) {
+        transitionCallbacks.get(callbackId)?.(value)
+      },
+      invokeLifecycleCallback(callbackId, _identityId) {
+        lifecycleCallbacks.get(callbackId)?.()
+      },
+      commitHostUpdate(record) {
+        const element = mountedElements.find(
+          (candidate) =>
+            candidate.ownerDriverId === record.driverId &&
+            (candidate.handle as number | null) === record.handleId,
+        )
+        if (element === null || element === undefined || element.handle === null) return
+        if (element.delegate.isDisposed()) return
+        const values: Record<string, number> = {}
+        for (const value of record.values) values[value.key] = value.value
+        writeDelegateValues(element, values)
+        element.frameValuesListener?.(element.delegate.driver.committed(element.handle))
+      },
+      requestJsFrame: () => undefined,
+      cancelJsFrame: () => undefined,
+    },
+    externalAnimationLedger: createExternalAnimationLedger({
+      graph: channel.graph,
+      initialState: initialExternalAnimationLedgerState(),
+    }),
+  }
+
+  const runtimeIdentities = runtime.state.identities as IdentityGlobalValueChannelIdentityState[]
+
+  function currentIdentity(
+    authority: IdentityValueChannelIdentityAuthority,
+  ): IdentityGlobalValueChannelIdentityState {
+    const identity = runtimeIdentities.find(
+      (candidate) => candidate.identityId === authority.identityId,
+    )
+    if (identity === undefined) {
+      throw new IdentityGlobalValueChannelInvariantError('identity-unknown')
+    }
+    return identity
+  }
+
+  function updateIdentity(
+    authority: IdentityValueChannelIdentityAuthority,
+    update: (
+      identity: IdentityGlobalValueChannelIdentityState,
+    ) => IdentityGlobalValueChannelIdentityState,
+  ): IdentityGlobalValueChannelIdentityState {
+    const index = runtimeIdentities.findIndex(
+      (candidate) => candidate.identityId === authority.identityId,
+    )
+    if (index < 0) throw new IdentityGlobalValueChannelInvariantError('identity-unknown')
+    const updated = update(runtimeIdentities[index]!)
+    runtimeIdentities[index] = updated
+    return updated
+  }
+
+  function readPublicControlSlot(
+    authority: IdentityValueChannelIdentityAuthority,
+  ): IdentityGlobalValueChannelPublicControlState | null {
+    const executionId = currentIdentity(authority).publicControlExecutionId
+    if (executionId === null) return null
+    return authority.slotByExecutionId.get(executionId) ?? null
+  }
+
+  /** The stop continuation every physical stopper routes: runtime state + the adapter's record. */
+  function onExecutionStopped(
+    authority: IdentityValueChannelIdentityAuthority,
+    executionId: number,
+  ): void {
+    const execution = authority.executions.find(
+      (candidate) => candidate.executionId === executionId,
+    )
+    if (execution !== undefined) execution.stopped = true
+    updateIdentity(authority, (current) => ({
+      ...current,
+      publicControlExecutionId:
+        current.publicControlExecutionId === executionId ? null : current.publicControlExecutionId,
+      physicalExecutions: current.physicalExecutions.map((candidate) =>
+        candidate.executionId === executionId
+          ? { ...candidate, phase: 'STOPPED' as const }
+          : candidate,
+      ),
+    }))
+  }
+
+  function initialRecordState(
+    channelId: number,
+    currentValue: number,
+    ownerGeneration: number,
+  ): DriverValueChannelState {
+    return {
+      identity: {
+        channelId,
+        jsRecordId: nextJsRecordId++,
+        uiRecordId: nextUiRecordId++,
+        creationKind: 'direct-public-finite-number',
+        publicReferenceRetained: true,
+        sinkCount: 1,
+        changeObserverCount: 0,
+        publicControlSlotId: null,
+        physicalExecutionIds: [],
+        dueWorkSequences: [],
+        valueCompletionSequences: [],
+        targetBatchDependencyIds: [],
+        dependencyEventOutboxSequences: [],
+        dependencyEventAckWatermark: 0,
+        sharedBatchReferenceCount: 0,
+        pendingFrameActivity: false,
+        currentBindingGeneration: ownerGeneration,
+        retiredBindingGeneration: 0,
+        directOperationEpoch: 1,
+        executionLeaseEpoch: 1,
+        history: {
+          currentValue,
+          previousValue: currentValue,
+          currentTimestampMs: 0,
+          previousTimestampMs: 0,
+        },
+        sequences: {
+          authoritativeSequence: 1,
+          commandSequence: 1,
+          writeSequence: 1,
+          eventSequence: 1,
+          frameSequence: 1,
+          dueWorkSequence: 1,
+          valueCompletionSequence: 1,
+          batchDependencyEventSequence: 0,
+          dependencyOutboxAckSequence: 0,
+        },
+      },
+      handoff: {
+        ownership: 'UI_RUNNING',
+        desiredSide: null,
+        direction: null,
+        transferLease: 1,
+        phaseToken: 1,
+        sourceRecordId: null,
+        destinationRecordId: null,
+        absoluteTransferDeadlineMs: null,
+        absoluteNoConsumerDeadlineMs: null,
+        releaseFenceSequence: null,
+        sentThroughAuthoritativeSequence: 1,
+        drainedThroughAuthoritativeSequence: 1,
+        preparedMutableTuple: null,
+        destinationRuntime: null,
+        sourceMutationQueue: [],
+        commitQueue: [],
+        resources: {
+          preparedStateRetained: false,
+          preparedCloneRetained: false,
+          transferActivityRetained: false,
+          transferTimerArmed: false,
+        },
+      },
+    }
+  }
+
+  /** The change lane: a public direct write schedules its task and commits every attached sink. */
+  function subscribeChangeLane(authority: IdentityValueChannelIdentityAuthority): () => void {
+    return authority.record.value.on('change', (latest: number) => {
+      if (changeLaneSuppressionDepth > 0) return
+      if (typeof latest !== 'number') return
+      authority.controller.schedule({
+        kind: 'SCHEDULE_IDENTITY_GLOBAL_VALUE_CHANNEL_DIRECT_WRITE',
+        operation: 'SET',
+        value: latest,
+      })
+      for (const sink of currentIdentity(authority).sinks) {
+        if (!sink.attached) continue
+        const element = mountedElements.find(
+          (candidate) =>
+            candidate.ownerDriverId === sink.driverId &&
+            (candidate.handle as number | null) === sink.handleId,
+        )
+        if (element === undefined || element.handle === null || element.delegate.isDisposed()) {
+          continue
+        }
+        writeDelegateValues(element, { [sink.key]: latest })
+        element.frameValuesListener?.(element.delegate.driver.committed(element.handle))
+      }
+    })
+  }
+
+  /** Attach one element's key to an exact identity, creating the canonical record on first use. */
+  function attachIdentityValueToElement(
+    element: IdentityValueChannelElementAuthority,
+    key: string,
+    value: MotionValue<number>,
+    currentValue: number,
+    previous: {
+      readonly previousValue: MotionValue<number>
+      readonly previousSink: DriverValueChannelSinkRegistration
+    } | null,
+  ): IdentityValueChannelIdentityAuthority | null {
+    if (element.handle === null) return null
+    const handle = element.handle as number
+    const existing = identities.find((candidate) => candidate.record.value === value)
+    if (existing !== undefined) {
+      const sink: DriverValueChannelSinkRegistration = {
+        driverId: element.ownerDriverId,
+        handle,
+        key,
+        bindingGeneration: element.ownerGeneration,
+      }
+      if (previous !== null) {
+        identityRegistry.rebind({
+          previousValue: previous.previousValue,
+          previousSink: previous.previousSink,
+          replacement: {
+            value: existing.record.value,
+            port: existing.record.port,
+            currentValue,
+            requestedState: existing.record.state,
+            sink,
+          },
+        })
+      } else {
+        identityRegistry.resolveBinding({
+          value: existing.record.value,
+          port: existing.record.port,
+          currentValue,
+          requestedState: existing.record.state,
+          sink,
+        })
+      }
+      const sinkId = nextSinkId++
+      updateIdentity(existing, (current) => ({
+        ...current,
+        sinks: [
+          ...current.sinks,
+          {
+            sinkId,
+            driverId: element.ownerDriverId,
+            handleId: handle,
+            bindingGeneration: element.ownerGeneration,
+            key,
+            passive: false,
+            attached: true,
+          },
+        ],
+      }))
+      existing.attachedSinkCount += 1
+      element.identityBindings.set(key, existing)
+      return existing
+    }
+
+    const identityId = nextIdentityId++
+    const channelId = nextChannelId++
+    const port = createMotionValueDriverPort({
+      value,
+      clock: new ManualClock(),
+      channelId,
+      rawSnapshot: {
+        kind: 'collector-silent-motion-value-raw-snapshot',
+        currentValue,
+        history: { kind: 'single-sample', currentValue, currentTimestampMs: 0 },
+        directOperationEpoch: 1,
+        authoritativeSequence: 1,
+      },
+    })
+    const sink: DriverValueChannelSinkRegistration = {
+      driverId: element.ownerDriverId,
+      handle,
+      key,
+      bindingGeneration: element.ownerGeneration,
+    }
+    const requestedState = initialRecordState(channelId, currentValue, element.ownerGeneration)
+    const resolution =
+      previous !== null
+        ? identityRegistry.rebind({
+            previousValue: previous.previousValue,
+            previousSink: previous.previousSink,
+            replacement: { value, port, currentValue, requestedState, sink },
+          }).replacement
+        : identityRegistry.resolveBinding({ value, port, currentValue, requestedState, sink })
+    if (resolution.kind !== 'eligible') return null
+    const record = resolution.record
+    const identity: IdentityGlobalValueChannelIdentityState = {
+      identityId,
+      channelId,
+      value: record.value,
+      ownership: {
+        kind: 'UI_RUNNING',
+        driverId: element.ownerDriverId,
+        ownerGeneration: element.ownerGeneration,
+      },
+      publicControlExecutionId: null,
+      sinks: [
+        {
+          sinkId: nextSinkId++,
+          driverId: element.ownerDriverId,
+          handleId: handle,
+          bindingGeneration: element.ownerGeneration,
+          key,
+          passive: false,
+          attached: true,
+        },
+      ],
+      observers: [],
+      physicalExecutions: [],
+      pendingTasks: [],
+      pendingValueCompletions: [],
+      pendingFrameActivity: false,
+      targetBatchDependencyEvents: [],
+      dependencyEventAckWatermark: 0,
+      carrierReferenceCount: 0,
+      cache: {
+        currentValue,
+        previousValue: currentValue,
+        currentTimestampMs: 0,
+        previousTimestampMs: 0,
+        velocity: 0,
+      },
+    }
+    runtimeIdentities.push(identity)
+    const authority: IdentityValueChannelIdentityAuthority = {
+      identityId,
+      channelId,
+      record,
+      controller: createIdentityGlobalValueChannelHostOperationController({ record, runtime }),
+      slotByExecutionId: new Map(),
+      executions: [],
+      unsubscribeChangeLane: () => undefined,
+      attachedSinkCount: 1,
+    }
+    identities.push(authority)
+    ;(authority as { unsubscribeChangeLane: () => void }).unsubscribeChangeLane =
+      subscribeChangeLane(authority)
+    element.identityBindings.set(key, authority)
+    return authority
+  }
+
+  /** Detach one element's sink from an exact identity; returns the sink for a rebind chain. */
+  function detachIdentityValueFromElement(
+    element: IdentityValueChannelElementAuthority,
+    key: string,
+    value: MotionValue<number>,
+    spliceRegistry: boolean,
+  ): DriverValueChannelSinkRegistration | null {
+    if (element.handle === null) return null
+    const authority = identities.find((candidate) => candidate.record.value === value)
+    if (authority === undefined) {
+      element.identityBindings.delete(key)
+      return null
+    }
+    const handle = element.handle as number
+    const sink =
+      authority.record.sinks.find(
+        (candidate) =>
+          candidate.driverId === element.ownerDriverId &&
+          candidate.handle === handle &&
+          candidate.key === key,
+      ) ?? null
+    if (sink !== null && spliceRegistry) {
+      identityRegistry.detachBinding({ value: authority.record.value, sink })
+    }
+    if (sink !== null) {
+      updateIdentity(authority, (current) => ({
+        ...current,
+        sinks: current.sinks.map((candidate) =>
+          candidate.driverId === element.ownerDriverId &&
+          candidate.handleId === handle &&
+          candidate.key === key
+            ? { ...candidate, attached: false }
+            : candidate,
+        ),
+      }))
+      authority.attachedSinkCount -= 1
+      if (authority.attachedSinkCount === 0) authority.unsubscribeChangeLane()
+    }
+    element.identityBindings.delete(key)
+    return sink
+  }
+
+  /** Attach one element's eligible key to its value's canonical identity, creating it on first use. */
+  function bindIdentityKey(
+    element: IdentityValueChannelElementAuthority,
+    key: string,
+  ): IdentityValueChannelIdentityAuthority | null {
+    const bound = element.adapter.stylePreparation.boundStyleValues[key]
+    const currentValue = element.resolvedStyleValues[key]
+    if (bound === undefined || currentValue === undefined || element.handle === null) return null
+    // The mount snapshot already filtered to this class; the predicate re-narrows the type (and
+    // keeps the one-read law — the scalar is the captured snapshot, never a fresh get()).
+    if (!isDirectPublicNumericMotionValue(bound, currentValue)) return null
+    return attachIdentityValueToElement(element, key, bound, currentValue, null)
+  }
+
+  /**
+   * One ordinary identity start: install the runtime control BEFORE the physical start so the
+   * synchronous animationStart stack observes it, then capture the graph handle/generator.
+   */
+  function startIdentityExecution(
+    element: IdentityValueChannelElementAuthority,
+    authority: IdentityValueChannelIdentityAuthority,
+    target: number | readonly (number | null)[],
+    transition: Transition,
+  ): void {
+    const identity = currentIdentity(authority)
+    // Stale-clear: executions stopped BEFORE this start retire with it, so a successor coexists
+    // only with the live orphan lineage (the current start's own interruption is not stale).
+    const preStoppedExecutionIds = new Set(
+      identity.physicalExecutions
+        .filter((candidate) => candidate.phase === 'STOPPED')
+        .map((candidate) => candidate.executionId),
+    )
+    const executionId = nextExecutionId++
+    const controlId = nextControlId++
+    const valueCompletionSequence = nextValueCompletionSequence++
+    const directOperationEpoch = nextDirectOperationEpoch++
+    const executionLease = nextExecutionLease++
+    const initiatingSink = identity.sinks.find(
+      (candidate) =>
+        candidate.attached &&
+        candidate.driverId === element.ownerDriverId &&
+        candidate.handleId === (element.handle as number),
+    )
+    authority.controller.dispatch({
+      kind: 'HOST_START_IDENTITY_GLOBAL_VALUE_CHANNEL_EXECUTION',
+      identityId: authority.identityId,
+      initiatingSinkId: initiatingSink?.sinkId ?? 0,
+      commandSequence: nextCommandSequence++,
+      directOperationEpoch,
+      executionLease,
+      requestedExecution: {
+        executionId,
+        creationSequence: nextExecutionCreationSequence++,
+        updateSequence: 0,
+        phase: 'RUNNING',
+        orphaned: false,
+        retained: true,
+        sample: {
+          writeSequence: 0,
+          value: identity.cache.currentValue,
+          velocity: identity.cache.velocity,
+          done: false,
+        },
+        transitionOnUpdateCallbackId: null,
+        transitionOnCompleteCallbackId: null,
+      },
+    })
+    authority.slotByExecutionId.set(executionId, {
+      controlId,
+      executionId,
+      valueCompletionSequence,
+    })
+    const lifecycleCallbackId = nextCallbackId++
+    lifecycleCallbacks.set(lifecycleCallbackId, () =>
+      emitIdentityValueEvent(authority.record.value, 'animationComplete'),
+    )
+    updateIdentity(authority, (current) => ({
+      ...current,
+      pendingValueCompletions: [
+        ...current.pendingValueCompletions,
+        {
+          completionSequence: valueCompletionSequence,
+          executionId,
+          lifecycleCallbackId,
+          publicStartPromiseId: null,
+          armed: true,
+        },
+      ],
+    }))
+    const factory = identityTrajectoryFactory(target, transition)
+    const execution: IdentityValueChannelExecutionRecord = {
+      executionId,
+      controlId,
+      valueCompletionSequence,
+      lifecycleCallbackId,
+      directOperationEpoch,
+      executionLease,
+      owner: element,
+      generator: null as unknown as Generator,
+      handle: null as unknown as Animation,
+      elapsedMs: 0,
+      done: false,
+      stopped: false,
+    }
+    const handle = channel.graph.animate(authority.record.value, (seed) => {
+      const generator = factory(seed)
+      execution.generator = generator
+      return generator
+    })
+    execution.handle = handle
+    authority.executions.push(execution)
+    // A stop through the graph's own stopper during the animationStart stack (no port installation
+    // existed yet) leaves no continuation hook; reconcile it from the finished handle.
+    if (handle.done && !execution.stopped) onExecutionStopped(authority, executionId)
+    // The port slot installs only while the runtime slot still holds THIS execution; a listener
+    // that replaced or stopped it keeps its own outcome.
+    if (currentIdentity(authority).publicControlExecutionId === executionId) {
+      authority.record.port.installPublicControlSlot({
+        controlId,
+        executionId,
+        stopPhysicalExecution: () => {
+          handle.stop()
+          onExecutionStopped(authority, executionId)
+        },
+      })
+    }
+    if (preStoppedExecutionIds.size > 0) {
+      updateIdentity(authority, (current) => ({
+        ...current,
+        physicalExecutions: current.physicalExecutions.filter(
+          (candidate) => !preStoppedExecutionIds.has(candidate.executionId),
+        ),
+      }))
+    }
+  }
+
+  /** The canonical target-command flow: one batch per command, one capture/carrier per key. */
+  function runIdentityTargetCommandFlow(
+    element: IdentityValueChannelElementAuthority,
+    command: DriverCommand & { readonly targets: object },
+    identityKeys: readonly string[],
+    carrierClass: boolean,
+  ): void {
+    targetBatchState = advanceGlobalTargetBatch(targetBatchState, {
+      kind: 'OPEN_TARGET_BATCH',
+      creationSequence: nextBatchCreationSequence++,
+      ownerDriverId: element.ownerDriverId,
+      ownerGeneration: element.ownerGeneration,
+      orchestrationDependencyCount: 0,
+    }).state
+    const batchId = targetBatchState.batches[targetBatchState.batches.length - 1]!.batchId
+    const deferredCarriers: {
+      readonly authority: IdentityValueChannelIdentityAuthority
+      readonly key: string
+      readonly authoredIndex: number
+      readonly carrierId: number
+      readonly value: number
+    }[] = []
+    identityKeys.forEach((key, authoredIndex) => {
+      const authority = element.identityBindings.get(key)
+      if (authority === undefined) return
+      const { target, transition } = resolveIdentityTarget(command, key)
+      // The host-resolved carrier class (a gesture-state/presence retarget of any transition
+      // shape) rides the apparent-instant lane: no control, no flight — the carrier commit below
+      // is the write — while a declarative/transition-defined target keeps its timed trajectory.
+      const instant = carrierClass || isInstantIdentityTransition(transition)
+      if (instant) {
+        // The apparent-instant lane leaves no slot and emits no cancel: no runtime control, no
+        // physical execution; the start still publishes so listeners observe the absent slot.
+        if (currentIdentity(authority).publicControlExecutionId !== null) {
+          authority.record.value.stop()
+        }
+        emitIdentityValueEvent(authority.record.value, 'animationStart')
+      } else {
+        startIdentityExecution(element, authority, target, transition)
+      }
+      const captureId = nextCaptureId++
+      const listenerStackCompletionSequence = nextEdgeSequence++
+      orderedEdges.push({
+        kind: 'LISTENER_STACK_COMPLETED',
+        sequence: listenerStackCompletionSequence,
+        batchId,
+      })
+      const dependencyId = nextDependencyId++
+      const constructed = constructGlobalTargetBatchFromPostListenerMotionValueSlot(
+        targetBatchState,
+        {
+          kind: instant
+            ? 'CONSTRUCT_APPARENT_INSTANT_GLOBAL_TARGET_BATCH_CAPTURE'
+            : 'CONSTRUCT_REPLACED_ORDINARY_GLOBAL_TARGET_BATCH_CAPTURE',
+          batchId,
+          identityId: authority.identityId,
+          captureId,
+          authoredIndex,
+          listenerStackCompletionSequence,
+          dependencyId,
+        },
+        {
+          value: authority.record.value,
+          readPublicControlSlot: () => readPublicControlSlot(authority),
+        },
+      )
+      targetBatchState = constructed.state
+      const batch = targetBatchState.batches.find((candidate) => candidate.batchId === batchId)
+      const capture = batch?.capturedControls.find((candidate) => candidate.captureId === captureId)
+      const carrierValue = instantFinalKeyframe(target)
+      if (capture?.kind === 'PUBLIC_IDENTITY') {
+        orderedEdges.push({
+          kind: 'TARGET_BATCH_DEPENDENCY_APPENDED',
+          sequence: nextEdgeSequence++,
+          batchId,
+          dependencyId,
+        })
+        const carrierId = nextCarrierId++
+        const receipt = authority.controller.schedule({
+          kind: 'SCHEDULE_IDENTITY_GLOBAL_VALUE_CHANNEL_CARRIER',
+          carrierId,
+          authoredIndex,
+          key,
+          value: carrierValue,
+        })
+        targetBatchState = advanceGlobalTargetBatch(targetBatchState, {
+          kind: 'APPEND_AUTHORED_TARGET_BATCH_CARRIER',
+          batchId,
+          carrier: {
+            carrierId,
+            authoredIndex,
+            identityId: authority.identityId,
+            key,
+            taskSequence: receipt.scheduledTask.taskSequence,
+          },
+        }).state
+        carrierValues.set(carrierId, carrierValue)
+        // A raw-waiting carrier's delivery records when it actually drains at the reaction.
+        return
+      }
+      deferredCarriers.push({
+        authority,
+        key,
+        authoredIndex,
+        carrierId: nextCarrierId++,
+        value: carrierValue,
+      })
+    })
+    const sealed = targetBatchState.batches.find((candidate) => candidate.batchId === batchId)
+    if (sealed !== undefined && sealed.dependencies.length === 0) {
+      // Zero-dependency seal: the carrier tasks schedule inside the production boundary, and the
+      // delivery records land now while the element delivery waits for the reaction.
+      const produced = produceIdentityGlobalValueChannelSealedEmptyBatch(
+        targetBatchState,
+        runtime,
+        {
+          kind: 'PRODUCE_IDENTITY_GLOBAL_VALUE_CHANNEL_SEALED_EMPTY_BATCH',
+          batchId,
+          preparedTargets: [],
+          authoredCarriers: deferredCarriers.map(
+            ({ authority, authoredIndex, carrierId, key, value }) => ({
+              identityId: authority.identityId,
+              command: {
+                kind: 'SCHEDULE_IDENTITY_GLOBAL_VALUE_CHANNEL_CARRIER',
+                carrierId,
+                authoredIndex,
+                key,
+                value,
+              },
+            }),
+          ),
+        },
+      )
+      targetBatchState = produced.batchState
+      produced.carrierReceipts.forEach((receipt, index) => {
+        const deferred = deferredCarriers[index]!
+        carrierValues.set(deferred.carrierId, deferred.value)
+        // A sealed-empty carrier queued synchronously at seal: its delivery records now, while
+        // the element delivery still waits for the reaction.
+        recordCarrierDelivery({
+          batchId,
+          carrierId: deferred.carrierId,
+          authoredIndex: deferred.authoredIndex,
+          identityId: deferred.authority.identityId,
+          key: deferred.key,
+          taskSequence: receipt.scheduledTask.taskSequence,
+        })
+      })
+      return
+    }
+    targetBatchState = advanceGlobalTargetBatch(targetBatchState, {
+      kind: 'SEAL_TARGET_BATCH',
+      batchId,
+    }).state
+  }
+
+  /**
+   * A completing execution: the lifecycle emits while the post-listener slot is still installed,
+   * then the slot clears token-blind WITHOUT stopping the retained physical execution (the
+   * successor keeps sampling as an orphan), and only then do the batch dependency events stage.
+   */
+  function completeIdentityExecution(
+    authority: IdentityValueChannelIdentityAuthority,
+    execution: IdentityValueChannelExecutionRecord,
+    openEntries: ChannelMailboxEntry[],
+  ): void {
+    const descriptor = {
+      controlId: execution.controlId,
+      executionId: execution.executionId,
+      valueCompletionSequence: execution.valueCompletionSequence,
+      target: currentIdentity(authority).cache.currentValue,
+    }
+    const slot = readPublicControlSlot(authority)
+    completeIdentityGlobalValueChannelExecution(
+      {
+        value: authority.record.value,
+        readPublicControlSlot: () => readPublicControlSlot(authority),
+        startExecution: () => undefined,
+        invokeDetachedCallback: () => undefined,
+        invokeCompletionListener: (listenerId) => {
+          transitionCallbacks.get(listenerId)?.(currentIdentity(authority).cache.currentValue)
+        },
+        emitAnimationCancel: () => undefined,
+        emitAnimationComplete: () =>
+          emitIdentityValueEvent(authority.record.value, 'animationComplete'),
+        clearPublicControlSlotTokenBlind: (causedByExecutionId) => {
+          const cleared = currentIdentity(authority).publicControlExecutionId
+          // Token-blind (pinned completion/cancellation continuation): the post-listener slot
+          // clears unconditionally and the retained physical execution is NEVER stopped.
+          authority.record.port.clearPublicControlSlotTokenBlind(causedByExecutionId)
+          updateIdentity(authority, (current) => ({
+            ...current,
+            publicControlExecutionId: null,
+            physicalExecutions: current.physicalExecutions.map((candidate) =>
+              candidate.executionId === cleared && cleared !== causedByExecutionId
+                ? { ...candidate, orphaned: true }
+                : candidate,
+            ),
+            pendingValueCompletions: current.pendingValueCompletions.filter(
+              (candidate) => candidate.completionSequence !== execution.valueCompletionSequence,
+            ),
+          }))
+        },
+        stopPublicControl: () => authority.record.value.stop(),
+        adoptPassiveTerminalCache: () => undefined,
+        readSynchronousUiSnapshot: () => {
+          const cache = currentIdentity(authority).cache
+          return { value: cache.currentValue, velocity: cache.velocity }
+        },
+      },
+      {
+        kind: 'DELIVER_ORPHAN_IDENTITY_COMPLETION_AGAINST_SUCCESSOR_SLOT',
+        identityId: authority.identityId,
+        orphanExecution: descriptor,
+        installedSuccessor:
+          slot === null
+            ? descriptor
+            : {
+                controlId: slot.controlId,
+                executionId: slot.executionId,
+                valueCompletionSequence: slot.valueCompletionSequence,
+                target: currentIdentity(authority).cache.currentValue,
+              },
+        listenerId: execution.lifecycleCallbackId,
+      },
+    )
+    execution.done = true
+    const drainId = runtime.state.nextMailboxDrainId
+    const stage = (
+      batchId: number,
+      dependencyId: number,
+      dependencyEventKind: TargetBatchDependencyEventKind,
+    ): void => {
+      openEntries.push({
+        kind: 'TARGET_BATCH_DEPENDENCY_EVENT',
+        entryId: drainId * 1000 + openEntries.length,
+        index: openEntries.length,
+        batchId,
+        dependencyId,
+        source: {
+          kind: 'PUBLIC_IDENTITY',
+          identityId: authority.identityId,
+          channelId: authority.channelId,
+        },
+        dependencyEventKind,
+        eventSequence: nextDependencyEventSequence++,
+      })
+    }
+    for (const batch of targetBatchState.batches) {
+      for (const dependency of batch.dependencies) {
+        if (dependency.source.kind !== 'PUBLIC_IDENTITY') continue
+        if (
+          dependency.source.identityId !== authority.identityId ||
+          dependency.source.executionId !== execution.executionId
+        ) {
+          continue
+        }
+        if (dependency.rawResolvedEventSequence === null) {
+          stage(batch.batchId, dependency.dependencyId, 'RAW_RESOLVED')
+        }
+        if (dependency.valueAcknowledgedEventSequence === null) {
+          stage(batch.batchId, dependency.dependencyId, 'VALUE_ACKNOWLEDGED')
+        }
+      }
+    }
+  }
+
+  function buildDrainRuntime(envelope: ChannelMailboxTurnEnvelope): ChannelMailboxDrainRuntime {
+    return {
+      transferStatusValidator: channelMailboxTransferStatusValidator,
+      transferStatusHandler: channelMailboxTransferStatusHandler,
+      transferStatusTimestampMs: 0,
+      canonicalTransferStatusState: unexpectedIdentityTransferStatus,
+      persistTransferStatusTransition: unexpectedIdentityTransferStatus,
+      publishTransferStatus: unexpectedIdentityTransferStatus,
+      reportTransferStatusRefusal: unexpectedIdentityTransferStatus,
+      entryHandlers: {
+        VALUE_WRITE: unexpectedIdentityMailboxEntry,
+        TOKENLESS_TASK_CALLBACK: unexpectedIdentityMailboxEntry,
+        ELEMENT_HOST_COMMIT: unexpectedIdentityMailboxEntry,
+        TRANSITION_CALLBACK: unexpectedIdentityMailboxEntry,
+        LIFECYCLE_CALLBACK: unexpectedIdentityMailboxEntry,
+        DESTINATION_COMMIT_ACKNOWLEDGEMENT: unexpectedIdentityMailboxEntry,
+        TARGET_BATCH_DEPENDENCY_EVENT(entry) {
+          const reported = advanceGlobalTargetBatch(targetBatchState, {
+            kind: 'REPORT_DEPENDENCY_EVENT',
+            mailboxDrainId: envelope.mailboxDrainId,
+            event: {
+              batchId: entry.batchId,
+              dependencyId: entry.dependencyId,
+              kind: entry.dependencyEventKind,
+              eventSequence: entry.eventSequence,
+            },
+          })
+          targetBatchState = reported.state
+          // One drained-completion edge per dependency: the acknowledgement report that advanced
+          // (never the raw half, never a replayed dedupe).
+          if (
+            entry.dependencyEventKind === 'VALUE_ACKNOWLEDGED' &&
+            reported.orderedEffects.some((effect) => effect.kind === 'ADVANCE_DEPENDENCY')
+          ) {
+            orderedEdges.push({
+              kind: 'ASYNCHRONOUS_COMPLETION_DRAINED',
+              sequence: nextEdgeSequence++,
+              batchId: entry.batchId,
+              dependencyId: entry.dependencyId,
+            })
+          }
+        },
+        TARGET_BATCH_DEPENDENCY_HANDOFF: unexpectedIdentityMailboxEntry,
+        TARGET_BATCH_DEPENDENCY_OUTBOX_ACKNOWLEDGEMENT: unexpectedIdentityMailboxEntry,
+        LAYOUT_RELEASE: unexpectedIdentityMailboxEntry,
+        PROJECTION_STALE: unexpectedIdentityMailboxEntry,
+        LAYOUT_SETTLE: unexpectedIdentityMailboxEntry,
+        DRIVER_SETTLE: unexpectedIdentityMailboxEntry,
+      },
+      transportedSamplePort(channelId) {
+        const authority = identities.find((candidate) => candidate.channelId === channelId)
+        if (authority === undefined) {
+          throw new IdentityGlobalValueChannelInvariantError('identity-unknown')
+        }
+        return authority.record.port
+      },
+      invokeTransitionCallback(callbackId) {
+        transitionCallbacks.get(callbackId)?.(0)
+      },
+      invokeLifecycleCallback(callbackId) {
+        lifecycleCallbacks.get(callbackId)?.()
+      },
+      abortAppliedPrefixAndResolveReadyAggregates: () => undefined,
+      finishAuthoritativeMailboxDrainAndTargetBatchTail(mailboxDrainId) {
+        targetBatchState = advanceGlobalTargetBatch(targetBatchState, {
+          kind: 'FINISH_MAILBOX_TAIL',
+          mailboxDrainId,
+        }).state
+      },
+    }
+  }
+
+  function recordCarrierDelivery(delivery: IdentityValueChannelCarrierDelivery): void {
+    if (recordedCarrierDeliveryIds.has(delivery.carrierId)) return
+    recordedCarrierDeliveryIds.add(delivery.carrierId)
+    carrierDeliveries.push(delivery)
+  }
+
+  function drainEnvelope(
+    envelope: ChannelMailboxTurnEnvelope,
+    state: ChannelMailboxDrainState,
+  ): ChannelMailboxDrainState {
+    return drainChannelMailboxTurnEnvelope(
+      state,
+      envelope,
+      buildDrainRuntime(envelope),
+      new IdentityValueChannelDrainProgressWriter(),
+    ).state
+  }
+
+  function createElementBinding(
+    element: IdentityValueChannelElementAuthority,
+  ): WorkletDriverBinding {
+    const delegate = element.delegate
+    // The scheduled lane's dual-authority refusal cannot reach writeDelegateValues' synchronous
+    // catch — the crossing is fire-and-forget (REQ-DRIVER-013) — so the delegate delivers it
+    // here instead of retiring the admitted flight. Same terminal as the catch: latch, and owned
+    // writes stay with the flight.
+    const unsubscribeBoundValueRefusal = delegate.onBoundValueWriteRefusal((refusedHandle) => {
+      if (element.handle === null) return
+      if ((element.handle as number) !== (refusedHandle as number)) return
+      element.delegateRefusesOwnedWrites = true
+    })
+    const driver: WorkletDriverBinding['driver'] = {
+      register(initial) {
+        const handle = delegate.driver.register(initial)
+        element.handle = handle
+        // Sink attachment precedes any controller command (register returns first): every eligible
+        // key resolves its canonical identity and appends its sink before mount() can issue one.
+        for (const key of element.eligibleKeys) {
+          bindIdentityKey(element, key)
+        }
+        mountedElements.push(element)
+        // First-paint constructor writes (two-pass law): with every sink registered, each
+        // eligible identity receives its per-key initial record value as an ordinary write —
+        // no lifecycle, the value's own identical-write suppression keeps a resting key silent.
+        for (const key of element.eligibleKeys) {
+          const authority = element.identityBindings.get(key)
+          const startValue = initial[key]
+          if (authority === undefined || typeof startValue !== 'number') continue
+          authority.record.value.set(startValue)
+        }
+        return handle
+      },
+      command(handle, command) {
+        if (command.kind === 'stop') {
+          for (const authority of element.identityBindings.values()) {
+            authority.record.value.stop()
+          }
+          for (const key of element.identityBindings.keys()) element.commandOwnedKeys.delete(key)
+          delegate.driver.command(handle, command)
+          return
+        }
+        const { identityKeys } = partitionIdentityCommandKeys(
+          element.identityBindings,
+          command.targets,
+        )
+        // The delegate is the host authority for the property: every command crosses unchanged,
+        // identity keys included (one trajectory family, REQ-DRIVER-003).
+        delegate.driver.command(handle, command)
+        if (identityKeys.length === 0) return
+        for (const key of identityKeys) element.commandOwnedKeys.add(key)
+        // The host-resolved carrier law (the carrier keyed to the host's own returned controls):
+        // a settled element whose delegate did not take a flight commits the target's ordinary
+        // set right away — gesture-state/presence retargets through the apparent-instant lane,
+        // declarative updates through their timed trajectory plus the same carrier write.
+        const hostResolved = element.mountSettled && !delegate.driver.isActive(handle)
+        const declarative =
+          (command as unknown as Record<symbol, unknown>)[IDENTITY_DECLARATIVE_LANE_COMMAND] ===
+          true
+        runIdentityTargetCommandFlow(element, command, identityKeys, hostResolved && !declarative)
+        if (!hostResolved) return
+        for (const key of identityKeys) {
+          const authority = element.identityBindings.get(key)
+          if (authority === undefined) continue
+          const finalValue = instantFinalKeyframe(resolveIdentityTarget(command, key).target)
+          if (typeof finalValue === 'number') authority.record.value.set(finalValue)
+        }
+      },
+      step(elapsedMs) {
+        delegate.driver.step(elapsedMs)
+      },
+      committed(committedHandle) {
+        return delegate.driver.committed(committedHandle)
+      },
+      setActive(activeHandle, active) {
+        if (!active) {
+          // Quiesce-before-unmount: the element is leaving, so its in-flight identity flights
+          // halt silently with it (teardown is not a cancellation) — the value rests where it is.
+          for (const authority of element.identityBindings.values()) {
+            for (const execution of authority.executions) {
+              if (execution.owner !== element || execution.done || execution.stopped) continue
+              execution.handle.stop()
+              onExecutionStopped(authority, execution.executionId)
+            }
+          }
+        }
+        delegate.driver.setActive(activeHandle, active)
+      },
+      isActive(activeHandle) {
+        if (delegate.driver.isActive(activeHandle)) return true
+        return identities.some((authority) =>
+          authority.executions.some(
+            (execution) => execution.owner === element && !execution.done && !execution.stopped,
+          ),
+        )
+      },
+      write(writeHandle, values, velocities, eventShape) {
+        delegate.driver.write(writeHandle, values, velocities, eventShape)
+      },
+      liveFor(liveHandle, key) {
+        return delegate.driver.liveFor(liveHandle, key)
+      },
+    }
+    return {
+      driver,
+      sharedFor(handle, key) {
+        return delegate.sharedFor(handle, key)
+      },
+      writeBoundValue(handle, values) {
+        const identityValues: Record<string, number> = {}
+        const restValues: Record<string, number> = {}
+        for (const [key, value] of Object.entries(values)) {
+          const authority = element.identityBindings.get(key)
+          if (authority === undefined) {
+            restValues[key] = value
+            continue
+          }
+          authority.controller.schedule({
+            kind: 'SCHEDULE_IDENTITY_GLOBAL_VALUE_CHANNEL_DIRECT_WRITE',
+            operation: 'SET',
+            value,
+          })
+          identityValues[key] = value
+        }
+        if (Object.keys(identityValues).length > 0) {
+          writeDelegateValues(element, identityValues)
+          element.frameValuesListener?.(delegate.driver.committed(handle))
+        }
+        if (Object.keys(restValues).length > 0) delegate.writeBoundValue(handle, restValues)
+      },
+      ...(delegate.propertyStateFor === undefined
+        ? {}
+        : { propertyStateFor: delegate.propertyStateFor.bind(delegate) }),
+      setFrameValuesListener(handle, listener) {
+        element.frameValuesListener = listener
+        delegate.setFrameValuesListener(handle, listener)
+      },
+      onBoundValueWriteRefusal(listener) {
+        return delegate.onBoundValueWriteRefusal(listener)
+      },
+      layout: delegate.layout,
+      dispose() {
+        // Teardown stops this element's in-flight identity executions silently (teardown is not
+        // a cancellation), then detaches its sinks and change lanes before the delegate tears down.
+        unsubscribeBoundValueRefusal()
+        for (const authority of element.identityBindings.values()) {
+          for (const execution of authority.executions) {
+            if (execution.owner !== element || execution.done || execution.stopped) continue
+            execution.handle.stop()
+            onExecutionStopped(authority, execution.executionId)
+          }
+        }
+        for (const [key, authority] of element.identityBindings) {
+          const handle = element.handle as number
+          const sink = authority.record.sinks.find(
+            (candidate) =>
+              candidate.driverId === element.ownerDriverId &&
+              candidate.handle === handle &&
+              candidate.key === key,
+          )
+          if (sink !== undefined) {
+            identityRegistry.detachBinding({ value: authority.record.value, sink })
+          }
+          updateIdentity(authority, (current) => ({
+            ...current,
+            sinks: current.sinks.map((candidate) =>
+              candidate.driverId === element.ownerDriverId &&
+              candidate.handleId === handle &&
+              candidate.key === key
+                ? { ...candidate, attached: false }
+                : candidate,
+            ),
+          }))
+          authority.attachedSinkCount -= 1
+          if (authority.attachedSinkCount === 0) authority.unsubscribeChangeLane()
+        }
+        delegate.dispose()
+      },
+      isDisposed: () => delegate.isDisposed(),
+    }
+  }
+
+  const runtimeInterface: IdentityValueChannelControllerRuntime = {
+    bindingForElement(bindingOptions) {
+      const snapshot = identityChannelEligibleBoundStyleSnapshot(bindingOptions.stylePreparation)
+      const element: IdentityValueChannelElementAuthority = {
+        adapter: null as unknown as IdentityValueChannelControllerElementAdapter,
+        delegate: bindingOptions.delegate,
+        ownerDriverId: bindingOptions.ownerDriverId,
+        ownerGeneration: bindingOptions.ownerGeneration,
+        eligibleKeys: snapshot.keys,
+        resolvedStyleValues: snapshot.resolvedStyleValues,
+        identityBindings: new Map(),
+        commandOwnedKeys: new Set(),
+        delegateRefusesOwnedWrites: false,
+        handle: null,
+        frameValuesListener: null,
+        mountSettled: false,
+      }
+      // The mount commit's synchronous block owns every entrance command; the first task boundary
+      // after it flips the element to its settled (carrier-commit) law.
+      queueMicrotask(() => {
+        element.mountSettled = true
+      })
+      elements.push(element)
+      const binding = createElementBinding(element)
+      const adapter = {
+        ownerDriverId: bindingOptions.ownerDriverId,
+        ownerGeneration: bindingOptions.ownerGeneration,
+        stylePreparation: bindingOptions.stylePreparation,
+        delegate: bindingOptions.delegate,
+        binding,
+      } as IdentityValueChannelControllerElementAdapter
+      ;(element as { adapter: IdentityValueChannelControllerElementAdapter }).adapter = adapter
+      elementByAdapter.set(adapter, element)
+      return adapter
+    },
+
+    advanceFrame(elapsedMs) {
+      frameTimeMs += elapsedMs
+      for (const element of mountedElements) {
+        if (element.handle === null || element.delegate.isDisposed()) continue
+        element.delegate.driver.step(elapsedMs)
+      }
+      // Exactly one mailbox turn per frame across every identity; it seals only when the frame
+      // actually staged dependency events (an empty turn has no envelope to close).
+      const openEntries: ChannelMailboxEntry[] = []
+      for (const authority of identities) {
+        const running = authority.executions.filter((execution) => !execution.done)
+        for (const execution of running) {
+          const record = currentIdentity(authority).physicalExecutions.find(
+            (candidate) => candidate.executionId === execution.executionId,
+          )
+          if (record === undefined || record.phase === 'STOPPED') {
+            execution.stopped = true
+            continue
+          }
+          execution.elapsedMs += elapsedMs
+          const sample = execution.generator.sample(execution.elapsedMs)
+          changeLaneSuppressionDepth += 1
+          try {
+            authority.controller.dispatch({
+              kind: 'HOST_APPLY_IDENTITY_GLOBAL_VALUE_CHANNEL_WRITE',
+              identityId: authority.identityId,
+              executionId: execution.executionId,
+              executionLease: execution.executionLease,
+              directOperationEpoch: execution.directOperationEpoch,
+              source: 'GENERATOR',
+              writeSequence: nextWriteSequence++,
+              value: sample.value,
+              velocity: sample.velocity,
+              absoluteTimestampMs: frameTimeMs,
+            })
+          } finally {
+            changeLaneSuppressionDepth -= 1
+          }
+          // A completion whose host fanout reentrantly stopped the control still completes: the
+          // lifecycle emission observes the post-listener slot before the token-blind clear.
+          if (sample.done) completeIdentityExecution(authority, execution, openEntries)
+        }
+      }
+      if (openEntries.length === 0) return
+      const mailboxDrainId = runtime.state.nextMailboxDrainId
+      const envelope = sealChannelMailboxTurnEnvelope({
+        mailboxOrigin: 'UI',
+        mailboxDrainId,
+        stagedEntries: openEntries,
+        sealed: false,
+      })
+      ;(runtime.state as { nextMailboxDrainId: number }).nextMailboxDrainId = mailboxDrainId + 1
+      closedMailboxTurns.push(envelope)
+    },
+
+    drainNextMailboxTurn() {
+      const envelope = closedMailboxTurns[mailboxDrainCursor]
+      if (envelope === undefined) return
+      mailboxDrainCursor += 1
+      drainState = drainEnvelope(envelope, drainState)
+    },
+
+    replayMailboxTurn(envelope) {
+      // The replay lane keeps its own drain cell: a valid replay applies (dedupe-inert through the
+      // batch controller), while a malformed candidate refuses before anything mutates.
+      replayDrainState = drainEnvelope(envelope, replayDrainState)
+    },
+
+    runReadyAggregateReactions() {
+      const ready = targetBatchState.batches
+        .filter(
+          (batch) =>
+            batch.stage === 'READY_REACTION_REGISTERED' ||
+            batch.stage === 'SEALED_EMPTY_REACTION_REGISTERED',
+        )
+        .sort(
+          (left, right) =>
+            (left.aggregateReactionSequence ?? 0) - (right.aggregateReactionSequence ?? 0),
+        )
+      for (const batch of ready) {
+        const reaction = advanceGlobalTargetBatch(targetBatchState, {
+          kind: 'RUN_AGGREGATE_REACTION',
+          batchId: batch.batchId,
+        })
+        targetBatchState = reaction.state
+        if (
+          !reaction.orderedEffects.some((effect) => effect.kind === 'DELIVER_LIVE_OWNER_ELEMENT')
+        ) {
+          continue
+        }
+        elementDeliveries.push({
+          batchId: batch.batchId,
+          ownerDriverId: batch.ownerDriverId,
+          ownerGeneration: batch.ownerGeneration,
+        })
+        const element = mountedElements.find(
+          (candidate) =>
+            candidate.ownerDriverId === batch.ownerDriverId &&
+            candidate.ownerGeneration === batch.ownerGeneration,
+        )
+        const delivered = targetBatchState.batches.find(
+          (candidate) => candidate.batchId === batch.batchId,
+        )
+        if (element === undefined || delivered === undefined || element.handle === null) continue
+        for (const carrier of delivered.carriers) {
+          if (!carrier.enqueued || carrier.pendingFrameActivityReleased) continue
+          const authority = identities.find(
+            (candidate) => candidate.identityId === carrier.identityId,
+          )
+          const value = carrierValues.get(carrier.carrierId)
+          if (authority === undefined || value === undefined) continue
+          // Enqueued carriers drain their tasks to the delegate host, then settle in order.
+          recordCarrierDelivery({
+            batchId: batch.batchId,
+            carrierId: carrier.carrierId,
+            authoredIndex: carrier.authoredIndex,
+            identityId: carrier.identityId,
+            key: carrier.key,
+            taskSequence: carrier.taskSequence,
+          })
+          if (!delegateOwnsKey(element, carrier.key)) {
+            writeDelegateValues(element, { [carrier.key]: value })
+          }
+          updateIdentity(authority, (current) => ({
+            ...current,
+            pendingTasks: current.pendingTasks.filter(
+              (task) => task.taskSequence !== carrier.taskSequence,
+            ),
+          }))
+          targetBatchState = advanceGlobalTargetBatch(targetBatchState, {
+            kind: 'SETTLE_TARGET_BATCH_CARRIER',
+            batchId: batch.batchId,
+            carrierId: carrier.carrierId,
+            identityId: carrier.identityId,
+            taskSequence: carrier.taskSequence,
+          }).state
+        }
+      }
+    },
+
+    observe() {
+      return {
+        identities: identities.map((authority) => ({
+          record: authority.record,
+          host: authority.controller.observe(),
+          publicControlSlot: readPublicControlSlot(authority),
+        })),
+        mountedElements: mountedElements.map((element) => ({
+          adapter: element.adapter,
+          handle: element.handle as ElementHandle,
+          sinkRegistrations: identities.flatMap((authority) =>
+            authority.record.sinks.filter(
+              (sink) =>
+                sink.driverId === element.ownerDriverId &&
+                sink.handle === (element.handle as number),
+            ),
+          ),
+          delegateCommittedValues: element.delegate.driver.committed(
+            element.handle as ElementHandle,
+          ),
+        })),
+        runtimeState: runtime.state,
+        targetBatchState,
+        orderedEdges: [...orderedEdges],
+        closedMailboxTurns: [...closedMailboxTurns],
+        carrierDeliveries: [...carrierDeliveries],
+        elementDeliveries: [...elementDeliveries],
+      }
+    },
+  }
+
+  controllerRuntimeInternals.set(runtimeInterface, {
+    findElementByAdapter(adapter) {
+      return elements.find((candidate) => candidate.adapter === adapter) ?? null
+    },
+    ensureElement(ensureOptions) {
+      const existing = elements.find((candidate) => candidate.adapter === ensureOptions.adapter)
+      if (existing !== undefined) {
+        // A reconcile-created element carries its already-registered handle straight into the
+        // mounted observation; no second register crossing exists for it.
+        if (existing.handle === null) existing.handle = ensureOptions.handle
+        if (!mountedElements.includes(existing)) mountedElements.push(existing)
+        return existing
+      }
+      const element: IdentityValueChannelElementAuthority = {
+        adapter: ensureOptions.adapter,
+        delegate: ensureOptions.delegate,
+        ownerDriverId: ensureOptions.ownerDriverId,
+        ownerGeneration: ensureOptions.ownerGeneration,
+        eligibleKeys: [],
+        resolvedStyleValues: {},
+        identityBindings: new Map(),
+        commandOwnedKeys: new Set(),
+        delegateRefusesOwnedWrites: false,
+        handle: ensureOptions.handle,
+        frameValuesListener: null,
+        mountSettled: false,
+      }
+      queueMicrotask(() => {
+        element.mountSettled = true
+      })
+      elements.push(element)
+      mountedElements.push(element)
+      return element
+    },
+    detachIdentityValue: detachIdentityValueFromElement,
+    attachIdentityValue: attachIdentityValueToElement,
+  })
+  return runtimeInterface
+}
+
+const canonicalRuntimes = new WeakMap<ValueChannel, IdentityValueChannelControllerRuntime>()
+const ownerGenerationByDelegate = new WeakMap<WorkletDriverBinding, number>()
+
+/** The one JS-global identity runtime for an exact public ValueChannel graph. */
+export function resolveIdentityValueChannelControllerRuntime(
+  channel: ValueChannel,
+): IdentityValueChannelControllerRuntime {
+  const existing = canonicalRuntimes.get(channel)
+  if (existing !== undefined) return existing
+  const runtime = createIdentityValueChannelControllerRuntime({
+    channel,
+    identityRegistry: createDriverValueChannelIdentityRegistry<number>(),
+  })
+  canonicalRuntimes.set(channel, runtime)
+  return runtime
+}
+
+/**
+ * Production MotionView entrance. Legacy/derived/color bindings stay on their existing delegate;
+ * an exact finite direct-public numeric value resolves the channel-global runtime and receives the
+ * next engine-owned controller generation before `driver.register` can issue a command.
+ */
+export function attachIdentityValueChannelControllerElement(
+  options: AttachIdentityValueChannelControllerElementOptions,
+): IdentityValueChannelControllerElementAdapter | null {
+  const hasEligibleIdentity = Object.entries(options.stylePreparation.boundStyleValues).some(
+    ([key, value]) => isDirectPublicNumericMotionValue(value, options.resolvedStyleValues[key]),
+  )
+  if (!hasEligibleIdentity) return null
+
+  const ownerDriverId = identityValueChannelDriverIdForBinding(options.delegate)
+  if (ownerDriverId === null) {
+    throw new IdentityValueChannelControllerAdapterInvariantError(
+      'UNREGISTERED_WORKLET_DRIVER_BINDING',
+    )
+  }
+  const runtime = resolveIdentityValueChannelControllerRuntime(options.channel)
+  const ownerGeneration = (ownerGenerationByDelegate.get(options.delegate) ?? 0) + 1
+  ownerGenerationByDelegate.set(options.delegate, ownerGeneration)
+  return runtime.bindingForElement({
+    ownerDriverId,
+    ownerGeneration,
+    stylePreparation: options.stylePreparation,
+    delegate: options.delegate,
+  })
+}
+
+/**
+ * Production commit entrance for exact bound-value replacement and removal. The complete ordered
+ * plan is consumed inside MotionView's first insertion effect — detach-before-attach per
+ * replacement — before the same commit's controller update command may start through the key.
+ */
+export function reconcileIdentityValueChannelControllerElement(
+  options: ReconcileIdentityValueChannelControllerElementOptions,
+): void {
+  if (options.plan.changes.length === 0) return
+  const runtime = resolveIdentityValueChannelControllerRuntime(options.channel)
+  const internals = controllerRuntimeInternals.get(runtime)
+  if (internals === undefined) {
+    throw new IdentityValueChannelControllerAdapterInvariantError(
+      'UNREGISTERED_WORKLET_DRIVER_BINDING',
+    )
+  }
+  let adapter = options.adapter
+  if (adapter === null) {
+    // The mount had no eligible identity, so no adapter exists yet: the attach still lands, on
+    // the next engine-owned generation for this exact delegate.
+    const ownerDriverId = identityValueChannelDriverIdForBinding(options.delegate)
+    if (ownerDriverId === null) {
+      throw new IdentityValueChannelControllerAdapterInvariantError(
+        'UNREGISTERED_WORKLET_DRIVER_BINDING',
+      )
+    }
+    const ownerGeneration = (ownerGenerationByDelegate.get(options.delegate) ?? 0) + 1
+    ownerGenerationByDelegate.set(options.delegate, ownerGeneration)
+    adapter = runtime.bindingForElement({
+      ownerDriverId,
+      ownerGeneration,
+      stylePreparation: EMPTY_MOUNT_STYLE_PREPARATION,
+      delegate: options.delegate,
+    })
+  }
+  const element = internals.ensureElement({
+    adapter,
+    delegate: options.delegate,
+    ownerDriverId: adapter.ownerDriverId,
+    ownerGeneration: adapter.ownerGeneration,
+    handle: options.handle,
+  })
+
+  for (const change of options.plan.changes) {
+    if (change.kind === 'REPLACE_BOUND_VALUE') {
+      const [detachEdge, attachEdge] = change.orderedEdges
+      // Detach-then-attach in that order; the registry transition rides rebind for an exact
+      // replacement, so the previous record and its successor never fork. An eligible edge is a
+      // direct-public numeric identity by the plan's own admission.
+      const previousSink = detachEdge.identityEligible
+        ? internals.detachIdentityValue(
+            element,
+            detachEdge.key,
+            detachEdge.value as MotionValue<number>,
+            false,
+          )
+        : null
+      if (!attachEdge.identityEligible || typeof attachEdge.resolvedValue !== 'number') continue
+      internals.attachIdentityValue(
+        element,
+        attachEdge.key,
+        attachEdge.value as MotionValue<number>,
+        attachEdge.resolvedValue,
+        previousSink === null
+          ? null
+          : { previousValue: detachEdge.value as MotionValue<number>, previousSink },
+      )
+      writeDelegateValues(element, { [attachEdge.key]: attachEdge.resolvedValue })
+      continue
+    }
+    for (const edge of change.orderedEdges) {
+      if (edge.kind === 'DETACH_BOUND_VALUE') {
+        if (edge.identityEligible) {
+          internals.detachIdentityValue(element, edge.key, edge.value as MotionValue<number>, true)
+        }
+        continue
+      }
+      if (!edge.identityEligible || typeof edge.resolvedValue !== 'number') continue
+      internals.attachIdentityValue(
+        element,
+        edge.key,
+        edge.value as MotionValue<number>,
+        edge.resolvedValue,
+        null,
+      )
+      // The rebind push law: the freshly attached source's live value writes through immediately,
+      // so the host never shows the stale source for one commit.
+      writeDelegateValues(element, { [edge.key]: edge.resolvedValue })
+    }
+  }
+}