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

package/Async.js

@@ -2,7 +2,7 @@ import { OperationCanceledException, Trampoline } from "./AsyncBuilder.js";
 import { CancellationToken } from "./AsyncBuilder.js";
 import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.js";
 import { Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.js";
-import { TimeoutException_$ctor } from "./System.js";
+import { InvalidOperationException_$ctor_Z721C83C5, TimeoutException_$ctor } from "./System.js";
 import { Exception } from "./Util.js";
 function emptyContinuation(_x) {
     // NOP
@@ -86,6 +86,9 @@ export function awaitEvent(event, cancelAction) {
             }
             ctx.onCancel(new OperationCanceledException());
         });
+        if (ctx.cancelToken.isCancelled) {
+            return;
+        }
         event.AddHandler(handler);
     });
 }
@@ -104,8 +107,49 @@ export function catchAsync(work) {
         });
     });
 }
+export function tryCancelled(computation, compensation) {
+    return (ctx) => {
+        // invariant: install the handler without adding a cancellation checkpoint, including for nested handlers
+        computation({
+            ...ctx,
+            onCancel: (error) => {
+                // decision: preserve the original cancellation even when compensation throws, matching .NET
+                try {
+                    compensation(error);
+                }
+                catch { /* Cancellation takes precedence. */ }
+                if (ctx.trampoline.incrementAndCheck()) {
+                    ctx.trampoline.hijack(() => ctx.onCancel(error));
+                }
+                else {
+                    ctx.onCancel(error);
+                }
+            },
+        });
+    };
+}
 export function fromContinuations(f) {
-    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
+    return (ctx) => {
+        let settled = false;
+        const claim = () => {
+            if (settled) {
+                throw InvalidOperationException_$ctor_Z721C83C5("A continuation was invoked more than once");
+            }
+            settled = true;
+        };
+        const success = (x) => { claim(); ctx.onSuccess(x); };
+        const error = (x) => { claim(); ctx.onError(x); };
+        const cancelled = (x) => { claim(); ctx.onCancel(x); };
+        protectedCont(() => f([success, error, cancelled]))({
+            onSuccess: success,
+            onError: (x) => { if (settled) {
+                throw x;
+            } error(x); },
+            onCancel: cancelled,
+            cancelToken: ctx.cancelToken,
+            trampoline: ctx.trampoline,
+        });
+    };
 }
 export function ignore(computation) {
     return protectedBind(computation, (_x) => protectedReturn(void 0));
@@ -127,15 +171,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) {
@@ -145,24 +174,54 @@ export class AsyncBuilder {
         return computation;
     }
     TryFinally(computation, compensation) {
-        return protectedCont((ctx) => {
-            computation({
+        // The cancellation check in protectedCont must see the cleanup continuations
+        return (ctx) => {
+            let settled = false;
+            protectedCont(computation)({
                 onSuccess: (x) => {
-                    compensation();
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    try {
+                        compensation();
+                    }
+                    catch (error) {
+                        ctx.onError(ensureErrorOrException(error));
+                        return;
+                    }
                     ctx.onSuccess(x);
                 },
                 onError: (x) => {
-                    compensation();
+                    if (settled) {
+                        throw x;
+                    }
+                    settled = true;
+                    try {
+                        compensation();
+                    }
+                    catch (error) {
+                        ctx.onError(ensureErrorOrException(error));
+                        return;
+                    }
                     ctx.onError(x);
                 },
                 onCancel: (x) => {
-                    compensation();
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    // decision: cancellation remains terminal when compensation throws, matching .NET Async.TryFinally
+                    try {
+                        compensation();
+                    }
+                    catch { /* Cancellation takes precedence. */ }
                     ctx.onCancel(x);
                 },
                 cancelToken: ctx.cancelToken,
                 trampoline: ctx.trampoline,
             });
-        });
+        };
     }
     TryWith(computation, catchHandler) {
         return protectedCont((ctx) => {
@@ -187,7 +246,8 @@ export class AsyncBuilder {
         });
     }
     Using(resource, binder) {
-        return this.TryFinally(binder(resource), () => resource.Dispose());
+        // Without Delay the binder runs before TryFinally installs Dispose
+        return this.TryFinally(this.Delay(() => binder(resource)), () => resource.Dispose());
     }
     While(guard, computation) {
         if (guard()) {

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: 2369fbd24fafe851544c1ed6eb54f0bfc2b75f36
+last_commit_released: e33c57870454fea189a3eb33519f583a5003f8c3
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,28 @@ 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.9.0 - 2026-10-16
+
+### 🚀 Features
+
+* *(js/ts/python/beam)* Support Async.TryCancelled (#5083) ([1643297d](https://github.com/fable-compiler/Fable/commit/1643297d9297fef536c8d10091d5b0d1fad77af7))
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* Avoid full array copy in Encoding.GetString (#5069) ([e6b72ec7](https://github.com/fable-compiler/Fable/commit/e6b72ec73be454bd3b3233167542a65fc6553c8a))
+* *(js/ts/python)* Preserve cancelled cleanup and generic unit callbacks (#5062) ([5dd6b497](https://github.com/fable-compiler/Fable/commit/5dd6b4979e79c8f7c4632cbfb5254d6cf0d2e8d2))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/148f989e1b37b3f6560c3dda615b6a3a8efffcb8..e33c57870454fea189a3eb33519f583a5003f8c3)</small></strong>
+
+## 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/Encoding.js

@@ -90,6 +90,27 @@ function utf8_decode(bytes) {
     }
     return chars.join("");
 }
+function toUint8Array(bytes, index, count) {
+    if (ArrayBuffer.isView(bytes)) {
+        const buffer = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        if (index != null && count != null) {
+            return buffer.subarray(index, index + count);
+        }
+        else if (index != null) {
+            return buffer.subarray(index);
+        }
+        return buffer;
+    }
+    else {
+        if (index != null && count != null) {
+            return Uint8Array.from(Array.prototype.slice.call(bytes, index, index + count));
+        }
+        else if (index != null) {
+            return Uint8Array.from(Array.prototype.slice.call(bytes, index));
+        }
+        return Uint8Array.from(bytes);
+    }
+}
 class UTF16LE {
     getBytes(str, index, count) {
         str = Array.isArray(str) ? str.join("") : str;
@@ -111,14 +132,7 @@ class UTF16LE {
         }
     }
     getString(bytes, index, count) {
-        const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
-        let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
-        if (index != null && count != null) {
-            buffer = buffer.subarray(index, index + count);
-        }
-        else if (index != null) {
-            buffer = buffer.subarray(index);
-        }
+        const buffer = toUint8Array(bytes, index, count);
         // Allow to compile for Browser environment without @types/node being installed
         // See https://github.com/fable-compiler/Fable/issues/4368
         const g = globalThis;
@@ -157,14 +171,7 @@ class UTF8 {
         }
     }
     getString(bytes, index, count) {
-        const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
-        let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
-        if (index != null && count != null) {
-            buffer = buffer.subarray(index, index + count);
-        }
-        else if (index != null) {
-            buffer = buffer.subarray(index);
-        }
+        const buffer = toUint8Array(bytes, index, count);
         // Allow to compile for Browser environment without @types/node being installed
         // See https://github.com/fable-compiler/Fable/issues/4368
         const g = globalThis;

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) {
@@ -80,6 +96,10 @@ export function postAndAsyncReply($this, buildMessage) {
     }
     const reply = {
         reply: (res) => {
+            // .NET AsyncReplyChannel.Reply ignores a second reply
+            if (replied) {
+                return;
+            }
             result = res;
             replied = true;
             checkCompletion();

package/package.json

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