@pibbl/core 0.0.1

package/dist/lib/signals/graph.js

@@ -0,0 +1,1035 @@
+import {
+  beginReactiveCollection,
+  collectReactiveDependency,
+  finishReactiveCollection,
+  linkReactiveEdgeToSource,
+  notifyReactiveEdges,
+  unlinkReactiveEdgeFromSource
+} from "./edge.js";
+const signalNodes = /* @__PURE__ */ new WeakMap();
+const signalValues = /* @__PURE__ */ new WeakSet();
+let activeSignalDependencyCollector;
+const writePolicyStack = [];
+const computedStack = [];
+function createSignalNodeState(value, equals, debugName) {
+  return {
+    value,
+    equals,
+    debugName,
+    version: 0,
+    observerHead: void 0,
+    observerTail: void 0,
+    observerCount: 0,
+    activeObserverCursor: void 0
+  };
+}
+const commandAssertionNode = createSignalNodeState(
+  void 0,
+  Object.is,
+  void 0
+);
+const activeSignalRenderProvisions = /* @__PURE__ */ new WeakMap();
+const pendingComputedValidations = /* @__PURE__ */ new Set();
+let flushingPendingComputedValidations = false;
+let rendererConsumers = 0;
+let rendererEdges = 0;
+let createdRendererConsumers = 0;
+let releasedRendererConsumers = 0;
+let createdRendererEdges = 0;
+let releasedRendererEdges = 0;
+let signalCommitNotifications = 0;
+let planComputedValidations = 0;
+let computedSourceEdges = 0;
+let createdComputedSourceEdges = 0;
+let releasedComputedSourceEdges = 0;
+let lazyRendererConsumers = 0;
+let reusedRendererEdges = 0;
+let plainInputResolutions = 0;
+let signalInputResolutions = 0;
+let shallowInputCopies = 0;
+let receiverInputProvisions = 0;
+let adoptedReceiverInputProvisions = 0;
+let rolledBackReceiverInputProvisions = 0;
+let batchedObserverInvalidations = 0;
+let reactionConsumers = 0;
+let reactionEdges = 0;
+let reactionRuns = 0;
+let reactionCleanups = 0;
+let reactionFailures = 0;
+let signalGraphPlanWorkNotifier;
+let signalWriterLeasePolicy;
+let activePublicSignalBatch;
+function signalGraphSnapshot() {
+  return Object.freeze({
+    rendererConsumers,
+    rendererEdges,
+    computedSourceEdges,
+    pendingComputedValidations: pendingComputedValidations.size,
+    createdRendererConsumers,
+    releasedRendererConsumers,
+    createdRendererEdges,
+    releasedRendererEdges,
+    signalCommitNotifications,
+    planComputedValidations,
+    createdComputedSourceEdges,
+    releasedComputedSourceEdges,
+    lazyRendererConsumers,
+    reusedRendererEdges,
+    plainInputResolutions,
+    signalInputResolutions,
+    shallowInputCopies,
+    receiverInputProvisions,
+    adoptedReceiverInputProvisions,
+    rolledBackReceiverInputProvisions,
+    batchedObserverInvalidations,
+    reactionConsumers,
+    reactionEdges,
+    reactionRuns,
+    reactionCleanups,
+    reactionFailures
+  });
+}
+function recordLazyRendererConsumerCreated() {
+  lazyRendererConsumers++;
+}
+function recordRendererEdgeReused(restored = false) {
+  if (restored) rendererEdges++;
+  reusedRendererEdges++;
+}
+function recordPlainInputResolution() {
+  plainInputResolutions++;
+}
+function recordSignalInputResolution() {
+  signalInputResolutions++;
+}
+function recordShallowInputCopy() {
+  shallowInputCopies++;
+}
+function recordReceiverInputProvisionCreated() {
+  receiverInputProvisions++;
+}
+function recordReceiverInputProvisionAdopted() {
+  receiverInputProvisions--;
+  adoptedReceiverInputProvisions++;
+}
+function recordReceiverInputProvisionRolledBack() {
+  receiverInputProvisions--;
+  rolledBackReceiverInputProvisions++;
+}
+function trackSignalDependency(node) {
+  activeSignalDependencyCollector?.addDependency(node);
+}
+function recordBatchedObserverInvalidation() {
+  batchedObserverInvalidations++;
+}
+function recordReactionConsumerCreated() {
+  reactionConsumers++;
+}
+function recordReactionConsumerReleased() {
+  reactionConsumers--;
+}
+function recordReactionEdgeCreated() {
+  reactionEdges++;
+}
+function recordReactionEdgeReleased() {
+  reactionEdges--;
+}
+function recordReactionRun() {
+  reactionRuns++;
+}
+function recordReactionCleanup() {
+  reactionCleanups++;
+}
+function recordReactionFailure() {
+  reactionFailures++;
+}
+function recordRendererConsumerCreated() {
+  rendererConsumers++;
+  createdRendererConsumers++;
+}
+function recordRendererConsumerReleased() {
+  rendererConsumers--;
+  releasedRendererConsumers++;
+}
+function recordRendererEdgeCreated() {
+  rendererEdges++;
+  createdRendererEdges++;
+}
+function recordRendererEdgeReleased() {
+  rendererEdges--;
+  releasedRendererEdges++;
+}
+function batch(callback) {
+  if (activePublicSignalBatch !== void 0) return callback();
+  const state = {
+    entries: /* @__PURE__ */ new Map(),
+    failures: []
+  };
+  activePublicSignalBatch = state;
+  let result;
+  let callbackFailure;
+  let callbackFailed = false;
+  try {
+    result = callback();
+  } catch (error) {
+    callbackFailed = true;
+    callbackFailure = error;
+  }
+  const notificationFailures = flushPublicSignalBatch(state);
+  if (callbackFailed) {
+    if (notificationFailures.length === 0) throw callbackFailure;
+    throw new AggregateError(
+      [callbackFailure, ...notificationFailures],
+      "Pibbl signal batch callback and observer notifications failed."
+    );
+  }
+  throwSignalObserverFailures(notificationFailures);
+  return result;
+}
+function recordPublicBatchEntry(node) {
+  const state = activePublicSignalBatch;
+  if (state === void 0 || state.entries.has(node)) return;
+  const computedNode = isComputedSignalNode(node) ? node : void 0;
+  state.entries.set(node, {
+    value: node.value,
+    computedHasError: computedNode?.hasError,
+    computedError: computedNode?.error
+  });
+}
+function flushPublicSignalBatch(state) {
+  try {
+    flushPendingComputedValidations();
+  } catch (error) {
+    if (error instanceof AggregateError && error.message === "Pibbl signal observer notifications failed.") {
+      state.failures.push(...error.errors);
+    } else {
+      state.failures.push(error);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const consumers = [];
+  for (const [source, entry] of state.entries) {
+    let unchanged = false;
+    try {
+      unchanged = publicBatchEntryEquals(source, entry);
+    } catch (error) {
+      state.failures.push(error);
+    }
+    if (unchanged) continue;
+    signalCommitNotifications++;
+    for (let edge = source.observerHead; edge !== void 0; edge = edge.sourceNext) {
+      const consumer = edge.consumer;
+      if (consumer.propagateInvalidation === true) continue;
+      if (seen.has(consumer)) {
+        recordBatchedObserverInvalidation();
+        continue;
+      }
+      seen.add(consumer);
+      consumers.push({ consumer, source });
+    }
+  }
+  activePublicSignalBatch = void 0;
+  for (const { consumer, source } of consumers) {
+    try {
+      consumer.notify(source);
+    } catch (error) {
+      state.failures.push(error);
+    }
+  }
+  return state.failures;
+}
+function publicBatchEntryEquals(node, entry) {
+  if (isComputedSignalNode(node)) {
+    if (node.hasError !== entry.computedHasError) return false;
+    if (node.hasError && node.error !== entry.computedError) return false;
+  }
+  return node.equals(entry.value, node.value);
+}
+function computedWriteErrorLabel(node) {
+  return node.debugName === void 0 ? "Cannot write to a signal while evaluating a computed signal." : `Cannot write to a signal while evaluating computed signal "${node.debugName}".`;
+}
+function notifySignalObservers(node) {
+  const batchState = activePublicSignalBatch;
+  if (batchState !== void 0) {
+    batchState.failures.push(...notifyComputedInvalidationObservers(node));
+    return [];
+  }
+  signalCommitNotifications++;
+  return notifyReactiveEdges(node);
+}
+function notifyComputedInvalidationObservers(node) {
+  return notifyReactiveEdges(
+    node,
+    (consumer) => consumer.propagateInvalidation === true
+  );
+}
+function notifyRendererInvalidationObservers(node) {
+  return notifyReactiveEdges(
+    node,
+    (consumer) => consumer.renderInvalidation === true
+  );
+}
+function throwSignalObserverFailures(failures) {
+  if (failures.length > 0) {
+    throw new AggregateError(failures, "Pibbl signal observer notifications failed.");
+  }
+}
+function signal(initialValue, options = {}) {
+  const equals = options.equals ?? Object.is;
+  const debugName = options.debugName;
+  const node = createSignalNodeState(initialValue, equals, debugName);
+  let readonlySignal;
+  const read = () => {
+    activeSignalDependencyCollector?.addDependency(node);
+    return node.value;
+  };
+  const assertWriteAllowed = () => {
+    writePolicyStack[writePolicyStack.length - 1]?.(
+      node,
+      "direct"
+    );
+    signalWriterLeasePolicy?.assertDirectWriteAllowed(node);
+  };
+  const commit = (nextValue) => {
+    if (node.equals(node.value, nextValue)) {
+      return;
+    }
+    recordPublicBatchEntry(node);
+    node.value = nextValue;
+    node.version++;
+    throwSignalObserverFailures(notifySignalObservers(node));
+  };
+  const writable = {
+    get: read,
+    set(nextValue) {
+      assertWriteAllowed();
+      commit(nextValue);
+    },
+    update(updateValue) {
+      assertWriteAllowed();
+      commit(updateValue(node.value));
+    },
+    asReadonly() {
+      if (readonlySignal === void 0) {
+        readonlySignal = { get: read };
+        signalValues.add(readonlySignal);
+        signalNodes.set(readonlySignal, node);
+      }
+      return readonlySignal;
+    }
+  };
+  signalValues.add(writable);
+  signalNodes.set(writable, node);
+  return writable;
+}
+function provisionSignalValueForRender(value, nextValue, transaction) {
+  const node = getSignalNode(value);
+  const publishComputedVersion = (next) => {
+    node.value = next;
+    node.version++;
+    throwSignalObserverFailures(
+      notifyComputedInvalidationObservers(node)
+    );
+  };
+  let state = activeSignalRenderProvisions.get(node);
+  if (state === void 0) {
+    state = {
+      baseValue: node.value,
+      entries: [],
+      entriesByTransaction: /* @__PURE__ */ new Map()
+    };
+    activeSignalRenderProvisions.set(node, state);
+  }
+  const effectiveEntry = () => {
+    for (let index = state.entries.length - 1; index >= 0; index--) {
+      const entry2 = state.entries[index];
+      if (entry2.status !== "failure") return entry2;
+    }
+    return void 0;
+  };
+  const publishEffectiveValue = (forceEntry) => {
+    const entry2 = effectiveEntry();
+    const effectiveValue = entry2?.value ?? state.baseValue;
+    if (forceEntry !== void 0 && entry2 === forceEntry || !Object.is(node.value, effectiveValue)) {
+      publishComputedVersion(effectiveValue);
+      return true;
+    }
+    return false;
+  };
+  let entry = state.entriesByTransaction.get(transaction);
+  if (entry === void 0) {
+    entry = { transaction, value: nextValue, status: "pending" };
+    state.entries.push(entry);
+    state.entriesByTransaction.set(transaction, entry);
+    const provisionState = state;
+    const provisionEntry = entry;
+    transaction.onFinish((success) => {
+      if (provisionEntry.status !== "pending") return;
+      provisionEntry.status = success ? "success" : "failure";
+      while (provisionState.entries[0]?.status !== "pending" && provisionState.entries.length > 0) {
+        const settled = provisionState.entries.shift();
+        provisionState.entriesByTransaction.delete(settled.transaction);
+        if (settled.status === "success") {
+          provisionState.baseValue = settled.value;
+        }
+      }
+      const effectiveValueChanged = publishEffectiveValue();
+      if (!success && effectiveValueChanged) {
+        throwSignalObserverFailures(notifyRendererInvalidationObservers(node));
+      }
+      if (provisionState.entries.length === 0) {
+        activeSignalRenderProvisions.delete(node);
+      }
+    });
+  }
+  entry.value = nextValue;
+  publishEffectiveValue(entry);
+}
+function computed(compute, options = {}) {
+  const node = Object.assign(
+    createSignalNodeState(
+      void 0,
+      options.equals ?? Object.is,
+      options.debugName
+    ),
+    {
+      kind: "computed",
+      compute,
+      state: "check",
+      hasValue: false,
+      hasError: false,
+      error: void 0,
+      dependencyHead: void 0,
+      dependencyTail: void 0,
+      dependencyFreeHead: void 0,
+      dependencyFreeCount: 0,
+      dependencyCount: 0,
+      dependencyHighWater: 0,
+      collectionCursor: void 0,
+      collectionGeneration: 0,
+      observedCount: 0,
+      pendingValidation: false,
+      propagateInvalidation: true,
+      addDependency(dependency) {
+        if (!isComputedSignalNode(dependency) || dependency.state !== "evaluating") {
+          collectReactiveDependency(node, dependency);
+        }
+      },
+      notify: () => {
+      },
+      observe: () => () => {
+      },
+      invalidate: () => {
+      },
+      validate: () => {
+      },
+      adoptCandidate: () => {
+      },
+      replaceCompute: () => {
+      }
+    }
+  );
+  const notifyObservers = () => {
+    return notifySignalObservers(node);
+  };
+  const enqueueValidation = () => {
+    if (node.observedCount === 0 || node.pendingValidation) {
+      return;
+    }
+    node.pendingValidation = true;
+    const wasEmpty = pendingComputedValidations.size === 0;
+    pendingComputedValidations.add(node);
+    if (wasEmpty) signalGraphPlanWorkNotifier?.();
+  };
+  const removePendingValidation = () => {
+    if (!node.pendingValidation) return;
+    node.pendingValidation = false;
+    pendingComputedValidations.delete(node);
+    if (pendingComputedValidations.size === 0) signalGraphPlanWorkNotifier?.();
+  };
+  const invalidate = () => {
+    if (node.state !== "clean") {
+      return;
+    }
+    node.state = "check";
+    enqueueValidation();
+    throwSignalObserverFailures(
+      notifyComputedInvalidationObservers(node)
+    );
+  };
+  node.notify = invalidate;
+  const acquireDependency = (edge) => {
+    if (edge.sourceLinked) return;
+    const dependency = edge.source;
+    linkReactiveEdgeToSource(edge, dependency.observe?.());
+    computedSourceEdges++;
+    createdComputedSourceEdges++;
+  };
+  const releaseDependency = (edge) => {
+    if (!edge.sourceLinked) return;
+    unlinkReactiveEdgeFromSource(edge);
+    computedSourceEdges--;
+    releasedComputedSourceEdges++;
+  };
+  const acquireDependencies = () => {
+    for (let edge = node.dependencyHead; edge !== void 0; edge = edge.consumerNext) {
+      acquireDependency(edge);
+    }
+  };
+  const releaseDependencies = () => {
+    for (let edge = node.dependencyHead; edge !== void 0; edge = edge.consumerNext) {
+      releaseDependency(edge);
+    }
+  };
+  const finishDependencies = () => {
+    finishReactiveCollection(
+      node,
+      (edge) => {
+        if (node.observedCount > 0) acquireDependency(edge);
+        edge.observedVersion = edge.source.version;
+        edge.collectionKind = void 0;
+      },
+      releaseDependency
+    );
+  };
+  const cycleError = () => {
+    const start = computedStack.indexOf(node);
+    const cycle = [...computedStack.slice(start), node].map((computedNode) => computedNode.debugName ?? "<computed>").join(" -> ");
+    return new Error(`Pibbl computed cycle: ${cycle}`);
+  };
+  const evaluate = () => {
+    if (node.state === "evaluating") {
+      throw cycleError();
+    }
+    beginReactiveCollection(node);
+    node.state = "evaluating";
+    computedStack.push(node);
+    let changed;
+    try {
+      const result = withSignalWriteForbidden(
+        computedWriteErrorLabel(node),
+        () => {
+          const nextValue = withSignalTracking(node, node.compute);
+          return {
+            nextValue,
+            changed: !node.hasValue || node.hasError || !node.equals(node.value, nextValue)
+          };
+        }
+      );
+      changed = result.changed;
+      if (changed) {
+        recordPublicBatchEntry(node);
+        node.value = result.nextValue;
+        node.version++;
+      }
+      node.hasValue = true;
+      node.hasError = false;
+      node.error = void 0;
+    } catch (error) {
+      changed = !node.hasError || node.error !== error;
+      if (changed) recordPublicBatchEntry(node);
+      node.hasError = true;
+      node.error = error;
+    } finally {
+      computedStack.pop();
+      finishDependencies();
+      node.state = "clean";
+    }
+    if (changed) {
+      if (node.hasError) node.version++;
+      throwSignalObserverFailures(notifyObservers());
+    }
+  };
+  const validate = () => {
+    if (node.state === "evaluating") {
+      throw cycleError();
+    }
+    let dependencyChanged = false;
+    if (node.state === "clean" && node.observedCount > 0) return;
+    for (let edge = node.dependencyHead; edge !== void 0; edge = edge.consumerNext) {
+      const dependency = edge.source;
+      dependency.validate?.();
+      if (dependency.version !== edge.observedVersion) {
+        dependencyChanged = true;
+      }
+    }
+    if (node.state === "clean" && !dependencyChanged) return;
+    if (dependencyChanged || node.dependencyCount === 0 || !node.hasValue) {
+      evaluate();
+    } else {
+      node.state = "clean";
+    }
+  };
+  const hasChangedDependencyVersion = () => {
+    for (let edge = node.dependencyHead; edge !== void 0; edge = edge.consumerNext) {
+      if (edge.source.version !== edge.observedVersion) return true;
+    }
+    return false;
+  };
+  node.invalidate = invalidate;
+  node.validate = validate;
+  node.replaceCompute = (nextCompute, shouldInvalidate) => {
+    node.compute = nextCompute;
+    if (shouldInvalidate) invalidate();
+  };
+  node.adoptCandidate = (candidate, nextCompute, changed, readers) => {
+    if (!candidate.hasValue || candidate.hasError) {
+      throw new Error("Cannot adopt an unevaluated computed formula candidate.");
+    }
+    node.compute = nextCompute;
+    beginReactiveCollection(node);
+    for (let edge = candidate.dependencyHead; edge !== void 0; edge = edge.consumerNext) {
+      collectReactiveDependency(node, edge.source);
+    }
+    finishDependencies();
+    removePendingValidation();
+    node.state = "clean";
+    node.hasValue = true;
+    node.hasError = false;
+    node.error = void 0;
+    if (!changed) return;
+    recordPublicBatchEntry(node);
+    node.value = candidate.value;
+    node.version++;
+    signalCommitNotifications++;
+    throwSignalObserverFailures(notifyReactiveEdges(
+      node,
+      (consumer) => !readers.has(consumer)
+    ));
+  };
+  node.observe = () => {
+    node.observedCount++;
+    if (node.observedCount === 1) {
+      acquireDependencies();
+      if (node.state === "clean" && hasChangedDependencyVersion()) {
+        node.state = "check";
+      }
+    }
+    if (node.state === "check") {
+      enqueueValidation();
+    }
+    let detached = false;
+    return () => {
+      if (detached) {
+        return;
+      }
+      detached = true;
+      node.observedCount--;
+      if (node.observedCount === 0) {
+        removePendingValidation();
+        releaseDependencies();
+      }
+    };
+  };
+  const readonly = {
+    get() {
+      activeSignalDependencyCollector?.addDependency(
+        node
+      );
+      validate();
+      removePendingValidation();
+      if (node.hasError) {
+        throw node.error;
+      }
+      return node.value;
+    }
+  };
+  signalValues.add(readonly);
+  signalNodes.set(readonly, node);
+  return readonly;
+}
+function createComputedSignalAlias(target, read) {
+  const node = requireComputedSignalNode(target);
+  const alias = { get: read };
+  signalValues.add(alias);
+  signalNodes.set(alias, node);
+  return alias;
+}
+function createComputedFormulaCandidate(target, compute) {
+  const node = requireComputedSignalNode(target);
+  return {
+    signal: computed(compute, {
+      equals: node.equals,
+      debugName: node.debugName
+    }),
+    readers: /* @__PURE__ */ new Set(),
+    changed: false,
+    evaluated: false,
+    value: void 0
+  };
+}
+function readComputedFormulaCandidate(target, candidate) {
+  const node = requireComputedSignalNode(target);
+  const reader = activeSignalDependencyCollector;
+  reader?.addDependency(node);
+  if (reader !== void 0) candidate.readers.add(reader);
+  if (!candidate.evaluated) {
+    const value = untracked(() => candidate.signal.get());
+    candidate.changed = !node.hasValue || node.hasError || !node.equals(node.value, value);
+    candidate.value = value;
+    candidate.evaluated = true;
+  }
+  return candidate.value;
+}
+function adoptComputedFormulaCandidate(target, candidate, compute) {
+  const node = requireComputedSignalNode(target);
+  const candidateNode = requireComputedSignalNode(candidate.signal);
+  node.adoptCandidate(
+    candidateNode,
+    compute,
+    candidate.changed,
+    candidate.readers
+  );
+}
+function replaceComputedFormula(target, compute, invalidate) {
+  requireComputedSignalNode(target).replaceCompute(compute, invalidate);
+}
+function requireComputedSignalNode(value) {
+  const node = getSignalNode(value);
+  if (!isComputedSignalNode(node)) {
+    throw new TypeError("Expected a computed signal.");
+  }
+  return node;
+}
+function flushPendingComputedValidations() {
+  if (flushingPendingComputedValidations) {
+    return;
+  }
+  flushingPendingComputedValidations = true;
+  const attempted = /* @__PURE__ */ new Set();
+  const failures = [];
+  try {
+    while (pendingComputedValidations.size > 0) {
+      const node = Array.from(pendingComputedValidations).find((candidate) => !attempted.has(candidate));
+      if (node === void 0) {
+        break;
+      }
+      attempted.add(node);
+      node.pendingValidation = false;
+      pendingComputedValidations.delete(node);
+      if (pendingComputedValidations.size === 0) signalGraphPlanWorkNotifier?.();
+      if (node.observedCount > 0) {
+        planComputedValidations++;
+        try {
+          node.validate();
+        } catch (error) {
+          if (error instanceof AggregateError && error.message === "Pibbl signal observer notifications failed.") {
+            failures.push(...error.errors);
+          } else {
+            failures.push(error);
+          }
+          if (node.state === "check") enqueueComputedValidation(node);
+        }
+      }
+    }
+  } finally {
+    flushingPendingComputedValidations = false;
+  }
+  throwSignalObserverFailures(failures);
+}
+function hasPendingComputedValidations() {
+  return pendingComputedValidations.size > 0;
+}
+function setSignalGraphPlanWorkNotifier(notifier) {
+  signalGraphPlanWorkNotifier = notifier;
+  if (pendingComputedValidations.size > 0) notifier();
+}
+function untracked(callback) {
+  const previous = activeSignalDependencyCollector;
+  activeSignalDependencyCollector = void 0;
+  try {
+    return callback();
+  } finally {
+    activeSignalDependencyCollector = previous;
+  }
+}
+function isSignal(value) {
+  return typeof value === "object" && value !== null && signalValues.has(value);
+}
+function getSignalNode(value) {
+  const node = typeof value === "object" && value !== null ? signalNodes.get(value) : void 0;
+  if (node === void 0) {
+    throw new TypeError("Expected a signal created by signal().");
+  }
+  return node;
+}
+const signalCommitBatchStates = /* @__PURE__ */ new WeakMap();
+function createSignalCommitBatch() {
+  const staged = /* @__PURE__ */ new Map();
+  const batch2 = {
+    read(value) {
+      const node = getSignalNode(value);
+      const candidate = staged.get(node);
+      return candidate === void 0 ? node.value : candidate.value;
+    },
+    stage(value, nextValue, writer) {
+      stageSignalCommitBatchCandidate(
+        staged,
+        value,
+        nextValue,
+        writer,
+        void 0
+      );
+    },
+    registerLifecycle(writer, lifecycle) {
+      const prior = state.lifecycles.get(writer);
+      if (prior) abortLifecycle(prior);
+      state.lifecycles.set(writer, lifecycle);
+    },
+    discardWriter(writer) {
+      for (const [node, candidate] of staged) {
+        if (candidate.writer === writer) {
+          staged.delete(node);
+        }
+      }
+      const lifecycle = state.lifecycles.get(writer);
+      state.lifecycles.delete(writer);
+      if (lifecycle) abortLifecycle(lifecycle);
+    },
+    commit(onApplied) {
+      const candidates = [...staged.values()];
+      staged.clear();
+      try {
+        for (const candidate of candidates) {
+          signalWriterLeasePolicy?.assertStagedWriteAllowed(
+            candidate.node,
+            candidate.writer,
+            candidate.authorization
+          );
+        }
+        const changed = [];
+        for (const candidate of candidates) {
+          const node = candidate.node;
+          if (!node.equals(node.value, candidate.value)) {
+            changed.push(candidate);
+          }
+        }
+        const changedWriters = new Set(changed.map((candidate) => candidate.writer));
+        const applied = [];
+        for (const candidate of candidates) {
+          const lifecycle = state.lifecycles.get(candidate.writer);
+          state.lifecycles.delete(candidate.writer);
+          if (!lifecycle) continue;
+          if (!changedWriters.has(candidate.writer)) {
+            abortLifecycle(lifecycle);
+            continue;
+          }
+          try {
+            lifecycle.apply();
+            applied.push(lifecycle);
+          } catch (error) {
+            abortLifecycle(lifecycle);
+            for (const appliedLifecycle of applied.reverse()) {
+              try {
+                appliedLifecycle.rollback?.();
+              } catch {
+              }
+              abortLifecycle(appliedLifecycle);
+            }
+            throw error;
+          }
+        }
+        for (const candidate of changed) {
+          const node = candidate.node;
+          recordPublicBatchEntry(node);
+          node.value = candidate.value;
+          node.version++;
+        }
+        onApplied?.();
+        const failures = [];
+        for (const candidate of changed) {
+          failures.push(...notifySignalObservers(candidate.node));
+        }
+        for (const lifecycle of state.lifecycles.values()) abortLifecycle(lifecycle);
+        state.lifecycles.clear();
+        throwSignalObserverFailures(failures);
+      } catch (error) {
+        for (const lifecycle of state.lifecycles.values()) abortLifecycle(lifecycle);
+        state.lifecycles.clear();
+        throw error;
+      }
+    },
+    clear() {
+      staged.clear();
+      for (const lifecycle of state.lifecycles.values()) abortLifecycle(lifecycle);
+      state.lifecycles.clear();
+    }
+  };
+  const state = { staged, lifecycles: /* @__PURE__ */ new Map() };
+  signalCommitBatchStates.set(batch2, state);
+  return batch2;
+}
+function abortLifecycle(lifecycle) {
+  try {
+    lifecycle.abort();
+  } catch {
+  }
+}
+function stageSignalCommitBatchWithProvenance(batch2, provenance, signal2, value, writer) {
+  stageSignalCommitBatchCandidate(
+    requireSignalCommitBatchState(batch2).staged,
+    signal2,
+    value,
+    writer,
+    provenance
+  );
+}
+function discardSignalCommitBatchProvenance(batch2, provenance) {
+  discardSignalCommitBatchCandidates(
+    requireSignalCommitBatchState(batch2).staged,
+    (candidate) => candidate.provenance === provenance
+  );
+}
+function discardSignalCommitBatchWriterForProvenance(batch2, provenance, writer) {
+  discardSignalCommitBatchCandidates(
+    requireSignalCommitBatchState(batch2).staged,
+    (candidate) => candidate.provenance === provenance && candidate.writer === writer
+  );
+}
+function stageSignalCommitBatchCandidate(staged, value, nextValue, writer, provenance) {
+  const node = getSignalNode(value);
+  const unknownNode = node;
+  writePolicyStack[writePolicyStack.length - 1]?.(unknownNode, "staged");
+  staged.set(unknownNode, {
+    node: unknownNode,
+    value: nextValue,
+    writer,
+    authorization: signalWriterLeasePolicy?.captureStagedWrite(
+      unknownNode,
+      writer
+    ),
+    provenance,
+    previous: staged.get(unknownNode)
+  });
+}
+function requireSignalCommitBatchState(batch2) {
+  const state = signalCommitBatchStates.get(batch2);
+  if (!state) throw new TypeError("Expected a Pibbl signal Commit batch.");
+  return state;
+}
+function discardSignalCommitBatchCandidates(staged, discard) {
+  for (const [node, candidate] of staged) {
+    const retained = discardStagedSignalCandidates(candidate, discard);
+    if (retained === void 0) staged.delete(node);
+    else staged.set(node, retained);
+  }
+}
+function discardStagedSignalCandidates(candidate, discard) {
+  const retained = [];
+  let current = candidate;
+  while (current !== void 0) {
+    if (!discard(current)) retained.push(current);
+    current = current.previous;
+  }
+  let previous;
+  for (let index = retained.length - 1; index >= 0; index--) {
+    retained[index].previous = previous;
+    previous = retained[index];
+  }
+  return previous;
+}
+function withSignalTracking(collector, callback) {
+  const previous = activeSignalDependencyCollector;
+  activeSignalDependencyCollector = collector;
+  try {
+    return callback();
+  } finally {
+    activeSignalDependencyCollector = previous;
+  }
+}
+function withSignalWritePolicy(policy, callback) {
+  writePolicyStack.push(policy);
+  try {
+    return callback();
+  } finally {
+    writePolicyStack.pop();
+  }
+}
+function withSignalWriteForbidden(reason, callback) {
+  return withSignalWritePolicy(() => {
+    throw new Error(reason);
+  }, callback);
+}
+function withDirectSignalWriteForbidden(reason, callback) {
+  return withSignalWritePolicy((_node, operation) => {
+    if (operation === "direct") throw new Error(reason);
+  }, callback);
+}
+function assertSignalCommandAllowed() {
+  writePolicyStack[writePolicyStack.length - 1]?.(
+    commandAssertionNode,
+    "direct"
+  );
+}
+function assertDirectSignalWriteAllowed(value) {
+  const node = getSignalNode(value);
+  writePolicyStack[writePolicyStack.length - 1]?.(node, "direct");
+  signalWriterLeasePolicy?.assertDirectWriteAllowed(node);
+}
+function installSignalWriterLeasePolicy(policy) {
+  if (signalWriterLeasePolicy !== void 0 && signalWriterLeasePolicy !== policy) {
+    throw new Error("Pibbl signal writer-lease policy is already installed.");
+  }
+  signalWriterLeasePolicy = policy;
+}
+function isComputedSignalNode(node) {
+  return "kind" in node && node.kind === "computed";
+}
+function enqueueComputedValidation(node) {
+  if (node.observedCount === 0 || node.pendingValidation) return;
+  node.pendingValidation = true;
+  const wasEmpty = pendingComputedValidations.size === 0;
+  pendingComputedValidations.add(node);
+  if (wasEmpty) signalGraphPlanWorkNotifier?.();
+}
+export {
+  adoptComputedFormulaCandidate,
+  assertDirectSignalWriteAllowed,
+  assertSignalCommandAllowed,
+  batch,
+  computed,
+  createComputedFormulaCandidate,
+  createComputedSignalAlias,
+  createSignalCommitBatch,
+  discardSignalCommitBatchProvenance,
+  discardSignalCommitBatchWriterForProvenance,
+  flushPendingComputedValidations,
+  getSignalNode,
+  hasPendingComputedValidations,
+  installSignalWriterLeasePolicy,
+  isSignal,
+  provisionSignalValueForRender,
+  readComputedFormulaCandidate,
+  recordBatchedObserverInvalidation,
+  recordLazyRendererConsumerCreated,
+  recordPlainInputResolution,
+  recordReactionCleanup,
+  recordReactionConsumerCreated,
+  recordReactionConsumerReleased,
+  recordReactionEdgeCreated,
+  recordReactionEdgeReleased,
+  recordReactionFailure,
+  recordReactionRun,
+  recordReceiverInputProvisionAdopted,
+  recordReceiverInputProvisionCreated,
+  recordReceiverInputProvisionRolledBack,
+  recordRendererConsumerCreated,
+  recordRendererConsumerReleased,
+  recordRendererEdgeCreated,
+  recordRendererEdgeReleased,
+  recordRendererEdgeReused,
+  recordShallowInputCopy,
+  recordSignalInputResolution,
+  replaceComputedFormula,
+  setSignalGraphPlanWorkNotifier,
+  signal,
+  signalGraphSnapshot,
+  stageSignalCommitBatchWithProvenance,
+  trackSignalDependency,
+  untracked,
+  withDirectSignalWriteForbidden,
+  withSignalTracking,
+  withSignalWriteForbidden,
+  withSignalWritePolicy
+};
+//# sourceMappingURL=graph.js.map