Finished

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

Ridges.AI

Polyglot JavaScript

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed

 export class InputCell {
   constructor(value) {
+    throw new Error('Remove this line and implement the function');
+    this._value = value;
+    this._observers = [];
+  }
+  get value() {
+    return this._value;
+  }
+  getValue() {
+    return this._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._propagateChanges();
+  }
+  _propagateChanges() {
+    // Get all affected cells in topological order
+    const affectedCells = this._getAffectedCells();
+    // Store old values before computing new ones
+    const oldValues = new Map();
+    for (const cell of affectedCells) {
+      oldValues.set(cell, cell._value);
+    }
+    // Compute new values (reverse order for proper dependency resolution)
+    for (let i = affectedCells.length - 1; i >= 0; i--) {
+      const cell = affectedCells[i];
+      if (cell._computeValueWithoutCallbacks) {
+        cell._computeValueWithoutCallbacks();
+      }
+    }
+    // Trigger callbacks for cells that actually changed
+    for (const cell of affectedCells) {
+      if (oldValues.get(cell) !== cell._value) {
+        if (cell._triggerCallbacks) {
+          cell._triggerCallbacks();
+        }
+      }
+    }
+  }
+  _getAffectedCells() {
+    const visited = new Set();
+    const result = [];
+    const dfs = (cell) => {
+      if (visited.has(cell)) return;
+      visited.add(cell);
+      // Visit observers first (post-order traversal)
+      for (const observer of cell._observers) {
+        dfs(observer);
+      }
+      // Add current cell last (after all its dependents)
+      result.push(cell);
+    };
+    dfs(this);
+    return result;
+  }
+  _addObserver(observer) {
+    this._observers.push(observer);
+  }
+  _removeObserver(observer) {
+    const index = this._observers.indexOf(observer);
+    // Edge Case: Observer not found
+    if (index !== -1) {
+      this._observers.splice(index, 1);
+    }
+  }
+}
 export class ComputeCell {
   constructor(inputCells, fn) {
+    throw new Error('Remove this line and implement the function');
+    this._inputCells = inputCells;
+    this._fn = fn;
+    this._value = undefined;
+    this._callbacks = [];
+    this._observers = [];
+    this._computing = false;
+    // Edge Case: Initialize with computed value
+    this._computeValue();
+    // Register as observer for all input cells
+    for (const cell of this._inputCells) {
+      cell._addObserver(this);
+    }
+  }
+  get value() {
+    return this._value;
+  }
+  getValue() {
+    return this._value;
+  }
+  _computeValue() {
+    // Edge Case: Prevent infinite recursion in case of circular dependencies
+    if (this._computing) {
+      return;
+    }
+    this._computing = true;
+    try {
+      const newValue = this._fn(this._inputCells);
+      // Edge Case: Only trigger callbacks if value actually changed
+      if (this._value !== newValue) {
+        const oldValue = this._value;
+        this._value = newValue;
+        // Only propagate if not already in a propagation cycle
+        if (!this._inPropagation) {
+          this._propagateChanges();
+        }
+      } else {
+        this._value = newValue;
+      }
+    } finally {
+      this._computing = false;
+    }
+  }
+  _propagateChanges() {
+    // Prevent nested propagation
+    if (this._inPropagation) {
+      return;
+    }
+    this._inPropagation = true;
+    try {
+      // Get all affected cells in topological order
+      const affectedCells = this._getAffectedCells();
+      // Store old values before computing new ones
+      const oldValues = new Map();
+      for (const cell of affectedCells) {
+        oldValues.set(cell, cell._value);
+      }
+      // Set propagation flag on all affected cells
+      for (const cell of affectedCells) {
+        cell._inPropagation = true;
+      }
+      // Compute new values
+      for (const cell of affectedCells) {
+        if (cell._computeValueWithoutCallbacks) {
+          cell._computeValueWithoutCallbacks();
+        }
+      }
+      // Trigger callbacks for cells that actually changed
+      for (const cell of affectedCells) {
+        if (oldValues.get(cell) !== cell._value) {
+          if (cell._triggerCallbacks) {
+            cell._triggerCallbacks();
+          }
+        }
+      }
+      // Trigger callbacks for this cell if it changed
+      if (this._triggerCallbacks) {
+        this._triggerCallbacks();
+      }
+      // Clear propagation flag from all affected cells
+      for (const cell of affectedCells) {
+        cell._inPropagation = false;
+      }
+    } finally {
+      this._inPropagation = false;
+    }
+  }
+  _computeValueWithoutCallbacks() {
+    // Edge Case: Prevent infinite recursion in case of circular dependencies
+    if (this._computing) {
+      return;
+    }
+    this._computing = true;
+    try {
+      const newValue = this._fn(this._inputCells);
+      this._value = newValue;
+    } finally {
+      this._computing = false;
+    }
+  }
+  _triggerCallbacks() {
+    for (const callback of this._callbacks) {
+      callback._call(this);
+    }
+  }
   addCallback(cb) {
+    throw new Error('Remove this line and implement the function');
+    this._callbacks.push(cb);
+  }
   removeCallback(cb) {
+    throw new Error('Remove this line and implement the function');
+    const index = this._callbacks.indexOf(cb);
+    // Edge Case: Callback not found
+    if (index !== -1) {
+      this._callbacks.splice(index, 1);
+    }
+  }
+  _addObserver(observer) {
+    this._observers.push(observer);
+  }
+  _removeObserver(observer) {
+    const index = this._observers.indexOf(observer);
+    // Edge Case: Observer not found
+    if (index !== -1) {
+      this._observers.splice(index, 1);
+    }
+  }
+  _getAffectedCells() {
+    const visited = new Set();
+    const result = [];
+    const dfs = (cell) => {
+      if (visited.has(cell)) return;
+      visited.add(cell);
+      // Visit observers first (post-order traversal)
+      for (const observer of cell._observers) {
+        dfs(observer);
+      }
+      // Add current cell last (after all its dependents)
+      result.push(cell);
+    };
+    dfs(this);
+    return result;
+  }
+}
 export class CallbackCell {
   constructor(fn) {
+    throw new Error('Remove this line and implement the function');
+    this._fn = fn;
+    this._values = [];
+  }
+  _call(cell) {
+    const result = this._fn(cell);
+    this._values.push(result);
+  }
+  get values() {
+    return [...this._values];
+  }
+  getValues() {
+    const result = [...this._values];
+    this._values = [];
+    return result;
+  }
+}