dazscript-framework 0.3.1 → 1.0.1

package/src/helpers/message-box-helper.ts

@@ -10,7 +10,7 @@ export const error = (message: string, writeLog: boolean = true) => {
 }
 
 export const warning = (message: string) => {
-    MessageBox.warning(message, "Warning", "Ok")
+    MessageBox.warning(message, "Warning", "Ok", "")
 }
 
 export const confirm = (message?: string): { ok: boolean, cancel: boolean } => {
@@ -20,7 +20,7 @@ export const confirm = (message?: string): { ok: boolean, cancel: boolean } => {
 }
 
 export const prompt = (text: string, title: string, button0: string, button1?: string): { cancel: boolean, selection: number } => {
-    const response = MessageBox.question(text, title, button0, button1, "Cancel")
+    const response = MessageBox.question(text, title, button0, button1 ?? "", "Cancel")
 
     return { cancel: response === 0, selection: response };
 }

package/src/helpers/node-helper.ts

@@ -26,7 +26,7 @@ export const isFigure = (node: DzNode): boolean => {
  * @param node
  * @returns The root of the node, if the node is part of a figure, return the figure (skeleton) otherwise return the node itself
  */
-export const getRoot = (node: DzNode): DzNode => {
+export const getRoot = (node: DzNode | null): DzNode | null => {
     if (node && node.className() === "DzBone" && node.getSkeleton)
         return node.getSkeleton();
     else
@@ -44,8 +44,8 @@ export const getFigure = (node: DzNode): DzSkeleton | null => {
  * @returns The first property with the given name or internal name, or NULL.
  */
 export const findProperty = <T extends DzProperty = DzProperty>(node: DzNode, name: string): T | null => {
-    return sceneHelper.findPropertyOnNode(name, node) as T
-        ?? sceneHelper.findPropertyOnNodeByInternalName(name, node) as T
+    return sceneHelper.findPropertyOnNode(name, node) as unknown as T
+        ?? sceneHelper.findPropertyOnNodeByInternalName(name, node) as unknown as T
 }
 
 /**
@@ -90,7 +90,7 @@ export const isChildOf = (node: DzNode, figure: DzNode): boolean => {
  * @returns the fitting target (skeleton) of the node or null
  */
 export const getFittingTarget = (node: DzNode): DzSkeleton | null => {
-    return getRoot(node).getSkeleton()?.getFollowTarget()
+    return getRoot(node)?.getSkeleton()?.getFollowTarget() ?? null
 }
 
 /**
@@ -99,7 +99,7 @@ export const getFittingTarget = (node: DzNode): DzSkeleton | null => {
 * @param target if specified, check if the node is fitted to the target node, otherwise check if the node is fitted to any other node
 * @returns true if the node is fitted to another node
 */
-export const isFitting = (figure: DzSkeleton, target?: DzNode): boolean => {
+export const isFitting = (figure: DzSkeleton | null, target?: DzNode): boolean => {
     return target
         ? figure?.getFollowTarget() == target
         : figure?.getFollowTarget() != null
@@ -140,12 +140,12 @@ export const getTransforms = (node: DzNode, include: { rotations?: boolean, tran
 export const getRotations = (node: DzNode, includeExtraRotations: boolean = true): DzFloatProperty[] => {
     if (!node) return [];
 
-    const xRotate = sceneHelper.findPropertyOnNode('XRotate', node) as DzFloatProperty;
-    const xRotate2 = sceneHelper.findPropertyOnNode('XRotate2', node) as DzFloatProperty;
-    const yRotate = sceneHelper.findPropertyOnNode('YRotate', node) as DzFloatProperty;
-    const yRotate2 = sceneHelper.findPropertyOnNode('YRotate2', node) as DzFloatProperty;
-    const zRotate = sceneHelper.findPropertyOnNode('ZRotate', node) as DzFloatProperty;
-    const zRotate2 = sceneHelper.findPropertyOnNode('ZRotate2', node) as DzFloatProperty;
+    const xRotate = sceneHelper.findPropertyOnNode('XRotate', node) as unknown as DzFloatProperty;
+    const xRotate2 = sceneHelper.findPropertyOnNode('XRotate2', node) as unknown as DzFloatProperty;
+    const yRotate = sceneHelper.findPropertyOnNode('YRotate', node) as unknown as DzFloatProperty;
+    const yRotate2 = sceneHelper.findPropertyOnNode('YRotate2', node) as unknown as DzFloatProperty;
+    const zRotate = sceneHelper.findPropertyOnNode('ZRotate', node) as unknown as DzFloatProperty;
+    const zRotate2 = sceneHelper.findPropertyOnNode('ZRotate2', node) as unknown as DzFloatProperty;
 
     if (includeExtraRotations) {
         return [xRotate, xRotate2, yRotate, yRotate2, zRotate, zRotate2].filter(Boolean);
@@ -162,7 +162,7 @@ export const getRotations = (node: DzNode, includeExtraRotations: boolean = true
 export const getRotationsForAxis = (node: DzNode, axis: 'x' | 'y' | 'z'): DzFloatProperty => {
     debug(`Getting rotation property for axis: ${axis} on node: ${node.getName()} - isBone: ${isBone(node)}`);
 
-    let prop: DzFloatProperty | undefined;
+    let prop: DzFloatProperty | null = null;
 
     if (isBone(node)) {
         prop = getNamedRotationForAxis(node, axis);
@@ -175,7 +175,7 @@ export const getRotationsForAxis = (node: DzNode, axis: 'x' | 'y' | 'z'): DzFloa
         prop = find(
             getRotations(node, false),
             (rotation) => rotation.getName().valueOf()[0].toLowerCase() === axis
-        ) as DzFloatProperty;
+        ) as unknown as DzFloatProperty;
     }
 
     return prop;
@@ -185,7 +185,7 @@ export const getNamedRotations = (node: DzNode): DzFloatProperty[] => {
     const rotations: DzFloatProperty[] = []
 
     for (let namedAxis in NamedAxis) {
-        let property = sceneHelper.findPropertyOnNodeByLabel(NamedAxis[namedAxis], node) as DzFloatProperty
+        let property = sceneHelper.findPropertyOnNodeByLabel(NamedAxis[namedAxis], node) as unknown as DzFloatProperty
         if (property) rotations.push(property)
     }
 

package/src/helpers/pane-helper.ts

@@ -1,11 +1,11 @@
 import { mainWindow } from '@dsf/core/global'
 
 const findPane = <T extends DzPane>(className: string): T => {
-    return mainWindow.getPaneMgr().findPane(className) as T
+    return mainWindow.getPaneMgr().findPane(className) as unknown as T
 }
 
 export const getSmartContentPane = (): DzSmartContentPane => {
-    return <DzSmartContentPane>findPane("DzSmartContentPane")
+    return findPane("DzSmartContentPane") as unknown as DzSmartContentPane
 }
 
 export const getSurfacesPane = (): DzSurfacesPane => {
@@ -20,10 +20,10 @@ export const getParametersPane = (): DzParametersPane => {
     return findPane<DzParametersPane>("DzParametersPane")
 }
 
-export const getParametersPaneNodeEditor = (): DzPropertySideNavHierarchy => {
+export const getParametersPaneNodeEditor = (): DzPropertySideNavHierarchy | null => {
     return findPane<DzParametersPane>("DzParametersPane")?.getNodeEditor() ?? null
 }
 
-export const getPaneNodeEditor = (pane: DzAbstractNodeEditorPane): DzPropertySideNavHierarchy => {
+export const getPaneNodeEditor = (pane: DzAbstractNodeEditorPane): DzPropertySideNavHierarchy | null => {
     return pane.getNodeEditor ? pane.getNodeEditor() : null
-}
+}

package/src/helpers/scene-helper.ts

@@ -4,9 +4,9 @@ import { getRoot, isFigure } from './node-helper'
 import { getPaneNodeEditor, getParametersPane, getParametersPaneNodeEditor } from './pane-helper'
 
 export const getSelectedOf = <T>(typeName: string): DzNode[] => {
-    let nodes = []
+    let nodes: DzNode[] = []
     for (let node of scene.getSelectedNodeList()) {
-        if (!node.inherits(typeName)) continue
+        if (!node || !node.inherits(typeName)) continue
         nodes.push(node)
     }
     return nodes
@@ -45,7 +45,7 @@ export const getFigures = (): DzSkeleton[] => {
  * @returns the figure skeleton, or null if there is no current selection or the selected node is not part of a figure
  */
 export const getSelectedFigure = (): DzSkeleton | null => {
-    return getSelectedNode()?.getSkeleton?.()
+    return getSelectedNode()?.getSkeleton?.() ?? null
 }
 
 /**
@@ -66,12 +66,12 @@ export const getSelectedNodes = (): DzNode[] => {
     return scene.getSelectedNodeList()
 }
 
-export const getSelectedRoot = (): DzNode => {
+export const getSelectedRoot = (): DzNode | null => {
     return getRoot(getSelectedNode())
 }
 
 export const getSelectedRoots = (): DzNode[] => {
-    return distinct(getSelectedNodes().map(n => getRoot(n)))
+    return distinct(getSelectedNodes().map(n => getRoot(n))).filter(n => n !== null) as DzNode[]
 }
 
 export const getSelectedProperties = (): DzProperty[] => {
@@ -79,7 +79,7 @@ export const getSelectedProperties = (): DzProperty[] => {
 }
 
 export const getSelectedNumericProperties = (): (DzFloatProperty | DzIntProperty | DzBoolProperty)[] => {
-    return getParametersPane()?.getNodeEditor()?.getPropertySelections(true).map(p => p as DzFloatProperty | DzIntProperty | DzBoolProperty) ?? []
+    return getParametersPane()?.getNodeEditor()?.getPropertySelections(true).map(p => p as unknown as DzFloatProperty | DzIntProperty | DzBoolProperty) ?? []
 }
 
 export const getSelectedPropertiesOfType = <TProperty extends DzProperty>(type: string): TProperty[] => {
@@ -125,7 +125,7 @@ export const getCurrentFrame = (): number => {
 }
 
 export const getEndFrame = (): number => {
-    return scene.getAnimRange().end / scene.getTimeStep().valueOf()
+    return scene.getAnimRange().end.valueOf() / scene.getTimeStep().valueOf()
 }
 
 /**
@@ -133,7 +133,7 @@ export const getEndFrame = (): number => {
  * @returns the last frame number (0-based)
  */
 export const getLastFrame = (): number => {
-    return scene.getAnimRange().end / scene.getTimeStep().valueOf()
+    return scene.getAnimRange().end.valueOf() / scene.getTimeStep().valueOf()
 }
 
 export const timeToFrame = (time: DzTime): number => {
@@ -142,4 +142,4 @@ export const timeToFrame = (time: DzTime): number => {
 
 export const frameToTime = (frame: number): DzTime => {
     return new DzTime(scene.getTimeStep().valueOf() * frame)
-}
+}

package/src/helpers/viewport-helper.ts

@@ -2,7 +2,7 @@ import { mainWindow } from '@dsf/core/global'
 
 export const selectUniversalRotateTool = (coordinateSpace?: number): DzUniversalRotateTool => {
     const viewportMgr = mainWindow.getViewportMgr()
-    const tool = viewportMgr.findTool('DzUniversalRotateTool') as DzUniversalRotateTool
+    const tool = viewportMgr.findTool('DzUniversalRotateTool') as unknown as DzUniversalRotateTool
     viewportMgr.setActiveTool(tool)
     if (coordinateSpace) tool.setCoordinateSpace(coordinateSpace)
     return tool
@@ -19,4 +19,4 @@ export const getAuxViewport = (): DzViewport | null => {
         if (viewport.name === 'AuxViewportView') return viewport
     }
     return null
-}
+}

package/src/lib/observable.test.ts

@@ -0,0 +1,416 @@
+import { describe, expect, it, vi } from 'vitest'
+import { BooleanObservable, Observable } from './observable'
+
+// ─── Observable ───────────────────────────────────────────────────────────────
+
+describe('Observable — constructor', () => {
+    it('initializes with undefined when no value is provided', () => {
+        const obs = new Observable<string>()
+        expect(obs.value).toBeUndefined()
+    })
+
+    it('initializes with the provided value', () => {
+        const obs = new Observable(42)
+        expect(obs.value).toBe(42)
+    })
+
+    it('registers an onChange callback provided at construction', () => {
+        const cb = vi.fn()
+        const obs = new Observable<string>('a', cb)
+        obs.value = 'b'
+        expect(cb).toHaveBeenCalledWith('b')
+    })
+})
+
+describe('Observable — value setter', () => {
+    it('updates the stored value', () => {
+        const obs = new Observable(1)
+        obs.value = 2
+        expect(obs.value).toBe(2)
+    })
+
+    it('fires connected callbacks with the new value', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb)
+        obs.value = 99
+        expect(cb).toHaveBeenCalledOnce()
+        expect(cb).toHaveBeenCalledWith(99)
+    })
+
+    it('fires all connected callbacks', () => {
+        const cb1 = vi.fn()
+        const cb2 = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb1).connect(cb2)
+        obs.value = 1
+        expect(cb1).toHaveBeenCalledWith(1)
+        expect(cb2).toHaveBeenCalledWith(1)
+    })
+
+    it('does not fire callbacks when the value is unchanged', () => {
+        const cb = vi.fn()
+        const obs = new Observable('same')
+        obs.connect(cb)
+        obs.value = 'same'
+        expect(cb).not.toHaveBeenCalled()
+    })
+})
+
+describe('Observable — connect / disconnect', () => {
+    it('returns this for chaining', () => {
+        const obs = new Observable(0)
+        const cb = vi.fn()
+        expect(obs.connect(cb)).toBe(obs)
+    })
+
+    it('does not register the same callback twice', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb).connect(cb)
+        obs.value = 1
+        expect(cb).toHaveBeenCalledOnce()
+    })
+
+    it('stops firing a disconnected callback', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb)
+        obs.disconnect(cb)
+        obs.value = 1
+        expect(cb).not.toHaveBeenCalled()
+    })
+
+    it('ignores disconnect of a callback that was never connected', () => {
+        const obs = new Observable(0)
+        expect(() => obs.disconnect(vi.fn())).not.toThrow()
+    })
+})
+
+describe('Observable — pause / resume', () => {
+    it('suppresses callbacks inside the pause block', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb)
+        obs.pause(() => { obs.value = 1 })
+        expect(cb).not.toHaveBeenCalled()
+    })
+
+    it('still updates the value during the pause block', () => {
+        const obs = new Observable(0)
+        obs.pause(() => { obs.value = 99 })
+        expect(obs.value).toBe(99)
+    })
+
+    it('resumes callbacks after the pause block completes', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb)
+        obs.pause(() => { obs.value = 1 })
+        obs.value = 2
+        expect(cb).toHaveBeenCalledOnce()
+        expect(cb).toHaveBeenCalledWith(2)
+    })
+
+    it('suppresses callbacks when paused manually without a block', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb)
+        obs.pause()
+        obs.value = 1
+        expect(cb).not.toHaveBeenCalled()
+    })
+
+    it('resumes callbacks after an explicit resume()', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb)
+        obs.pause()
+        obs.resume()
+        obs.value = 1
+        expect(cb).toHaveBeenCalledWith(1)
+    })
+})
+
+describe('Observable — trigger', () => {
+    it('fires all callbacks with the current value', () => {
+        const cb = vi.fn()
+        const obs = new Observable('x')
+        obs.connect(cb)
+        obs.trigger()
+        expect(cb).toHaveBeenCalledWith('x')
+    })
+
+    it('does not fire callbacks when paused', () => {
+        const cb = vi.fn()
+        const obs = new Observable('x')
+        obs.connect(cb)
+        obs.pause()
+        obs.trigger()
+        expect(cb).not.toHaveBeenCalled()
+    })
+})
+
+describe('Observable — setSilently', () => {
+    it('updates the value without firing callbacks', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb)
+        obs.setSilently(5)
+        expect(obs.value).toBe(5)
+        expect(cb).not.toHaveBeenCalled()
+    })
+})
+
+describe('Observable — toJSON', () => {
+    it('returns the current value', () => {
+        const obs = new Observable(42)
+        expect(obs.toJSON()).toBe(42)
+    })
+})
+
+describe('Observable — intercept: beforeChange', () => {
+    it('transforms the incoming value before it is applied', () => {
+        const obs = new Observable<string>('')
+        obs.intercept((_prev, current) => current.toUpperCase())
+        obs.value = 'hello'
+        expect(obs.value).toBe('HELLO')
+    })
+
+    it('passes the transformed value to callbacks', () => {
+        const cb = vi.fn()
+        const obs = new Observable<string>('')
+        obs.intercept((_prev, current) => current.trim())
+        obs.connect(cb)
+        obs.value = '  hi  '
+        expect(cb).toHaveBeenCalledWith('hi')
+    })
+
+    it('blocks a change when beforeChange returns the previous value', () => {
+        const cb = vi.fn()
+        const obs = new Observable(5)
+        // reject negative numbers — return prev unchanged
+        obs.intercept((prev, current) => current < 0 ? prev : current)
+        obs.connect(cb)
+        obs.value = -1
+        expect(obs.value).toBe(5)
+        expect(cb).not.toHaveBeenCalled()
+    })
+})
+
+describe('Observable — intercept: afterChange', () => {
+    it('applies a post-set transformation until the value stabilizes', () => {
+        const obs = new Observable(0)
+        // clamp to [0, 100]: if already in range afterChange returns same value → loop ends
+        obs.intercept(
+            (_prev, current) => current,
+            (_prev, current) => Math.max(0, Math.min(100, current))
+        )
+        obs.value = 150
+        expect(obs.value).toBe(100)
+    })
+
+    it('fires callbacks with the afterChange result', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.intercept(
+            (_prev, current) => current,
+            (_prev, current) => Math.max(0, Math.min(100, current))
+        )
+        obs.connect(cb)
+        obs.value = 200
+        expect(cb).toHaveBeenLastCalledWith(100)
+    })
+
+    it('throws when afterChange never stabilizes (infinite loop guard)', () => {
+        const obs = new Observable(0)
+        obs.intercept(
+            (_prev, current) => current,
+            (_prev, current) => current + 1  // always returns a new value
+        )
+        expect(() => { obs.value = 1 }).toThrow(/afterChange exceeded depth/)
+    })
+})
+
+describe('Observable — re-entrant set (coalescing)', () => {
+    it('applies only the last value requested during an active callback', () => {
+        const obs = new Observable(0)
+        const calls: number[] = []
+
+        obs.connect((v) => {
+            calls.push(v)
+            if (v === 1) {
+                obs.value = 2  // queued as pending
+                obs.value = 3  // overwrites pending — only 3 should run
+            }
+        })
+
+        obs.value = 1
+        expect(obs.value).toBe(3)
+        expect(calls).toEqual([1, 3])
+    })
+
+    it('does not produce a chained set when the pending value equals current', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+
+        obs.connect(() => {
+            obs.value = obs.value  // set to same — should be a no-op after coalescing
+        })
+        obs.connect(cb)
+
+        obs.value = 1
+        // cb fires once (for the initial set to 1); no chained set because pending === current
+        expect(cb).toHaveBeenCalledOnce()
+    })
+})
+
+describe('Observable — chained sets (listener-driven)', () => {
+    it('processes a value requested by a listener after the current cycle', () => {
+        const obs = new Observable(0)
+        const calls: number[] = []
+
+        obs.connect((v) => {
+            calls.push(v)
+            if (v === 1) obs.value = 2  // request one further change only
+        })
+
+        obs.value = 1
+        expect(obs.value).toBe(2)
+        expect(calls).toEqual([1, 2])
+    })
+
+    it('throws when a listener causes an infinite chain of distinct values (loop guard)', () => {
+        const obs = new Observable(0)
+        obs.connect((v) => { obs.value = v + 1 })  // always requests a different value
+        expect(() => { obs.value = 1 }).toThrow(/Too many chained set operations/)
+    })
+})
+
+describe('Observable — custom equals', () => {
+    it('uses the provided comparator to decide whether the value changed', () => {
+        const cb = vi.fn()
+        const obs = new Observable<string>('hello', undefined, (a, b) => a?.toLowerCase() === b?.toLowerCase())
+        obs.connect(cb)
+        obs.value = 'HELLO'  // equal by custom comparator → no change
+        expect(cb).not.toHaveBeenCalled()
+        expect(obs.value).toBe('hello')
+    })
+})
+
+// ─── BooleanObservable ────────────────────────────────────────────────────────
+
+describe('Observable — resilience: callback throws', () => {
+    it('remains usable after a callback throws', () => {
+        const obs = new Observable(0)
+        const boom = () => { throw new Error('boom') }
+        obs.connect(boom)
+        expect(() => { obs.value = 1 }).toThrow('boom')
+
+        // disconnect the bad callback, then confirm _isSetting was cleared
+        obs.disconnect(boom)
+        const cb = vi.fn()
+        obs.connect(cb)
+        obs.value = 2
+        expect(cb).toHaveBeenCalledWith(2)
+    })
+
+    it('resumes notifications after the pause block throws', () => {
+        const cb = vi.fn()
+        const obs = new Observable(0)
+        obs.connect(cb)
+        expect(() => obs.pause(() => { throw new Error('boom') })).toThrow('boom')
+
+        // _paused must be false so future changes still fire callbacks
+        obs.value = 1
+        expect(cb).toHaveBeenCalledWith(1)
+    })
+})
+
+describe('Observable — subscriber list mutation during fire', () => {
+    it('does not call a callback that disconnects itself during the current fire', () => {
+        const obs = new Observable(0)
+        const calls: string[] = []
+
+        const selfRemove = () => {
+            calls.push('selfRemove')
+            obs.disconnect(selfRemove)
+        }
+        const other = () => calls.push('other')
+
+        obs.connect(selfRemove).connect(other)
+        obs.value = 1
+
+        expect(calls).toEqual(['selfRemove', 'other'])
+
+        // selfRemove was disconnected — should not fire on the next change
+        calls.length = 0
+        obs.value = 2
+        expect(calls).toEqual(['other'])
+    })
+
+    it('does not call a callback added during the current fire', () => {
+        const obs = new Observable(0)
+        const late = vi.fn()
+
+        obs.connect(() => { obs.connect(late) })
+        obs.value = 1
+
+        // late was added mid-fire from a snapshot, should not have been called yet
+        expect(late).not.toHaveBeenCalled()
+
+        // but it is registered for future changes
+        obs.value = 2
+        expect(late).toHaveBeenCalledWith(2)
+    })
+})
+
+describe('BooleanObservable — combine', () => {
+    it('initializes to true when all combined observables are true', () => {
+        const a = new BooleanObservable(true)
+        const b = new BooleanObservable(true)
+        const combined = new BooleanObservable()
+        combined.combine(a, b)
+        expect(combined.value).toBe(true)
+    })
+
+    it('initializes to false when any combined observable is false', () => {
+        const a = new BooleanObservable(true)
+        const b = new BooleanObservable(false)
+        const combined = new BooleanObservable()
+        combined.combine(a, b)
+        expect(combined.value).toBe(false)
+    })
+
+    it('updates to false when a combined observable becomes false', () => {
+        const a = new BooleanObservable(true)
+        const b = new BooleanObservable(true)
+        const combined = new BooleanObservable()
+        combined.combine(a, b)
+        b.value = false
+        expect(combined.value).toBe(false)
+    })
+
+    it('updates to true when all combined observables become true', () => {
+        const a = new BooleanObservable(true)
+        const b = new BooleanObservable(false)
+        const combined = new BooleanObservable()
+        combined.combine(a, b)
+        b.value = true
+        expect(combined.value).toBe(true)
+    })
+
+    it('throws when attempting to combine with itself', () => {
+        const obs = new BooleanObservable(true)
+        expect(() => obs.combine(obs)).toThrow('Cannot combine with itself')
+    })
+
+    it('does not stack overflow or throw when combined observables change (circular guard)', () => {
+        const a = new BooleanObservable(true)
+        const b = new BooleanObservable(true)
+        const combined = new BooleanObservable()
+        combined.combine(a, b)
+        expect(() => { a.value = false }).not.toThrow()
+        expect(combined.value).toBe(false)
+    })
+})

package/src/lib/observable.ts

@@ -40,24 +40,25 @@ export class Observable<T> {
             }
 
             this._isSetting = true;
-            this._value = candidate;
-            if (!this._paused) this._onChange.slice().forEach(cb => cb(this._value));
-
-            // Apply afterChange transformations (bounded)
-            let transformed = this._afterChange?.(prev, this._value);
-            while (transformed !== undefined && !this._equals(this._value, transformed)) {
-                afterDepth++;
-                if (afterDepth > Observable.MAX_AFTER_CHANGE_DEPTH) {
-                    this._isSetting = false;
-                    this._pendingValue = undefined;
-                    throw new Error(`Observable: _afterChange exceeded depth ${Observable.MAX_AFTER_CHANGE_DEPTH}. Possible loop.`);
-                }
-                this._value = transformed;
+            try {
+                this._value = candidate;
                 if (!this._paused) this._onChange.slice().forEach(cb => cb(this._value));
-                transformed = this._afterChange?.(prev, this._value);
-            }
 
-            this._isSetting = false;
+                // Apply afterChange transformations (bounded)
+                let transformed = this._afterChange?.(prev, this._value);
+                while (transformed !== undefined && !this._equals(this._value, transformed)) {
+                    afterDepth++;
+                    if (afterDepth > Observable.MAX_AFTER_CHANGE_DEPTH) {
+                        this._pendingValue = undefined;
+                        throw new Error(`Observable: _afterChange exceeded depth ${Observable.MAX_AFTER_CHANGE_DEPTH}. Possible loop.`);
+                    }
+                    this._value = transformed;
+                    if (!this._paused) this._onChange.slice().forEach(cb => cb(this._value));
+                    transformed = this._afterChange?.(prev, this._value);
+                }
+            } finally {
+                this._isSetting = false;
+            }
 
             // If a listener requested a new value during this cycle, process it
             if (this._pendingValue !== undefined && !this._equals(this._value, this._pendingValue)) {
@@ -99,8 +100,13 @@ export class Observable<T> {
 
     pause(callback?: () => void): void {
         this._paused = true;
-        callback?.();
-        this.resume();
+        if (callback !== undefined) {
+            try {
+                callback();
+            } finally {
+                this.resume();
+            }
+        }
     }
     resume(): void { this._paused = false; }