Protect tilia from exceptions in computed or observed

Author: gaspard

README.md

@@ -17,6 +17,7 @@ Simple documentation on the [README](./tilia/README.md).
 - 2025-08-08 **3.0.0-beta**
   - Rename `unwrap` for `lift`, change syntax for `signal` to expose setter. Might remove `carve` as it
     forces mutability in the exposed object and is hard to reason about.
+  - Protect tilia from exceptions in computed: the exception is caught, logged to `console.error` and re-thrown at the end of the next flush.
 - 2025-08-08 **2.2.0**
   - Add `unwrap` to ease inserting a signal into a tilia object.
 - 2025-08-08 **2.1.1**

tilia/README.md

@@ -4,7 +4,12 @@
 
 ### Why Tilia for Domain-Driven Design ?
 
-Tilia’s minimal, expressive API lets you model application state and business logic in the language of your domain—without boilerplate or framework jargon. Features like `carve` encourage modular, feature-focused state that maps naturally to DDD’s bounded contexts. Computed properties and derived actions keep business logic close to your data, making code more readable, maintainable, and easier to evolve as your domain grows.
+Tilia’s minimal, expressive API lets you model application state and business
+logic in the language of your domain—without boilerplate or framework jargon.
+Features like `carve` encourage modular, feature-focused state that maps
+naturally to DDD’s bounded contexts. Computed properties and derived actions
+keep business logic close to your data, making code more readable, maintainable,
+and easier to evolve as your domain grows.
 
 In short: Tilia helps you write code that matches your business, not your framework.
 
@@ -16,6 +21,13 @@ For more information, check out the [**DDD section**](https://tiliajs.com/docs#d
 
 Check the [**website**](https://tiliajs.com) for full documentation and more examples for both TypeScript and ReScript.
 
+## Note on exceptions
+
+If a computed or observe callback throws an exception, the exception is caught,
+logged to `console.error` and re-thrown at the end of the next flush. This is
+done to avoid breaking the application in case of a bug in the callback but
+still bubbling the error to the user.
+
 ## API for versin **2.x** (in case the website is not available)
 
 (TypeScript version below)

tilia/src/Tilia.mjs

@@ -5,6 +5,33 @@ var raise = (function (message) {
   throw new Error(message)
 });
 
+var reraise = (function (e) {
+  console.error("Reraising exception after flush");
+  throw e
+});
+
+function cleanTrace(stack) {
+  if (typeof stack !== "string") return stack;
+  
+  const cleaned = ["Exception thrown in computed or observe"];
+  let collapsing = false;
+
+  for (const line of stack.split("\n")) {
+    if (/src\/Tilia\.mjs:\d+:\d+/.test(line)) {
+      if (!collapsing) {
+        cleaned.push("    [... tilia internals]");
+        collapsing = true;
+      }
+    } else {
+      cleaned.push(line);
+      collapsing = false;
+    }
+  }
+
+  return cleaned.join("\n");
+}
+;
+
 var symbol = (function(s) {
   return Symbol.for('tilia:' + s);
 });
@@ -38,6 +65,17 @@ function readonly(o, k) {
   }
 }
 
+var setError = (function (root, e) {
+  if (typeof e === "object" && e !== null) {
+    if (e.stack) {
+      console.error(cleanTrace(e.stack));
+    } else {
+      console.error(e);
+    }
+    root.error = e;
+  }
+});
+
 function observeKey(observed, key) {
   var w = observed.get(key);
   if (!(w === null || w === undefined)) {
@@ -76,9 +114,13 @@ function flush(root) {
         });
     gc.quarantine = gc.active;
     gc.active = new Set();
+  }
+  if (root.error === undefined) {
     return ;
   }
-  
+  var e = root.error;
+  root.error = undefined;
+  reraise(e);
 }
 
 function _clear(observer) {
@@ -337,7 +379,20 @@ function compile(root, observed, proxied, computes, isArray, target, key, callba
     observer.o = o;
     var previous = root.observer;
     root.observer = o;
-    var v = callback();
+    var v;
+    try {
+      v = callback();
+    }
+    catch (_e){
+      setError(root, _e);
+      _clear(o);
+      if (previous === null || previous === undefined) {
+        previous === null;
+      } else {
+        _clear(previous);
+      }
+      v = lastValue.v;
+    }
     root.observer = previous;
     if (o_observing.length === 0) {
       _clear(o);
@@ -572,8 +627,14 @@ function makeObserve(root) {
       };
       root.observer = observer;
       var o = observer;
-      callback();
-      _ready(o, true);
+      try {
+        callback();
+        return _ready(o, true);
+      }
+      catch (_e){
+        setError(root, _e);
+        return _clear(o);
+      }
     };
     notify();
   };
@@ -684,6 +745,8 @@ function make(gcOpt) {
     observer: undefined,
     expired: new Set(),
     lock: false,
+    error: undefined,
+    id: Math.random(),
     gc: gc$1
   };
   var tilia = makeTilia(root);
@@ -787,4 +850,4 @@ export {
   _meta ,
   _ctx ,
 }
-/* indexKey Not a pure module */
+/*  Not a pure module */

tilia/src/Tilia.res

@@ -11,6 +11,33 @@ let raise: string => 'a = %raw(`function (message) {
   throw new Error(message)
 }`)
 
+let reraise: 'a => 'b = %raw(`function (e) {
+  console.error("Reraising exception after flush");
+  throw e
+}`)
+
+%%raw(`
+function cleanTrace(stack) {
+  if (typeof stack !== "string") return stack;
+  
+  const cleaned = ["Exception thrown in computed or observe"];
+  let collapsing = false;
+
+  for (const line of stack.split("\n")) {
+    if (/src\/Tilia\.mjs:\d+:\d+/.test(line)) {
+      if (!collapsing) {
+        cleaned.push("    [... tilia internals]");
+        collapsing = true;
+      }
+    } else {
+      cleaned.push(line);
+      collapsing = false;
+    }
+  }
+
+  return cleaned.join("\n");
+}`)
+
 module Proxy = {
   @new external make: ('a, 'b) => 'c = "Proxy"
 }
@@ -88,6 +115,7 @@ module Dict = {
 }
 
 type dict<'a> = Dict.t<'a>
+type error
 
 type state =
   | Pristine // Hasn't changed since value read.
@@ -131,13 +159,26 @@ and root = {
   mutable expired: Set.t<observer>,
   // If set to true, wait for end of batch before flush
   mutable lock: bool,
+  mutable error: nullable<error>,
+  id: float,
   // Garbage collection handling
   gc: gc,
 }
 
 // List of watchers to which the the observer should add itself on ready
 and observing = array<watchers>
 
+let setError: (root, 'a) => unit = %raw(`function (root, e) {
+  if (typeof e === "object" && e !== null) {
+    if (e.stack) {
+      console.error(cleanTrace(e.stack));
+    } else {
+      console.error(e);
+    }
+    root.error = e;
+  }
+}`)
+
 type rec meta<'a> = {
   target: 'a,
   root: root,
@@ -207,6 +248,7 @@ let flush = root => {
     while Set.size(root.expired) > 0 {
       let expired = root.expired
       root.expired = Set.make()
+      // We need to notify
       Set.forEach(expired, observer => observer.notify())
     }
   }
@@ -223,6 +265,11 @@ let flush = root => {
     gc.quarantine = gc.active
     gc.active = Set.make()
   }
+  if root.error !== Undefined {
+    let e = root.error
+    root.error = Undefined
+    reraise(e)
+  }
 }
 
 let _clear = (observer: observer) => {
@@ -512,7 +559,19 @@ and compile = (
 
     let previous = root.observer
     root.observer = Value(o)
-    let v = callback()
+    let v = try {
+      callback()
+    } catch {
+    | _e => {
+        setError(root, %raw(`_e`))
+        _clear(o)
+        switch previous {
+        | Value(previous) => _clear(previous)
+        | _ => ()
+        }
+        lastValue.v
+      }
+    }
 
     // We need to reset previous observer before calling setReady so that
     // setReady does not trigger flush.
@@ -700,8 +759,15 @@ let makeCarve = (root: root) => (fn: deriver<'a> => 'a) => {
 let makeObserve = (root: root) => (callback: unit => unit) => {
   let rec notify = () => {
     let o = _observe(root, notify)
-    callback()
-    _ready(o, true)
+    try {
+      callback()
+      _ready(o, true)
+    } catch {
+    | _e => {
+        setError(root, %raw(`_e`))
+        _clear(o)
+      }
+    }
   }
   notify()
 }
@@ -813,7 +879,14 @@ let make = (~gc=defaultGc): tilia => {
     quarantine: Set.make(),
     threshold: gc,
   }
-  let root = {observer: Undefined, expired: Set.make(), lock: false, gc}
+  let root = {
+    observer: Undefined,
+    expired: Set.make(),
+    lock: false,
+    gc,
+    error: Undefined,
+    id: Math.random(),
+  }
   // We need to use raw to hide the types here.
   let tilia = makeTilia(root)
   let _observe = _observe(root, ...)