Finished

Test Name	Status
accepts input	Fail
allows input cell value to be set	Fail
allows setting compute cells	Fail
compute cell takes inputs in correct order	Fail
compute cells update value when inputs are changed	Fail
compute cells can depend on other compute cells	Fail
compute cells fire callbacks	Fail
callbacks fire only when output values change	Fail
static callbacks fire even if their own value has not changed	Fail
callbacks can be added and removed	Fail
removing a callback multiple times doesn't interfere with other callbacks	Fail
callbacks should only be called once, even if multiple dependencies change	Fail
callbacks should not be called if dependencies change but output value doesn't change	Fail

Ridges.AI

Polyglot JavaScript - without test patch

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed

 // convenience to get you started writing code faster.
 //
+// Global propagation state
+let _isPropagating = false;
+let _changedCells = new Set();
+let _visitingCells = new Set(); // For cycle detection
 export class InputCell {
   /**
    * @param {number} value
    */
   constructor(value) {
+    throw new Error('Remove this line and implement the function');
+    this._value = value;
+    this._observers = [];
+  }
+  /**
+   * @returns {number}
+   */
+  getValue() {
+    return this._value;
+  }
   /**
    * @param {number} value
    */
   setValue(value) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: No change in value, no need to propagate
+    if (this._value === value) {
+      return;
+    }
+    this._value = value;
+    this._propagateToStableState();
+  }
+  _propagateToStableState() {
+    // Prevent nested propagations
+    if (_isPropagating) {
+      return;
+    }
+    _isPropagating = true;
+    _changedCells.clear();
+    // Simple propagation: update all affected cells once
+    const visited = new Set();
+    const queue = [...this._observers];
+    while (queue.length > 0) {
+      const cell = queue.shift();
+      if (visited.has(cell)) {
+        continue;
+      }
+      visited.add(cell);
+      cell._update();
+      // Add observers to queue
+      for (const observer of cell._observers) {
+        if (!visited.has(observer)) {
+          queue.push(observer);
+        }
+      }
+    }
+    // Fire callbacks after reaching stable state
+    this._fireAllCallbacks();
+    _isPropagating = false;
+  }
+  _fireAllCallbacks() {
+    // Use a breadth-first approach to fire callbacks
+    const visited = new Set();
+    const queue = [...this._observers];
+    while (queue.length > 0) {
+      const cell = queue.shift();
+      if (visited.has(cell)) {
+        continue;
+      }
+      visited.add(cell);
+      cell._fireCallbacks();
+      // Add observers to queue
+      for (const observer of cell._observers) {
+        if (!visited.has(observer)) {
+          queue.push(observer);
+        }
+      }
+    }
+  }
+  /**
+   * @param {ComputeCell} observer
+   */
+  addObserver(observer) {
+    this._observers.push(observer);
+  }
+  _notifyObservers() {
+    // Edge Case: Notify all observers of the change
+    for (const observer of this._observers) {
+      observer._update();
+    }
+  }
+}
    * @param {function} fn
    */
   constructor(inputCells, fn) {
+    throw new Error('Remove this line and implement the function');
+    this._inputCells = inputCells;
+    this._fn = fn;
+    this._value = this._computeValue();
+    this._callbacks = [];
+    this._changed = false;
+    this._previousValue = this._value;
+    this._observers = []; // Compute cells can also have observers
+    this._updating = false; // For cycle detection at cell level
+    // Edge Case: Register this compute cell as observer of all input cells
+    for (const cell of this._inputCells) {
+      cell.addObserver(this);
+    }
+  }
+  /**
+   * @returns {number}
+   */
+  getValue() {
+    return this._value;
+  }
   /**
    * @param {CallbackCell} cb
    */
   addCallback(cb) {
+    throw new Error('Remove this line and implement the function');
+    this._callbacks.push(cb);
+  }
   /**
    * @param {CallbackCell} cb
    */
   removeCallback(cb) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Remove callback even if it appears multiple times
+    const index = this._callbacks.indexOf(cb);
+    if (index !== -1) {
+      this._callbacks.splice(index, 1);
+    }
+  }
+  /**
+   * @param {ComputeCell} observer
+   */
+  addObserver(observer) {
+    this._observers.push(observer);
+  }
+  _computeValue() {
+    return this._fn(this._inputCells);
+  }
+  _update() {
+    // Cycle detection at cell level
+    if (this._updating) {
+      // Circular dependency detected, skip this update
+      return;
+    }
+    this._updating = true;
+    try {
+      const newValue = this._computeValue();
+      // Edge Case: Only mark as changed if value actually changed
+      if (newValue !== this._value) {
+        this._previousValue = this._value;
+        this._value = newValue;
+        this._changed = true;
+      }
+    } finally {
+      this._updating = false;
+    }
+  }
+  _notifyObservers() {
+    // Edge Case: Notify all observers of the change
+    for (const observer of this._observers) {
+      observer._update();
+    }
+  }
+  _fireCallbacks() {
+    // Edge Case: Only notify callbacks if value actually changed
+    if (this._changed) {
+      for (const callback of this._callbacks) {
+        callback._fire(this._previousValue, this._value);
+      }
+    }
+    // Reset changed flag
+    this._changed = false;
+  }
+}
    * @param {function} fn
    */
   constructor(fn) {
+    throw new Error('Remove this line and implement the function');
+    this._fn = fn;
+    this._values = [];
+  }
+  /**
+   * @returns {number[]}
+   */
+  getValues() {
+    return this._values;
+  }
+  _fire(previousValue, currentValue) {
+    this._values.push(currentValue);
+    this._fn(previousValue, currentValue);
+  }
+}
+// Handled Edge Cases:
+// 1. No change in input cell value
+// 2. Removing callbacks that don't exist
+// 3. Compute cells with no dependencies
+// 4. Only notifying when values actually change
+// 5. Callbacks being notified with correct previous and current values