@pibbl/core 0.0.1

package/dist/features/particles/lib/system/controller.js

@@ -0,0 +1,1446 @@
+import { getFlowController2D } from "../flow/hook.js";
+import { signal } from "@pibbl/core";
+import {
+  pibblInternalAssertCommandAllowed,
+  pibblInternalQueueBegin,
+  pibblInternalQueueCurrentCommit,
+  pibblInternalQueueCurrentComplete,
+  pibblInternalRegisterAdvance
+} from "@pibbl/core/internal";
+import { parseParticleColor } from "../color.js";
+import {
+  compileParticleEffect2D
+} from "../compiler.js";
+import { getParticleEffect2DRecord } from "../definition-records.js";
+import { sampleBurstCount } from "../emission.js";
+import {
+  recordParticleBindingAcquired,
+  recordParticleCommandCreated,
+  recordParticleParameterEpochCreated,
+  recordParticleSchedulerRegistration,
+  recordParticleSystemCreated
+} from "./ownership.js";
+const controllers = /* @__PURE__ */ new WeakMap();
+function normalizeSeed(value) {
+  if (value === void 0) return 0;
+  if (!Number.isFinite(value)) {
+    throw new RangeError("Pibbl particle system seed must be finite.");
+  }
+  return Math.trunc(value) >>> 0;
+}
+function validateOptions(options) {
+  if (options.flow !== void 0) getFlowController2D(options.flow);
+  if (options.autoplay !== void 0 && typeof options.autoplay !== "boolean") {
+    throw new TypeError("Pibbl particle system autoplay must be boolean.");
+  }
+  normalizeSeed(options.seed);
+  if (options.debugName !== void 0 && typeof options.debugName !== "string") {
+    throw new TypeError("Pibbl particle system debugName must be a string.");
+  }
+  if (options.onEvent !== void 0 && typeof options.onEvent !== "function") {
+    throw new TypeError("Pibbl particle system onEvent must be a function.");
+  }
+  if (options.onError !== void 0 && typeof options.onError !== "function") {
+    throw new TypeError("Pibbl particle system onError must be a function.");
+  }
+}
+function compileEffect(effect) {
+  const record = getParticleEffect2DRecord(effect);
+  return {
+    effect,
+    compiled: compileParticleEffect2D(effect),
+    options: {},
+    debugName: record.debugName
+  };
+}
+function parameterValuesEqual(left, right, mask) {
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    if ((mask === void 0 || mask[index] === 1) && left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function copyParameters(parameters) {
+  return new Float64Array(parameters);
+}
+function validateParameterArray(compiled, parameters) {
+  if (!(parameters instanceof Float64Array)) {
+    throw new TypeError(
+      "Pibbl particle binding parameters must be a Float64Array."
+    );
+  }
+  if (parameters.length !== compiled.parameterLayout.defaults.length) {
+    throw new RangeError(
+      `Pibbl particle binding parameter length must be ${compiled.parameterLayout.defaults.length}; received ${parameters.length}.`
+    );
+  }
+  for (let index = 0; index < parameters.length; index += 1) {
+    if (!Number.isFinite(parameters[index])) {
+      throw new RangeError(
+        `Pibbl particle binding parameter at offset ${index} must be finite.`
+      );
+    }
+  }
+}
+function eventRecord(type, frame, effect, fields = {}) {
+  return Object.freeze({
+    type,
+    frameId: frame.frameId,
+    logicalTime: frame.logicalTime,
+    ...effect === void 0 ? {} : { effect },
+    ...fields
+  });
+}
+function diagnosticRecord(type, message, frame, effect, fields = {}) {
+  return Object.freeze({
+    type,
+    message,
+    frameId: frame.frameId,
+    logicalTime: frame.logicalTime,
+    ...effect === void 0 ? {} : { effect },
+    ...fields
+  });
+}
+function aggregateObserverFailures(failures) {
+  const messages = failures.map(
+    (error) => error instanceof Error ? error.message : String(error)
+  );
+  throw new AggregateError(
+    failures,
+    `Pibbl particle observer failed: ${messages.join("; ")}`
+  );
+}
+function createParticleSystemController(owner, initialEffect, initialOptions = {}) {
+  validateOptions(initialOptions);
+  const initial = compileEffect(initialEffect);
+  let compiled = initial.compiled;
+  let effectDebugName = initial.debugName;
+  let options = Object.freeze({ ...initialOptions });
+  let originalSeed = normalizeSeed(initialOptions.seed);
+  let seed = originalSeed;
+  let disposed = false;
+  let statusState = "idle";
+  let executionState = "unbound";
+  let generation = 0;
+  let effectTime = 0;
+  let previousEffectTime = 0;
+  let anchorEffectTime = 0;
+  let anchorLogicalTime = 0;
+  let startPending = false;
+  let automaticClosed = false;
+  let drainFinishTime = 0;
+  let pendingFrameAdoption = false;
+  let bindingFrameState;
+  let activeBinding;
+  let reservation;
+  let unregisterAdvance;
+  const deliveries = [];
+  let metadataPublication;
+  let nextEpoch = 0;
+  let currentEpoch = 0;
+  let simulationParameters = copyParameters(compiled.parameterLayout.defaults);
+  let renderParameters = copyParameters(compiled.parameterLayout.defaults);
+  const epochs = /* @__PURE__ */ new Map();
+  const acceptedLifetimes = [];
+  const liveByEmitter = /* @__PURE__ */ new Map();
+  const nextOrdinalByEmitter = /* @__PURE__ */ new Map();
+  const pendingCommands = /* @__PURE__ */ new Set();
+  const retiredCandidates = /* @__PURE__ */ new Set();
+  const metadataWriter = Object.freeze({
+    name: "Pibbl particle system metadata"
+  });
+  const releaseSystemOwnership = recordParticleSystemCreated();
+  const statusSignal = signal("idle", {
+    debugName: initialOptions.debugName === void 0 ? void 0 : `${initialOptions.debugName} status`
+  });
+  const executionSignal = signal("unbound", {
+    debugName: initialOptions.debugName === void 0 ? void 0 : `${initialOptions.debugName} execution`
+  });
+  function releaseEpoch(epoch) {
+    if (!epochs.delete(epoch.id)) return;
+    epoch.releaseOwnership();
+  }
+  function releaseAllEpochs() {
+    for (const epoch of Array.from(epochs.values())) releaseEpoch(epoch);
+    currentEpoch = 0;
+  }
+  function releaseInactiveEpochs() {
+    for (const epoch of Array.from(epochs.values())) {
+      if (epoch.id !== currentEpoch && epoch.references === 0) {
+        releaseEpoch(epoch);
+      }
+    }
+  }
+  function createEpoch(parameters) {
+    const id = ++nextEpoch;
+    epochs.set(id, {
+      id,
+      parameters: copyParameters(parameters),
+      references: 0,
+      releaseOwnership: recordParticleParameterEpochCreated()
+    });
+    return id;
+  }
+  function adoptParameters(parameters) {
+    validateParameterArray(compiled, parameters);
+    const previous = epochs.get(currentEpoch);
+    if (previous === void 0 || !parameterValuesEqual(
+      previous.parameters,
+      parameters,
+      compiled.parameterLayout.spawnMask
+    )) {
+      currentEpoch = createEpoch(parameters);
+    }
+    simulationParameters = copyParameters(parameters);
+    renderParameters = copyParameters(parameters);
+  }
+  function pruneEpoch(epoch) {
+    if (epoch.id !== currentEpoch && epoch.references === 0)
+      releaseEpoch(epoch);
+  }
+  function retainEpoch(epochId, count) {
+    const epoch = epochs.get(epochId);
+    if (epoch === void 0) {
+      throw new RangeError(
+        `Pibbl particle system received unknown parameter epoch ${epochId}.`
+      );
+    }
+    if (!Number.isSafeInteger(count) || count <= 0) {
+      throw new RangeError(
+        "Pibbl particle epoch retain count must be a positive safe integer."
+      );
+    }
+    epoch.references += count;
+  }
+  function releaseEpochReferences(epochId, count) {
+    const epoch = epochs.get(epochId);
+    if (epoch === void 0) {
+      throw new RangeError(
+        `Pibbl particle system received unknown parameter epoch ${epochId}.`
+      );
+    }
+    if (!Number.isSafeInteger(count) || count <= 0 || count > epoch.references) {
+      throw new RangeError(
+        "Pibbl particle epoch release exceeds its retained references."
+      );
+    }
+    epoch.references -= count;
+    pruneEpoch(epoch);
+  }
+  function ensureDelivery(frame) {
+    const latest = deliveries.at(-1);
+    if (latest?.frameId === frame.frameId && !latest.finalized) return latest;
+    const pendingPresentation = deliveries.findLast(
+      (candidate) => !candidate.finalized && candidate.presentationOwner !== void 0 && candidate.rendererSucceeded === void 0
+    );
+    const current = {
+      frameId: frame.frameId,
+      events: [],
+      errors: [],
+      commitApplied: false,
+      commitCompleted: false,
+      finalized: false,
+      presentationOwner: pendingPresentation?.presentationOwner,
+      rendererSucceeded: void 0,
+      stateBefore: void 0,
+      resourcesBefore: void 0,
+      metadataAfter: void 0,
+      metadataDeferred: false,
+      publicationQueued: false
+    };
+    deliveries.push(current);
+    pibblInternalQueueCurrentCommit(owner, (_commitFrame, outcome) => {
+      current.commitApplied = outcome.applied;
+    });
+    pibblInternalQueueCurrentComplete(owner, () => {
+      current.commitCompleted = true;
+      finalizeDeliveryIfReady(current);
+    });
+    return current;
+  }
+  function removeDelivery(current) {
+    current.finalized = true;
+    const index = deliveries.indexOf(current);
+    if (index >= 0) deliveries.splice(index, 1);
+  }
+  function deliverRecords(events, errors) {
+    const failures = [];
+    for (const event of events) {
+      try {
+        options.onEvent?.(event);
+      } catch (error) {
+        failures.push(error);
+      }
+      try {
+        activeBinding?.observers.onEvent?.(event);
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    for (const error of errors) {
+      let observed = false;
+      if (options.onError !== void 0) {
+        observed = true;
+        try {
+          options.onError(error);
+        } catch (observerError) {
+          failures.push(observerError);
+        }
+      }
+      if (activeBinding?.observers.onError !== void 0) {
+        observed = true;
+        try {
+          activeBinding.observers.onError(error);
+        } catch (observerError) {
+          failures.push(observerError);
+        }
+      }
+      if (!observed) failures.push(error);
+    }
+    if (failures.length > 0) aggregateObserverFailures(failures);
+  }
+  function deliver(current) {
+    deliverRecords(current.events, current.errors);
+  }
+  function rollbackDelivery(current) {
+    if (current.resourcesBefore !== void 0) {
+      restoreResourceSnapshot(current.resourcesBefore);
+    }
+    if (current.stateBefore !== void 0) restoreState(current.stateBefore);
+    executionState = activeBinding?.candidate.execution ?? "unbound";
+  }
+  function failDeliveryCascade(current) {
+    const index = deliveries.indexOf(current);
+    if (index < 0) return;
+    for (const failed of deliveries.slice(index)) removeDelivery(failed);
+    rollbackDelivery(current);
+  }
+  function queueMetadataPublication(current) {
+    if (current.publicationQueued || current.metadataAfter === void 0 || metadataPublication !== void 0)
+      return;
+    current.publicationQueued = true;
+    metadataPublication = current;
+    const metadata = current.metadataAfter;
+    enqueue((_frame, batch) => {
+      if (current.finalized) {
+        if (metadataPublication === current) metadataPublication = void 0;
+        queueNextMetadataPublication();
+        return;
+      }
+      stageMetadata(batch, metadata, current);
+      let applied = false;
+      pibblInternalQueueCurrentCommit(owner, (_commitFrame, outcome) => {
+        applied = outcome.applied;
+      });
+      pibblInternalQueueCurrentComplete(owner, () => {
+        if (metadataPublication === current) metadataPublication = void 0;
+        if (current.finalized) {
+          queueNextMetadataPublication();
+          return;
+        }
+        if (!applied) {
+          failDeliveryCascade(current);
+          return;
+        }
+        removeDelivery(current);
+        try {
+          if (!disposed) deliver(current);
+        } finally {
+          queueNextMetadataPublication();
+        }
+      });
+    });
+  }
+  function queueNextMetadataPublication() {
+    if (disposed || metadataPublication !== void 0) return;
+    const next = deliveries.find(
+      (current) => !current.finalized && current.metadataDeferred && !current.publicationQueued && current.metadataAfter !== void 0 && current.commitCompleted && current.commitApplied && (current.presentationOwner === void 0 || current.rendererSucceeded === true)
+    );
+    if (next !== void 0) queueMetadataPublication(next);
+  }
+  function metadataMatchesPrecedingSnapshot(current) {
+    const metadata = current.metadataAfter;
+    if (metadata === void 0) return true;
+    const index = deliveries.indexOf(current);
+    for (let precedingIndex = index - 1; precedingIndex >= 0; precedingIndex--) {
+      const preceding = deliveries[precedingIndex];
+      if (preceding?.finalized || preceding?.metadataAfter === void 0)
+        continue;
+      return preceding.metadataAfter.status === metadata.status && preceding.metadataAfter.execution === metadata.execution;
+    }
+    return statusSignal.get() === metadata.status && executionSignal.get() === metadata.execution;
+  }
+  function finalizeDeliveryIfReady(current) {
+    if (current.finalized || !current.commitCompleted) return;
+    if (!current.commitApplied) {
+      failDeliveryCascade(current);
+      return;
+    }
+    if (current.presentationOwner !== void 0 && current.rendererSucceeded === void 0) {
+      return;
+    }
+    if (current.rendererSucceeded === false) {
+      removeDelivery(current);
+      rollbackDelivery(current);
+      return;
+    }
+    if (current.metadataDeferred) {
+      if (current.events.length === 0 && current.errors.length === 0 && metadataMatchesPrecedingSnapshot(current)) {
+        removeDelivery(current);
+        return;
+      }
+      queueMetadataPublication(current);
+      return;
+    }
+    removeDelivery(current);
+    if (!disposed) deliver(current);
+  }
+  function requirePresentation(frame, bindingOwner) {
+    const current = ensureDelivery(frame);
+    if (current.presentationOwner !== void 0 && current.presentationOwner !== bindingOwner) {
+      throw new Error(
+        "A Pibbl particle frame cannot target multiple renderer owners."
+      );
+    }
+    current.presentationOwner = bindingOwner;
+  }
+  function failRendererTransactions(bindingOwner) {
+    const failed = deliveries.filter(
+      (current) => !current.finalized && current.presentationOwner === bindingOwner && current.rendererSucceeded === void 0
+    );
+    if (failed.length === 0) return;
+    const earliest = failed[0];
+    for (const current of failed) removeDelivery(current);
+    rollbackDelivery(earliest);
+  }
+  function queueEvent(frame, type, fields) {
+    ensureDelivery(frame).events.push(
+      eventRecord(type, frame, effectDebugName, fields)
+    );
+  }
+  function queueError(frame, error) {
+    ensureDelivery(frame).errors.push(error);
+  }
+  function queueIsolatedError(error) {
+    enqueue((_frame, _batch) => {
+      let applied = false;
+      pibblInternalQueueCurrentCommit(owner, (_commitFrame, outcome) => {
+        applied = outcome.applied;
+      });
+      pibblInternalQueueCurrentComplete(owner, () => {
+        if (applied && !disposed) deliverRecords([], [error]);
+      });
+    });
+  }
+  function failCurrentDelivery(frame, error, operation) {
+    const current = ensureDelivery(frame);
+    failDeliveryCascade(current);
+    const diagnostic = diagnosticRecord(
+      "execution-failed",
+      error instanceof Error ? error.message : String(error),
+      frame,
+      effectDebugName,
+      { operation }
+    );
+    pibblInternalQueueCurrentComplete(owner, () => {
+      if (!disposed) queueIsolatedError(diagnostic);
+    });
+  }
+  function disposeRendererCandidate(candidate, operation) {
+    try {
+      candidate.dispose();
+      retiredCandidates.delete(candidate);
+    } catch (error) {
+      retiredCandidates.add(candidate);
+      if (disposed) return;
+      enqueue((frame, batch) => {
+        transaction(frame, batch, () => {
+          queueError(
+            frame,
+            diagnosticRecord(
+              "execution-failed",
+              error instanceof Error ? error.message : String(error),
+              frame,
+              effectDebugName,
+              { operation }
+            )
+          );
+        });
+      });
+    }
+  }
+  function snapshotMetadata() {
+    return { status: statusState, execution: executionState };
+  }
+  function stageMetadata(batch, metadata = snapshotMetadata(), writer = metadataWriter) {
+    batch.stage(statusSignal, metadata.status, writer);
+    batch.stage(executionSignal, metadata.execution, writer);
+  }
+  function snapshotState() {
+    return {
+      status: statusState,
+      execution: executionState,
+      generation,
+      seed,
+      effectTime,
+      previousEffectTime,
+      anchorEffectTime,
+      anchorLogicalTime,
+      startPending,
+      automaticClosed,
+      drainFinishTime,
+      pendingFrameAdoption,
+      bindingFrameState
+    };
+  }
+  function snapshotResources() {
+    return {
+      nextEpoch,
+      currentEpoch,
+      epochs: Array.from(epochs.values(), (epoch) => ({
+        id: epoch.id,
+        parameters: copyParameters(epoch.parameters),
+        references: epoch.references
+      })),
+      acceptedLifetimes: acceptedLifetimes.map((accepted) => ({
+        ...accepted
+      })),
+      liveByEmitter: new Map(liveByEmitter),
+      nextOrdinalByEmitter: new Map(nextOrdinalByEmitter),
+      simulationParameters: copyParameters(simulationParameters),
+      renderParameters: copyParameters(renderParameters)
+    };
+  }
+  function restoreResourceSnapshot(snapshot) {
+    releaseAllEpochs();
+    nextEpoch = snapshot.nextEpoch;
+    currentEpoch = snapshot.currentEpoch;
+    for (const saved of snapshot.epochs) {
+      epochs.set(saved.id, {
+        id: saved.id,
+        parameters: copyParameters(saved.parameters),
+        references: saved.references,
+        releaseOwnership: recordParticleParameterEpochCreated()
+      });
+    }
+    acceptedLifetimes.length = 0;
+    acceptedLifetimes.push(
+      ...snapshot.acceptedLifetimes.map((accepted) => ({ ...accepted }))
+    );
+    liveByEmitter.clear();
+    for (const [name, count] of snapshot.liveByEmitter) {
+      liveByEmitter.set(name, count);
+    }
+    nextOrdinalByEmitter.clear();
+    for (const [name, ordinal] of snapshot.nextOrdinalByEmitter) {
+      nextOrdinalByEmitter.set(name, ordinal);
+    }
+    simulationParameters = copyParameters(snapshot.simulationParameters);
+    renderParameters = copyParameters(snapshot.renderParameters);
+  }
+  function restoreState(snapshot) {
+    statusState = snapshot.status;
+    executionState = snapshot.execution;
+    generation = snapshot.generation;
+    seed = snapshot.seed;
+    effectTime = snapshot.effectTime;
+    previousEffectTime = snapshot.previousEffectTime;
+    anchorEffectTime = snapshot.anchorEffectTime;
+    anchorLogicalTime = snapshot.anchorLogicalTime;
+    startPending = snapshot.startPending;
+    automaticClosed = snapshot.automaticClosed;
+    drainFinishTime = snapshot.drainFinishTime;
+    pendingFrameAdoption = snapshot.pendingFrameAdoption;
+    bindingFrameState = snapshot.bindingFrameState;
+    synchronizeAdvanceRegistration();
+  }
+  function transaction(frame, batch, mutate) {
+    const current = ensureDelivery(frame);
+    current.stateBefore ??= snapshotState();
+    current.resourcesBefore ??= snapshotResources();
+    mutate();
+    if (current.finalized) return;
+    if (current.presentationOwner === void 0 && activeBinding !== void 0 && shouldAdvance()) {
+      requirePresentation(frame, activeBinding.owner);
+    }
+    current.metadataAfter = snapshotMetadata();
+    if (current.presentationOwner === void 0 && metadataPublication === void 0) {
+      stageMetadata(batch, current.metadataAfter);
+    } else {
+      current.metadataDeferred = true;
+      batch.discardWriter(metadataWriter);
+    }
+  }
+  function maximumLifetimeMilliseconds() {
+    let maximum = 0;
+    const epoch = epochs.get(currentEpoch)?.parameters ?? simulationParameters;
+    for (const emitter of compiled.emitters) {
+      const lifetime = emitter.maximumLifetime;
+      maximum = Math.max(
+        maximum,
+        lifetime.kind === "fixed" ? lifetime.milliseconds : epoch[lifetime.offset]
+      );
+    }
+    return maximum;
+  }
+  function finiteCompletionMilliseconds() {
+    let completion = 0;
+    for (const emitter of compiled.emitters) {
+      if (emitter.emission.completion !== "finite") return void 0;
+      const latest = emitter.emission.latestAutomaticBirthMilliseconds;
+      if (latest === null) continue;
+      const lifetime = emitter.maximumLifetime;
+      const lifetimeMilliseconds = lifetime.kind === "fixed" ? lifetime.milliseconds : epochs.get(currentEpoch)?.parameters[lifetime.offset] ?? simulationParameters[lifetime.offset];
+      completion = Math.max(completion, latest + lifetimeMilliseconds);
+    }
+    return completion;
+  }
+  function hasOpenAutomaticEmission() {
+    if (automaticClosed) return false;
+    return compiled.emitters.some(
+      (emitter) => emitter.emission.rates.length > 0 || emitter.emission.bursts.length > 0
+    );
+  }
+  function shouldAdvance() {
+    if (activeBinding === void 0 || disposed) return false;
+    if (pendingFrameAdoption) return true;
+    if (statusState === "running") {
+      if (bindingFrameState !== void 0) {
+        return bindingFrameState.nextAutomaticBirthMilliseconds !== null || bindingFrameState.liveCount > 0;
+      }
+      return hasOpenAutomaticEmission() || acceptedLifetimes.length > 0 || finiteCompletionMilliseconds() !== void 0;
+    }
+    return statusState === "draining" && (bindingFrameState === void 0 || bindingFrameState.liveCount > 0);
+  }
+  function synchronizeAdvanceRegistration() {
+    if (shouldAdvance()) {
+      if (unregisterAdvance === void 0) {
+        const releaseFlow = options.flow === void 0 ? void 0 : getFlowController2D(options.flow).retain();
+        const unregister = pibblInternalRegisterAdvance(owner, advance);
+        const releaseOwnership = recordParticleSchedulerRegistration();
+        unregisterAdvance = () => {
+          unregister();
+          releaseFlow?.();
+          releaseOwnership();
+        };
+      }
+    } else if (unregisterAdvance !== void 0) {
+      unregisterAdvance();
+      unregisterAdvance = void 0;
+    }
+  }
+  function releaseExpired(effectTimeMilliseconds) {
+    let writeIndex = 0;
+    for (let index = 0; index < acceptedLifetimes.length; index += 1) {
+      const accepted = acceptedLifetimes[index];
+      if (accepted.deathTime <= effectTimeMilliseconds) {
+        liveByEmitter.set(
+          accepted.emitter,
+          Math.max(
+            0,
+            (liveByEmitter.get(accepted.emitter) ?? 0) - accepted.count
+          )
+        );
+        releaseEpochReferences(accepted.epoch, accepted.count);
+      } else {
+        acceptedLifetimes[writeIndex++] = accepted;
+      }
+    }
+    acceptedLifetimes.length = writeIndex;
+  }
+  function releaseAcceptedLifetimes() {
+    for (const accepted of acceptedLifetimes) {
+      const epoch = epochs.get(accepted.epoch);
+      if (epoch !== void 0) {
+        epoch.references = Math.max(0, epoch.references - accepted.count);
+        pruneEpoch(epoch);
+      }
+    }
+    acceptedLifetimes.length = 0;
+    liveByEmitter.clear();
+  }
+  function startRun(frame, nextSeed) {
+    generation += 1;
+    seed = nextSeed;
+    effectTime = 0;
+    previousEffectTime = 0;
+    anchorEffectTime = 0;
+    anchorLogicalTime = frame.logicalTime;
+    automaticClosed = false;
+    drainFinishTime = 0;
+    pendingFrameAdoption = true;
+    bindingFrameState = void 0;
+    startPending = true;
+    nextOrdinalByEmitter.clear();
+    if (activeBinding === void 0) {
+      statusState = "scheduled";
+      return;
+    }
+    statusState = "running";
+    startPending = false;
+    queueEvent(frame, "start");
+  }
+  function resetRunStorage(frame) {
+    try {
+      const cleared = activeBinding?.candidate.clear();
+      if (cleared !== void 0) bindingFrameState = cleared;
+    } catch (error) {
+      queueError(
+        frame,
+        diagnosticRecord(
+          "execution-failed",
+          error instanceof Error ? error.message : String(error),
+          frame,
+          effectDebugName,
+          { operation: "clear-binding" }
+        )
+      );
+      return false;
+    }
+    releaseAcceptedLifetimes();
+    nextOrdinalByEmitter.clear();
+    return true;
+  }
+  function effectTimeAt(logicalTime) {
+    if (statusState === "paused") return effectTime;
+    return anchorEffectTime + Math.max(0, logicalTime - anchorLogicalTime);
+  }
+  function finishRun(frame) {
+    if (statusState === "finished") return;
+    statusState = "finished";
+    automaticClosed = true;
+    queueEvent(frame, "finish");
+  }
+  function advance(frame, batch) {
+    if (disposed || activeBinding === void 0) return;
+    transaction(frame, batch, () => {
+      const binding = activeBinding;
+      previousEffectTime = effectTime;
+      effectTime = effectTimeAt(frame.logicalTime);
+      if (bindingFrameState === void 0) releaseExpired(effectTime);
+      const particleFrame = Object.freeze({
+        generation,
+        frameId: frame.frameId,
+        logicalTime: frame.logicalTime,
+        effectTimeMilliseconds: effectTime,
+        previousEffectTimeMilliseconds: previousEffectTime,
+        seed,
+        status: statusState
+      });
+      try {
+        const adopted = binding.candidate.adoptFrame(particleFrame);
+        if (adopted !== void 0) bindingFrameState = adopted;
+      } catch (error) {
+        failCurrentDelivery(frame, error, "adopt-frame");
+        return;
+      }
+      if (bindingFrameState !== void 0) {
+        if (statusState === "running" && compiled.emitters.every(
+          (emitter) => emitter.emission.completion === "finite"
+        ) && bindingFrameState.nextAutomaticBirthMilliseconds === null && bindingFrameState.liveCount === 0) {
+          finishRun(frame);
+        } else if (statusState === "draining" && bindingFrameState.liveCount === 0) {
+          finishRun(frame);
+        }
+      } else if (statusState === "running") {
+        const completion = finiteCompletionMilliseconds();
+        if (completion !== void 0 && effectTime >= completion)
+          finishRun(frame);
+      } else if (statusState === "draining" && effectTime >= drainFinishTime && acceptedLifetimes.length === 0) {
+        finishRun(frame);
+      }
+      try {
+        binding.candidate.requestRender();
+      } catch (error) {
+        failCurrentDelivery(frame, error, "request-render");
+        return;
+      }
+      requirePresentation(frame, binding.owner);
+      pendingFrameAdoption = false;
+      synchronizeAdvanceRegistration();
+    });
+  }
+  function cancelPendingCommands() {
+    for (const pending of Array.from(pendingCommands)) {
+      pending.handle.cancel();
+      pending.releaseOwnership();
+    }
+    pendingCommands.clear();
+  }
+  function enqueue(apply) {
+    if (disposed) return;
+    const releaseOwnership = recordParticleCommandCreated();
+    let pending;
+    try {
+      const handle2 = pibblInternalQueueBegin(owner, (frame, batch) => {
+        pendingCommands.delete(pending);
+        releaseOwnership();
+        if (!disposed) apply(frame, batch);
+      });
+      pending = { handle: handle2, releaseOwnership };
+      pendingCommands.add(pending);
+    } catch (error) {
+      releaseOwnership();
+      throw error;
+    }
+  }
+  function emitterByName(name) {
+    return compiled.emitters.find((emitter) => emitter.name === name);
+  }
+  function emitterIndexByName(name) {
+    for (let index = 0; index < compiled.emitters.length; index += 1) {
+      if (compiled.emitters[index]?.name === name) return index;
+    }
+    return -1;
+  }
+  function validatePositiveCount(count) {
+    if (count !== void 0 && (!Number.isSafeInteger(count) || count <= 0)) {
+      throw new RangeError(
+        "Pibbl particle burst count must be a positive safe integer."
+      );
+    }
+  }
+  function validateFiniteVector(name, value, dimension) {
+    if (value === void 0) return;
+    if (!Array.isArray(value) || value.length !== dimension || value.some((entry) => !Number.isFinite(entry))) {
+      throw new RangeError(
+        `Pibbl particle burst ${name} must be a finite ${dimension}-dimensional vector.`
+      );
+    }
+  }
+  function writeParameterOverride(output, entry, value) {
+    if (entry.timing !== "spawn") {
+      throw new TypeError(
+        `Pibbl particle burst parameter "${entry.name}" must use spawn timing.`
+      );
+    }
+    const numeric = entry.type === "color" ? typeof value === "string" ? parseParticleColor(value) : void 0 : entry.length === 1 ? typeof value === "number" ? [value] : void 0 : Array.isArray(value) ? value : void 0;
+    if (numeric === void 0 || numeric.length !== entry.length || numeric.some((component) => !Number.isFinite(component))) {
+      throw new TypeError(
+        `Pibbl particle burst parameter "${entry.name}" does not match ${entry.type}.`
+      );
+    }
+    output.set(numeric, entry.offset);
+  }
+  function validateBurst(emitterName, overrides) {
+    const emitter = emitterByName(emitterName);
+    if (emitter === void 0) {
+      throw new TypeError(
+        `Pibbl particle system received unknown emitter "${emitterName}".`
+      );
+    }
+    if (emitter.emission.manual.length === 0) {
+      throw new TypeError(
+        `Pibbl particle emitter "${emitterName}" has no manual emission source.`
+      );
+    }
+    validatePositiveCount(overrides.count);
+    validateFiniteVector("position", overrides.position, compiled.dimension);
+    if (overrides.seedSalt !== void 0 && !Number.isFinite(overrides.seedSalt)) {
+      throw new RangeError("Pibbl particle burst seedSalt must be finite.");
+    }
+    if (overrides.parameters !== void 0) {
+      const values = copyParameters(
+        epochs.get(currentEpoch)?.parameters ?? simulationParameters
+      );
+      for (const [name, value] of Object.entries(overrides.parameters)) {
+        const entry = compiled.parameterLayout.byName.get(name);
+        if (entry === void 0) {
+          throw new TypeError(
+            `Pibbl particle burst references unknown parameter "${name}".`
+          );
+        }
+        writeParameterOverride(values, entry, value);
+      }
+      return values;
+    }
+    return void 0;
+  }
+  function requestedBurstCount(emitter, override) {
+    if (override !== void 0) return override;
+    let requested = 0;
+    let ordinal = nextOrdinalByEmitter.get(emitter.name) ?? 0;
+    for (const manual of emitter.emission.manual) {
+      requested += sampleBurstCount(
+        manual,
+        seed,
+        emitter.emitterHash,
+        ordinal++
+      );
+    }
+    return requested;
+  }
+  function acceptBurst(emitterName, overrides, overrideParameters, frame) {
+    const emitter = emitterByName(emitterName);
+    const emitterIndex = emitterIndexByName(emitterName);
+    const requested = activeBinding?.candidate.requestedBurstCount?.(
+      emitterIndex,
+      overrides.count,
+      seed
+    ) ?? requestedBurstCount(emitter, overrides.count);
+    if (statusState === "paused" || statusState === "draining" || statusState === "finished" || activeBinding === void 0) {
+      const reason = statusState === "paused" ? "paused" : "stopped";
+      queueEvent(frame, "burst-rejected", {
+        emitter: emitterName,
+        requested,
+        accepted: 0,
+        reason
+      });
+      return;
+    }
+    if (statusState === "idle") startRun(frame, seed);
+    if (activeBinding?.candidate.emitBurst !== void 0) {
+      const currentParameters = epochs.get(currentEpoch).parameters;
+      const epoch = overrideParameters !== void 0 && !parameterValuesEqual(
+        currentParameters,
+        overrideParameters,
+        compiled.parameterLayout.spawnMask
+      ) ? createEpoch(overrideParameters) : currentEpoch;
+      let result;
+      try {
+        result = activeBinding.candidate.emitBurst({
+          generation,
+          emitterIndex,
+          count: overrides.count,
+          birthTimeMilliseconds: effectTimeAt(frame.logicalTime),
+          seed,
+          seedSalt: Math.trunc(overrides.seedSalt ?? 0) >>> 0,
+          origin: overrides.position ?? [0, 0],
+          spawnEpoch: epoch
+        });
+      } catch (error) {
+        if (epoch !== currentEpoch) releaseEpoch(epochs.get(epoch));
+        failCurrentDelivery(frame, error, "emit-burst");
+        return;
+      }
+      bindingFrameState = result;
+      if (result.accepted === 0 && epoch !== currentEpoch) {
+        releaseEpoch(epochs.get(epoch));
+      }
+      const exactRequested = result.requested;
+      if (result.accepted > 0) {
+        queueEvent(frame, "burst-accepted", {
+          emitter: emitterName,
+          requested: exactRequested,
+          accepted: result.accepted
+        });
+      } else {
+        queueEvent(frame, "burst-rejected", {
+          emitter: emitterName,
+          requested: exactRequested,
+          accepted: 0,
+          reason: "capacity"
+        });
+      }
+      if (result.rejected > 0) {
+        queueError(
+          frame,
+          diagnosticRecord(
+            "capacity-rejected",
+            `Pibbl particle emitter "${emitterName}" accepted ${result.accepted} of ${exactRequested} requested particles.`,
+            frame,
+            effectDebugName,
+            {
+              emitter: emitterName,
+              requested: exactRequested,
+              accepted: result.accepted
+            }
+          )
+        );
+      }
+      synchronizeAdvanceRegistration();
+      return;
+    }
+    const live = liveByEmitter.get(emitterName) ?? 0;
+    const available = Math.max(0, emitter.capacity - live);
+    const accepted = Math.min(requested, available);
+    if (accepted > 0) {
+      const currentParameters = epochs.get(currentEpoch).parameters;
+      const epoch = overrideParameters !== void 0 && !parameterValuesEqual(
+        currentParameters,
+        overrideParameters,
+        compiled.parameterLayout.spawnMask
+      ) ? createEpoch(overrideParameters) : currentEpoch;
+      retainEpoch(epoch, accepted);
+      acceptedLifetimes.push({
+        deathTime: effectTimeAt(frame.logicalTime) + (emitter.maximumLifetime.kind === "fixed" ? emitter.maximumLifetime.milliseconds : epochs.get(epoch).parameters[emitter.maximumLifetime.offset]),
+        emitter: emitterName,
+        epoch,
+        count: accepted
+      });
+      liveByEmitter.set(emitterName, live + accepted);
+      nextOrdinalByEmitter.set(
+        emitterName,
+        (nextOrdinalByEmitter.get(emitterName) ?? 0) + requested
+      );
+      queueEvent(frame, "burst-accepted", {
+        emitter: emitterName,
+        requested,
+        accepted
+      });
+    } else {
+      queueEvent(frame, "burst-rejected", {
+        emitter: emitterName,
+        requested,
+        accepted: 0,
+        reason: "capacity"
+      });
+    }
+    if (accepted < requested) {
+      queueError(
+        frame,
+        diagnosticRecord(
+          "capacity-rejected",
+          `Pibbl particle emitter "${emitterName}" accepted ${accepted} of ${requested} requested particles.`,
+          frame,
+          effectDebugName,
+          { emitter: emitterName, requested, accepted }
+        )
+      );
+    }
+    synchronizeAdvanceRegistration();
+  }
+  const handle = Object.freeze({
+    status: statusSignal.asReadonly(),
+    execution: executionSignal.asReadonly(),
+    play() {
+      pibblInternalAssertCommandAllowed();
+      if (disposed) return;
+      enqueue((frame, batch) => {
+        transaction(frame, batch, () => {
+          if (statusState === "running" || statusState === "paused" || statusState === "draining" || statusState === "scheduled") {
+            return;
+          }
+          if (!resetRunStorage(frame)) return;
+          startRun(frame, originalSeed);
+          synchronizeAdvanceRegistration();
+        });
+      });
+    },
+    pause() {
+      pibblInternalAssertCommandAllowed();
+      if (disposed) return;
+      enqueue((frame, batch) => {
+        transaction(frame, batch, () => {
+          if (statusState !== "running") return;
+          effectTime = effectTimeAt(frame.logicalTime);
+          previousEffectTime = effectTime;
+          anchorEffectTime = effectTime;
+          anchorLogicalTime = frame.logicalTime;
+          statusState = "paused";
+          synchronizeAdvanceRegistration();
+        });
+      });
+    },
+    resume() {
+      pibblInternalAssertCommandAllowed();
+      if (disposed) return;
+      enqueue((frame, batch) => {
+        transaction(frame, batch, () => {
+          if (statusState !== "paused") return;
+          anchorEffectTime = effectTime;
+          anchorLogicalTime = frame.logicalTime;
+          statusState = activeBinding === void 0 ? "scheduled" : "running";
+          synchronizeAdvanceRegistration();
+        });
+      });
+    },
+    restart(restartOptions = {}) {
+      pibblInternalAssertCommandAllowed();
+      if (restartOptions === null || typeof restartOptions !== "object" || Array.isArray(restartOptions)) {
+        throw new TypeError("Pibbl particle restart options must be a record.");
+      }
+      const nextSeed = restartOptions.seed === void 0 ? originalSeed : normalizeSeed(restartOptions.seed);
+      if (disposed) return;
+      enqueue((frame, batch) => {
+        transaction(frame, batch, () => {
+          if (!resetRunStorage(frame)) return;
+          startRun(frame, nextSeed);
+          synchronizeAdvanceRegistration();
+        });
+      });
+    },
+    emit(emitter, overrides = {}) {
+      pibblInternalAssertCommandAllowed();
+      if (typeof emitter !== "string") {
+        throw new TypeError("Pibbl particle emitter name must be a string.");
+      }
+      if (overrides === null || typeof overrides !== "object" || Array.isArray(overrides)) {
+        throw new TypeError("Pibbl particle burst overrides must be a record.");
+      }
+      const overrideParameters = validateBurst(emitter, overrides);
+      if (disposed) return;
+      const frozenOverrides = Object.freeze({ ...overrides });
+      enqueue((frame, batch) => {
+        transaction(
+          frame,
+          batch,
+          () => acceptBurst(emitter, frozenOverrides, overrideParameters, frame)
+        );
+      });
+    },
+    stop(stopOptions = {}) {
+      pibblInternalAssertCommandAllowed();
+      if (stopOptions === null || typeof stopOptions !== "object" || Array.isArray(stopOptions)) {
+        throw new TypeError("Pibbl particle stop options must be a record.");
+      }
+      const mode = stopOptions.mode ?? "drain";
+      if (mode !== "drain" && mode !== "clear") {
+        throw new TypeError(
+          'Pibbl particle stop mode must be "drain" or "clear".'
+        );
+      }
+      if (disposed) return;
+      enqueue((frame, batch) => {
+        transaction(frame, batch, () => {
+          if (statusState === "idle" || statusState === "finished") return;
+          const clearBinding = mode === "clear" ? activeBinding : void 0;
+          if (clearBinding !== void 0) {
+            try {
+              clearBinding.candidate.requestRender();
+            } catch (error) {
+              failCurrentDelivery(frame, error, "request-clear-render");
+              return;
+            }
+          }
+          if (mode === "clear" && !resetRunStorage(frame)) return;
+          effectTime = effectTimeAt(frame.logicalTime);
+          previousEffectTime = effectTime;
+          anchorEffectTime = effectTime;
+          anchorLogicalTime = frame.logicalTime;
+          automaticClosed = true;
+          if (mode === "clear") {
+            if (clearBinding !== void 0) {
+              requirePresentation(frame, clearBinding.owner);
+            }
+            finishRun(frame);
+          } else {
+            statusState = "draining";
+            pendingFrameAdoption = true;
+            const hasAutomaticSources = compiled.emitters.some(
+              (emitter) => emitter.emission.rates.length > 0 || emitter.emission.bursts.length > 0
+            );
+            drainFinishTime = Math.max(
+              effectTime,
+              ...acceptedLifetimes.map((accepted) => accepted.deathTime),
+              bindingFrameState?.latestDeathMilliseconds ?? effectTime,
+              hasAutomaticSources ? effectTime + maximumLifetimeMilliseconds() : effectTime
+            );
+            queueEvent(frame, "drain-start");
+          }
+          synchronizeAdvanceRegistration();
+        });
+      });
+    }
+  });
+  let preparedCompiled = compiled;
+  let preparedEffectCandidate;
+  const controller = Object.freeze({
+    handle,
+    get flow() {
+      return initialOptions.flow;
+    },
+    get compiled() {
+      return compiled;
+    },
+    get bindingCandidate() {
+      return activeBinding?.candidate;
+    },
+    get currentSpawnEpoch() {
+      return currentEpoch;
+    },
+    get simulationParameters() {
+      return simulationParameters;
+    },
+    get renderParameters() {
+      return renderParameters;
+    },
+    prepareEffect(effect, nextOptions = {}) {
+      validateOptions(nextOptions);
+      if (nextOptions.flow !== initialOptions.flow) throw new Error("Particle flow binding is mount-only; use a keyed remount to change it.");
+      const compiledCandidate = compileEffect(effect);
+      const candidate = Object.freeze({
+        ...compiledCandidate,
+        options: Object.freeze({ ...nextOptions })
+      });
+      preparedEffectCandidate = candidate;
+      preparedCompiled = candidate.compiled;
+      return candidate;
+    },
+    cancelEffect(candidate) {
+      if (preparedEffectCandidate !== candidate) return;
+      preparedEffectCandidate = void 0;
+      preparedCompiled = compiled;
+    },
+    adoptEffect(candidate) {
+      if (disposed) return;
+      if (preparedEffectCandidate !== candidate) return;
+      preparedEffectCandidate = void 0;
+      const changed = compiled !== candidate.compiled;
+      if (changed) {
+        const restartMode = statusState === "paused" ? "paused" : statusState === "running" || statusState === "draining" || statusState === "scheduled" ? "running" : "idle";
+        cancelPendingCommands();
+        releaseAcceptedLifetimes();
+        nextOrdinalByEmitter.clear();
+        currentEpoch = 0;
+        releaseInactiveEpochs();
+        compiled = candidate.compiled;
+        bindingFrameState = void 0;
+        originalSeed = normalizeSeed(candidate.options.seed);
+        enqueue((frame, batch) => {
+          transaction(frame, batch, () => {
+            seed = originalSeed;
+            effectTime = 0;
+            previousEffectTime = 0;
+            anchorEffectTime = 0;
+            anchorLogicalTime = frame.logicalTime;
+            automaticClosed = false;
+            drainFinishTime = 0;
+            nextOrdinalByEmitter.clear();
+            if (restartMode === "idle") {
+              statusState = "idle";
+              startPending = false;
+              pendingFrameAdoption = false;
+            } else {
+              generation += 1;
+              statusState = restartMode === "paused" ? "paused" : activeBinding === void 0 ? "scheduled" : "running";
+              startPending = statusState !== "running";
+              pendingFrameAdoption = statusState === "running";
+              if (statusState === "running") queueEvent(frame, "start");
+            }
+            synchronizeAdvanceRegistration();
+          });
+        });
+      }
+      effectDebugName = candidate.debugName;
+      options = Object.freeze({ ...candidate.options });
+      preparedCompiled = compiled;
+    },
+    reserveBinding(bindingOwner, backend) {
+      if (disposed) {
+        throw new TypeError("Cannot bind a disposed Pibbl particle system.");
+      }
+      if (reservation !== void 0) {
+        throw new TypeError(
+          "Pibbl particle system already has a pending binding reservation."
+        );
+      }
+      if (activeBinding?.owner !== void 0 && activeBinding.owner !== bindingOwner) {
+        throw new TypeError(
+          "Pibbl particle system is already bound to another component."
+        );
+      }
+      const next = Object.freeze({ owner: bindingOwner, backend, token: {} });
+      reservation = next;
+      return next;
+    },
+    validateBindingCandidate(bindingReservation, candidate) {
+      if (reservation !== bindingReservation) {
+        throw new TypeError("Pibbl particle binding reservation is stale.");
+      }
+      if (candidate.owner !== bindingReservation.owner || candidate.backend !== bindingReservation.backend) {
+        throw new TypeError(
+          "Pibbl particle binding candidate owner/backend mismatch."
+        );
+      }
+      if (candidate.compiled !== preparedCompiled) {
+        throw new TypeError(
+          "Pibbl particle binding definition does not match its system definition."
+        );
+      }
+      if (candidate.compiled.dimension !== 2) {
+        throw new TypeError(
+          "Pibbl particle binding backend does not match effect dimension."
+        );
+      }
+      if (candidate.execution !== "stateless-canvas" && candidate.execution !== "flow-canvas") {
+        throw new TypeError(
+          "Pibbl particle binding execution does not match its backend."
+        );
+      }
+      if (!candidate.compiled.execution[candidate.execution].supported) {
+        throw new TypeError(
+          `Pibbl particle execution "${candidate.execution}" is unavailable: ${candidate.compiled.execution[candidate.execution].reasons.join("; ")}.`
+        );
+      }
+      validateParameterArray(candidate.compiled, candidate.parameters);
+    },
+    cancelBindingReservation(bindingReservation) {
+      if (bindingReservation !== void 0 && reservation === bindingReservation) {
+        reservation = void 0;
+      }
+    },
+    discardBindingCandidate(candidate, operation) {
+      if (candidate === activeBinding?.candidate) return;
+      disposeRendererCandidate(candidate, operation);
+    },
+    adoptBinding(bindingReservation, candidate, observers = {}) {
+      if (disposed || reservation !== bindingReservation) {
+        controller.cancelBindingReservation(bindingReservation);
+        if (candidate !== activeBinding?.candidate) {
+          disposeRendererCandidate(candidate, "dispose-stale-binding");
+        }
+        return;
+      }
+      controller.validateBindingCandidate(bindingReservation, candidate);
+      reservation = void 0;
+      adoptParameters(candidate.parameters);
+      if (activeBinding?.candidate === candidate) {
+        activeBinding.observers = observers;
+        return;
+      }
+      const previous = activeBinding;
+      activeBinding = {
+        candidate,
+        owner: bindingReservation.owner,
+        observers,
+        releaseOwnership: recordParticleBindingAcquired()
+      };
+      executionState = candidate.execution;
+      bindingFrameState = void 0;
+      previous?.releaseOwnership();
+      if (previous !== void 0) {
+        disposeRendererCandidate(
+          previous.candidate,
+          "dispose-replaced-binding"
+        );
+      }
+      enqueue((frame, batch) => {
+        transaction(frame, batch, () => {
+          executionState = candidate.execution;
+          if (statusState === "scheduled") {
+            statusState = "running";
+            anchorEffectTime = effectTime;
+            anchorLogicalTime = frame.logicalTime;
+            if (startPending) {
+              startPending = false;
+              queueEvent(frame, "start");
+            }
+          }
+          synchronizeAdvanceRegistration();
+        });
+      });
+    },
+    releaseBinding(bindingOwner, candidate) {
+      if (activeBinding === void 0 || activeBinding.owner !== bindingOwner || candidate !== void 0 && candidate !== activeBinding.candidate) {
+        return;
+      }
+      const released = activeBinding;
+      activeBinding = void 0;
+      executionState = "unbound";
+      bindingFrameState = void 0;
+      failRendererTransactions(bindingOwner);
+      unregisterAdvance?.();
+      unregisterAdvance = void 0;
+      released.releaseOwnership();
+      try {
+        disposeRendererCandidate(
+          released.candidate,
+          "dispose-released-binding"
+        );
+      } finally {
+        if (!disposed) {
+          enqueue((frame, batch) => {
+            transaction(frame, batch, () => {
+              executionState = "unbound";
+            });
+          });
+        }
+      }
+    },
+    recordRendererTransaction(bindingOwner, success) {
+      if (!success) {
+        failRendererTransactions(bindingOwner);
+        return;
+      }
+      const completed = deliveries.filter(
+        (pending) => !pending.finalized && pending.presentationOwner === bindingOwner && pending.rendererSucceeded === void 0
+      );
+      for (const current of completed) {
+        current.rendererSucceeded = true;
+        finalizeDeliveryIfReady(current);
+      }
+      releaseInactiveEpochs();
+    },
+    spawnParameters(epoch) {
+      const found = epochs.get(epoch);
+      if (found === void 0) {
+        throw new RangeError(
+          `Pibbl particle system received unknown parameter epoch ${epoch}.`
+        );
+      }
+      return found.parameters;
+    },
+    retainSpawnEpoch(epoch, count = 1) {
+      retainEpoch(epoch, count);
+    },
+    releaseSpawnEpoch(epoch, count = 1) {
+      releaseEpochReferences(epoch, count);
+    },
+    snapshot() {
+      return Object.freeze({
+        disposed,
+        generation,
+        seed,
+        effectTimeMilliseconds: effectTime,
+        previousEffectTimeMilliseconds: previousEffectTime,
+        binding: activeBinding?.candidate.backend ?? "unbound",
+        parameterEpochs: epochs.size
+      });
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      metadataPublication = void 0;
+      for (const pending of Array.from(deliveries)) removeDelivery(pending);
+      cancelPendingCommands();
+      preparedEffectCandidate = void 0;
+      preparedCompiled = compiled;
+      reservation = void 0;
+      unregisterAdvance?.();
+      unregisterAdvance = void 0;
+      releaseAcceptedLifetimes();
+      const binding = activeBinding;
+      activeBinding = void 0;
+      bindingFrameState = void 0;
+      binding?.releaseOwnership();
+      try {
+        if (binding !== void 0) {
+          disposeRendererCandidate(binding.candidate, "dispose-binding");
+        }
+        for (const candidate of Array.from(retiredCandidates)) {
+          disposeRendererCandidate(candidate, "retry-retired-binding");
+        }
+      } finally {
+        releaseAllEpochs();
+        statusState = "disposed";
+        executionState = "unbound";
+        statusSignal.set("disposed");
+        executionSignal.set("unbound");
+        releaseSystemOwnership();
+      }
+    }
+  });
+  controllers.set(handle, controller);
+  return controller;
+}
+function getParticleSystemController(system) {
+  const controller = controllers.get(system);
+  if (controller === void 0) {
+    throw new TypeError(
+      "Expected a Pibbl particle system created by useParticleSystem()."
+    );
+  }
+  return controller;
+}
+function particleSystemControllerSnapshot(system) {
+  return getParticleSystemController(system).snapshot();
+}
+export {
+  createParticleSystemController,
+  getParticleSystemController,
+  particleSystemControllerSnapshot
+};
+//# sourceMappingURL=controller.js.map