Knockout computed observables and DOM bindings: handling stale cache after async dependency updates

Short answer

No. Knockout does not automatically purge a computed’s cached value merely because one of its dependencies was disposed. deferredUpdates does not guarantee recomputation for an asynchronous update; it only changes when a valid change notification is processed. Explicit disposal is the reliable way to stop a computed from serving future values after its lifetime ends, but it is not a substitute for making the async dependency emit a change while the computed is still active.

Likely explanation versus confirmed behavior

Assuming Knockout 3.5.x/3.6.x, the confirmed model is that a computed caches its last evaluated result until a tracked dependency notifies subscribers. If an async callback mutates a plain object property, a non-observable field, or a value inside an observable without calling the observable setter, no dependency change event is emitted. The cache therefore remains valid from Knockout’s perspective, even though your application data changed.

If the dependency is an observable and the async code calls source(newValue), then deferUpdates should schedule the computed to re-evaluate after the change notification. The likely stale-cache cases are silent mutation, a disposed dependency while the computed remains alive, or a computed that has been disposed but is still being read.

What disposal actually protects against

Disposing the computed, or the subscription that keeps it awake, removes its dependency subscriptions and stops future recomputation and notification. If a dependency is disposed first, a still-live computed will not receive further notifications and can keep returning its last cached value. For DOM bindings, dispose the computed with the DOM node or binding context so the consumer cannot outlive its dependencies.

Minimal verification

Run this against your bundled Knockout build because cache internals are version-sensitive:

const source = ko.observable('initial');

const live = ko.pureComputed(() => source().length)
  .extend({ deferUpdates: true });

// Notifying async update: should recompute after the change event.
setTimeout(() => source('updated'), 0);

// Silent async update: no observable setter, so no cache invalidation.
const silent = { value: 'other' };
const stale = ko.pureComputed(() => silent.value.length);

// Lifecycle cleanup: stop tracking when the view/binding is removed.
// live.dispose();

Recommended handling

1. Make every async dependency a Knockout observable and write to it with the setter form, not by mutating a plain property.
2. Use ko.pureComputed plus deferUpdates when you want batching, not as a cache-clearing mechanism.
3. Dispose the computed or its subscription when the DOM element or binding is removed; cascade disposal if a dependency computed is disposed.
4. If a dependency may be disposed independently, either dispose the dependent computed too or replace the dependency with a new observable and force a new evaluation rather than relying on the old subscription.

One diagnostic that changes the advice

Is the async dependency updated through a Knockout observable setter, or is it a plain object property mutated inside the callback? If it is plain, the fix is notification, not disposal timing.