@fable-org/fable-library-js 2.0.0-rc.5 → 2.0.0-rc.6

package/Array.js

@@ -3,8 +3,9 @@ import { Helpers_allocateArrayFromCons } from "./Native.js";
 import { setItem as setItem_1, item as item_2 } from "./Array.js";
 import { value as value_2, map as map_1, defaultArg, some } from "./Option.js";
 import { min as min_1, max as max_1 } from "./Double.js";
-import { SR_indexOutOfBounds } from "./Global.js";
+import { SR_notEnoughElements, SR_inputMustBeNonNegative, SR_inputSequenceEmpty, SR_Arg_ArgumentOutOfRangeException, SR_indexOutOfBounds } from "./Global.js";
 import { Operators_IsNull } from "./FSharp.Core.js";
+import { nonSeeded } from "./Random.js";
 function indexNotFound() {
     throw new Exception("An index satisfying the predicate was not found in the collection.");
 }
@@ -1173,6 +1174,105 @@ export function insertManyAt(index, ys, xs, cons) {
     }
     return target;
 }
+export function randomShuffleInPlaceBy(randomizer, xs) {
+    const len = xs.length | 0;
+    for (let i = len - 1; i >= 1; i--) {
+        const r = randomizer();
+        if ((r < 0) ? true : (r >= 1)) {
+            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        }
+        const j = ~~(r * (i + 1)) | 0;
+        const tmp = item_2(i, xs);
+        setItem_1(xs, i, item_2(j, xs));
+        setItem_1(xs, j, tmp);
+    }
+}
+export function randomShuffleInPlaceWith(random, xs) {
+    randomShuffleInPlaceBy(() => random.NextDouble(), xs);
+}
+export function randomShuffleInPlace(xs) {
+    randomShuffleInPlaceWith(nonSeeded(), xs);
+}
+export function randomShuffleBy(randomizer, xs) {
+    const arr = copy(xs);
+    randomShuffleInPlaceBy(randomizer, arr);
+    return arr;
+}
+export function randomShuffleWith(random, xs) {
+    return randomShuffleBy(() => random.NextDouble(), xs);
+}
+export function randomShuffle(xs) {
+    return randomShuffleWith(nonSeeded(), xs);
+}
+export function randomChoiceBy(randomizer, xs) {
+    if (isEmpty(xs)) {
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    const len = xs.length | 0;
+    const r = randomizer();
+    if ((r < 0) ? true : (r >= 1)) {
+        throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+    }
+    return item_2(~~(r * len), xs);
+}
+export function randomChoiceWith(random, xs) {
+    return randomChoiceBy(() => random.NextDouble(), xs);
+}
+export function randomChoice(xs) {
+    return randomChoiceWith(nonSeeded(), xs);
+}
+export function randomChoicesBy(randomizer, count, xs, cons) {
+    if (count < 0) {
+        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+    }
+    if ((count > 0) && isEmpty(xs)) {
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    const len = xs.length | 0;
+    return initialize(count, (_arg) => {
+        const r = randomizer();
+        if ((r < 0) ? true : (r >= 1)) {
+            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        }
+        return item_2(~~(r * len), xs);
+    }, cons);
+}
+export function randomChoicesWith(random, count, xs, cons) {
+    return randomChoicesBy(() => random.NextDouble(), count, xs, cons);
+}
+export function randomChoices(count, xs, cons) {
+    return randomChoicesWith(nonSeeded(), count, xs, cons);
+}
+export function randomSampleBy(randomizer, count, xs) {
+    if (count < 0) {
+        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+    }
+    const arr = copy(xs);
+    const len = arr.length | 0;
+    if ((len === 0) && (count > 0)) {
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    if (count > len) {
+        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "count");
+    }
+    for (let i = 0; i <= (count - 1); i++) {
+        const r = randomizer();
+        if ((r < 0) ? true : (r >= 1)) {
+            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        }
+        const j = (i + ~~(r * (len - i))) | 0;
+        const tmp = item_2(i, arr);
+        setItem_1(arr, i, item_2(j, arr));
+        setItem_1(arr, j, tmp);
+    }
+    return getSubArray(arr, 0, count);
+}
+export function randomSampleWith(random, count, xs) {
+    return randomSampleBy(() => random.NextDouble(), count, xs);
+}
+export function randomSample(count, xs) {
+    return randomSampleWith(nonSeeded(), count, xs);
+}
 export function removeAt(index, xs) {
     if ((index < 0) ? true : (index >= xs.length)) {
         throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");

package/Async.js

@@ -48,28 +48,19 @@ export function throwIfCancellationRequested(token) {
         throw new Exception("Operation is cancelled");
     }
 }
-function throwAfter(millisecondsDueTime) {
-    return protectedCont((ctx) => {
-        let tokenId;
-        const timeoutId = setTimeout(() => {
-            ctx.cancelToken.removeListener(tokenId);
-            ctx.onError(TimeoutException_$ctor());
-        }, millisecondsDueTime);
-        tokenId = ctx.cancelToken.addListener(() => {
-            clearTimeout(timeoutId);
-            ctx.onCancel(new OperationCanceledException());
-        });
-    });
-}
 export function startChild(computation, ms) {
+    const promise = startAsPromise(computation);
+    let promiseToRun = promise;
     if (ms) {
-        const computationWithTimeout = protectedBind(parallel2(computation, throwAfter(ms)), xs => protectedReturn(xs[0]));
-        return startChild(computationWithTimeout);
+        // Race the computation against a timeout: whichever settles first wins.
+        promiseToRun = new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => reject(TimeoutException_$ctor()), ms);
+            promise.then(value => { clearTimeout(timeoutId); resolve(value); }, error => { clearTimeout(timeoutId); reject(error); });
+        });
     }
-    const promise = startAsPromise(computation);
     // JS Promises are hot, computation has already started
     // but we delay returning the result
-    return protectedCont((ctx) => protectedReturn(awaitPromise(promise))(ctx));
+    return protectedCont((ctx) => protectedReturn(awaitPromise(promiseToRun))(ctx));
 }
 export function awaitPromise(p) {
     return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledException
@@ -99,9 +90,6 @@ export function ignore(computation) {
 export function parallel(computations) {
     return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
 }
-function parallel2(a, b) {
-    return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));
-}
 export function sequential(computations) {
     function _sequential(computations) {
         let pr = Promise.resolve([]);

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 2.0.0-rc.6 - 2026-04-07
+
+### Fixed
+
+* [JS/TS] Fix `Async.StartChild` with timeout always timing out even when the computation finishes before the deadline (fixes #4481) (by @MangelMaxime)
+
 ## 2.0.0-rc.5 - 2026-03-31
 
 ### Fixed

package/Guid.js

@@ -56,15 +56,33 @@ export function tryParse(str, defValue) {
         return false;
     }
 }
-// From https://gist.github.com/LeverOne/1308368
 export function newGuid() {
-    let b = "";
-    for (let a = 0; a++ < 36;) {
-        b += a * 51 & 52
-            ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)
-            : "-";
-    }
-    return b;
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 1
+    const hex = Array.from(bytes, b => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+// RFC 9562 UUID v7
+export function createVersion7(timestamp) {
+    const ms = timestamp != null ? timestamp.getTime() : Date.now();
+    // 48-bit timestamp as hex
+    const msHex = Math.floor(ms).toString(16).padStart(12, "0");
+    // random bits
+    const bytes = new Uint8Array(10);
+    crypto.getRandomValues(bytes);
+    const view = new DataView(bytes.buffer);
+    const randA = view.getUint16(0) & 0x0fff; // 12 bits
+    const randB1 = view.getUint16(2) & 0x3fff; // 14 bits
+    const randB2 = view.getUint32(4); // 32 bits
+    const randB3 = view.getUint16(8); // 16 bits
+    const timeLow = msHex.slice(0, 8);
+    const timeMid = msHex.slice(8, 12);
+    const ver = (0x7000 | randA).toString(16).padStart(4, "0");
+    const variantAndRandB = (0x8000 | randB1).toString(16).padStart(4, "0");
+    const node = randB2.toString(16).padStart(8, "0") + randB3.toString(16).padStart(4, "0");
+    return `${timeLow}-${timeMid}-${ver}-${variantAndRandB}-${node}`;
 }
 // Maps for number <-> hex string conversion
 let _convertMapsInitialized = false;

package/List.js

@@ -5,7 +5,8 @@ import { Record } from "./Types.js";
 import { class_type, record_type, option_type } from "./Reflection.js";
 import { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from "./Global.js";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.js";
-import { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, item as item_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, setItem, fill } from "./Array.js";
+import { randomSampleBy as randomSampleBy_1, randomChoicesBy as randomChoicesBy_1, randomChoiceBy as randomChoiceBy_1, randomShuffleInPlaceBy, transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, item as item_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, setItem, fill } from "./Array.js";
+import { nonSeeded } from "./Random.js";
 export class FSharpList extends Record {
     constructor(head, tail) {
         super();
@@ -1282,3 +1283,41 @@ export function updateAt(index, y, xs) {
     }
     return ys;
 }
+export function randomShuffleBy(randomizer, xs) {
+    const arr = toArray(xs);
+    randomShuffleInPlaceBy(randomizer, arr);
+    return ofArray(arr);
+}
+export function randomShuffleWith(random, xs) {
+    return randomShuffleBy(() => random.NextDouble(), xs);
+}
+export function randomShuffle(xs) {
+    return randomShuffleWith(nonSeeded(), xs);
+}
+export function randomChoiceBy(randomizer, xs) {
+    return randomChoiceBy_1(randomizer, toArray(xs));
+}
+export function randomChoiceWith(random, xs) {
+    return randomChoiceBy(() => random.NextDouble(), xs);
+}
+export function randomChoice(xs) {
+    return randomChoiceWith(nonSeeded(), xs);
+}
+export function randomChoicesBy(randomizer, count, xs) {
+    return ofArray(randomChoicesBy_1(randomizer, count, toArray(xs)));
+}
+export function randomChoicesWith(random, count, xs) {
+    return randomChoicesBy(() => random.NextDouble(), count, xs);
+}
+export function randomChoices(count, xs) {
+    return randomChoicesWith(nonSeeded(), count, xs);
+}
+export function randomSampleBy(randomizer, count, xs) {
+    return ofArray(randomSampleBy_1(randomizer, count, toArray(xs)));
+}
+export function randomSampleWith(random, count, xs) {
+    return randomSampleBy(() => random.NextDouble(), count, xs);
+}
+export function randomSample(count, xs) {
+    return randomSampleWith(nonSeeded(), count, xs);
+}

package/Seq.js

@@ -5,9 +5,10 @@ import { class_type } from "./Reflection.js";
 import { some, value as value_1 } from "./Option.js";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.js";
 import { Operators_Lock, Operators_NullArgCheck } from "./FSharp.Core.js";
-import { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, item as item_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.js";
+import { randomSampleBy as randomSampleBy_1, randomChoicesBy as randomChoicesBy_1, randomChoice as randomChoice_1, randomChoiceWith as randomChoiceWith_1, randomChoiceBy as randomChoiceBy_1, randomShuffleInPlaceBy, chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, item as item_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.js";
 import { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from "./List.js";
 import { SR_indexOutOfBounds } from "./Global.js";
+import { nonSeeded } from "./Random.js";
 export const SR_enumerationAlreadyFinished = "Enumeration already finished.";
 export const SR_enumerationNotStarted = "Enumeration has not started. Call MoveNext.";
 export const SR_inputSequenceEmpty = "The input sequence was empty.";
@@ -1368,3 +1369,41 @@ export function updateAt(index, y, xs) {
         disposeSafe(e_1);
     });
 }
+export function randomShuffleBy(randomizer, xs) {
+    const arr = toArray(xs);
+    randomShuffleInPlaceBy(randomizer, arr);
+    return ofArray(arr);
+}
+export function randomShuffleWith(random, xs) {
+    return randomShuffleBy(() => random.NextDouble(), xs);
+}
+export function randomShuffle(xs) {
+    return randomShuffleWith(nonSeeded(), xs);
+}
+export function randomChoiceBy(randomizer, xs) {
+    return randomChoiceBy_1(randomizer, toArray(xs));
+}
+export function randomChoiceWith(random, xs) {
+    return randomChoiceWith_1(random, toArray(xs));
+}
+export function randomChoice(xs) {
+    return randomChoice_1(toArray(xs));
+}
+export function randomChoicesBy(randomizer, count, xs) {
+    return ofArray(randomChoicesBy_1(randomizer, count, toArray(xs)));
+}
+export function randomChoicesWith(random, count, xs) {
+    return randomChoicesBy(() => random.NextDouble(), count, xs);
+}
+export function randomChoices(count, xs) {
+    return randomChoicesWith(nonSeeded(), count, xs);
+}
+export function randomSampleBy(randomizer, count, xs) {
+    return ofArray(randomSampleBy_1(randomizer, count, toArray(xs)));
+}
+export function randomSampleWith(random, count, xs) {
+    return randomSampleBy(() => random.NextDouble(), count, xs);
+}
+export function randomSample(count, xs) {
+    return randomSampleWith(nonSeeded(), count, xs);
+}

package/package.json

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

package/quotation.js

@@ -0,0 +1,618 @@
+/**
+ * F# Quotation runtime support for Fable JS/TS target.
+ *
+ * Provides class-based representations of F# quotation AST nodes
+ * and pattern matching helpers compatible with Fable's option convention
+ * (undefined = no match, value/tuple = match).
+ */
+// ===================================================================
+// Var: represents an F# quotation variable
+// ===================================================================
+export class Var {
+    constructor(name, type_, isMutable) {
+        this.Name = name;
+        this.Type = type_;
+        this.IsMutable = isMutable;
+    }
+}
+export function mkQuotVar(name, type_, isMutable = false) {
+    return new Var(name, type_, isMutable);
+}
+export function varGetName(v) { return v.Name; }
+export function varGetType(v) { return v.Type; }
+export function varGetIsMutable(v) { return v.IsMutable; }
+// ===================================================================
+// Expr nodes: tagged classes for each quotation expression kind
+// ===================================================================
+export class ExprValue {
+    constructor(value, type) {
+        this.tag = "Value";
+        this.value = value;
+        this.type = type;
+    }
+    toJSON() { return ["Value", this.value, this.type]; }
+}
+export class ExprVarExpr {
+    constructor(var_) {
+        this.tag = "Var";
+        this.var_ = var_;
+    }
+    toJSON() { return ["Var", this.var_]; }
+}
+export class ExprLambda {
+    constructor(var_, body) {
+        this.tag = "Lambda";
+        this.var_ = var_;
+        this.body = body;
+    }
+    toJSON() { return ["Lambda", this.var_, this.body]; }
+}
+export class ExprApplication {
+    constructor(func, arg) {
+        this.tag = "Application";
+        this.func = func;
+        this.arg = arg;
+    }
+    toJSON() { return ["Application", this.func, this.arg]; }
+}
+export class ExprLet {
+    constructor(var_, value, body) {
+        this.tag = "Let";
+        this.var_ = var_;
+        this.value = value;
+        this.body = body;
+    }
+    toJSON() { return ["Let", this.var_, this.value, this.body]; }
+}
+export class ExprIfThenElse {
+    constructor(guard, thenExpr, elseExpr) {
+        this.tag = "IfThenElse";
+        this.guard = guard;
+        this.thenExpr = thenExpr;
+        this.elseExpr = elseExpr;
+    }
+    toJSON() { return ["IfThenElse", this.guard, this.thenExpr, this.elseExpr]; }
+}
+export class ExprCall {
+    constructor(instance, method, args) {
+        this.tag = "Call";
+        this.instance = instance;
+        this.method = method;
+        this.args = args;
+    }
+    toJSON() { return ["Call", this.instance, this.method, this.args]; }
+}
+export class ExprSequential {
+    constructor(first, second) {
+        this.tag = "Sequential";
+        this.first = first;
+        this.second = second;
+    }
+    toJSON() { return ["Sequential", this.first, this.second]; }
+}
+export class ExprNewTuple {
+    constructor(elements) {
+        this.tag = "NewTuple";
+        this.elements = elements;
+    }
+    toJSON() { return ["NewTuple", this.elements]; }
+}
+export class ExprNewUnion {
+    constructor(typeName, unionTag, fields) {
+        this.tag = "NewUnion";
+        this.typeName = typeName;
+        this.unionTag = unionTag;
+        this.fields = fields;
+    }
+    toJSON() { return ["NewUnion", this.typeName, this.unionTag, this.fields]; }
+}
+export class ExprNewRecord {
+    constructor(fieldNames, values) {
+        this.tag = "NewRecord";
+        this.fieldNames = fieldNames;
+        this.values = values;
+    }
+    toJSON() { return ["NewRecord", this.fieldNames, this.values]; }
+}
+export class ExprNewList {
+    constructor(head, tail) {
+        this.tag = "NewList";
+        this.head = head;
+        this.tail = tail;
+    }
+    toJSON() { return ["NewList", this.head, this.tail]; }
+}
+export class ExprTupleGet {
+    constructor(expr, index) {
+        this.tag = "TupleGet";
+        this.expr = expr;
+        this.index = index;
+    }
+    toJSON() { return ["TupleGet", this.expr, this.index]; }
+}
+export class ExprUnionTag {
+    constructor(expr) {
+        this.tag = "UnionTag";
+        this.expr = expr;
+    }
+    toJSON() { return ["UnionTag", this.expr]; }
+}
+export class ExprUnionField {
+    constructor(expr, fieldIndex) {
+        this.tag = "UnionField";
+        this.expr = expr;
+        this.fieldIndex = fieldIndex;
+    }
+    toJSON() { return ["UnionField", this.expr, this.fieldIndex]; }
+}
+export class ExprFieldGet {
+    constructor(expr, fieldName) {
+        this.tag = "FieldGet";
+        this.expr = expr;
+        this.fieldName = fieldName;
+    }
+    toJSON() { return ["FieldGet", this.expr, this.fieldName]; }
+}
+export class ExprFieldSet {
+    constructor(expr, fieldName, value) {
+        this.tag = "FieldSet";
+        this.expr = expr;
+        this.fieldName = fieldName;
+        this.value = value;
+    }
+    toJSON() { return ["FieldSet", this.expr, this.fieldName, this.value]; }
+}
+export class ExprVarSet {
+    constructor(target, value) {
+        this.tag = "VarSet";
+        this.target = target;
+        this.value = value;
+    }
+    toJSON() { return ["VarSet", this.target, this.value]; }
+}
+// ===================================================================
+// Constructors (called by QuotationEmitter.fs)
+// ===================================================================
+export function mkValue(value, type) {
+    return new ExprValue(value, type);
+}
+export function mkVar(v) {
+    return new ExprVarExpr(v);
+}
+export function mkLambda(v, body) {
+    return new ExprLambda(v, body);
+}
+export function mkApplication(func, arg) {
+    return new ExprApplication(func, arg);
+}
+export function mkLet(v, value, body) {
+    return new ExprLet(v, value, body);
+}
+export function mkIfThenElse(guard, thenExpr, elseExpr) {
+    return new ExprIfThenElse(guard, thenExpr, elseExpr);
+}
+export function mkCall(instance, method, args) {
+    return new ExprCall(instance, method, args);
+}
+export function mkSequential(first, second) {
+    return new ExprSequential(first, second);
+}
+export function mkNewTuple(elements) {
+    return new ExprNewTuple(elements);
+}
+export function mkTupleGet(expr, index) {
+    return new ExprTupleGet(expr, index);
+}
+export function mkUnionTag(expr) {
+    return new ExprUnionTag(expr);
+}
+export function mkUnionField(expr, fieldIndex) {
+    return new ExprUnionField(expr, fieldIndex);
+}
+export function mkFieldGet(expr, fieldName) {
+    return new ExprFieldGet(expr, fieldName);
+}
+export function mkFieldSet(expr, fieldName, value) {
+    return new ExprFieldSet(expr, fieldName, value);
+}
+export function mkVarSet(target, value) {
+    return new ExprVarSet(target, value);
+}
+export function mkNewUnion(typeName, tag, fields) {
+    return new ExprNewUnion(typeName, tag, fields);
+}
+export function mkNewRecord(fieldNames, values) {
+    return new ExprNewRecord(fieldNames, values);
+}
+export function mkNewList(head, tail) {
+    return new ExprNewList(head, tail);
+}
+// ===================================================================
+// Accessors
+// ===================================================================
+export function getType(expr) {
+    if (expr instanceof ExprValue)
+        return expr.type;
+    if (expr instanceof ExprLambda)
+        return expr.var_.Type;
+    return "obj";
+}
+// ===================================================================
+// Pattern match helpers
+// Returns undefined (no match) or a value/tuple (match), following
+// Fable's option convention for active patterns.
+// ===================================================================
+export function isValue(expr) {
+    if (expr instanceof ExprValue)
+        return [expr.value, expr.type];
+    return undefined;
+}
+export function isVar(expr) {
+    if (expr instanceof ExprVarExpr)
+        return expr.var_;
+    return undefined;
+}
+export function isLambda(expr) {
+    if (expr instanceof ExprLambda)
+        return [expr.var_, expr.body];
+    return undefined;
+}
+export function isApplication(expr) {
+    if (expr instanceof ExprApplication)
+        return [expr.func, expr.arg];
+    return undefined;
+}
+export function isLet(expr) {
+    if (expr instanceof ExprLet)
+        return [expr.var_, expr.value, expr.body];
+    return undefined;
+}
+export function isIfThenElse(expr) {
+    if (expr instanceof ExprIfThenElse)
+        return [expr.guard, expr.thenExpr, expr.elseExpr];
+    return undefined;
+}
+export function isCall(expr) {
+    if (expr instanceof ExprCall)
+        return [expr.instance, expr.method, expr.args];
+    return undefined;
+}
+export function isSequential(expr) {
+    if (expr instanceof ExprSequential)
+        return [expr.first, expr.second];
+    return undefined;
+}
+export function isNewTuple(expr) {
+    if (expr instanceof ExprNewTuple)
+        return expr.elements;
+    return undefined;
+}
+export function isNewUnionCase(expr) {
+    if (expr instanceof ExprNewUnion)
+        return [expr.typeName, expr.fields];
+    return undefined;
+}
+export function isNewRecord(expr) {
+    if (expr instanceof ExprNewRecord)
+        return [expr.fieldNames, expr.values];
+    return undefined;
+}
+export function isTupleGet(expr) {
+    if (expr instanceof ExprTupleGet)
+        return [expr.expr, expr.index];
+    return undefined;
+}
+export function isFieldGet(expr) {
+    if (expr instanceof ExprFieldGet)
+        return [expr.expr, expr.fieldName];
+    return undefined;
+}
+// ===================================================================
+// Evaluation
+// ===================================================================
+const OPERATORS = {
+    "op_Addition": (a, b) => a + b,
+    "op_Subtraction": (a, b) => a - b,
+    "op_Multiply": (a, b) => a * b,
+    "op_Division": (a, b) => a / b,
+    "op_Modulus": (a, b) => a % b,
+    "op_Exponentiation": (a, b) => a ** b,
+    "op_UnaryNegation": (a) => -a,
+    "op_UnaryPlus": (a) => +a,
+    "op_LogicalNot": (a) => !a,
+    "op_BitwiseOr": (a, b) => a | b,
+    "op_BitwiseAnd": (a, b) => a & b,
+    "op_ExclusiveOr": (a, b) => a ^ b,
+    "op_LeftShift": (a, b) => a << b,
+    "op_RightShift": (a, b) => a >> b,
+    "op_Equality": (a, b) => a === b,
+    "op_Inequality": (a, b) => a !== b,
+    "op_LessThan": (a, b) => a < b,
+    "op_LessThanOrEqual": (a, b) => a <= b,
+    "op_GreaterThan": (a, b) => a > b,
+    "op_GreaterThanOrEqual": (a, b) => a >= b,
+    "op_BooleanAnd": (a, b) => a && b,
+    "op_BooleanOr": (a, b) => a || b,
+};
+export function evaluate(expr, env) {
+    if (env == null)
+        env = new Map();
+    if (expr instanceof ExprValue)
+        return expr.value;
+    if (expr instanceof ExprVarExpr) {
+        if (env.has(expr.var_.Name))
+            return env.get(expr.var_.Name);
+        throw new Error(`Unbound variable: ${expr.var_.Name}`);
+    }
+    if (expr instanceof ExprLambda) {
+        const capturedEnv = new Map(env);
+        return (arg) => {
+            const newEnv = new Map(capturedEnv);
+            newEnv.set(expr.var_.Name, arg);
+            return evaluate(expr.body, newEnv);
+        };
+    }
+    if (expr instanceof ExprApplication) {
+        return evaluate(expr.func, env)(evaluate(expr.arg, env));
+    }
+    if (expr instanceof ExprLet) {
+        const newEnv = new Map(env);
+        newEnv.set(expr.var_.Name, evaluate(expr.value, env));
+        return evaluate(expr.body, newEnv);
+    }
+    if (expr instanceof ExprIfThenElse) {
+        return evaluate(expr.guard, env) ? evaluate(expr.thenExpr, env) : evaluate(expr.elseExpr, env);
+    }
+    if (expr instanceof ExprSequential) {
+        evaluate(expr.first, env);
+        return evaluate(expr.second, env);
+    }
+    if (expr instanceof ExprNewTuple) {
+        return expr.elements.map(e => evaluate(e, env));
+    }
+    if (expr instanceof ExprCall) {
+        const evaluatedArgs = expr.args.map((a) => evaluate(a, env));
+        if (expr.method in OPERATORS)
+            return OPERATORS[expr.method](...evaluatedArgs);
+        throw new Error(`Unknown method: ${expr.method}`);
+    }
+    if (expr instanceof ExprTupleGet) {
+        return evaluate(expr.expr, env)[expr.index];
+    }
+    if (expr instanceof ExprNewUnion) {
+        return [expr.unionTag, ...expr.fields.map((f) => evaluate(f, env))];
+    }
+    if (expr instanceof ExprNewRecord) {
+        const result = {};
+        for (let i = 0; i < expr.fieldNames.length; i++) {
+            result[expr.fieldNames[i]] = evaluate(expr.values[i], env);
+        }
+        return result;
+    }
+    if (expr instanceof ExprNewList) {
+        return [evaluate(expr.head, env), ...evaluate(expr.tail, env)];
+    }
+    if (expr instanceof ExprVarSet) {
+        if (expr.target instanceof ExprVarExpr) {
+            env.set(expr.target.var_.Name, evaluate(expr.value, env));
+            return undefined;
+        }
+        throw new Error("VarSet target must be a variable");
+    }
+    if (expr instanceof ExprFieldGet) {
+        const obj = evaluate(expr.expr, env);
+        return obj[expr.fieldName];
+    }
+    throw new Error(`Cannot evaluate expression: ${expr.tag}`);
+}
+// ===================================================================
+// FSharpExpr instance methods
+// ===================================================================
+const OP_SYMBOLS = {
+    "op_Addition": "+",
+    "op_Subtraction": "-",
+    "op_Multiply": "*",
+    "op_Division": "/",
+    "op_Modulus": "%",
+    "op_Exponentiation": "**",
+    "op_Equality": "=",
+    "op_Inequality": "<>",
+    "op_LessThan": "<",
+    "op_LessThanOrEqual": "<=",
+    "op_GreaterThan": ">",
+    "op_GreaterThanOrEqual": ">=",
+    "op_BooleanAnd": "&&",
+    "op_BooleanOr": "||",
+    "op_UnaryNegation": "-",
+    "op_LogicalNot": "not",
+};
+export function exprToString(expr) {
+    if (expr instanceof ExprValue) {
+        if (expr.type === "string")
+            return `"${expr.value}"`;
+        if (expr.type === "unit")
+            return "()";
+        if (expr.type === "bool")
+            return expr.value ? "true" : "false";
+        return String(expr.value);
+    }
+    if (expr instanceof ExprVarExpr)
+        return expr.var_.Name;
+    if (expr instanceof ExprLambda)
+        return `fun ${expr.var_.Name} -> ${exprToString(expr.body)}`;
+    if (expr instanceof ExprApplication)
+        return `${exprToString(expr.func)} ${exprToString(expr.arg)}`;
+    if (expr instanceof ExprLet)
+        return `let ${expr.var_.Name} = ${exprToString(expr.value)} in ${exprToString(expr.body)}`;
+    if (expr instanceof ExprIfThenElse)
+        return `if ${exprToString(expr.guard)} then ${exprToString(expr.thenExpr)} else ${exprToString(expr.elseExpr)}`;
+    if (expr instanceof ExprCall) {
+        if (expr.method in OP_SYMBOLS && expr.args.length === 2) {
+            return `(${exprToString(expr.args[0])} ${OP_SYMBOLS[expr.method]} ${exprToString(expr.args[1])})`;
+        }
+        if (expr.method in OP_SYMBOLS && expr.args.length === 1) {
+            return `${OP_SYMBOLS[expr.method]}${exprToString(expr.args[0])}`;
+        }
+        return `${expr.method}(${expr.args.map(exprToString).join(", ")})`;
+    }
+    if (expr instanceof ExprSequential)
+        return `${exprToString(expr.first)}; ${exprToString(expr.second)}`;
+    if (expr instanceof ExprNewTuple)
+        return `(${expr.elements.map(exprToString).join(", ")})`;
+    if (expr instanceof ExprTupleGet)
+        return `Item${expr.index + 1}(${exprToString(expr.expr)})`;
+    if (expr instanceof ExprFieldGet)
+        return `${exprToString(expr.expr)}.${expr.fieldName}`;
+    return `<${expr.tag}>`;
+}
+export function getFreeVars(expr) {
+    const free = [];
+    const seen = new Set();
+    function walk(e, bound) {
+        if (e instanceof ExprVarExpr) {
+            if (!bound.has(e.var_.Name) && !seen.has(e.var_.Name)) {
+                free.push(e.var_);
+                seen.add(e.var_.Name);
+            }
+        }
+        else if (e instanceof ExprLambda) {
+            walk(e.body, new Set([...bound, e.var_.Name]));
+        }
+        else if (e instanceof ExprLet) {
+            walk(e.value, bound);
+            walk(e.body, new Set([...bound, e.var_.Name]));
+        }
+        else if (e instanceof ExprApplication) {
+            walk(e.func, bound);
+            walk(e.arg, bound);
+        }
+        else if (e instanceof ExprIfThenElse) {
+            walk(e.guard, bound);
+            walk(e.thenExpr, bound);
+            walk(e.elseExpr, bound);
+        }
+        else if (e instanceof ExprCall) {
+            for (const a of e.args)
+                walk(a, bound);
+        }
+        else if (e instanceof ExprSequential) {
+            walk(e.first, bound);
+            walk(e.second, bound);
+        }
+        else if (e instanceof ExprNewTuple) {
+            for (const el of e.elements)
+                walk(el, bound);
+        }
+        else if (e instanceof ExprTupleGet) {
+            walk(e.expr, bound);
+        }
+        else if (e instanceof ExprNewUnion) {
+            for (const f of e.fields)
+                walk(f, bound);
+        }
+        else if (e instanceof ExprNewRecord) {
+            for (const v of e.values)
+                walk(v, bound);
+        }
+        else if (e instanceof ExprNewList) {
+            walk(e.head, bound);
+            walk(e.tail, bound);
+        }
+        else if (e instanceof ExprUnionTag) {
+            walk(e.expr, bound);
+        }
+        else if (e instanceof ExprUnionField) {
+            walk(e.expr, bound);
+        }
+        else if (e instanceof ExprFieldGet) {
+            walk(e.expr, bound);
+        }
+        else if (e instanceof ExprFieldSet) {
+            walk(e.expr, bound);
+            walk(e.value, bound);
+        }
+        else if (e instanceof ExprVarSet) {
+            walk(e.target, bound);
+            walk(e.value, bound);
+        }
+    }
+    walk(expr, new Set());
+    return free;
+}
+export function substitute(expr, fn) {
+    function sub(e) {
+        if (e instanceof ExprVarExpr) {
+            const result = fn(e.var_);
+            return result !== undefined ? result : e;
+        }
+        if (e instanceof ExprLambda)
+            return new ExprLambda(e.var_, sub(e.body));
+        if (e instanceof ExprLet)
+            return new ExprLet(e.var_, sub(e.value), sub(e.body));
+        if (e instanceof ExprApplication)
+            return new ExprApplication(sub(e.func), sub(e.arg));
+        if (e instanceof ExprIfThenElse)
+            return new ExprIfThenElse(sub(e.guard), sub(e.thenExpr), sub(e.elseExpr));
+        if (e instanceof ExprCall) {
+            const newInst = e.instance != null ? sub(e.instance) : e.instance;
+            return new ExprCall(newInst, e.method, e.args.map(sub));
+        }
+        if (e instanceof ExprSequential)
+            return new ExprSequential(sub(e.first), sub(e.second));
+        if (e instanceof ExprNewTuple)
+            return new ExprNewTuple(e.elements.map(sub));
+        if (e instanceof ExprTupleGet)
+            return new ExprTupleGet(sub(e.expr), e.index);
+        if (e instanceof ExprNewUnion)
+            return new ExprNewUnion(e.typeName, e.unionTag, e.fields.map(sub));
+        if (e instanceof ExprNewRecord)
+            return new ExprNewRecord(e.fieldNames, e.values.map(sub));
+        if (e instanceof ExprNewList)
+            return new ExprNewList(sub(e.head), sub(e.tail));
+        if (e instanceof ExprUnionTag)
+            return new ExprUnionTag(sub(e.expr));
+        if (e instanceof ExprUnionField)
+            return new ExprUnionField(sub(e.expr), e.fieldIndex);
+        if (e instanceof ExprFieldGet)
+            return new ExprFieldGet(sub(e.expr), e.fieldName);
+        if (e instanceof ExprFieldSet)
+            return new ExprFieldSet(sub(e.expr), e.fieldName, sub(e.value));
+        if (e instanceof ExprVarSet)
+            return new ExprVarSet(sub(e.target), sub(e.value));
+        return e;
+    }
+    return sub(expr);
+}
+// ===================================================================
+// JSON deserialization
+// Reconstructs Expr/Var from the toJSON() array format.
+// ===================================================================
+function varFromJSON(json) {
+    return new Var(json.Name, json.Type, json.IsMutable);
+}
+export function exprFromJSON(json) {
+    if (!Array.isArray(json))
+        return new ExprValue(json, typeof json);
+    const [tag, ...fields] = json;
+    switch (tag) {
+        case "Value": return new ExprValue(fields[0], fields[1]);
+        case "Var": return new ExprVarExpr(varFromJSON(fields[0]));
+        case "Lambda": return new ExprLambda(varFromJSON(fields[0]), exprFromJSON(fields[1]));
+        case "Application": return new ExprApplication(exprFromJSON(fields[0]), exprFromJSON(fields[1]));
+        case "Let": return new ExprLet(varFromJSON(fields[0]), exprFromJSON(fields[1]), exprFromJSON(fields[2]));
+        case "IfThenElse": return new ExprIfThenElse(exprFromJSON(fields[0]), exprFromJSON(fields[1]), exprFromJSON(fields[2]));
+        case "Call": return new ExprCall(fields[0] != null ? exprFromJSON(fields[0]) : null, fields[1], fields[2].map(exprFromJSON));
+        case "Sequential": return new ExprSequential(exprFromJSON(fields[0]), exprFromJSON(fields[1]));
+        case "NewTuple": return new ExprNewTuple(fields[0].map(exprFromJSON));
+        case "TupleGet": return new ExprTupleGet(exprFromJSON(fields[0]), fields[1]);
+        case "NewUnion": return new ExprNewUnion(fields[0], fields[1], fields[2].map(exprFromJSON));
+        case "UnionTag": return new ExprUnionTag(exprFromJSON(fields[0]));
+        case "UnionField": return new ExprUnionField(exprFromJSON(fields[0]), fields[1]);
+        case "NewRecord": return new ExprNewRecord(fields[0], fields[1].map(exprFromJSON));
+        case "FieldGet": return new ExprFieldGet(exprFromJSON(fields[0]), fields[1]);
+        case "FieldSet": return new ExprFieldSet(exprFromJSON(fields[0]), fields[1], exprFromJSON(fields[2]));
+        case "VarSet": return new ExprVarSet(exprFromJSON(fields[0]), exprFromJSON(fields[1]));
+        case "NewList": return new ExprNewList(exprFromJSON(fields[0]), exprFromJSON(fields[1]));
+        default: return new ExprValue(json, "unknown");
+    }
+}