@pibbl/core 0.0.1 → 0.0.3-alpha.109.1

package/dist/lib/scheduler/renderer-participant.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/scheduler/renderer-participant.ts"],
-  "sourcesContent": ["import type { pibblInternalQueueSimulationBegin } from './simulation-participant.js';\nimport {\n  GLOBAL_STATE,\n} from '../global-state.js';\nimport {\n  collectSignalReads,\n  createSignalRenderConsumer,\n  disposeSignalRenderConsumer,\n} from '../signals/render-consumer.js';\nimport {\n  assertSignalCommandAllowed,\n} from '../signals/graph.js';\nimport type { WritableSignal } from '../signals/types.js';\nimport { usePaintTarget } from '../hooks/use-paint-target.js';\nimport type {\n  PibblEventHandlers,\n  PibblEventTargetOptions,\n  PibblEventTargetSnapshot,\n  PibblPointerEvents,\n} from '../events/types.js';\nimport type { PibblComponentRefs, PibblInstance } from '../types.js';\nimport {\n  getCurrentFrameSnapshot,\n  queueBeginCommand,\n  queueCurrentFrameCommitAcknowledgement,\n  queueCurrentFrameCompletion,\n  queueRendererParticipantComplete,\n  registerAdvanceParticipant,\n  removeRendererParticipantOwner,\n  requestInstanceRender,\n  requestRendererParticipantWork,\n  type RendererParticipantOwner,\n} from './realm-scheduler.js';\n\ndeclare const internalRenderOwnerBrand: unique symbol;\n\n/**\n * Opaque ownership identity for renderer scheduling and cleanup.\n *\n * @see {@link pibblInternalCreateSignalConsumer}\n * @see {@link pibblInternalCurrentRenderOwner}\n * @see {@link pibblInternalOnRenderFinish}\n */\nexport interface PibblInternalRenderOwner {\n  readonly [internalRenderOwnerBrand]: true;\n}\n\n/**\n * Shared scheduler frame identity, logical timing, and admission context.\n *\n * @see {@link pibblInternalCurrentFrame}\n * @see {@link pibblInternalQueueBegin}\n * @see {@link pibblInternalQueueComplete}\n */\nexport interface PibblInternalFrame {\n  /** Identifier of the shared scheduler frame. See {@link PibblInternalFrame}. */\n  readonly frameId: number;\n  /** Logical scheduler time in milliseconds. See {@link PibblInternalFrame}. */\n  readonly logicalTime: number;\n}\n\n/**\n * Staged signal writes published together during scheduler Commit.\n *\n * @see {@link WritableSignal}\n * @see {@link pibblInternalQueueBegin}\n * @see {@link pibblInternalRegisterAdvance}\n * @see {@link pibblInternalQueueSimulationBegin}\n */\nexport interface PibblInternalSignalBatch {\n  /**\n   * Reads the current committed values required by this integration. See\n   * {@link PibblInternalSignalBatch}.\n   * @param signal - Signal whose staged or committed value should be read. See\n   * {@link WritableSignal} .\n   * @returns The current batch value, falling back to the committed signal value.\n   */\n  read<T>(signal: WritableSignal<T>): T;\n  /**\n   * Stages a signal write for publication during Commit. See {@link PibblInternalSignalBatch}.\n   * @param signal - Signal that will receive the value during Commit. See {@link WritableSignal}.\n   * @param value - Value to stage.\n   * @param writer - Identity used to attribute and discard staged writes.\n   */\n  stage<T>(signal: WritableSignal<T>, value: T, writer: object): void;\n  /**\n   * Discards writes belonging to the specified writer. See {@link PibblInternalSignalBatch}.\n   * @param writer - Writer identity whose pending writes should be discarded.\n   */\n  discardWriter(writer: object): void;\n}\n\n/**\n * Sequence identity and cancellation capability for a queued scheduler command.\n *\n * @see {@link pibblInternalQueueBegin}\n */\nexport interface PibblInternalCommandHandle {\n  /**\n   * Sequence number assigned when the scheduler command is queued. See\n   * {@link PibblInternalCommandHandle}.\n   */\n  readonly sequence: number;\n  /**\n   * Cancels this queued command before it is admitted by the scheduler. See\n   * {@link PibblInternalCommandHandle}.\n   */\n  cancel(): void;\n}\n\n/**\n * Ordered renderer stages around one owning Canvas instance traversal.\n * Every active callback in a stage runs in registration order. If one or more\n * callbacks fail, their errors are reported in that order, later dependent\n * stages are skipped, the root transaction fails, the instance revision stays\n * incomplete, and the failed batch plus unexecuted batches later in the same\n * root are retried on the next realm frame. Complete callbacks for those\n * retried owners are deferred until a successful frame. Other owners and roots\n * still complete normally.\n *\n * @see {@link pibblInternalRequestRendererWork}\n */\nexport type PibblInternalRendererWorkKind = 'resource' | 'draw' | 'compose';\n\n/**\n * Dependency tracking and disposal operations for an integration-owned signal consumer.\n *\n * @see {@link pibblInternalCreateSignalConsumer}\n */\nexport interface PibblInternalSignalConsumer {\n  /**\n   * Evaluates a callback while collecting signal dependencies for this consumer. See\n   * {@link PibblInternalSignalConsumer}.\n   * @param read - Synchronous computation whose signal dependencies are collected.\n   * @returns The computation's return value.\n   */\n  collect<T>(read: () => T): T;\n  /**\n   * Acknowledges the consumer's current invalidation as processed. See\n   * {@link PibblInternalSignalConsumer}.\n   */\n  markClean(): void;\n  /** Releases resources owned by this mounted object. See {@link PibblInternalSignalConsumer}. */\n  dispose(): void;\n}\n\ninterface RenderOwnerState {\n  readonly component: PibblComponentRefs<any>;\n  readonly instance: PibblInstance;\n  readonly schedulerOwner: RendererParticipantOwner;\n  readonly consumers: Set<PibblInternalSignalConsumer>;\n  readonly beginCommands: Set<PibblInternalCommandHandle>;\n  readonly advanceRegistrations: Set<() => void>;\n  active: boolean;\n}\n\nconst ownersByComponent = new WeakMap<\n  PibblComponentRefs<any>,\n  PibblInternalRenderOwner\n>();\nconst ownerStates = new WeakMap<PibblInternalRenderOwner, RenderOwnerState>();\n\n/**\n * Returns the active render owner required by official integration scheduling operations.\n *\n * @returns The render owner for the current runtime context. See {@link PibblInternalRenderOwner}.\n *\n * @see {@link PibblInternalRenderOwner}\n */\nexport function pibblInternalCurrentRenderOwner(): PibblInternalRenderOwner {\n  const component = GLOBAL_STATE.componentRefs;\n  const instance = GLOBAL_STATE.currentPibblInstance;\n  if (!component || !instance) {\n    throw new Error(\n      'pibblInternalCurrentRenderOwner() is only available during Pibbl component evaluation.',\n    );\n  }\n\n  const existing = ownersByComponent.get(component);\n  if (existing) return existing;\n\n  const owner = {} as PibblInternalRenderOwner;\n  const state = {} as RenderOwnerState;\n  const schedulerOwner: RendererParticipantOwner = {\n    instance,\n    isActive: () => state.active && isCurrentOwner(state),\n  };\n  Object.assign(state, {\n    component,\n    instance,\n    schedulerOwner,\n    consumers: new Set<PibblInternalSignalConsumer>(),\n    beginCommands: new Set<PibblInternalCommandHandle>(),\n    advanceRegistrations: new Set<() => void>(),\n    active: true,\n  });\n  ownersByComponent.set(component, owner);\n  ownerStates.set(owner, state);\n  component.teardowns.add(() => disposeRenderOwner(owner));\n  return owner;\n}\n\n/**\n * Creates an owner-scoped dependency consumer for an official renderer integration.\n *\n * @param options - Render owner, optional diagnostic name, and invalidation callback. See\n * {@link PibblInternalRenderOwner} .\n * @returns A consumer that tracks signal dependencies and owns their cleanup. See\n * {@link PibblInternalSignalConsumer} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalSignalConsumer}\n */\nexport function pibblInternalCreateSignalConsumer(options: {\n  owner: PibblInternalRenderOwner;\n  debugName?: string;\n  invalidate(): void;\n}): PibblInternalSignalConsumer {\n  const ownerState = requireActiveOwner(options.owner);\n  let disposed = false;\n  const signalConsumer = createSignalRenderConsumer({\n    debugName: options.debugName ??\n      `official renderer (${ownerState.component.id})`,\n    invalidate: () => {\n      if (!disposed && ownerState.schedulerOwner.isActive()) {\n        options.invalidate();\n      }\n    },\n  });\n  const consumer: PibblInternalSignalConsumer = {\n    collect<T>(read: () => T): T {\n      if (disposed) {\n        throw new Error('Cannot collect signal reads with a disposed Pibbl renderer consumer.');\n      }\n      requireActiveOwner(options.owner);\n      return collectSignalReads(signalConsumer, () => read());\n    },\n    markClean(): void {\n      if (!disposed) signalConsumer.markClean();\n    },\n    dispose(): void {\n      if (disposed) return;\n      disposed = true;\n      ownerState.consumers.delete(consumer);\n      disposeSignalRenderConsumer(signalConsumer);\n    },\n  };\n  ownerState.consumers.add(consumer);\n  return consumer;\n}\n\n/**\n * Requests keyed renderer work in the shared scheduler without creating a second frame loop.\n *\n * @param owner - Owner whose renderer work is being requested. See {@link PibblInternalRenderOwner}.\n * @param request - Work identity, renderer category, and frame callback. See\n * {@link PibblInternalRendererWorkKind} , {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalRendererWorkKind}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalRequestRendererWork(\n  owner: PibblInternalRenderOwner,\n  request: {\n    key: object;\n    kind: PibblInternalRendererWorkKind;\n    run(frame: PibblInternalFrame): void;\n  },\n): void {\n  const state = requireActiveOwner(owner);\n  requestRendererParticipantWork(state.schedulerOwner, request);\n}\n\n/**\n * Rejects commands issued from runtime evaluation contexts that forbid mutation.\n *\n * @see {@link pibblInternalQueueBegin}\n */\nexport function pibblInternalAssertCommandAllowed(): void {\n  assertSignalCommandAllowed();\n}\n\n/**\n * Queues an owner-scoped Begin command and returns a cancellation handle.\n *\n * @param owner - Owner admitting the command. See {@link PibblInternalRenderOwner}.\n * @param callback - Begin-phase callback receiving frame, staged writes, and command sequence. See\n * {@link PibblInternalFrame} , {@link PibblInternalSignalBatch} .\n * @returns A handle that can cancel the queued command. See {@link PibblInternalCommandHandle}.\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n * @see {@link PibblInternalSignalBatch}\n * @see {@link PibblInternalCommandHandle}\n */\nexport function pibblInternalQueueBegin(\n  owner: PibblInternalRenderOwner,\n  callback: (\n    frame: PibblInternalFrame,\n    batch: PibblInternalSignalBatch,\n    sequence: number,\n  ) => void,\n): PibblInternalCommandHandle {\n  const state = requireActiveOwner(owner);\n  let handle: PibblInternalCommandHandle;\n  const schedulerHandle = queueBeginCommand((frame, batch, sequence) => {\n    state.beginCommands.delete(handle);\n    if (!state.schedulerOwner.isActive()) return;\n    callback(frame, batch, sequence);\n  });\n  handle = Object.freeze({\n    sequence: schedulerHandle.sequence,\n    cancel(): void {\n      state.beginCommands.delete(handle);\n      schedulerHandle.cancel();\n    },\n  });\n  state.beginCommands.add(handle);\n  return handle;\n}\n\n/**\n * Registers renderer work for shared-frame Advance and returns its unregister callback.\n *\n * @param owner - Owner of the advancing work. See {@link PibblInternalRenderOwner}.\n * @param callback - Advance callback receiving the frame and staged signal writes. See\n * {@link PibblInternalFrame} , {@link PibblInternalSignalBatch} .\n * @returns A function unregistering the Advance callback.\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n * @see {@link PibblInternalSignalBatch}\n */\nexport function pibblInternalRegisterAdvance(\n  owner: PibblInternalRenderOwner,\n  callback: (frame: PibblInternalFrame, batch: PibblInternalSignalBatch) => void,\n): () => void {\n  const state = requireActiveOwner(owner);\n  let released = false;\n  const unregister = registerAdvanceParticipant((frame, batch) => {\n    if (!state.schedulerOwner.isActive()) return;\n    callback(frame, batch);\n  });\n  const release = (): void => {\n    if (released) return;\n    released = true;\n    state.advanceRegistrations.delete(release);\n    unregister();\n  };\n  state.advanceRegistrations.add(release);\n  return release;\n}\n\n/**\n * Registers acknowledgement of the current frame's committed staged writes.\n *\n * @param owner - Owner of the pending commit. See {@link PibblInternalRenderOwner}.\n * @param callback - Callback receiving the frame and whether the commit was applied. See\n * {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalQueueCurrentCommit(\n  owner: PibblInternalRenderOwner,\n  callback: (\n    frame: PibblInternalFrame,\n    outcome: Readonly<{ applied: boolean }>,\n  ) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  queueCurrentFrameCommitAcknowledgement((frame, outcome) => {\n    if (!state.schedulerOwner.isActive()) return;\n    callback(frame, outcome);\n  });\n}\n\n/**\n * Queues an owner-scoped completion callback in the current scheduler transaction.\n *\n * @param owner - Owner of the completion work. See {@link PibblInternalRenderOwner}.\n * @param callback - Callback invoked during Complete with the shared frame. See\n * {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalQueueCurrentComplete(\n  owner: PibblInternalRenderOwner,\n  callback: (frame: PibblInternalFrame) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  queueCurrentFrameCompletion(frame => {\n    if (!state.schedulerOwner.isActive()) return;\n    callback(frame);\n  });\n}\n\n/**\n * Marks the owning renderer dirty and requests shared scheduler work.\n *\n * @param owner - Owner whose renderer should become dirty. See {@link PibblInternalRenderOwner}.\n *\n * @see {@link PibblInternalRenderOwner}\n */\nexport function pibblInternalRequestRender(owner: PibblInternalRenderOwner): void {\n  const state = requireActiveOwner(owner);\n  requestInstanceRender(state.instance);\n}\n\n/**\n * Registers a callback reporting the outcome of the owner's render transaction.\n *\n * @param owner - Owner of the rendering transaction. See {@link PibblInternalRenderOwner}.\n * @param callback - Callback receiving whether the transaction succeeded.\n *\n * @see {@link PibblInternalRenderOwner}\n */\nexport function pibblInternalOnRenderFinish(\n  owner: PibblInternalRenderOwner,\n  callback: (success: boolean) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  if (\n    GLOBAL_STATE.componentRefs !== state.component ||\n    GLOBAL_STATE.currentPibblInstance !== state.instance ||\n    !GLOBAL_STATE.renderTransaction\n  ) {\n    throw new Error(\n      'pibblInternalOnRenderFinish() requires its owner to be the currently evaluating Pibbl component.',\n    );\n  }\n  GLOBAL_STATE.renderTransaction.onFinish(success => {\n    if (success && !state.schedulerOwner.isActive()) return;\n    callback(success);\n  });\n}\n\n/**\n * Registers one painted logical target with its handlers, geometry, and participation policy.\n *\n * @param handlers - Handlers for the painted target. See {@link PibblEventHandlers}.\n * @param options - Hit geometry and focus metadata. See {@link PibblEventTargetOptions}.\n * @param pointerEvents - Pointer participation policy; defaults to auto. See\n * {@link PibblPointerEvents} .\n * @returns The painted event target snapshot. See {@link PibblEventTargetSnapshot}.\n *\n * @see {@link PibblEventHandlers}\n * @see {@link PibblEventTargetOptions}\n * @see {@link PibblPointerEvents}\n * @see {@link PibblEventTargetSnapshot}\n */\nexport function pibblInternalPaintTarget(\n  handlers: PibblEventHandlers,\n  options: PibblEventTargetOptions,\n  pointerEvents: PibblPointerEvents = 'auto',\n): PibblEventTargetSnapshot {\n  return usePaintTarget(handlers, options, pointerEvents);\n}\n\n/**\n * Returns timing and phase information for the current shared scheduler frame.\n *\n * @returns The shared scheduler frame for the active phase. See {@link PibblInternalFrame}.\n *\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalCurrentFrame(): PibblInternalFrame {\n  const frame = getCurrentFrameSnapshot();\n  if (!frame) {\n    throw new Error('pibblInternalCurrentFrame() requires a current Pibbl frame.');\n  }\n  return frame;\n}\n\n/**\n * Queues an owner-scoped callback for a scheduler Complete phase.\n *\n * @param owner - Owner of the completion work. See {@link PibblInternalRenderOwner}.\n * @param callback - Callback invoked during Complete with the shared frame. See\n * {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalQueueComplete(\n  owner: PibblInternalRenderOwner,\n  callback: (frame: PibblInternalFrame) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  queueRendererParticipantComplete(state.schedulerOwner, callback);\n}\n\nfunction requireActiveOwner(owner: PibblInternalRenderOwner): RenderOwnerState {\n  const state = ownerStates.get(owner);\n  if (!state || !state.active || !isCurrentOwner(state)) {\n    throw new TypeError('Expected an active Pibbl internal render owner.');\n  }\n  return state;\n}\n\nfunction isCurrentOwner(state: RenderOwnerState): boolean {\n  return !state.component.teardowns.closed &&\n    !state.instance.mainTeardowns.closed &&\n    GLOBAL_STATE.pibblInstances.get(state.instance.canvas) === state.instance &&\n    state.instance.refs.get(state.component.id) === state.component;\n}\n\nfunction disposeRenderOwner(owner: PibblInternalRenderOwner): void {\n  const state = ownerStates.get(owner);\n  if (!state || !state.active) return;\n  state.active = false;\n  for (const command of Array.from(state.beginCommands)) {\n    command.cancel();\n  }\n  state.beginCommands.clear();\n  for (const release of Array.from(state.advanceRegistrations)) {\n    release();\n  }\n  state.advanceRegistrations.clear();\n  removeRendererParticipantOwner(state.schedulerOwner);\n  for (const consumer of Array.from(state.consumers)) {\n    consumer.dispose();\n  }\n  state.consumers.clear();\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import type { pibblInternalQueueSimulationBegin } from './simulation-participant.js';\nimport {\n  GLOBAL_STATE,\n} from '../global-state.js';\nimport {\n  collectSignalReads,\n  createSignalRenderConsumer,\n  disposeSignalRenderConsumer,\n} from '../signals/render-consumer.js';\nimport {\n  assertSignalCommandAllowed,\n} from '../signals/graph.js';\nimport type { WritableSignal } from '../signals/types.js';\nimport { usePaintTarget } from '../hooks/use-paint-target.js';\nimport type {\n  PibblEventHandlers,\n  PibblEventTargetOptions,\n  PibblEventTargetSnapshot,\n  PibblPointerEvents,\n} from '../events/types.js';\nimport type { PibblComponentRefs, PibblInstance } from '../types.js';\nimport {\n  getCurrentFrameSnapshot,\n  queueBeginCommand,\n  queueCurrentFrameCommitAcknowledgement,\n  queueCurrentFrameCompletion,\n  queueRendererParticipantComplete,\n  registerAdvanceParticipant,\n  removeRendererParticipantOwner,\n  requestInstanceRender,\n  requestRendererParticipantWork,\n  type RendererParticipantOwner,\n} from './realm-scheduler.js';\n\ndeclare const internalRenderOwnerBrand: unique symbol;\n\n/**\n * Opaque ownership identity for renderer scheduling and cleanup.\n *\n * @see {@link pibblInternalCreateSignalConsumer}\n * @see {@link pibblInternalCurrentRenderOwner}\n * @see {@link pibblInternalOnRenderFinish}\n */\nexport interface PibblInternalRenderOwner {\n  readonly [internalRenderOwnerBrand]: true;\n}\n\n/**\n * Shared scheduler frame identity, logical timing, and admission context.\n *\n * @see {@link pibblInternalCurrentFrame}\n * @see {@link pibblInternalQueueBegin}\n * @see {@link pibblInternalQueueComplete}\n */\nexport interface PibblInternalFrame {\n  /** Identifier of the shared scheduler frame. See {@link PibblInternalFrame}. */\n  readonly frameId: number;\n  /** Logical scheduler time in milliseconds. See {@link PibblInternalFrame}. */\n  readonly logicalTime: number;\n}\n\n/**\n * Staged signal writes published together during scheduler Commit.\n *\n * @see {@link WritableSignal}\n * @see {@link pibblInternalQueueBegin}\n * @see {@link pibblInternalRegisterAdvance}\n * @see {@link pibblInternalQueueSimulationBegin}\n */\nexport interface PibblInternalSignalBatch {\n  /**\n   * Reads the current committed values required by this integration. See\n   * {@link PibblInternalSignalBatch}.\n   * @param signal - Signal whose staged or committed value should be read. See\n   * {@link WritableSignal} .\n   * @returns The current batch value, falling back to the committed signal value.\n   */\n  read<T>(signal: WritableSignal<T>): T;\n  /**\n   * Stages a signal write for publication during Commit. See {@link PibblInternalSignalBatch}.\n   * @param signal - Signal that will receive the value during Commit. See {@link WritableSignal}.\n   * @param value - Value to stage.\n   * @param writer - Identity used to attribute and discard staged writes.\n   */\n  stage<T>(signal: WritableSignal<T>, value: T, writer: object): void;\n  /**\n   * Discards writes belonging to the specified writer. See {@link PibblInternalSignalBatch}.\n   * @param writer - Writer identity whose pending writes should be discarded.\n   */\n  discardWriter(writer: object): void;\n}\n\n/**\n * Sequence identity and cancellation capability for a queued scheduler command.\n *\n * @see {@link pibblInternalQueueBegin}\n */\nexport interface PibblInternalCommandHandle {\n  /**\n   * Sequence number assigned when the scheduler command is queued. See\n   * {@link PibblInternalCommandHandle}.\n   */\n  readonly sequence: number;\n  /**\n   * Cancels this queued command before it is admitted by the scheduler. See\n   * {@link PibblInternalCommandHandle}.\n   */\n  cancel(): void;\n}\n\n/**\n * Ordered renderer stages around one owning Canvas instance traversal.\n * Every active callback in a stage runs in registration order. If one or more\n * callbacks fail, their errors are reported in that order, later dependent\n * stages are skipped, the root transaction fails, the instance revision stays\n * incomplete, and the failed batch plus unexecuted batches later in the same\n * root are retried on the next realm frame. Complete callbacks for those\n * retried owners are deferred until a successful frame. Other owners and roots\n * still complete normally.\n *\n * @see {@link pibblInternalRequestRendererWork}\n */\nexport type PibblInternalRendererWorkKind = 'resource' | 'draw' | 'compose';\n\n/**\n * Dependency tracking and disposal operations for an integration-owned signal consumer.\n *\n * @see {@link pibblInternalCreateSignalConsumer}\n */\nexport interface PibblInternalSignalConsumer {\n  /**\n   * Evaluates a callback while collecting signal dependencies for this consumer. See\n   * {@link PibblInternalSignalConsumer}.\n   * @param read - Synchronous computation whose signal dependencies are collected.\n   * @returns The computation's return value.\n   */\n  collect<T>(read: () => T): T;\n  /**\n   * Acknowledges the consumer's current invalidation as processed. See\n   * {@link PibblInternalSignalConsumer}.\n   */\n  markClean(): void;\n  /** Releases resources owned by this mounted object. See {@link PibblInternalSignalConsumer}. */\n  dispose(): void;\n}\n\ninterface RenderOwnerState {\n  readonly component: PibblComponentRefs<any>;\n  readonly instance: PibblInstance;\n  readonly schedulerOwner: RendererParticipantOwner;\n  readonly consumers: Set<PibblInternalSignalConsumer>;\n  readonly beginCommands: Set<PibblInternalCommandHandle>;\n  readonly advanceRegistrations: Set<() => void>;\n  active: boolean;\n}\n\nconst ownersByComponent = new WeakMap<\n  PibblComponentRefs<any>,\n  PibblInternalRenderOwner\n>();\nconst ownerStates = new WeakMap<PibblInternalRenderOwner, RenderOwnerState>();\n\n/**\n * Returns the active render owner required by official integration scheduling operations.\n *\n * @returns The render owner for the current runtime context. See {@link PibblInternalRenderOwner}.\n *\n * @see {@link PibblInternalRenderOwner}\n */\nexport function pibblInternalCurrentRenderOwner(): PibblInternalRenderOwner {\n  const component = GLOBAL_STATE.componentRefs;\n  const instance = GLOBAL_STATE.currentPibblInstance;\n  if (!component || !instance) {\n    throw new Error(\n      'pibblInternalCurrentRenderOwner() is only available during Pibbl component evaluation.',\n    );\n  }\n\n  const existing = ownersByComponent.get(component);\n  if (existing) return existing;\n\n  const owner = {} as PibblInternalRenderOwner;\n  const state = {} as RenderOwnerState;\n  const schedulerOwner: RendererParticipantOwner = {\n    instance,\n    isActive: () => state.active && isCurrentOwner(state),\n  };\n  Object.assign(state, {\n    component,\n    instance,\n    schedulerOwner,\n    consumers: new Set<PibblInternalSignalConsumer>(),\n    beginCommands: new Set<PibblInternalCommandHandle>(),\n    advanceRegistrations: new Set<() => void>(),\n    active: true,\n  });\n  ownersByComponent.set(component, owner);\n  ownerStates.set(owner, state);\n  component.teardowns.add(() => disposeRenderOwner(owner));\n  return owner;\n}\n\n/**\n * Creates an owner-scoped dependency consumer for an official renderer integration.\n *\n * @param options - Render owner, optional diagnostic name, and invalidation callback. See\n * {@link PibblInternalRenderOwner} .\n * @returns A consumer that tracks signal dependencies and owns their cleanup. See\n * {@link PibblInternalSignalConsumer} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalSignalConsumer}\n */\nexport function pibblInternalCreateSignalConsumer(options: {\n  owner: PibblInternalRenderOwner;\n  debugName?: string;\n  invalidate(): void;\n}): PibblInternalSignalConsumer {\n  const ownerState = requireActiveOwner(options.owner);\n  let disposed = false;\n  const signalConsumer = createSignalRenderConsumer({\n    layoutOwner: ownerState.instance,\n    debugName: options.debugName ??\n      `official renderer (${ownerState.component.id})`,\n    invalidate: () => {\n      if (!disposed && ownerState.schedulerOwner.isActive()) {\n        options.invalidate();\n      }\n    },\n  });\n  const consumer: PibblInternalSignalConsumer = {\n    collect<T>(read: () => T): T {\n      if (disposed) {\n        throw new Error('Cannot collect signal reads with a disposed Pibbl renderer consumer.');\n      }\n      requireActiveOwner(options.owner);\n      return collectSignalReads(signalConsumer, () => read());\n    },\n    markClean(): void {\n      if (!disposed) signalConsumer.markClean();\n    },\n    dispose(): void {\n      if (disposed) return;\n      disposed = true;\n      ownerState.consumers.delete(consumer);\n      disposeSignalRenderConsumer(signalConsumer);\n    },\n  };\n  ownerState.consumers.add(consumer);\n  return consumer;\n}\n\n/**\n * Requests keyed renderer work in the shared scheduler without creating a second frame loop.\n *\n * @param owner - Owner whose renderer work is being requested. See {@link PibblInternalRenderOwner}.\n * @param request - Work identity, renderer category, and frame callback. See\n * {@link PibblInternalRendererWorkKind} , {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalRendererWorkKind}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalRequestRendererWork(\n  owner: PibblInternalRenderOwner,\n  request: {\n    key: object;\n    kind: PibblInternalRendererWorkKind;\n    run(frame: PibblInternalFrame): void;\n  },\n): void {\n  const state = requireActiveOwner(owner);\n  requestRendererParticipantWork(state.schedulerOwner, request);\n}\n\n/**\n * Rejects commands issued from runtime evaluation contexts that forbid mutation.\n *\n * @see {@link pibblInternalQueueBegin}\n */\nexport function pibblInternalAssertCommandAllowed(): void {\n  assertSignalCommandAllowed();\n}\n\n/**\n * Queues an owner-scoped Begin command and returns a cancellation handle.\n *\n * @param owner - Owner admitting the command. See {@link PibblInternalRenderOwner}.\n * @param callback - Begin-phase callback receiving frame, staged writes, and command sequence. See\n * {@link PibblInternalFrame} , {@link PibblInternalSignalBatch} .\n * @returns A handle that can cancel the queued command. See {@link PibblInternalCommandHandle}.\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n * @see {@link PibblInternalSignalBatch}\n * @see {@link PibblInternalCommandHandle}\n */\nexport function pibblInternalQueueBegin(\n  owner: PibblInternalRenderOwner,\n  callback: (\n    frame: PibblInternalFrame,\n    batch: PibblInternalSignalBatch,\n    sequence: number,\n  ) => void,\n): PibblInternalCommandHandle {\n  const state = requireActiveOwner(owner);\n  let handle: PibblInternalCommandHandle;\n  const schedulerHandle = queueBeginCommand((frame, batch, sequence) => {\n    state.beginCommands.delete(handle);\n    if (!state.schedulerOwner.isActive()) return;\n    callback(frame, batch, sequence);\n  });\n  handle = Object.freeze({\n    sequence: schedulerHandle.sequence,\n    cancel(): void {\n      state.beginCommands.delete(handle);\n      schedulerHandle.cancel();\n    },\n  });\n  state.beginCommands.add(handle);\n  return handle;\n}\n\n/**\n * Registers renderer work for shared-frame Advance and returns its unregister callback.\n *\n * @param owner - Owner of the advancing work. See {@link PibblInternalRenderOwner}.\n * @param callback - Advance callback receiving the frame and staged signal writes. See\n * {@link PibblInternalFrame} , {@link PibblInternalSignalBatch} .\n * @returns A function unregistering the Advance callback.\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n * @see {@link PibblInternalSignalBatch}\n */\nexport function pibblInternalRegisterAdvance(\n  owner: PibblInternalRenderOwner,\n  callback: (frame: PibblInternalFrame, batch: PibblInternalSignalBatch) => void,\n): () => void {\n  const state = requireActiveOwner(owner);\n  let released = false;\n  const unregister = registerAdvanceParticipant((frame, batch) => {\n    if (!state.schedulerOwner.isActive()) return;\n    callback(frame, batch);\n  });\n  const release = (): void => {\n    if (released) return;\n    released = true;\n    state.advanceRegistrations.delete(release);\n    unregister();\n  };\n  state.advanceRegistrations.add(release);\n  return release;\n}\n\n/**\n * Registers acknowledgement of the current frame's committed staged writes.\n *\n * @param owner - Owner of the pending commit. See {@link PibblInternalRenderOwner}.\n * @param callback - Callback receiving the frame and whether the commit was applied. See\n * {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalQueueCurrentCommit(\n  owner: PibblInternalRenderOwner,\n  callback: (\n    frame: PibblInternalFrame,\n    outcome: Readonly<{ applied: boolean }>,\n  ) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  queueCurrentFrameCommitAcknowledgement((frame, outcome) => {\n    if (!state.schedulerOwner.isActive()) return;\n    callback(frame, outcome);\n  });\n}\n\n/**\n * Queues an owner-scoped completion callback in the current scheduler transaction.\n *\n * @param owner - Owner of the completion work. See {@link PibblInternalRenderOwner}.\n * @param callback - Callback invoked during Complete with the shared frame. See\n * {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalQueueCurrentComplete(\n  owner: PibblInternalRenderOwner,\n  callback: (frame: PibblInternalFrame) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  queueCurrentFrameCompletion(frame => {\n    if (!state.schedulerOwner.isActive()) return;\n    callback(frame);\n  });\n}\n\n/**\n * Marks the owning renderer dirty and requests shared scheduler work.\n *\n * @param owner - Owner whose renderer should become dirty. See {@link PibblInternalRenderOwner}.\n *\n * @see {@link PibblInternalRenderOwner}\n */\nexport function pibblInternalRequestRender(owner: PibblInternalRenderOwner): void {\n  const state = requireActiveOwner(owner);\n  requestInstanceRender(state.instance);\n}\n\n/**\n * Registers a callback reporting the outcome of the owner's render transaction.\n *\n * @param owner - Owner of the rendering transaction. See {@link PibblInternalRenderOwner}.\n * @param callback - Callback receiving whether the transaction succeeded.\n *\n * @see {@link PibblInternalRenderOwner}\n */\nexport function pibblInternalOnRenderFinish(\n  owner: PibblInternalRenderOwner,\n  callback: (success: boolean) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  if (\n    GLOBAL_STATE.componentRefs !== state.component ||\n    GLOBAL_STATE.currentPibblInstance !== state.instance ||\n    !GLOBAL_STATE.renderTransaction\n  ) {\n    throw new Error(\n      'pibblInternalOnRenderFinish() requires its owner to be the currently evaluating Pibbl component.',\n    );\n  }\n  GLOBAL_STATE.renderTransaction.onFinish(success => {\n    if (success && !state.schedulerOwner.isActive()) return;\n    callback(success);\n  });\n}\n\n/**\n * Registers one painted logical target with its handlers, geometry, and participation policy.\n *\n * @param handlers - Handlers for the painted target. See {@link PibblEventHandlers}.\n * @param options - Hit geometry and focus metadata. See {@link PibblEventTargetOptions}.\n * @param pointerEvents - Pointer participation policy; defaults to auto. See\n * {@link PibblPointerEvents} .\n * @returns The painted event target snapshot. See {@link PibblEventTargetSnapshot}.\n *\n * @see {@link PibblEventHandlers}\n * @see {@link PibblEventTargetOptions}\n * @see {@link PibblPointerEvents}\n * @see {@link PibblEventTargetSnapshot}\n */\nexport function pibblInternalPaintTarget(\n  handlers: PibblEventHandlers,\n  options: PibblEventTargetOptions,\n  pointerEvents: PibblPointerEvents = 'auto',\n): PibblEventTargetSnapshot {\n  return usePaintTarget(handlers, options, pointerEvents);\n}\n\n/**\n * Returns timing and phase information for the current shared scheduler frame.\n *\n * @returns The shared scheduler frame for the active phase. See {@link PibblInternalFrame}.\n *\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalCurrentFrame(): PibblInternalFrame {\n  const frame = getCurrentFrameSnapshot();\n  if (!frame) {\n    throw new Error('pibblInternalCurrentFrame() requires a current Pibbl frame.');\n  }\n  return frame;\n}\n\n/**\n * Queues an owner-scoped callback for a scheduler Complete phase.\n *\n * @param owner - Owner of the completion work. See {@link PibblInternalRenderOwner}.\n * @param callback - Callback invoked during Complete with the shared frame. See\n * {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalRenderOwner}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalQueueComplete(\n  owner: PibblInternalRenderOwner,\n  callback: (frame: PibblInternalFrame) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  queueRendererParticipantComplete(state.schedulerOwner, callback);\n}\n\nfunction requireActiveOwner(owner: PibblInternalRenderOwner): RenderOwnerState {\n  const state = ownerStates.get(owner);\n  if (!state || !state.active || !isCurrentOwner(state)) {\n    throw new TypeError('Expected an active Pibbl internal render owner.');\n  }\n  return state;\n}\n\nfunction isCurrentOwner(state: RenderOwnerState): boolean {\n  return !state.component.teardowns.closed &&\n    !state.instance.mainTeardowns.closed &&\n    GLOBAL_STATE.pibblInstances.get(state.instance.canvas) === state.instance &&\n    state.instance.refs.get(state.component.id) === state.component;\n}\n\nfunction disposeRenderOwner(owner: PibblInternalRenderOwner): void {\n  const state = ownerStates.get(owner);\n  if (!state || !state.active) return;\n  state.active = false;\n  for (const command of Array.from(state.beginCommands)) {\n    command.cancel();\n  }\n  state.beginCommands.clear();\n  for (const release of Array.from(state.advanceRegistrations)) {\n    release();\n  }\n  state.advanceRegistrations.clear();\n  removeRendererParticipantOwner(state.schedulerOwner);\n  for (const consumer of Array.from(state.consumers)) {\n    consumer.dispose();\n  }\n  state.consumers.clear();\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/lib/series-inspection-frame.d.ts

@@ -0,0 +1,18 @@
+import type { PibblClippingStackEntry } from "./types.js";
+/** Private geometry/ownership seam; no inspection algorithms enter core rendering.
+ * @returns Captured receiver ownership and lazily composed root geometry.
+ * @see {@link PibblClippingStackEntry}
+ */
+export declare function captureSeriesInspectionFrame(): {
+    receiver: import("./types.js").PibblComponentRefs<any>;
+    onDispose: (callback: () => void) => void;
+    onFinish: (callback: (success: boolean) => void) => void;
+    alive: () => boolean;
+    generation: () => number;
+    resolve(): {
+        transform: DOMMatrix;
+        clips: PibblClippingStackEntry[];
+        generation: number;
+        canvas: HTMLCanvasElement;
+    } | undefined;
+};

package/dist/lib/series-inspection-frame.js

@@ -0,0 +1,70 @@
+import { GLOBAL_STATE } from "./global-state.js";
+import { requireHookContext } from "./hooks/hook-slot.js";
+import { getCurrentWorldTransform } from "./render-target.js";
+import { PibblPaintEntryKind } from "./events/paint-entry.js";
+function captureSeriesInspectionFrame() {
+  const { componentRefs, pibblInstance } = requireHookContext();
+  const localTransform = new DOMMatrix(
+    Array.from(getCurrentWorldTransform().toFloat64Array())
+  );
+  const localClips = GLOBAL_STATE.clippingStack.map((clip) => ({
+    ...clip,
+    path: new Path2D(clip.path),
+    transform: new DOMMatrix(Array.from(clip.transform.toFloat64Array()))
+  }));
+  const transaction = GLOBAL_STATE.renderTransaction;
+  return {
+    receiver: componentRefs,
+    onDispose: (callback) => componentRefs.teardowns.add(callback),
+    onFinish: (callback) => transaction.onFinish(callback),
+    alive: () => !componentRefs.teardowns.closed && !pibblInstance.mainTeardowns.closed,
+    generation: () => pibblInstance.eventRoot.rootInstance?.committedRenderGeneration ?? 0,
+    resolve() {
+      let owner = pibblInstance;
+      let transform = new DOMMatrix(
+        Array.from(localTransform.toFloat64Array())
+      );
+      let clips = localClips.slice();
+      while (owner !== owner.eventRoot.rootInstance) {
+        const parent = owner.parent && GLOBAL_STATE.pibblInstances.get(owner.parent);
+        if (!parent) return void 0;
+        const bridge = [...parent.paintEntries].find(
+          (entry) => entry.paintKind !== PibblPaintEntryKind.Path && entry.instance === owner
+        );
+        if (!bridge || bridge.paintKind === PibblPaintEntryKind.Path)
+          return void 0;
+        const outer = bridge.transform;
+        clips = clips.map((clip) => ({
+          ...clip,
+          transform: outer.multiply(clip.transform)
+        }));
+        clips.push(
+          ...bridge.clippingStack.map((clip) => ({
+            ...clip,
+            path: new Path2D(clip.path),
+            transform: new DOMMatrix(
+              Array.from(clip.transform.toFloat64Array())
+            )
+          }))
+        );
+        clips.push({
+          path: new Path2D(bridge.bounds),
+          transform: new DOMMatrix(Array.from(outer.toFloat64Array())),
+          fillRule: "nonzero"
+        });
+        transform = outer.multiply(transform);
+        owner = parent;
+      }
+      return {
+        transform,
+        clips,
+        generation: owner.committedRenderGeneration ?? 0,
+        canvas: owner.canvas
+      };
+    }
+  };
+}
+export {
+  captureSeriesInspectionFrame
+};
+//# sourceMappingURL=series-inspection-frame.js.map

package/dist/lib/series-inspection-frame.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/series-inspection-frame.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from \"./global-state.js\";\nimport { requireHookContext } from \"./hooks/hook-slot.js\";\nimport { getCurrentWorldTransform } from \"./render-target.js\";\nimport { PibblPaintEntryKind } from \"./events/paint-entry.js\";\nimport type { PibblClippingStackEntry } from \"./types.js\";\n\n/** Private geometry/ownership seam; no inspection algorithms enter core rendering.\n * @returns Captured receiver ownership and lazily composed root geometry.\n * @see {@link PibblClippingStackEntry}\n */\nexport function captureSeriesInspectionFrame() {\n  const { componentRefs, pibblInstance } = requireHookContext();\n  const localTransform = new DOMMatrix(\n    Array.from(getCurrentWorldTransform().toFloat64Array()),\n  );\n  const localClips = GLOBAL_STATE.clippingStack.map((clip) => ({\n    ...clip,\n    path: new Path2D(clip.path),\n    transform: new DOMMatrix(Array.from(clip.transform.toFloat64Array())),\n  }));\n  const transaction = GLOBAL_STATE.renderTransaction!;\n  return {\n    receiver: componentRefs,\n    onDispose: (callback: () => void) => componentRefs.teardowns.add(callback),\n    onFinish: (callback: (success: boolean) => void) =>\n      transaction.onFinish(callback),\n    alive: () =>\n      !componentRefs.teardowns.closed && !pibblInstance.mainTeardowns.closed,\n    generation: () =>\n      pibblInstance.eventRoot.rootInstance?.committedRenderGeneration ?? 0,\n    resolve() {\n      let owner = pibblInstance;\n      let transform = new DOMMatrix(\n        Array.from(localTransform.toFloat64Array()),\n      );\n      let clips: PibblClippingStackEntry[] = localClips.slice();\n      while (owner !== owner.eventRoot.rootInstance) {\n        const parent =\n          owner.parent && GLOBAL_STATE.pibblInstances.get(owner.parent);\n        if (!parent) return undefined;\n        const bridge = [...parent.paintEntries].find(\n          (entry) =>\n            entry.paintKind !== PibblPaintEntryKind.Path &&\n            entry.instance === owner,\n        );\n        if (!bridge || bridge.paintKind === PibblPaintEntryKind.Path)\n          return undefined;\n        const outer = bridge.transform;\n        clips = clips.map((clip) => ({\n          ...clip,\n          transform: outer.multiply(clip.transform),\n        }));\n        clips.push(\n          ...bridge.clippingStack.map((clip) => ({\n            ...clip,\n            path: new Path2D(clip.path),\n            transform: new DOMMatrix(\n              Array.from(clip.transform.toFloat64Array()),\n            ),\n          })),\n        );\n        clips.push({\n          path: new Path2D(bridge.bounds),\n          transform: new DOMMatrix(Array.from(outer.toFloat64Array())),\n          fillRule: \"nonzero\",\n        });\n        transform = outer.multiply(transform);\n        owner = parent;\n      }\n      return {\n        transform,\n        clips,\n        generation: owner.committedRenderGeneration ?? 0,\n        canvas: owner.canvas as HTMLCanvasElement,\n      };\n    },\n  };\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAC7B,SAAS,0BAA0B;AACnC,SAAS,gCAAgC;AACzC,SAAS,2BAA2B;AAO7B,SAAS,+BAA+B;AAC7C,QAAM,EAAE,eAAe,cAAc,IAAI,mBAAmB;AAC5D,QAAM,iBAAiB,IAAI;AAAA,IACzB,MAAM,KAAK,yBAAyB,EAAE,eAAe,CAAC;AAAA,EACxD;AACA,QAAM,aAAa,aAAa,cAAc,IAAI,CAAC,UAAU;AAAA,IAC3D,GAAG;AAAA,IACH,MAAM,IAAI,OAAO,KAAK,IAAI;AAAA,IAC1B,WAAW,IAAI,UAAU,MAAM,KAAK,KAAK,UAAU,eAAe,CAAC,CAAC;AAAA,EACtE,EAAE;AACF,QAAM,cAAc,aAAa;AACjC,SAAO;AAAA,IACL,UAAU;AAAA,IACV,WAAW,CAAC,aAAyB,cAAc,UAAU,IAAI,QAAQ;AAAA,IACzE,UAAU,CAAC,aACT,YAAY,SAAS,QAAQ;AAAA,IAC/B,OAAO,MACL,CAAC,cAAc,UAAU,UAAU,CAAC,cAAc,cAAc;AAAA,IAClE,YAAY,MACV,cAAc,UAAU,cAAc,6BAA6B;AAAA,IACrE,UAAU;AACR,UAAI,QAAQ;AACZ,UAAI,YAAY,IAAI;AAAA,QAClB,MAAM,KAAK,eAAe,eAAe,CAAC;AAAA,MAC5C;AACA,UAAI,QAAmC,WAAW,MAAM;AACxD,aAAO,UAAU,MAAM,UAAU,cAAc;AAC7C,cAAM,SACJ,MAAM,UAAU,aAAa,eAAe,IAAI,MAAM,MAAM;AAC9D,YAAI,CAAC,OAAQ,QAAO;AACpB,cAAM,SAAS,CAAC,GAAG,OAAO,YAAY,EAAE;AAAA,UACtC,CAAC,UACC,MAAM,cAAc,oBAAoB,QACxC,MAAM,aAAa;AAAA,QACvB;AACA,YAAI,CAAC,UAAU,OAAO,cAAc,oBAAoB;AACtD,iBAAO;AACT,cAAM,QAAQ,OAAO;AACrB,gBAAQ,MAAM,IAAI,CAAC,UAAU;AAAA,UAC3B,GAAG;AAAA,UACH,WAAW,MAAM,SAAS,KAAK,SAAS;AAAA,QAC1C,EAAE;AACF,cAAM;AAAA,UACJ,GAAG,OAAO,cAAc,IAAI,CAAC,UAAU;AAAA,YACrC,GAAG;AAAA,YACH,MAAM,IAAI,OAAO,KAAK,IAAI;AAAA,YAC1B,WAAW,IAAI;AAAA,cACb,MAAM,KAAK,KAAK,UAAU,eAAe,CAAC;AAAA,YAC5C;AAAA,UACF,EAAE;AAAA,QACJ;AACA,cAAM,KAAK;AAAA,UACT,MAAM,IAAI,OAAO,OAAO,MAAM;AAAA,UAC9B,WAAW,IAAI,UAAU,MAAM,KAAK,MAAM,eAAe,CAAC,CAAC;AAAA,UAC3D,UAAU;AAAA,QACZ,CAAC;AACD,oBAAY,MAAM,SAAS,SAAS;AACpC,gBAAQ;AAAA,MACV;AACA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA,YAAY,MAAM,6BAA6B;AAAA,QAC/C,QAAQ,MAAM;AAAA,MAChB;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/lib/signals/edge.d.ts

@@ -1,4 +1,5 @@
-import type { SignalNode } from './graph.js';
+import type { SignalDependencyRoleInput, SignalNode } from './graph.js';
+export declare function signalDependencyRoleMask(role: SignalDependencyRoleInput | undefined): number;
 export interface ReactiveEdge {
     source: SignalNode<unknown> | undefined;
     consumer: SignalDependencyConsumer;
@@ -13,6 +14,8 @@ export interface ReactiveEdge {
     sourceLinked: boolean;
     collectionKind: 'new' | 'reused' | undefined;
     releaseObservation: (() => void) | undefined;
+    dependencyRoles: number;
+    collectedDependencyRoles: number;
 }
 export interface ReactiveNotificationCursor {
     next: ReactiveEdge | undefined;
@@ -27,13 +30,13 @@ export interface SignalDependencyConsumer {
     dependencyHighWater: number;
     collectionCursor: ReactiveEdge | undefined;
     collectionGeneration: number;
-    addDependency(node: SignalNode<unknown>): void;
-    notify(node: SignalNode<unknown>): void;
+    addDependency(node: SignalNode<unknown>, role?: SignalDependencyRoleInput): void;
+    notify(node: SignalNode<unknown>, dependencyRoles?: number): void;
     propagateInvalidation?: boolean;
     renderInvalidation?: boolean;
 }
 export declare function beginReactiveCollection(consumer: SignalDependencyConsumer): number;
-export declare function collectReactiveDependency(consumer: SignalDependencyConsumer, source: SignalNode<unknown>): ReactiveEdge;
+export declare function collectReactiveDependency(consumer: SignalDependencyConsumer, source: SignalNode<unknown>, role?: SignalDependencyRoleInput): ReactiveEdge;
 export declare function finishReactiveCollection(consumer: SignalDependencyConsumer, publish: (edge: ReactiveEdge) => void, release: (edge: ReactiveEdge) => void): void;
 export declare function rollbackReactiveCollection(consumer: SignalDependencyConsumer): void;
 export declare function linkReactiveEdgeToSource(edge: ReactiveEdge, releaseObservation?: () => void): void;

package/dist/lib/signals/edge.js

@@ -1,14 +1,28 @@
+const dependencyRoleMasks = {
+  structure: 1,
+  layout: 2,
+  measurement: 4,
+  paint: 8,
+  transform: 16,
+  interaction: 32,
+  unknown: 64
+};
+function signalDependencyRoleMask(role) {
+  return typeof role === "number" ? role : dependencyRoleMasks[role ?? "unknown"];
+}
 function beginReactiveCollection(consumer) {
   consumer.collectionGeneration++;
   consumer.collectionCursor = consumer.dependencyHead;
   return consumer.collectionGeneration;
 }
-function collectReactiveDependency(consumer, source) {
+function collectReactiveDependency(consumer, source, role) {
   const generation = consumer.collectionGeneration;
+  const roleMask = signalDependencyRoleMask(role);
   let edge = consumer.collectionCursor;
   if (edge?.source === source && edge.collectionGeneration !== generation) {
     edge.collectionGeneration = generation;
     edge.collectionKind = "reused";
+    edge.collectedDependencyRoles = roleMask;
     consumer.collectionCursor = edge.consumerNext;
     return edge;
   }
@@ -17,7 +31,10 @@ function collectReactiveDependency(consumer, source) {
     if (edge.collectionGeneration !== generation) {
       edge.collectionGeneration = generation;
       edge.collectionKind = "reused";
+      edge.collectedDependencyRoles = roleMask;
       consumer.collectionCursor = edge.consumerNext;
+    } else {
+      edge.collectedDependencyRoles |= roleMask;
     }
     return edge;
   }
@@ -25,6 +42,7 @@ function collectReactiveDependency(consumer, source) {
   edge.source = source;
   edge.collectionGeneration = generation;
   edge.collectionKind = edge.everPublished ? "reused" : "new";
+  edge.collectedDependencyRoles = roleMask;
   edge.observedVersion = source.version;
   linkReactiveEdgeToConsumer(edge);
   consumer.collectionCursor = edge.consumerNext;
@@ -35,6 +53,7 @@ function finishReactiveCollection(consumer, publish, release) {
   while (edge !== void 0) {
     const next = edge.consumerNext;
     if (edge.collectionGeneration === consumer.collectionGeneration) {
+      edge.dependencyRoles = edge.collectedDependencyRoles;
       publish(edge);
     } else {
       release(edge);
@@ -150,7 +169,7 @@ function notifyReactiveEdges(source, accepts = () => true) {
       if (!edge.sourceLinked || edge.source !== source) continue;
       if (!accepts(edge.consumer)) continue;
       try {
-        edge.consumer.notify(source);
+        edge.consumer.notify(source, edge.dependencyRoles);
       } catch (error) {
         failures.push(error);
       }
@@ -182,7 +201,9 @@ function createReactiveEdge(consumer) {
     everPublished: false,
     sourceLinked: false,
     collectionKind: void 0,
-    releaseObservation: void 0
+    releaseObservation: void 0,
+    dependencyRoles: signalDependencyRoleMask(void 0),
+    collectedDependencyRoles: 0
   };
 }
 function linkReactiveEdgeToConsumer(edge) {
@@ -239,6 +260,7 @@ export {
   linkReactiveEdgeToSource,
   notifyReactiveEdges,
   rollbackReactiveCollection,
+  signalDependencyRoleMask,
   unlinkReactiveEdgeFromConsumer,
   unlinkReactiveEdgeFromSource
 };

package/dist/lib/signals/edge.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/signals/edge.ts"],
-  "sourcesContent": ["import type { SignalNode } from './graph.js';\n\nexport interface ReactiveEdge {\n  source: SignalNode<unknown> | undefined;\n  consumer: SignalDependencyConsumer;\n  sourcePrevious: ReactiveEdge | undefined;\n  sourceNext: ReactiveEdge | undefined;\n  consumerPrevious: ReactiveEdge | undefined;\n  consumerNext: ReactiveEdge | undefined;\n  freeNext: ReactiveEdge | undefined;\n  collectionGeneration: number;\n  observedVersion: number;\n  everPublished: boolean;\n  sourceLinked: boolean;\n  collectionKind: 'new' | 'reused' | undefined;\n  releaseObservation: (() => void) | undefined;\n}\n\nexport interface ReactiveNotificationCursor {\n  next: ReactiveEdge | undefined;\n  previous: ReactiveNotificationCursor | undefined;\n}\n\nexport interface SignalDependencyConsumer {\n  dependencyHead: ReactiveEdge | undefined;\n  dependencyTail: ReactiveEdge | undefined;\n  dependencyFreeHead: ReactiveEdge | undefined;\n  dependencyFreeCount: number;\n  dependencyCount: number;\n  dependencyHighWater: number;\n  collectionCursor: ReactiveEdge | undefined;\n  collectionGeneration: number;\n  addDependency(node: SignalNode<unknown>): void;\n  notify(node: SignalNode<unknown>): void;\n  propagateInvalidation?: boolean;\n  renderInvalidation?: boolean;\n}\n\nexport function beginReactiveCollection(\n  consumer: SignalDependencyConsumer,\n): number {\n  consumer.collectionGeneration++;\n  consumer.collectionCursor = consumer.dependencyHead;\n  return consumer.collectionGeneration;\n}\n\nexport function collectReactiveDependency(\n  consumer: SignalDependencyConsumer,\n  source: SignalNode<unknown>,\n): ReactiveEdge {\n  const generation = consumer.collectionGeneration;\n  let edge = consumer.collectionCursor;\n  if (\n    edge?.source === source &&\n    edge.collectionGeneration !== generation\n  ) {\n    edge.collectionGeneration = generation;\n    edge.collectionKind = 'reused';\n    consumer.collectionCursor = edge.consumerNext;\n    return edge;\n  }\n\n  for (edge = consumer.dependencyHead; edge !== undefined; edge = edge.consumerNext) {\n    if (edge.source !== source) continue;\n    if (edge.collectionGeneration !== generation) {\n      edge.collectionGeneration = generation;\n      edge.collectionKind = 'reused';\n      consumer.collectionCursor = edge.consumerNext;\n    }\n    return edge;\n  }\n\n  edge = takeFreeReactiveEdge(consumer) ?? createReactiveEdge(consumer);\n  edge.source = source;\n  edge.collectionGeneration = generation;\n  edge.collectionKind = edge.everPublished ? 'reused' : 'new';\n  edge.observedVersion = source.version;\n  linkReactiveEdgeToConsumer(edge);\n  consumer.collectionCursor = edge.consumerNext;\n  return edge;\n}\n\nexport function finishReactiveCollection(\n  consumer: SignalDependencyConsumer,\n  publish: (edge: ReactiveEdge) => void,\n  release: (edge: ReactiveEdge) => void,\n): void {\n  let edge = consumer.dependencyHead;\n  while (edge !== undefined) {\n    const next = edge.consumerNext;\n    if (edge.collectionGeneration === consumer.collectionGeneration) {\n      publish(edge);\n    } else {\n      release(edge);\n      unlinkReactiveEdgeFromConsumer(edge);\n      poolReactiveEdge(consumer, edge);\n    }\n    edge = next;\n  }\n  consumer.dependencyHighWater = Math.max(\n    consumer.dependencyHighWater,\n    consumer.dependencyCount,\n  );\n  trimReactiveEdgePool(consumer);\n  consumer.collectionCursor = undefined;\n}\n\nexport function rollbackReactiveCollection(\n  consumer: SignalDependencyConsumer,\n): void {\n  let edge = consumer.dependencyHead;\n  while (edge !== undefined) {\n    const next = edge.consumerNext;\n    if (\n      edge.collectionGeneration === consumer.collectionGeneration &&\n      !edge.sourceLinked\n    ) {\n      unlinkReactiveEdgeFromConsumer(edge);\n      poolReactiveEdge(consumer, edge);\n    }\n    edge = next;\n  }\n  trimReactiveEdgePool(consumer);\n  consumer.collectionCursor = undefined;\n}\n\nexport function linkReactiveEdgeToSource(\n  edge: ReactiveEdge,\n  releaseObservation?: () => void,\n): void {\n  if (edge.sourceLinked) return;\n  const source = edge.source;\n  if (source === undefined) {\n    throw new Error('Cannot link a reactive edge without a source.');\n  }\n  edge.sourcePrevious = source.observerTail;\n  edge.sourceNext = undefined;\n  if (source.observerTail === undefined) {\n    source.observerHead = edge;\n  } else {\n    source.observerTail.sourceNext = edge;\n  }\n  source.observerTail = edge;\n  source.observerCount++;\n  edge.sourceLinked = true;\n  edge.releaseObservation = releaseObservation;\n}\n\nexport function unlinkReactiveEdgeFromSource(edge: ReactiveEdge): void {\n  if (!edge.sourceLinked) return;\n  const source = edge.source!;\n  for (\n    let cursor = source.activeObserverCursor;\n    cursor !== undefined;\n    cursor = cursor.previous\n  ) {\n    if (cursor.next === edge) cursor.next = edge.sourceNext;\n  }\n  if (edge.sourcePrevious === undefined) {\n    source.observerHead = edge.sourceNext;\n  } else {\n    edge.sourcePrevious.sourceNext = edge.sourceNext;\n  }\n  if (edge.sourceNext === undefined) {\n    source.observerTail = edge.sourcePrevious;\n  } else {\n    edge.sourceNext.sourcePrevious = edge.sourcePrevious;\n  }\n  source.observerCount--;\n  edge.sourceLinked = false;\n  edge.sourcePrevious = undefined;\n  edge.sourceNext = undefined;\n  const releaseObservation = edge.releaseObservation;\n  edge.releaseObservation = undefined;\n  releaseObservation?.();\n}\n\nexport function unlinkReactiveEdgeFromConsumer(edge: ReactiveEdge): void {\n  const consumer = edge.consumer;\n  if (edge.consumerPrevious === undefined) {\n    if (consumer.dependencyHead !== edge) return;\n    consumer.dependencyHead = edge.consumerNext;\n  } else {\n    edge.consumerPrevious.consumerNext = edge.consumerNext;\n  }\n  if (edge.consumerNext === undefined) {\n    consumer.dependencyTail = edge.consumerPrevious;\n  } else {\n    edge.consumerNext.consumerPrevious = edge.consumerPrevious;\n  }\n  consumer.dependencyCount--;\n  edge.consumerPrevious = undefined;\n  edge.consumerNext = undefined;\n}\n\nexport function disposeReactiveConsumer(\n  consumer: SignalDependencyConsumer,\n  release: (edge: ReactiveEdge) => void,\n): void {\n  let edge = consumer.dependencyHead;\n  while (edge !== undefined) {\n    const next = edge.consumerNext;\n    release(edge);\n    unlinkReactiveEdgeFromConsumer(edge);\n    edge.source = undefined;\n    edge.freeNext = undefined;\n    edge = next;\n  }\n  consumer.dependencyFreeHead = undefined;\n  consumer.dependencyFreeCount = 0;\n  consumer.collectionCursor = undefined;\n}\n\nexport function notifyReactiveEdges(\n  source: SignalNode<unknown>,\n  accepts: (consumer: SignalDependencyConsumer) => boolean = () => true,\n): unknown[] {\n  const failures: unknown[] = [];\n  const cursor: ReactiveNotificationCursor = {\n    next: source.observerHead,\n    previous: source.activeObserverCursor,\n  };\n  source.activeObserverCursor = cursor;\n  try {\n    while (cursor.next !== undefined) {\n      const edge = cursor.next;\n      cursor.next = edge.sourceNext;\n      if (!edge.sourceLinked || edge.source !== source) continue;\n      if (!accepts(edge.consumer)) continue;\n      try {\n        edge.consumer.notify(source);\n      } catch (error) {\n        failures.push(error);\n      }\n    }\n  } finally {\n    source.activeObserverCursor = cursor.previous;\n  }\n  return failures;\n}\n\nexport function createDetachedReactiveEdge(\n  consumer: SignalDependencyConsumer,\n  source: SignalNode<unknown>,\n): ReactiveEdge {\n  const edge = createReactiveEdge(consumer);\n  edge.source = source;\n  edge.collectionGeneration = consumer.collectionGeneration;\n  edge.observedVersion = source.version;\n  linkReactiveEdgeToConsumer(edge);\n  return edge;\n}\n\nfunction createReactiveEdge(\n  consumer: SignalDependencyConsumer,\n): ReactiveEdge {\n  return {\n    source: undefined,\n    consumer,\n    sourcePrevious: undefined,\n    sourceNext: undefined,\n    consumerPrevious: undefined,\n    consumerNext: undefined,\n    freeNext: undefined,\n    collectionGeneration: 0,\n    observedVersion: -1,\n    everPublished: false,\n    sourceLinked: false,\n    collectionKind: undefined,\n    releaseObservation: undefined,\n  };\n}\n\nfunction linkReactiveEdgeToConsumer(edge: ReactiveEdge): void {\n  const consumer = edge.consumer;\n  edge.consumerPrevious = consumer.dependencyTail;\n  edge.consumerNext = undefined;\n  if (consumer.dependencyTail === undefined) {\n    consumer.dependencyHead = edge;\n  } else {\n    consumer.dependencyTail.consumerNext = edge;\n  }\n  consumer.dependencyTail = edge;\n  consumer.dependencyCount++;\n}\n\nfunction takeFreeReactiveEdge(\n  consumer: SignalDependencyConsumer,\n): ReactiveEdge | undefined {\n  const edge = consumer.dependencyFreeHead;\n  if (edge === undefined) return undefined;\n  consumer.dependencyFreeHead = edge.freeNext;\n  consumer.dependencyFreeCount--;\n  edge.freeNext = undefined;\n  return edge;\n}\n\nfunction poolReactiveEdge(\n  consumer: SignalDependencyConsumer,\n  edge: ReactiveEdge,\n): void {\n  edge.source = undefined;\n  edge.collectionKind = undefined;\n  edge.observedVersion = Math.max(edge.observedVersion, 0);\n  edge.freeNext = consumer.dependencyFreeHead;\n  consumer.dependencyFreeHead = edge;\n  consumer.dependencyFreeCount++;\n}\n\nfunction trimReactiveEdgePool(consumer: SignalDependencyConsumer): void {\n  if (consumer.dependencyFreeCount <= consumer.dependencyHighWater) return;\n  let retained = 0;\n  let edge = consumer.dependencyFreeHead;\n  let previous: ReactiveEdge | undefined;\n  while (edge !== undefined) {\n    retained++;\n    if (retained > consumer.dependencyHighWater) {\n      if (previous === undefined) consumer.dependencyFreeHead = undefined;\n      else previous.freeNext = undefined;\n      consumer.dependencyFreeCount = consumer.dependencyHighWater;\n      return;\n    }\n    previous = edge;\n    edge = edge.freeNext;\n  }\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import type { SignalDependencyRole, SignalDependencyRoleInput, SignalNode } from './graph.js';\n\nconst dependencyRoleMasks: Record<SignalDependencyRole, number> = {\n  structure: 1,\n  layout: 2,\n  measurement: 4,\n  paint: 8,\n  transform: 16,\n  interaction: 32,\n  unknown: 64,\n};\n\nexport function signalDependencyRoleMask(role: SignalDependencyRoleInput | undefined): number {\n  return typeof role === 'number' ? role : dependencyRoleMasks[role ?? 'unknown'];\n}\n\nexport interface ReactiveEdge {\n  source: SignalNode<unknown> | undefined;\n  consumer: SignalDependencyConsumer;\n  sourcePrevious: ReactiveEdge | undefined;\n  sourceNext: ReactiveEdge | undefined;\n  consumerPrevious: ReactiveEdge | undefined;\n  consumerNext: ReactiveEdge | undefined;\n  freeNext: ReactiveEdge | undefined;\n  collectionGeneration: number;\n  observedVersion: number;\n  everPublished: boolean;\n  sourceLinked: boolean;\n  collectionKind: 'new' | 'reused' | undefined;\n  releaseObservation: (() => void) | undefined;\n  dependencyRoles: number;\n  collectedDependencyRoles: number;\n}\n\nexport interface ReactiveNotificationCursor {\n  next: ReactiveEdge | undefined;\n  previous: ReactiveNotificationCursor | undefined;\n}\n\nexport interface SignalDependencyConsumer {\n  dependencyHead: ReactiveEdge | undefined;\n  dependencyTail: ReactiveEdge | undefined;\n  dependencyFreeHead: ReactiveEdge | undefined;\n  dependencyFreeCount: number;\n  dependencyCount: number;\n  dependencyHighWater: number;\n  collectionCursor: ReactiveEdge | undefined;\n  collectionGeneration: number;\n  addDependency(node: SignalNode<unknown>, role?: SignalDependencyRoleInput): void;\n  notify(node: SignalNode<unknown>, dependencyRoles?: number): void;\n  propagateInvalidation?: boolean;\n  renderInvalidation?: boolean;\n}\n\nexport function beginReactiveCollection(\n  consumer: SignalDependencyConsumer,\n): number {\n  consumer.collectionGeneration++;\n  consumer.collectionCursor = consumer.dependencyHead;\n  return consumer.collectionGeneration;\n}\n\nexport function collectReactiveDependency(\n  consumer: SignalDependencyConsumer,\n  source: SignalNode<unknown>,\n  role?: SignalDependencyRoleInput,\n): ReactiveEdge {\n  const generation = consumer.collectionGeneration;\n  const roleMask = signalDependencyRoleMask(role);\n  let edge = consumer.collectionCursor;\n  if (\n    edge?.source === source &&\n    edge.collectionGeneration !== generation\n  ) {\n    edge.collectionGeneration = generation;\n    edge.collectionKind = 'reused';\n    edge.collectedDependencyRoles = roleMask;\n    consumer.collectionCursor = edge.consumerNext;\n    return edge;\n  }\n\n  for (edge = consumer.dependencyHead; edge !== undefined; edge = edge.consumerNext) {\n    if (edge.source !== source) continue;\n    if (edge.collectionGeneration !== generation) {\n      edge.collectionGeneration = generation;\n      edge.collectionKind = 'reused';\n      edge.collectedDependencyRoles = roleMask;\n      consumer.collectionCursor = edge.consumerNext;\n    } else {\n      edge.collectedDependencyRoles |= roleMask;\n    }\n    return edge;\n  }\n\n  edge = takeFreeReactiveEdge(consumer) ?? createReactiveEdge(consumer);\n  edge.source = source;\n  edge.collectionGeneration = generation;\n  edge.collectionKind = edge.everPublished ? 'reused' : 'new';\n  edge.collectedDependencyRoles = roleMask;\n  edge.observedVersion = source.version;\n  linkReactiveEdgeToConsumer(edge);\n  consumer.collectionCursor = edge.consumerNext;\n  return edge;\n}\n\nexport function finishReactiveCollection(\n  consumer: SignalDependencyConsumer,\n  publish: (edge: ReactiveEdge) => void,\n  release: (edge: ReactiveEdge) => void,\n): void {\n  let edge = consumer.dependencyHead;\n  while (edge !== undefined) {\n    const next = edge.consumerNext;\n    if (edge.collectionGeneration === consumer.collectionGeneration) {\n      edge.dependencyRoles = edge.collectedDependencyRoles;\n      publish(edge);\n    } else {\n      release(edge);\n      unlinkReactiveEdgeFromConsumer(edge);\n      poolReactiveEdge(consumer, edge);\n    }\n    edge = next;\n  }\n  consumer.dependencyHighWater = Math.max(\n    consumer.dependencyHighWater,\n    consumer.dependencyCount,\n  );\n  trimReactiveEdgePool(consumer);\n  consumer.collectionCursor = undefined;\n}\n\nexport function rollbackReactiveCollection(\n  consumer: SignalDependencyConsumer,\n): void {\n  let edge = consumer.dependencyHead;\n  while (edge !== undefined) {\n    const next = edge.consumerNext;\n    if (\n      edge.collectionGeneration === consumer.collectionGeneration &&\n      !edge.sourceLinked\n    ) {\n      unlinkReactiveEdgeFromConsumer(edge);\n      poolReactiveEdge(consumer, edge);\n    }\n    edge = next;\n  }\n  trimReactiveEdgePool(consumer);\n  consumer.collectionCursor = undefined;\n}\n\nexport function linkReactiveEdgeToSource(\n  edge: ReactiveEdge,\n  releaseObservation?: () => void,\n): void {\n  if (edge.sourceLinked) return;\n  const source = edge.source;\n  if (source === undefined) {\n    throw new Error('Cannot link a reactive edge without a source.');\n  }\n  edge.sourcePrevious = source.observerTail;\n  edge.sourceNext = undefined;\n  if (source.observerTail === undefined) {\n    source.observerHead = edge;\n  } else {\n    source.observerTail.sourceNext = edge;\n  }\n  source.observerTail = edge;\n  source.observerCount++;\n  edge.sourceLinked = true;\n  edge.releaseObservation = releaseObservation;\n}\n\nexport function unlinkReactiveEdgeFromSource(edge: ReactiveEdge): void {\n  if (!edge.sourceLinked) return;\n  const source = edge.source!;\n  for (\n    let cursor = source.activeObserverCursor;\n    cursor !== undefined;\n    cursor = cursor.previous\n  ) {\n    if (cursor.next === edge) cursor.next = edge.sourceNext;\n  }\n  if (edge.sourcePrevious === undefined) {\n    source.observerHead = edge.sourceNext;\n  } else {\n    edge.sourcePrevious.sourceNext = edge.sourceNext;\n  }\n  if (edge.sourceNext === undefined) {\n    source.observerTail = edge.sourcePrevious;\n  } else {\n    edge.sourceNext.sourcePrevious = edge.sourcePrevious;\n  }\n  source.observerCount--;\n  edge.sourceLinked = false;\n  edge.sourcePrevious = undefined;\n  edge.sourceNext = undefined;\n  const releaseObservation = edge.releaseObservation;\n  edge.releaseObservation = undefined;\n  releaseObservation?.();\n}\n\nexport function unlinkReactiveEdgeFromConsumer(edge: ReactiveEdge): void {\n  const consumer = edge.consumer;\n  if (edge.consumerPrevious === undefined) {\n    if (consumer.dependencyHead !== edge) return;\n    consumer.dependencyHead = edge.consumerNext;\n  } else {\n    edge.consumerPrevious.consumerNext = edge.consumerNext;\n  }\n  if (edge.consumerNext === undefined) {\n    consumer.dependencyTail = edge.consumerPrevious;\n  } else {\n    edge.consumerNext.consumerPrevious = edge.consumerPrevious;\n  }\n  consumer.dependencyCount--;\n  edge.consumerPrevious = undefined;\n  edge.consumerNext = undefined;\n}\n\nexport function disposeReactiveConsumer(\n  consumer: SignalDependencyConsumer,\n  release: (edge: ReactiveEdge) => void,\n): void {\n  let edge = consumer.dependencyHead;\n  while (edge !== undefined) {\n    const next = edge.consumerNext;\n    release(edge);\n    unlinkReactiveEdgeFromConsumer(edge);\n    edge.source = undefined;\n    edge.freeNext = undefined;\n    edge = next;\n  }\n  consumer.dependencyFreeHead = undefined;\n  consumer.dependencyFreeCount = 0;\n  consumer.collectionCursor = undefined;\n}\n\nexport function notifyReactiveEdges(\n  source: SignalNode<unknown>,\n  accepts: (consumer: SignalDependencyConsumer) => boolean = () => true,\n): unknown[] {\n  const failures: unknown[] = [];\n  const cursor: ReactiveNotificationCursor = {\n    next: source.observerHead,\n    previous: source.activeObserverCursor,\n  };\n  source.activeObserverCursor = cursor;\n  try {\n    while (cursor.next !== undefined) {\n      const edge = cursor.next;\n      cursor.next = edge.sourceNext;\n      if (!edge.sourceLinked || edge.source !== source) continue;\n      if (!accepts(edge.consumer)) continue;\n      try {\n        edge.consumer.notify(source, edge.dependencyRoles);\n      } catch (error) {\n        failures.push(error);\n      }\n    }\n  } finally {\n    source.activeObserverCursor = cursor.previous;\n  }\n  return failures;\n}\n\nexport function createDetachedReactiveEdge(\n  consumer: SignalDependencyConsumer,\n  source: SignalNode<unknown>,\n): ReactiveEdge {\n  const edge = createReactiveEdge(consumer);\n  edge.source = source;\n  edge.collectionGeneration = consumer.collectionGeneration;\n  edge.observedVersion = source.version;\n  linkReactiveEdgeToConsumer(edge);\n  return edge;\n}\n\nfunction createReactiveEdge(\n  consumer: SignalDependencyConsumer,\n): ReactiveEdge {\n  return {\n    source: undefined,\n    consumer,\n    sourcePrevious: undefined,\n    sourceNext: undefined,\n    consumerPrevious: undefined,\n    consumerNext: undefined,\n    freeNext: undefined,\n    collectionGeneration: 0,\n    observedVersion: -1,\n    everPublished: false,\n    sourceLinked: false,\n    collectionKind: undefined,\n    releaseObservation: undefined,\n    dependencyRoles: signalDependencyRoleMask(undefined),\n    collectedDependencyRoles: 0,\n  };\n}\n\nfunction linkReactiveEdgeToConsumer(edge: ReactiveEdge): void {\n  const consumer = edge.consumer;\n  edge.consumerPrevious = consumer.dependencyTail;\n  edge.consumerNext = undefined;\n  if (consumer.dependencyTail === undefined) {\n    consumer.dependencyHead = edge;\n  } else {\n    consumer.dependencyTail.consumerNext = edge;\n  }\n  consumer.dependencyTail = edge;\n  consumer.dependencyCount++;\n}\n\nfunction takeFreeReactiveEdge(\n  consumer: SignalDependencyConsumer,\n): ReactiveEdge | undefined {\n  const edge = consumer.dependencyFreeHead;\n  if (edge === undefined) return undefined;\n  consumer.dependencyFreeHead = edge.freeNext;\n  consumer.dependencyFreeCount--;\n  edge.freeNext = undefined;\n  return edge;\n}\n\nfunction poolReactiveEdge(\n  consumer: SignalDependencyConsumer,\n  edge: ReactiveEdge,\n): void {\n  edge.source = undefined;\n  edge.collectionKind = undefined;\n  edge.observedVersion = Math.max(edge.observedVersion, 0);\n  edge.freeNext = consumer.dependencyFreeHead;\n  consumer.dependencyFreeHead = edge;\n  consumer.dependencyFreeCount++;\n}\n\nfunction trimReactiveEdgePool(consumer: SignalDependencyConsumer): void {\n  if (consumer.dependencyFreeCount <= consumer.dependencyHighWater) return;\n  let retained = 0;\n  let edge = consumer.dependencyFreeHead;\n  let previous: ReactiveEdge | undefined;\n  while (edge !== undefined) {\n    retained++;\n    if (retained > consumer.dependencyHighWater) {\n      if (previous === undefined) consumer.dependencyFreeHead = undefined;\n      else previous.freeNext = undefined;\n      consumer.dependencyFreeCount = consumer.dependencyHighWater;\n      return;\n    }\n    previous = edge;\n    edge = edge.freeNext;\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/lib/signals/graph.d.ts

@@ -21,8 +21,11 @@ export interface SignalNode<T> {
     observe?(): () => void;
     validate?(): void;
 }
+/** @internal The declared effect of one receiver-owned signal input. */
+export type SignalDependencyRole = 'structure' | 'layout' | 'measurement' | 'paint' | 'transform' | 'interaction' | 'unknown';
+export type SignalDependencyRoleInput = SignalDependencyRole | number;
 export interface SignalDependencyCollector {
-    addDependency(node: SignalNode<unknown>): void;
+    addDependency(node: SignalNode<unknown>, role?: SignalDependencyRoleInput): void;
 }
 export type SignalWriteOperation = 'direct' | 'staged';
 export type SignalWritePolicy = (node: SignalNode<unknown>, operation: SignalWriteOperation) => void;
@@ -54,6 +57,13 @@ export interface SignalGraphSnapshot {
     readonly adoptedReceiverInputProvisions: number;
     readonly rolledBackReceiverInputProvisions: number;
     readonly batchedObserverInvalidations: number;
+    readonly structureInputInvalidations: number;
+    readonly layoutInputInvalidations: number;
+    readonly measurementInputInvalidations: number;
+    readonly paintInputInvalidations: number;
+    readonly transformInputInvalidations: number;
+    readonly interactionInputInvalidations: number;
+    readonly unknownInputInvalidations: number;
     readonly reactionConsumers: number;
     readonly reactionEdges: number;
     readonly reactionRuns: number;
@@ -62,6 +72,8 @@ export interface SignalGraphSnapshot {
 }
 /** @internal Deterministic ownership and structural evidence for tests. */
 export declare function signalGraphSnapshot(): SignalGraphSnapshot;
+/** @internal Records roles carried by a receiver edge when its source changes. */
+export declare function recordSignalInputInvalidation(roles: number): void;
 /** @internal Records one component consumer materialized by its first read. */
 export declare function recordLazyRendererConsumerCreated(): void;
 /** @internal Records one render edge reused by recollection or restoration. */
@@ -79,7 +91,9 @@ export declare function recordReceiverInputProvisionAdopted(): void;
 /** @internal Records one provision discarded without publication. */
 export declare function recordReceiverInputProvisionRolledBack(): void;
 /** @internal Adds one already-read source to the active dependency collector. */
-export declare function trackSignalDependency(node: SignalNode<unknown>): void;
+export declare function trackSignalDependency(node: SignalNode<unknown>, role?: SignalDependencyRoleInput): void;
+/** @internal Tags reads while a declared receiver input is resolved. */
+export declare function withSignalDependencyRole<T>(role: SignalDependencyRole, callback: () => T): T;
 /** @internal Records one observer invalidation deduplicated by a public batch. */
 export declare function recordBatchedObserverInvalidation(): void;
 /** @internal Records one live component-owned reaction consumer. */

package/dist/lib/signals/graph.js

@@ -9,6 +9,7 @@ import {
 const signalNodes = /* @__PURE__ */ new WeakMap();
 const signalValues = /* @__PURE__ */ new WeakSet();
 let activeSignalDependencyCollector;
+let activeSignalDependencyRole;
 const writePolicyStack = [];
 const computedStack = [];
 function createSignalNodeState(value, equals, debugName) {
@@ -51,6 +52,13 @@ let receiverInputProvisions = 0;
 let adoptedReceiverInputProvisions = 0;
 let rolledBackReceiverInputProvisions = 0;
 let batchedObserverInvalidations = 0;
+let structureInputInvalidations = 0;
+let layoutInputInvalidations = 0;
+let measurementInputInvalidations = 0;
+let paintInputInvalidations = 0;
+let transformInputInvalidations = 0;
+let interactionInputInvalidations = 0;
+let unknownInputInvalidations = 0;
 let reactionConsumers = 0;
 let reactionEdges = 0;
 let reactionRuns = 0;
@@ -82,6 +90,13 @@ function signalGraphSnapshot() {
     adoptedReceiverInputProvisions,
     rolledBackReceiverInputProvisions,
     batchedObserverInvalidations,
+    structureInputInvalidations,
+    layoutInputInvalidations,
+    measurementInputInvalidations,
+    paintInputInvalidations,
+    transformInputInvalidations,
+    interactionInputInvalidations,
+    unknownInputInvalidations,
     reactionConsumers,
     reactionEdges,
     reactionRuns,
@@ -89,6 +104,15 @@ function signalGraphSnapshot() {
     reactionFailures
   });
 }
+function recordSignalInputInvalidation(roles) {
+  if (roles & 1) structureInputInvalidations++;
+  if (roles & 2) layoutInputInvalidations++;
+  if (roles & 4) measurementInputInvalidations++;
+  if (roles & 8) paintInputInvalidations++;
+  if (roles & 16) transformInputInvalidations++;
+  if (roles & 32) interactionInputInvalidations++;
+  if (roles & 64) unknownInputInvalidations++;
+}
 function recordLazyRendererConsumerCreated() {
   lazyRendererConsumers++;
 }
@@ -116,8 +140,20 @@ function recordReceiverInputProvisionRolledBack() {
   receiverInputProvisions--;
   rolledBackReceiverInputProvisions++;
 }
-function trackSignalDependency(node) {
-  activeSignalDependencyCollector?.addDependency(node);
+function trackSignalDependency(node, role) {
+  activeSignalDependencyCollector?.addDependency(
+    node,
+    role ?? activeSignalDependencyRole
+  );
+}
+function withSignalDependencyRole(role, callback) {
+  const previous = activeSignalDependencyRole;
+  activeSignalDependencyRole = role;
+  try {
+    return callback();
+  } finally {
+    activeSignalDependencyRole = previous;
+  }
 }
 function recordBatchedObserverInvalidation() {
   batchedObserverInvalidations++;
@@ -206,8 +242,7 @@ function flushPublicSignalBatch(state) {
       state.failures.push(error);
     }
   }
-  const seen = /* @__PURE__ */ new Set();
-  const consumers = [];
+  const consumers = /* @__PURE__ */ new Map();
   for (const [source, entry] of state.entries) {
     let unchanged = false;
     try {
@@ -220,18 +255,19 @@ function flushPublicSignalBatch(state) {
     for (let edge = source.observerHead; edge !== void 0; edge = edge.sourceNext) {
       const consumer = edge.consumer;
       if (consumer.propagateInvalidation === true) continue;
-      if (seen.has(consumer)) {
+      const existing = consumers.get(consumer);
+      if (existing !== void 0) {
+        existing.roles |= edge.dependencyRoles;
         recordBatchedObserverInvalidation();
         continue;
       }
-      seen.add(consumer);
-      consumers.push({ consumer, source });
+      consumers.set(consumer, { consumer, source, roles: edge.dependencyRoles });
     }
   }
   activePublicSignalBatch = void 0;
-  for (const { consumer, source } of consumers) {
+  for (const { consumer, source, roles } of consumers.values()) {
     try {
-      consumer.notify(source);
+      consumer.notify(source, roles);
     } catch (error) {
       state.failures.push(error);
     }
@@ -280,7 +316,10 @@ function signal(initialValue, options = {}) {
   const node = createSignalNodeState(initialValue, equals, debugName);
   let readonlySignal;
   const read = () => {
-    activeSignalDependencyCollector?.addDependency(node);
+    activeSignalDependencyCollector?.addDependency(
+      node,
+      activeSignalDependencyRole
+    );
     return node.value;
   };
   const assertWriteAllowed = () => {
@@ -624,7 +663,8 @@ function computed(compute, options = {}) {
   const readonly = {
     get() {
       activeSignalDependencyCollector?.addDependency(
-        node
+        node,
+        activeSignalDependencyRole
       );
       validate();
       removePendingValidation();
@@ -661,7 +701,7 @@ function createComputedFormulaCandidate(target, compute) {
 function readComputedFormulaCandidate(target, candidate) {
   const node = requireComputedSignalNode(target);
   const reader = activeSignalDependencyCollector;
-  reader?.addDependency(node);
+  reader?.addDependency(node, activeSignalDependencyRole);
   if (reader !== void 0) candidate.readers.add(reader);
   if (!candidate.evaluated) {
     const value = untracked(() => candidate.signal.get());
@@ -1019,6 +1059,7 @@ export {
   recordRendererEdgeReleased,
   recordRendererEdgeReused,
   recordShallowInputCopy,
+  recordSignalInputInvalidation,
   recordSignalInputResolution,
   replaceComputedFormula,
   setSignalGraphPlanWorkNotifier,
@@ -1028,6 +1069,7 @@ export {
   trackSignalDependency,
   untracked,
   withDirectSignalWriteForbidden,
+  withSignalDependencyRole,
   withSignalTracking,
   withSignalWriteForbidden,
   withSignalWritePolicy