@pibbl/core 0.0.1

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

@@ -0,0 +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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",
+  "names": []
+}

package/dist/lib/scheduler/simulation-participant.d.ts

@@ -0,0 +1,103 @@
+import type { PibblAdvanceLane } from "./types.js";
+import type { PibblInternalFrame, PibblInternalSignalBatch } from "./renderer-participant.js";
+/**
+ * The scheduler lane in which an official simulation integration advances.
+ *
+ * @see {@link pibblInternalRegisterSimulationAdvance}
+ */
+export type PibblInternalAdvanceLane = PibblAdvanceLane;
+declare const internalSimulationOwnerBrand: unique symbol;
+/**
+ * Opaque ownership identity tying simulation work to a mounted runtime resource.
+ *
+ * @see {@link pibblInternalCurrentSimulationOwner}
+ * @see {@link pibblInternalOnSimulationRenderTransactionFinish}
+ * @see {@link pibblInternalQueueSimulationBegin}
+ */
+export interface PibblInternalSimulationOwner {
+    readonly [internalSimulationOwnerBrand]: true;
+}
+/**
+ * Returns the active mount's simulation owner for a matching official integration.
+ *
+ * @returns The simulation owner for the active runtime context. See
+ * {@link PibblInternalSimulationOwner} .
+ *
+ * @see {@link PibblInternalSimulationOwner}
+ */
+export declare function pibblInternalCurrentSimulationOwner(): PibblInternalSimulationOwner;
+/**
+ * Queues a cancellable simulation command for the shared scheduler's Begin phase.
+ *
+ * @param owner - Simulation owner admitting this command. See {@link PibblInternalSimulationOwner}.
+ * @param command - Begin-phase work receiving frame, staged signal writes, and command sequence.
+ * See {@link PibblInternalFrame} , {@link PibblInternalSignalBatch} .
+ * @returns A command sequence and cancellation handle.
+ *
+ * @see {@link PibblInternalSimulationOwner}
+ * @see {@link PibblInternalFrame}
+ * @see {@link PibblInternalSignalBatch}
+ */
+export declare function pibblInternalQueueSimulationBegin(owner: PibblInternalSimulationOwner, command: (frame: PibblInternalFrame, batch: PibblInternalSignalBatch, sequence: number) => void): Readonly<{
+    readonly sequence: number;
+    cancel(): void;
+}>;
+/**
+ * Registers work in a simulation Advance lane and returns its unregister callback.
+ *
+ * @param owner - Simulation owner registering the work. See {@link PibblInternalSimulationOwner}.
+ * @param lane - Advance lane controlling execution order. See {@link PibblInternalAdvanceLane}.
+ * @param advance - Advance callback receiving frame timing and staged signal writes. See
+ * {@link PibblInternalFrame} , {@link PibblInternalSignalBatch} .
+ * @param requestsFrames - Whether this participant requests subsequent host frames; defaults to
+ * true.
+ * @returns A function that unregisters the participant.
+ *
+ * @see {@link PibblInternalSimulationOwner}
+ * @see {@link PibblInternalAdvanceLane}
+ * @see {@link PibblInternalFrame}
+ * @see {@link PibblInternalSignalBatch}
+ */
+export declare function pibblInternalRegisterSimulationAdvance(owner: PibblInternalSimulationOwner, lane: PibblInternalAdvanceLane, advance: (frame: PibblInternalFrame, batch: PibblInternalSignalBatch) => void, requestsFrames?: boolean): () => void;
+/**
+ * Reports whether the current simulation frame's staged writes were committed.
+ *
+ * @param owner - Owner of the pending commit. See {@link PibblInternalSimulationOwner}.
+ * @param callback - Callback receiving the frame and whether the commit was applied. See
+ * {@link PibblInternalFrame} .
+ *
+ * @see {@link PibblInternalSimulationOwner}
+ * @see {@link PibblInternalFrame}
+ */
+export declare function pibblInternalQueueSimulationCommitAcknowledgement(owner: PibblInternalSimulationOwner, callback: (frame: PibblInternalFrame, outcome: Readonly<{
+    readonly applied: boolean;
+}>) => void): void;
+/**
+ * Queues an owner-scoped callback for the scheduler's Complete phase.
+ *
+ * @param owner - Owner of the completion work. See {@link PibblInternalSimulationOwner}.
+ * @param callback - Callback invoked during Complete with the shared frame. See
+ * {@link PibblInternalFrame} .
+ *
+ * @see {@link PibblInternalSimulationOwner}
+ * @see {@link PibblInternalFrame}
+ */
+export declare function pibblInternalQueueSimulationComplete(owner: PibblInternalSimulationOwner, callback: (frame: PibblInternalFrame) => void): void;
+/**
+ * Invalidates the renderer associated with a simulation owner.
+ *
+ * @param owner - Owner whose renderer should become dirty. See {@link PibblInternalSimulationOwner}.
+ *
+ * @see {@link PibblInternalSimulationOwner}
+ */
+export declare function pibblInternalRequestSimulationRender(owner: PibblInternalSimulationOwner): void;
+/**
+ * Registers a callback reporting whether the owner's current render transaction succeeded.
+ *
+ * @param owner - Owner of the rendering transaction. See {@link PibblInternalSimulationOwner}.
+ * @param callback - Callback receiving whether the transaction succeeded.
+ *
+ * @see {@link PibblInternalSimulationOwner}
+ */
+export declare function pibblInternalOnSimulationRenderTransactionFinish(owner: PibblInternalSimulationOwner, callback: (success: boolean) => void): void;
+export {};

package/dist/lib/scheduler/simulation-participant.js

@@ -0,0 +1,229 @@
+import { GLOBAL_STATE } from "../global-state.js";
+import { requireHookContext, useInternalHookSlot } from "../hooks/hook-slot.js";
+import {
+  discardSignalCommitBatchProvenance,
+  discardSignalCommitBatchWriterForProvenance,
+  stageSignalCommitBatchWithProvenance
+} from "../signals/graph.js";
+import {
+  queueBeginCommand,
+  queueCurrentFrameCommitAcknowledgement,
+  queueCurrentFrameCompletion,
+  registerAdvanceParticipant,
+  requestInstanceRender
+} from "./realm-scheduler.js";
+const ownerStates = /* @__PURE__ */ new WeakMap();
+const batchViews = /* @__PURE__ */ new WeakMap();
+let currentSimulationOwner;
+function pibblInternalCurrentSimulationOwner() {
+  const { componentRefs, pibblInstance } = requireHookContext();
+  const slot = useInternalHookSlot(
+    "internalSimulationOwner",
+    (teardowns) => {
+      const owner = {};
+      ownerStates.set(owner, {
+        component: componentRefs,
+        instance: pibblInstance,
+        cancellations: /* @__PURE__ */ new Set(),
+        active: true
+      });
+      teardowns.add(() => disposeSimulationOwner(owner));
+      return owner;
+    }
+  );
+  requireActiveOwner(slot.value);
+  return slot.value;
+}
+function pibblInternalQueueSimulationBegin(owner, command) {
+  const state = requireActiveOwner(owner);
+  let active = true;
+  let handle;
+  const cancel = () => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(cancel);
+    handle.cancel();
+  };
+  handle = queueBeginCommand((frame, batch, sequence) => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(cancel);
+    if (!isCurrentOwner(state)) return;
+    try {
+      withCurrentSimulationOwner(owner, () => {
+        command(frame, simulationBatchView(batch), sequence);
+      });
+      if (!isCurrentOwner(state)) {
+        discardSimulationOwnerWriters(batch, owner);
+      }
+    } catch (error) {
+      discardSimulationOwnerWriters(batch, owner);
+      throw error;
+    }
+  });
+  state.cancellations.add(cancel);
+  return Object.freeze({ sequence: handle.sequence, cancel });
+}
+function pibblInternalRegisterSimulationAdvance(owner, lane, advance, requestsFrames = true) {
+  const state = requireActiveOwner(owner);
+  let active = true;
+  let unregister;
+  const release = () => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(release);
+    unregister();
+  };
+  unregister = registerAdvanceParticipant(
+    (frame, batch) => {
+      if (!active || !isCurrentOwner(state)) return;
+      try {
+        withCurrentSimulationOwner(owner, () => {
+          advance(frame, simulationBatchView(batch));
+        });
+        if (!isCurrentOwner(state)) {
+          discardSimulationOwnerWriters(batch, owner);
+        }
+      } catch (error) {
+        discardSimulationOwnerWriters(batch, owner);
+        throw error;
+      }
+    },
+    lane,
+    requestsFrames
+  );
+  state.cancellations.add(release);
+  return release;
+}
+function pibblInternalQueueSimulationCommitAcknowledgement(owner, callback) {
+  const state = requireActiveOwner(owner);
+  let active = true;
+  let cancelQueued = () => {
+  };
+  const cancel = () => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(cancel);
+    cancelQueued();
+  };
+  cancelQueued = queueCurrentFrameCommitAcknowledgement((frame, outcome) => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(cancel);
+    if (isCurrentOwner(state)) callback(frame, outcome);
+  });
+  state.cancellations.add(cancel);
+}
+function pibblInternalQueueSimulationComplete(owner, callback) {
+  const state = requireActiveOwner(owner);
+  let active = true;
+  let cancelQueued = () => {
+  };
+  const cancel = () => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(cancel);
+    cancelQueued();
+  };
+  cancelQueued = queueCurrentFrameCompletion((frame) => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(cancel);
+    if (isCurrentOwner(state)) callback(frame);
+  });
+  state.cancellations.add(cancel);
+}
+function pibblInternalRequestSimulationRender(owner) {
+  const state = requireActiveOwner(owner);
+  requestInstanceRender(state.instance);
+}
+function pibblInternalOnSimulationRenderTransactionFinish(owner, callback) {
+  const state = requireActiveOwner(owner);
+  const transaction = state.instance.eventRoot.renderTransaction;
+  if (!transaction) {
+    throw new Error(
+      "pibblInternalOnSimulationRenderTransactionFinish() requires an active Pibbl render transaction."
+    );
+  }
+  let active = true;
+  const cancel = () => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(cancel);
+  };
+  state.cancellations.add(cancel);
+  transaction.onFinish((success) => {
+    if (!active) return;
+    active = false;
+    state.cancellations.delete(cancel);
+    if (isCurrentOwner(state)) callback(success);
+  });
+}
+function simulationBatchView(batch) {
+  const existing = batchViews.get(batch);
+  if (existing) return existing;
+  const view = Object.freeze({
+    read(signal) {
+      return batch.read(signal);
+    },
+    stage(signal, value, writer) {
+      const owner = currentSimulationOwner;
+      if (owner === void 0) {
+        throw new Error(
+          "Pibbl internal simulation batches may only stage during their owning callback."
+        );
+      }
+      stageSignalCommitBatchWithProvenance(batch, owner, signal, value, writer);
+    },
+    discardWriter(writer) {
+      const owner = currentSimulationOwner;
+      if (owner === void 0) {
+        throw new Error(
+          "Pibbl internal simulation batches may only discard during their owning callback."
+        );
+      }
+      discardSignalCommitBatchWriterForProvenance(batch, owner, writer);
+    }
+  });
+  batchViews.set(batch, view);
+  return view;
+}
+function withCurrentSimulationOwner(owner, callback) {
+  const previous = currentSimulationOwner;
+  currentSimulationOwner = owner;
+  try {
+    return callback();
+  } finally {
+    currentSimulationOwner = previous;
+  }
+}
+function discardSimulationOwnerWriters(batch, owner) {
+  discardSignalCommitBatchProvenance(batch, owner);
+}
+function requireActiveOwner(owner) {
+  const state = ownerStates.get(owner);
+  if (!state || !state.active || !isCurrentOwner(state)) {
+    throw new TypeError("Expected an active Pibbl internal simulation owner.");
+  }
+  return state;
+}
+function isCurrentOwner(state) {
+  return !state.component.teardowns.closed && !state.instance.mainTeardowns.closed && GLOBAL_STATE.pibblInstances.get(state.instance.canvas) === state.instance && state.instance.refs.get(state.component.id) === state.component;
+}
+function disposeSimulationOwner(owner) {
+  const state = ownerStates.get(owner);
+  if (!state || !state.active) return;
+  state.active = false;
+  for (const cancel of Array.from(state.cancellations)) cancel();
+  state.cancellations.clear();
+}
+export {
+  pibblInternalCurrentSimulationOwner,
+  pibblInternalOnSimulationRenderTransactionFinish,
+  pibblInternalQueueSimulationBegin,
+  pibblInternalQueueSimulationCommitAcknowledgement,
+  pibblInternalQueueSimulationComplete,
+  pibblInternalRegisterSimulationAdvance,
+  pibblInternalRequestSimulationRender
+};
+//# sourceMappingURL=simulation-participant.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/scheduler/simulation-participant.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from \"../global-state.js\";\nimport { requireHookContext, useInternalHookSlot } from \"../hooks/hook-slot.js\";\nimport {\n  discardSignalCommitBatchProvenance,\n  discardSignalCommitBatchWriterForProvenance,\n  stageSignalCommitBatchWithProvenance,\n  type SignalCommitBatch,\n} from \"../signals/graph.js\";\nimport type { WritableSignal } from \"../signals/types.js\";\nimport type { PibblComponentRefs, PibblInstance } from \"../types.js\";\nimport {\n  queueBeginCommand,\n  queueCurrentFrameCommitAcknowledgement,\n  queueCurrentFrameCompletion,\n  registerAdvanceParticipant,\n  requestInstanceRender,\n} from \"./realm-scheduler.js\";\nimport type { PibblAdvanceLane, PibblBeginCommandHandle } from \"./types.js\";\nimport type {\n  PibblInternalFrame,\n  PibblInternalSignalBatch,\n} from \"./renderer-participant.js\";\n\n/**\n * The scheduler lane in which an official simulation integration advances.\n *\n * @see {@link pibblInternalRegisterSimulationAdvance}\n */\nexport type PibblInternalAdvanceLane = PibblAdvanceLane;\n\ndeclare const internalSimulationOwnerBrand: unique symbol;\n/**\n * Opaque ownership identity tying simulation work to a mounted runtime resource.\n *\n * @see {@link pibblInternalCurrentSimulationOwner}\n * @see {@link pibblInternalOnSimulationRenderTransactionFinish}\n * @see {@link pibblInternalQueueSimulationBegin}\n */\nexport interface PibblInternalSimulationOwner {\n  readonly [internalSimulationOwnerBrand]: true;\n}\n\ninterface SimulationOwnerState {\n  readonly component: PibblComponentRefs<any>;\n  readonly instance: PibblInstance;\n  readonly cancellations: Set<() => void>;\n  active: boolean;\n}\n\nconst ownerStates = new WeakMap<\n  PibblInternalSimulationOwner,\n  SimulationOwnerState\n>();\nconst batchViews = new WeakMap<SignalCommitBatch, PibblInternalSignalBatch>();\nlet currentSimulationOwner: PibblInternalSimulationOwner | undefined;\n\n/**\n * Returns the active mount's simulation owner for a matching official integration.\n *\n * @returns The simulation owner for the active runtime context. See\n * {@link PibblInternalSimulationOwner} .\n *\n * @see {@link PibblInternalSimulationOwner}\n */\nexport function pibblInternalCurrentSimulationOwner(): PibblInternalSimulationOwner {\n  const { componentRefs, pibblInstance } = requireHookContext();\n  const slot = useInternalHookSlot<PibblInternalSimulationOwner>(\n    \"internalSimulationOwner\",\n    (teardowns) => {\n      const owner = {} as PibblInternalSimulationOwner;\n      ownerStates.set(owner, {\n        component: componentRefs,\n        instance: pibblInstance,\n        cancellations: new Set(),\n        active: true,\n      });\n      teardowns.add(() => disposeSimulationOwner(owner));\n      return owner;\n    },\n  );\n  requireActiveOwner(slot.value);\n  return slot.value;\n}\n\n/**\n * Queues a cancellable simulation command for the shared scheduler's Begin phase.\n *\n * @param owner - Simulation owner admitting this command. See {@link PibblInternalSimulationOwner}.\n * @param command - Begin-phase work receiving frame, staged signal writes, and command sequence.\n * See {@link PibblInternalFrame} , {@link PibblInternalSignalBatch} .\n * @returns A command sequence and cancellation handle.\n *\n * @see {@link PibblInternalSimulationOwner}\n * @see {@link PibblInternalFrame}\n * @see {@link PibblInternalSignalBatch}\n */\nexport function pibblInternalQueueSimulationBegin(\n  owner: PibblInternalSimulationOwner,\n  command: (\n    frame: PibblInternalFrame,\n    batch: PibblInternalSignalBatch,\n    sequence: number,\n  ) => void,\n): Readonly<{ readonly sequence: number; cancel(): void }> {\n  const state = requireActiveOwner(owner);\n  let active = true;\n  let handle: PibblBeginCommandHandle;\n  const cancel = (): void => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(cancel);\n    handle.cancel();\n  };\n  handle = queueBeginCommand((frame, batch, sequence) => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(cancel);\n    if (!isCurrentOwner(state)) return;\n    try {\n      withCurrentSimulationOwner(owner, () => {\n        command(frame, simulationBatchView(batch), sequence);\n      });\n      if (!isCurrentOwner(state)) {\n        discardSimulationOwnerWriters(batch, owner);\n      }\n    } catch (error) {\n      discardSimulationOwnerWriters(batch, owner);\n      throw error;\n    }\n  });\n  state.cancellations.add(cancel);\n  return Object.freeze({ sequence: handle.sequence, cancel });\n}\n\n/**\n * Registers work in a simulation Advance lane and returns its unregister callback.\n *\n * @param owner - Simulation owner registering the work. See {@link PibblInternalSimulationOwner}.\n * @param lane - Advance lane controlling execution order. See {@link PibblInternalAdvanceLane}.\n * @param advance - Advance callback receiving frame timing and staged signal writes. See\n * {@link PibblInternalFrame} , {@link PibblInternalSignalBatch} .\n * @param requestsFrames - Whether this participant requests subsequent host frames; defaults to\n * true.\n * @returns A function that unregisters the participant.\n *\n * @see {@link PibblInternalSimulationOwner}\n * @see {@link PibblInternalAdvanceLane}\n * @see {@link PibblInternalFrame}\n * @see {@link PibblInternalSignalBatch}\n */\nexport function pibblInternalRegisterSimulationAdvance(\n  owner: PibblInternalSimulationOwner,\n  lane: PibblInternalAdvanceLane,\n  advance: (frame: PibblInternalFrame, batch: PibblInternalSignalBatch) => void,\n  requestsFrames = true,\n): () => void {\n  const state = requireActiveOwner(owner);\n  let active = true;\n  let unregister: () => void;\n  const release = (): void => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(release);\n    unregister();\n  };\n  unregister = registerAdvanceParticipant(\n    (frame, batch) => {\n      if (!active || !isCurrentOwner(state)) return;\n      try {\n        withCurrentSimulationOwner(owner, () => {\n          advance(frame, simulationBatchView(batch));\n        });\n        if (!isCurrentOwner(state)) {\n          discardSimulationOwnerWriters(batch, owner);\n        }\n      } catch (error) {\n        discardSimulationOwnerWriters(batch, owner);\n        throw error;\n      }\n    },\n    lane,\n    requestsFrames,\n  );\n  state.cancellations.add(release);\n  return release;\n}\n\n/**\n * Reports whether the current simulation frame's staged writes were committed.\n *\n * @param owner - Owner of the pending commit. See {@link PibblInternalSimulationOwner}.\n * @param callback - Callback receiving the frame and whether the commit was applied. See\n * {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalSimulationOwner}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalQueueSimulationCommitAcknowledgement(\n  owner: PibblInternalSimulationOwner,\n  callback: (\n    frame: PibblInternalFrame,\n    outcome: Readonly<{ readonly applied: boolean }>,\n  ) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  let active = true;\n  let cancelQueued = () => {};\n  const cancel = (): void => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(cancel);\n    cancelQueued();\n  };\n  cancelQueued = queueCurrentFrameCommitAcknowledgement((frame, outcome) => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(cancel);\n    if (isCurrentOwner(state)) callback(frame, outcome);\n  });\n  state.cancellations.add(cancel);\n}\n\n/**\n * Queues an owner-scoped callback for the scheduler's Complete phase.\n *\n * @param owner - Owner of the completion work. See {@link PibblInternalSimulationOwner}.\n * @param callback - Callback invoked during Complete with the shared frame. See\n * {@link PibblInternalFrame} .\n *\n * @see {@link PibblInternalSimulationOwner}\n * @see {@link PibblInternalFrame}\n */\nexport function pibblInternalQueueSimulationComplete(\n  owner: PibblInternalSimulationOwner,\n  callback: (frame: PibblInternalFrame) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  let active = true;\n  let cancelQueued = () => {};\n  const cancel = (): void => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(cancel);\n    cancelQueued();\n  };\n  cancelQueued = queueCurrentFrameCompletion((frame) => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(cancel);\n    if (isCurrentOwner(state)) callback(frame);\n  });\n  state.cancellations.add(cancel);\n}\n\n/**\n * Invalidates the renderer associated with a simulation owner.\n *\n * @param owner - Owner whose renderer should become dirty. See {@link PibblInternalSimulationOwner}.\n *\n * @see {@link PibblInternalSimulationOwner}\n */\nexport function pibblInternalRequestSimulationRender(\n  owner: PibblInternalSimulationOwner,\n): void {\n  const state = requireActiveOwner(owner);\n  requestInstanceRender(state.instance);\n}\n\n/**\n * Registers a callback reporting whether the owner's current render transaction succeeded.\n *\n * @param owner - Owner of the rendering transaction. See {@link PibblInternalSimulationOwner}.\n * @param callback - Callback receiving whether the transaction succeeded.\n *\n * @see {@link PibblInternalSimulationOwner}\n */\nexport function pibblInternalOnSimulationRenderTransactionFinish(\n  owner: PibblInternalSimulationOwner,\n  callback: (success: boolean) => void,\n): void {\n  const state = requireActiveOwner(owner);\n  const transaction = state.instance.eventRoot.renderTransaction;\n  if (!transaction) {\n    throw new Error(\n      \"pibblInternalOnSimulationRenderTransactionFinish() requires an active Pibbl render transaction.\",\n    );\n  }\n  let active = true;\n  const cancel = (): void => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(cancel);\n  };\n  state.cancellations.add(cancel);\n  transaction.onFinish((success) => {\n    if (!active) return;\n    active = false;\n    state.cancellations.delete(cancel);\n    if (isCurrentOwner(state)) callback(success);\n  });\n}\n\nfunction simulationBatchView(batch: SignalCommitBatch): PibblInternalSignalBatch {\n  const existing = batchViews.get(batch);\n  if (existing) return existing;\n  const view = Object.freeze({\n    read<T>(signal: WritableSignal<T>): T {\n      return batch.read(signal);\n    },\n    stage<T>(signal: WritableSignal<T>, value: T, writer: object): void {\n      const owner = currentSimulationOwner;\n      if (owner === undefined) {\n        throw new Error(\n          \"Pibbl internal simulation batches may only stage during their owning callback.\",\n        );\n      }\n      stageSignalCommitBatchWithProvenance(batch, owner, signal, value, writer);\n    },\n    discardWriter(writer: object): void {\n      const owner = currentSimulationOwner;\n      if (owner === undefined) {\n        throw new Error(\n          \"Pibbl internal simulation batches may only discard during their owning callback.\",\n        );\n      }\n      discardSignalCommitBatchWriterForProvenance(batch, owner, writer);\n    },\n  });\n  batchViews.set(batch, view);\n  return view;\n}\n\nfunction withCurrentSimulationOwner<T>(\n  owner: PibblInternalSimulationOwner,\n  callback: () => T,\n): T {\n  const previous = currentSimulationOwner;\n  currentSimulationOwner = owner;\n  try {\n    return callback();\n  } finally {\n    currentSimulationOwner = previous;\n  }\n}\n\nfunction discardSimulationOwnerWriters(\n  batch: SignalCommitBatch,\n  owner: PibblInternalSimulationOwner,\n): void {\n  discardSignalCommitBatchProvenance(batch, owner);\n}\n\nfunction requireActiveOwner(\n  owner: PibblInternalSimulationOwner,\n): SimulationOwnerState {\n  const state = ownerStates.get(owner);\n  if (!state || !state.active || !isCurrentOwner(state)) {\n    throw new TypeError(\"Expected an active Pibbl internal simulation owner.\");\n  }\n  return state;\n}\n\nfunction isCurrentOwner(state: SimulationOwnerState): boolean {\n  return (\n    !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}\n\nfunction disposeSimulationOwner(owner: PibblInternalSimulationOwner): void {\n  const state = ownerStates.get(owner);\n  if (!state || !state.active) return;\n  state.active = false;\n  for (const cancel of Array.from(state.cancellations)) cancel();\n  state.cancellations.clear();\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/scheduler/testing.d.ts

@@ -0,0 +1,56 @@
+import { installSchedulerTraceCollectorForTest, snapshotRealmScheduler } from './realm-scheduler.js';
+import type { PibblSchedulerTraceRecord, SchedulerDriver } from './types.js';
+/**
+ * A host-frame driver controlled explicitly by tests.
+ *
+ * @see {@link installSchedulerDriverForTest}
+ */
+export declare class ManualSchedulerDriver implements SchedulerDriver {
+    private readonly callbacks;
+    private nextFrameId;
+    /**
+     * Number of host-frame requests observed by this test driver. See {@link ManualSchedulerDriver}
+     * .
+     */
+    requestCount: number;
+    /**
+     * Number of host-frame cancellations observed by this test driver. See
+     * {@link ManualSchedulerDriver}.
+     */
+    cancelCount: number;
+    /**
+     * Number of host-frame callbacks currently pending in the driver. See
+     * {@link ManualSchedulerDriver}.
+     * @returns The number of queued host-frame callbacks.
+     */
+    get pendingHostFrames(): number;
+    /**
+     * Requests future work from the owning scheduler. See {@link ManualSchedulerDriver}.
+     * @param callback - Callback to invoke on a manually flushed frame.
+     * @returns An identifier usable to cancel the queued callback.
+     */
+    requestFrame(callback: FrameRequestCallback): number;
+    /**
+     * Cancels the identified pending host callback. See {@link ManualSchedulerDriver}.
+     * @param frameId - Identifier returned by requestFrame.
+     */
+    cancelFrame(frameId: number): void;
+    /**
+     * Delivers a pending host callback at the requested test time. See {@link ManualSchedulerDriver}
+     * .
+     * @param hostTime - Host timestamp in milliseconds supplied to pending callbacks.
+     */
+    flush(hostTime: number): void;
+}
+/**
+ * Installs a deterministic host-frame driver and returns the callback that restores the previous
+ * driver.
+ *
+ * @param driver - Manual driver to install for deterministic scheduler tests. See
+ * {@link ManualSchedulerDriver} .
+ * @returns A function restoring the previous scheduler driver.
+ *
+ * @see {@link ManualSchedulerDriver}
+ */
+export declare function installSchedulerDriverForTest(driver: ManualSchedulerDriver): () => void;
+export { installSchedulerTraceCollectorForTest, snapshotRealmScheduler, type PibblSchedulerTraceRecord, };

package/dist/lib/scheduler/testing.js

@@ -0,0 +1,71 @@
+import {
+  installSchedulerDriverForTest as installDriver,
+  installSchedulerTraceCollectorForTest,
+  snapshotRealmScheduler
+} from "./realm-scheduler.js";
+class ManualSchedulerDriver {
+  callbacks = /* @__PURE__ */ new Map();
+  nextFrameId = 0;
+  /**
+   * Number of host-frame requests observed by this test driver. See {@link ManualSchedulerDriver}
+   * .
+   */
+  requestCount = 0;
+  /**
+   * Number of host-frame cancellations observed by this test driver. See
+   * {@link ManualSchedulerDriver}.
+   */
+  cancelCount = 0;
+  /**
+   * Number of host-frame callbacks currently pending in the driver. See
+   * {@link ManualSchedulerDriver}.
+   * @returns The number of queued host-frame callbacks.
+   */
+  get pendingHostFrames() {
+    return this.callbacks.size;
+  }
+  /**
+   * Requests future work from the owning scheduler. See {@link ManualSchedulerDriver}.
+   * @param callback - Callback to invoke on a manually flushed frame.
+   * @returns An identifier usable to cancel the queued callback.
+   */
+  requestFrame(callback) {
+    const frameId = ++this.nextFrameId;
+    this.requestCount++;
+    this.callbacks.set(frameId, callback);
+    return frameId;
+  }
+  /**
+   * Cancels the identified pending host callback. See {@link ManualSchedulerDriver}.
+   * @param frameId - Identifier returned by requestFrame.
+   */
+  cancelFrame(frameId) {
+    if (this.callbacks.delete(frameId)) {
+      this.cancelCount++;
+    }
+  }
+  /**
+   * Delivers a pending host callback at the requested test time. See {@link ManualSchedulerDriver}
+   * .
+   * @param hostTime - Host timestamp in milliseconds supplied to pending callbacks.
+   */
+  flush(hostTime) {
+    const entry = this.callbacks.entries().next().value;
+    if (!entry) {
+      throw new Error("No Pibbl host frame is pending.");
+    }
+    const [frameId, callback] = entry;
+    this.callbacks.delete(frameId);
+    callback(hostTime);
+  }
+}
+function installSchedulerDriverForTest(driver) {
+  return installDriver(driver);
+}
+export {
+  ManualSchedulerDriver,
+  installSchedulerDriverForTest,
+  installSchedulerTraceCollectorForTest,
+  snapshotRealmScheduler
+};
+//# sourceMappingURL=testing.js.map

package/dist/lib/scheduler/testing.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/scheduler/testing.ts"],
+  "sourcesContent": ["import {\n  installSchedulerDriverForTest as installDriver,\n  installSchedulerTraceCollectorForTest,\n  snapshotRealmScheduler,\n} from './realm-scheduler.js';\nimport type { PibblSchedulerTraceRecord, SchedulerDriver } from './types.js';\n\n/**\n * A host-frame driver controlled explicitly by tests.\n *\n * @see {@link installSchedulerDriverForTest}\n */\nexport class ManualSchedulerDriver implements SchedulerDriver {\n  private readonly callbacks = new Map<number, FrameRequestCallback>();\n  private nextFrameId = 0;\n  /**\n   * Number of host-frame requests observed by this test driver. See {@link ManualSchedulerDriver}\n   * .\n   */\n  requestCount = 0;\n  /**\n   * Number of host-frame cancellations observed by this test driver. See\n   * {@link ManualSchedulerDriver}.\n   */\n  cancelCount = 0;\n\n  /**\n   * Number of host-frame callbacks currently pending in the driver. See\n   * {@link ManualSchedulerDriver}.\n   * @returns The number of queued host-frame callbacks.\n   */\n  get pendingHostFrames(): number {\n    return this.callbacks.size;\n  }\n\n  /**\n   * Requests future work from the owning scheduler. See {@link ManualSchedulerDriver}.\n   * @param callback - Callback to invoke on a manually flushed frame.\n   * @returns An identifier usable to cancel the queued callback.\n   */\n  requestFrame(callback: FrameRequestCallback): number {\n    const frameId = ++this.nextFrameId;\n    this.requestCount++;\n    this.callbacks.set(frameId, callback);\n    return frameId;\n  }\n\n  /**\n   * Cancels the identified pending host callback. See {@link ManualSchedulerDriver}.\n   * @param frameId - Identifier returned by requestFrame.\n   */\n  cancelFrame(frameId: number): void {\n    if (this.callbacks.delete(frameId)) {\n      this.cancelCount++;\n    }\n  }\n\n  /**\n   * Delivers a pending host callback at the requested test time. See {@link ManualSchedulerDriver}\n   * .\n   * @param hostTime - Host timestamp in milliseconds supplied to pending callbacks.\n   */\n  flush(hostTime: number): void {\n    const entry = this.callbacks.entries().next().value as\n      | [number, FrameRequestCallback]\n      | undefined;\n    if (!entry) {\n      throw new Error('No Pibbl host frame is pending.');\n    }\n    const [frameId, callback] = entry;\n    this.callbacks.delete(frameId);\n    callback(hostTime);\n  }\n}\n\n/**\n * Installs a deterministic host-frame driver and returns the callback that restores the previous\n * driver.\n *\n * @param driver - Manual driver to install for deterministic scheduler tests. See\n * {@link ManualSchedulerDriver} .\n * @returns A function restoring the previous scheduler driver.\n *\n * @see {@link ManualSchedulerDriver}\n */\nexport function installSchedulerDriverForTest(\n  driver: ManualSchedulerDriver,\n): () => void {\n  return installDriver(driver);\n}\n\nexport {\n  installSchedulerTraceCollectorForTest,\n  snapshotRealmScheduler,\n  type PibblSchedulerTraceRecord,\n};\n"],
+  "mappings": "AAAA;AAAA,EACE,iCAAiC;AAAA,EACjC;AAAA,EACA;AAAA,OACK;AAQA,MAAM,sBAAiD;AAAA,EAC3C,YAAY,oBAAI,IAAkC;AAAA,EAC3D,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtB,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA,EAKf,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOd,IAAI,oBAA4B;AAC9B,WAAO,KAAK,UAAU;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,aAAa,UAAwC;AACnD,UAAM,UAAU,EAAE,KAAK;AACvB,SAAK;AACL,SAAK,UAAU,IAAI,SAAS,QAAQ;AACpC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAY,SAAuB;AACjC,QAAI,KAAK,UAAU,OAAO,OAAO,GAAG;AAClC,WAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,UAAwB;AAC5B,UAAM,QAAQ,KAAK,UAAU,QAAQ,EAAE,KAAK,EAAE;AAG9C,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,iCAAiC;AAAA,IACnD;AACA,UAAM,CAAC,SAAS,QAAQ,IAAI;AAC5B,SAAK,UAAU,OAAO,OAAO;AAC7B,aAAS,QAAQ;AAAA,EACnB;AACF;AAYO,SAAS,8BACd,QACY;AACZ,SAAO,cAAc,MAAM;AAC7B;",
+  "names": []
+}