@fable-org/fable-library-js 2.8.0 → 2.8.1

package/Async.js

@@ -86,6 +86,9 @@ export function awaitEvent(event, cancelAction) {
             }
             ctx.onCancel(new OperationCanceledException());
         });
+        if (ctx.cancelToken.isCancelled) {
+            return;
+        }
         event.AddHandler(handler);
     });
 }
@@ -127,15 +130,26 @@ export function sequential(computations) {
 }
 export function sleep(millisecondsDueTime) {
     return protectedCont((ctx) => {
+        let completed = false;
         let tokenId;
-        const timeoutId = setTimeout(() => {
-            ctx.cancelToken.removeListener(tokenId);
-            ctx.onSuccess(void 0);
-        }, millisecondsDueTime);
-        tokenId = ctx.cancelToken.addListener(() => {
+        const settle = (cancelled) => {
+            if (completed) {
+                return;
+            }
+            completed = true;
             clearTimeout(timeoutId);
-            ctx.onCancel(new OperationCanceledException());
-        });
+            if (tokenId !== undefined) {
+                ctx.cancelToken.removeListener(tokenId);
+            }
+            if (cancelled) {
+                ctx.onCancel(new OperationCanceledException());
+            }
+            else {
+                ctx.onSuccess(void 0);
+            }
+        };
+        const timeoutId = setTimeout(() => settle(false), millisecondsDueTime);
+        tokenId = ctx.cancelToken.addListener(() => settle(true));
     });
 }
 export function start(computation, cancellationToken) {

package/AsyncBuilder.js

@@ -1,4 +1,12 @@
 import { Exception, ensureErrorOrException } from "./Util.js";
+// AggregateError requires ES2021; the runtime also supports ES2020 hosts.
+export class CancellationCallbackError extends Exception {
+    constructor(errors) {
+        // invariant: F# InnerException exposes the first failure without discarding the remaining errors
+        super("Cancellation callbacks failed", errors[0]);
+        this.errors = errors;
+    }
+}
 export class CancellationToken {
     constructor(cancelled = false) {
         this._id = 0;
@@ -11,14 +19,35 @@ export class CancellationToken {
     cancel() {
         if (!this._cancelled) {
             this._cancelled = true;
-            for (const [, listener] of this._listeners) {
-                listener();
+            // decision: visit newest registrations first, matching .NET; disposal can skip pending callbacks
+            const pending = Array.from(this._listeners.keys()).reverse();
+            const errors = [];
+            for (const id of pending) {
+                const listener = this._listeners.get(id);
+                this._listeners.delete(id);
+                if (listener) {
+                    try {
+                        listener();
+                    }
+                    catch (error) {
+                        errors.push(error);
+                    }
+                }
+            }
+            if (errors.length > 0) {
+                throw new CancellationCallbackError(errors);
             }
         }
     }
     addListener(f) {
         const id = this._id;
-        this._listeners.set(this._id++, f);
+        this._id++;
+        if (this._cancelled) {
+            f();
+        }
+        else {
+            this._listeners.set(id, f);
+        }
         return id;
     }
     removeListener(id) {
@@ -148,15 +177,31 @@ export class AsyncBuilder {
         return protectedCont((ctx) => {
             computation({
                 onSuccess: (x) => {
-                    compensation();
+                    try {
+                        compensation();
+                    }
+                    catch (error) {
+                        ctx.onError(ensureErrorOrException(error));
+                        return;
+                    }
                     ctx.onSuccess(x);
                 },
                 onError: (x) => {
-                    compensation();
+                    try {
+                        compensation();
+                    }
+                    catch (error) {
+                        ctx.onError(ensureErrorOrException(error));
+                        return;
+                    }
                     ctx.onError(x);
                 },
                 onCancel: (x) => {
-                    compensation();
+                    // decision: cancellation remains terminal when compensation throws, matching .NET Async.TryFinally
+                    try {
+                        compensation();
+                    }
+                    catch { /* Cancellation takes precedence. */ }
                     ctx.onCancel(x);
                 },
                 cancelToken: ctx.cancelToken,

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: 2369fbd24fafe851544c1ed6eb54f0bfc2b75f36
+last_commit_released: 148f989e1b37b3f6560c3dda615b6a3a8efffcb8
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 2.8.1 - 2026-10-12
+
+### 🐞 Bug Fixes
+
+* *(js/ts/python)* Synchronize cancellation registrations (#5036) ([07db576c](https://github.com/fable-compiler/Fable/commit/07db576c4ae16dcef9d1773ac4d6c70b2a223f0a))
+* *(js/ts/python)* Settle cancelled delays and finalizers once (#5038) ([a9802484](https://github.com/fable-compiler/Fable/commit/a9802484c8cdeadd5203123d76f42e375c1c3159))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/2369fbd24fafe851544c1ed6eb54f0bfc2b75f36..148f989e1b37b3f6560c3dda615b6a3a8efffcb8)</small></strong>
+
 ## 2.8.0 - 2026-09-25
 
 ### 🐞 Bug Fixes

package/MailboxProcessor.js

@@ -1,6 +1,7 @@
 import { defaultCancellationToken } from "./Async.js";
 import { fromContinuations } from "./Async.js";
 import { startImmediate } from "./Async.js";
+import { OperationCanceledException, protectedCont } from "./AsyncBuilder.js";
 import { Exception } from "./Util.js";
 class QueueCell {
     constructor(message) {
@@ -55,12 +56,27 @@ export function startInstance($this) {
     startImmediate($this.body($this), $this.cancellationToken);
 }
 export function receive($this) {
-    return fromContinuations((conts) => {
+    return protectedCont((ctx) => {
         if ($this.continuation) {
             throw new Exception("Receive can only be called once!");
         }
-        $this.continuation = conts[0];
-        __processEvents($this);
+        let tokenId;
+        const continuation = (message) => {
+            if (tokenId !== undefined) {
+                ctx.cancelToken.removeListener(tokenId);
+            }
+            ctx.onSuccess(message);
+        };
+        $this.continuation = continuation;
+        tokenId = ctx.cancelToken.addListener(() => {
+            if ($this.continuation === continuation) {
+                delete $this.continuation;
+                ctx.onCancel(new OperationCanceledException());
+            }
+        });
+        if ($this.continuation === continuation) {
+            __processEvents($this);
+        }
     });
 }
 export function post($this, message) {

package/package.json

@@ -3,7 +3,7 @@
     "private": false,
     "type": "module",
     "name": "@fable-org/fable-library-js",
-    "version": "2.8.0",
+    "version": "2.8.1",
     "description": "Core library used by F# projects compiled with fable.io",
     "author": "Fable Contributors",
     "license": "MIT",