@fable-org/fable-library-js 2.8.1 → 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
@@ -107,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));

package/AsyncBuilder.js

@@ -174,9 +174,15 @@ 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) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
                     try {
                         compensation();
                     }
@@ -187,6 +193,10 @@ export class AsyncBuilder {
                     ctx.onSuccess(x);
                 },
                 onError: (x) => {
+                    if (settled) {
+                        throw x;
+                    }
+                    settled = true;
                     try {
                         compensation();
                     }
@@ -197,6 +207,10 @@ export class AsyncBuilder {
                     ctx.onError(x);
                 },
                 onCancel: (x) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
                     // decision: cancellation remains terminal when compensation throws, matching .NET Async.TryFinally
                     try {
                         compensation();
@@ -207,7 +221,7 @@ export class AsyncBuilder {
                 cancelToken: ctx.cancelToken,
                 trampoline: ctx.trampoline,
             });
-        });
+        };
     }
     TryWith(computation, catchHandler) {
         return protectedCont((ctx) => {
@@ -232,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: 148f989e1b37b3f6560c3dda615b6a3a8efffcb8
+last_commit_released: e33c57870454fea189a3eb33519f583a5003f8c3
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,19 @@ 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

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

@@ -96,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.1",
+    "version": "2.9.0",
     "description": "Core library used by F# projects compiled with fable.io",
     "author": "Fable Contributors",
     "license": "MIT",