bun-scikit 0.1.3 → 0.1.5

package/src/native/zigKernels.ts

@@ -88,6 +88,33 @@ type DecisionTreeModelPredictFn = (
   nFeatures: number,
   outLabels: Uint8Array,
 ) => number;
+type RandomForestClassifierModelCreateFn = (
+  nEstimators: number,
+  maxDepth: number,
+  minSamplesSplit: number,
+  minSamplesLeaf: number,
+  maxFeaturesMode: number,
+  maxFeaturesValue: number,
+  bootstrap: number,
+  randomState: number,
+  useRandomState: number,
+  nFeatures: number,
+) => NativeHandle;
+type RandomForestClassifierModelDestroyFn = (handle: NativeHandle) => void;
+type RandomForestClassifierModelFitFn = (
+  handle: NativeHandle,
+  x: Float64Array,
+  y: Uint8Array,
+  nSamples: number,
+  nFeatures: number,
+) => number;
+type RandomForestClassifierModelPredictFn = (
+  handle: NativeHandle,
+  x: Float64Array,
+  nSamples: number,
+  nFeatures: number,
+  outLabels: Uint8Array,
+) => number;
 
 type LogisticTrainEpochFn = (
   x: Float64Array,
@@ -138,6 +165,10 @@ interface ZigKernelLibrary {
     decision_tree_model_destroy?: DecisionTreeModelDestroyFn;
     decision_tree_model_fit?: DecisionTreeModelFitFn;
     decision_tree_model_predict?: DecisionTreeModelPredictFn;
+    random_forest_classifier_model_create?: RandomForestClassifierModelCreateFn;
+    random_forest_classifier_model_destroy?: RandomForestClassifierModelDestroyFn;
+    random_forest_classifier_model_fit?: RandomForestClassifierModelFitFn;
+    random_forest_classifier_model_predict?: RandomForestClassifierModelPredictFn;
     logistic_train_epoch?: LogisticTrainEpochFn;
     logistic_train_epochs?: LogisticTrainEpochsFn;
   };
@@ -162,6 +193,10 @@ export interface ZigKernels {
   decisionTreeModelDestroy: DecisionTreeModelDestroyFn | null;
   decisionTreeModelFit: DecisionTreeModelFitFn | null;
   decisionTreeModelPredict: DecisionTreeModelPredictFn | null;
+  randomForestClassifierModelCreate: RandomForestClassifierModelCreateFn | null;
+  randomForestClassifierModelDestroy: RandomForestClassifierModelDestroyFn | null;
+  randomForestClassifierModelFit: RandomForestClassifierModelFitFn | null;
+  randomForestClassifierModelPredict: RandomForestClassifierModelPredictFn | null;
   logisticTrainEpoch: LogisticTrainEpochFn | null;
   logisticTrainEpochs: LogisticTrainEpochsFn | null;
   abiVersion: number | null;
@@ -243,6 +278,14 @@ interface NodeApiAddon {
   logisticModelFitLbfgs: LogisticModelFitLbfgsFn;
   logisticModelCopyCoefficients: LogisticModelCopyCoefficientsFn;
   logisticModelGetIntercept: LogisticModelGetInterceptFn;
+  decisionTreeModelCreate?: DecisionTreeModelCreateFn;
+  decisionTreeModelDestroy?: DecisionTreeModelDestroyFn;
+  decisionTreeModelFit?: DecisionTreeModelFitFn;
+  decisionTreeModelPredict?: DecisionTreeModelPredictFn;
+  randomForestClassifierModelCreate?: RandomForestClassifierModelCreateFn;
+  randomForestClassifierModelDestroy?: RandomForestClassifierModelDestroyFn;
+  randomForestClassifierModelFit?: RandomForestClassifierModelFitFn;
+  randomForestClassifierModelPredict?: RandomForestClassifierModelPredictFn;
 }
 
 function tryLoadNodeApiKernels(): ZigKernels | null {
@@ -281,10 +324,17 @@ function tryLoadNodeApiKernels(): ZigKernels | null {
           logisticModelPredict: null,
           logisticModelCopyCoefficients: addon.logisticModelCopyCoefficients ?? null,
           logisticModelGetIntercept: addon.logisticModelGetIntercept ?? null,
-          decisionTreeModelCreate: null,
-          decisionTreeModelDestroy: null,
-          decisionTreeModelFit: null,
-          decisionTreeModelPredict: null,
+          decisionTreeModelCreate: addon.decisionTreeModelCreate ?? null,
+          decisionTreeModelDestroy: addon.decisionTreeModelDestroy ?? null,
+          decisionTreeModelFit: addon.decisionTreeModelFit ?? null,
+          decisionTreeModelPredict: addon.decisionTreeModelPredict ?? null,
+          randomForestClassifierModelCreate:
+            addon.randomForestClassifierModelCreate ?? null,
+          randomForestClassifierModelDestroy:
+            addon.randomForestClassifierModelDestroy ?? null,
+          randomForestClassifierModelFit: addon.randomForestClassifierModelFit ?? null,
+          randomForestClassifierModelPredict:
+            addon.randomForestClassifierModelPredict ?? null,
           logisticTrainEpoch: null,
           logisticTrainEpochs: null,
           abiVersion,
@@ -403,6 +453,58 @@ export function getZigKernels(): ZigKernels | null {
             args: ["usize"],
             returns: FFIType.f64,
           },
+          decision_tree_model_create: {
+            args: [
+              "usize",
+              "usize",
+              "usize",
+              FFIType.u8,
+              "usize",
+              FFIType.u32,
+              FFIType.u8,
+              "usize",
+            ],
+            returns: "usize",
+          },
+          decision_tree_model_destroy: {
+            args: ["usize"],
+            returns: FFIType.void,
+          },
+          decision_tree_model_fit: {
+            args: ["usize", FFIType.ptr, FFIType.ptr, "usize", "usize", FFIType.ptr, "usize"],
+            returns: FFIType.u8,
+          },
+          decision_tree_model_predict: {
+            args: ["usize", FFIType.ptr, "usize", "usize", FFIType.ptr],
+            returns: FFIType.u8,
+          },
+          random_forest_classifier_model_create: {
+            args: [
+              "usize",
+              "usize",
+              "usize",
+              "usize",
+              FFIType.u8,
+              "usize",
+              FFIType.u8,
+              FFIType.u32,
+              FFIType.u8,
+              "usize",
+            ],
+            returns: "usize",
+          },
+          random_forest_classifier_model_destroy: {
+            args: ["usize"],
+            returns: FFIType.void,
+          },
+          random_forest_classifier_model_fit: {
+            args: ["usize", FFIType.ptr, FFIType.ptr, "usize", "usize"],
+            returns: FFIType.u8,
+          },
+          random_forest_classifier_model_predict: {
+            args: ["usize", FFIType.ptr, "usize", "usize", FFIType.ptr],
+            returns: FFIType.u8,
+          },
           logistic_train_epoch: {
             args: [
               FFIType.ptr,
@@ -463,6 +565,14 @@ export function getZigKernels(): ZigKernels | null {
           decisionTreeModelDestroy: library.symbols.decision_tree_model_destroy ?? null,
           decisionTreeModelFit: library.symbols.decision_tree_model_fit ?? null,
           decisionTreeModelPredict: library.symbols.decision_tree_model_predict ?? null,
+          randomForestClassifierModelCreate:
+            library.symbols.random_forest_classifier_model_create ?? null,
+          randomForestClassifierModelDestroy:
+            library.symbols.random_forest_classifier_model_destroy ?? null,
+          randomForestClassifierModelFit:
+            library.symbols.random_forest_classifier_model_fit ?? null,
+          randomForestClassifierModelPredict:
+            library.symbols.random_forest_classifier_model_predict ?? null,
           logisticTrainEpoch: library.symbols.logistic_train_epoch ?? null,
           logisticTrainEpochs: library.symbols.logistic_train_epochs ?? null,
           abiVersion,
@@ -526,6 +636,10 @@ export function getZigKernels(): ZigKernels | null {
             decisionTreeModelDestroy: null,
             decisionTreeModelFit: null,
             decisionTreeModelPredict: null,
+            randomForestClassifierModelCreate: null,
+            randomForestClassifierModelDestroy: null,
+            randomForestClassifierModelFit: null,
+            randomForestClassifierModelPredict: null,
             logisticTrainEpoch: library.symbols.logistic_train_epoch ?? null,
             logisticTrainEpochs: library.symbols.logistic_train_epochs ?? null,
             abiVersion: null,
@@ -571,6 +685,10 @@ export function getZigKernels(): ZigKernels | null {
             decisionTreeModelDestroy: null,
             decisionTreeModelFit: null,
             decisionTreeModelPredict: null,
+            randomForestClassifierModelCreate: null,
+            randomForestClassifierModelDestroy: null,
+            randomForestClassifierModelFit: null,
+            randomForestClassifierModelPredict: null,
             logisticTrainEpoch: library.symbols.logistic_train_epoch ?? null,
             logisticTrainEpochs: null,
             abiVersion: null,

package/src/preprocessing/Binarizer.ts

@@ -0,0 +1,46 @@
+import type { Matrix } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export interface BinarizerOptions {
+  threshold?: number;
+}
+
+export class Binarizer {
+  nFeaturesIn_: number | null = null;
+  private readonly threshold: number;
+
+  constructor(options: BinarizerOptions = {}) {
+    this.threshold = options.threshold ?? 0;
+    if (!Number.isFinite(this.threshold)) {
+      throw new Error(`threshold must be finite. Got ${this.threshold}.`);
+    }
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+    this.nFeaturesIn_ = X[0].length;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (this.nFeaturesIn_ !== null && X[0].length !== this.nFeaturesIn_) {
+      throw new Error(`Feature size mismatch. Expected ${this.nFeaturesIn_}, got ${X[0].length}.`);
+    }
+
+    return X.map((row) => row.map((value) => (value > this.threshold ? 1 : 0)));
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+}

package/src/preprocessing/LabelEncoder.ts

@@ -0,0 +1,62 @@
+import type { Vector } from "../types";
+import { assertFiniteVector } from "../utils/validation";
+
+export class LabelEncoder {
+  classes_: number[] | null = null;
+  private classToIndex: Map<number, number> | null = null;
+
+  fit(y: Vector): this {
+    if (!Array.isArray(y) || y.length === 0) {
+      throw new Error("y must be a non-empty array.");
+    }
+    assertFiniteVector(y);
+
+    const classes = Array.from(new Set(y)).sort((a, b) => a - b);
+    const classToIndex = new Map<number, number>();
+    for (let i = 0; i < classes.length; i += 1) {
+      classToIndex.set(classes[i], i);
+    }
+
+    this.classes_ = classes;
+    this.classToIndex = classToIndex;
+    return this;
+  }
+
+  transform(y: Vector): Vector {
+    if (!this.classToIndex) {
+      throw new Error("LabelEncoder has not been fitted.");
+    }
+    assertFiniteVector(y);
+
+    const encoded = new Array<number>(y.length);
+    for (let i = 0; i < y.length; i += 1) {
+      const idx = this.classToIndex.get(y[i]);
+      if (idx === undefined) {
+        throw new Error(`Unknown label ${y[i]} at index ${i}.`);
+      }
+      encoded[i] = idx;
+    }
+    return encoded;
+  }
+
+  fitTransform(y: Vector): Vector {
+    return this.fit(y).transform(y);
+  }
+
+  inverseTransform(y: Vector): Vector {
+    if (!this.classes_) {
+      throw new Error("LabelEncoder has not been fitted.");
+    }
+    assertFiniteVector(y);
+
+    const decoded = new Array<number>(y.length);
+    for (let i = 0; i < y.length; i += 1) {
+      const encoded = y[i];
+      if (!Number.isInteger(encoded) || encoded < 0 || encoded >= this.classes_.length) {
+        throw new Error(`Encoded label out of range at index ${i}: ${encoded}.`);
+      }
+      decoded[i] = this.classes_[encoded];
+    }
+    return decoded;
+  }
+}

package/src/preprocessing/MaxAbsScaler.ts

@@ -0,0 +1,77 @@
+import type { Matrix, Vector } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export class MaxAbsScaler {
+  maxAbs_: Vector | null = null;
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const nFeatures = X[0].length;
+    const maxAbs = new Array<number>(nFeatures).fill(0);
+
+    for (let i = 0; i < X.length; i += 1) {
+      for (let j = 0; j < nFeatures; j += 1) {
+        const abs = Math.abs(X[i][j]);
+        if (abs > maxAbs[j]) {
+          maxAbs[j] = abs;
+        }
+      }
+    }
+
+    for (let j = 0; j < nFeatures; j += 1) {
+      if (maxAbs[j] === 0) {
+        maxAbs[j] = 1;
+      }
+    }
+
+    this.maxAbs_ = maxAbs;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (!this.maxAbs_) {
+      throw new Error("MaxAbsScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.maxAbs_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.maxAbs_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) => row.map((value, featureIdx) => value / this.maxAbs_![featureIdx]));
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+
+  inverseTransform(X: Matrix): Matrix {
+    if (!this.maxAbs_) {
+      throw new Error("MaxAbsScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.maxAbs_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.maxAbs_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) => row.map((value, featureIdx) => value * this.maxAbs_![featureIdx]));
+  }
+}

package/src/preprocessing/Normalizer.ts

@@ -0,0 +1,66 @@
+import type { Matrix } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export interface NormalizerOptions {
+  norm?: "l1" | "l2" | "max";
+}
+
+export class Normalizer {
+  private readonly norm: "l1" | "l2" | "max";
+  private nFeatures_: number | null = null;
+
+  constructor(options: NormalizerOptions = {}) {
+    this.norm = options.norm ?? "l2";
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+    this.nFeatures_ = X[0].length;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+    if (this.nFeatures_ !== null && X[0].length !== this.nFeatures_) {
+      throw new Error(`Feature size mismatch. Expected ${this.nFeatures_}, got ${X[0].length}.`);
+    }
+
+    return X.map((row) => {
+      let scale = 0;
+      if (this.norm === "l1") {
+        for (let i = 0; i < row.length; i += 1) {
+          scale += Math.abs(row[i]);
+        }
+      } else if (this.norm === "l2") {
+        for (let i = 0; i < row.length; i += 1) {
+          scale += row[i] * row[i];
+        }
+        scale = Math.sqrt(scale);
+      } else {
+        for (let i = 0; i < row.length; i += 1) {
+          const abs = Math.abs(row[i]);
+          if (abs > scale) {
+            scale = abs;
+          }
+        }
+      }
+
+      if (scale === 0) {
+        return [...row];
+      }
+      return row.map((value) => value / scale);
+    });
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+}

package/src/tree/DecisionTreeClassifier.ts

@@ -6,6 +6,7 @@ import {
   validateClassificationInputs,
 } from "../utils/validation";
 import { accuracyScore } from "../metrics/classification";
+import { getZigKernels } from "../native/zigKernels";
 
 export type MaxFeaturesOption = "sqrt" | "log2" | number | null;
 
@@ -38,6 +39,11 @@ interface SplitPartition {
 
 const MAX_THRESHOLD_BINS = 128;
 
+function isZigTreeBackendEnabled(): boolean {
+  const mode = process.env.BUN_SCIKIT_TREE_BACKEND?.trim().toLowerCase();
+  return mode === "zig" || mode === "native";
+}
+
 function mulberry32(seed: number): () => number {
   let state = seed >>> 0;
   return () => {
@@ -59,6 +65,8 @@ function giniImpurity(positiveCount: number, sampleCount: number): number {
 
 export class DecisionTreeClassifier implements ClassificationModel {
   classes_: Vector = [0, 1];
+  fitBackend_: "zig" | "js" = "js";
+  fitBackendLibrary_: string | null = null;
   private readonly maxDepth: number;
   private readonly minSamplesSplit: number;
   private readonly minSamplesLeaf: number;
@@ -73,6 +81,7 @@ export class DecisionTreeClassifier implements ClassificationModel {
   private featureSelectionMarks: Uint8Array | null = null;
   private binTotals: Uint32Array = new Uint32Array(MAX_THRESHOLD_BINS);
   private binPositives: Uint32Array = new Uint32Array(MAX_THRESHOLD_BINS);
+  private zigModelHandle: bigint | null = null;
 
   constructor(options: DecisionTreeClassifierOptions = {}) {
     this.maxDepth = options.maxDepth ?? 12;
@@ -90,6 +99,8 @@ export class DecisionTreeClassifier implements ClassificationModel {
     flattenedXTrain?: Float64Array,
     yBinaryTrain?: Uint8Array,
   ): this {
+    this.destroyZigModel();
+
     if (!skipValidation) {
       validateClassificationInputs(X, y);
     }
@@ -103,18 +114,28 @@ export class DecisionTreeClassifier implements ClassificationModel {
     this.featureSelectionMarks = new Uint8Array(this.featureCount);
     this.random = this.randomState === undefined ? Math.random : mulberry32(this.randomState);
 
-    let rootIndices: number[];
+    let validatedSampleIndices: Uint32Array | null = null;
     if (sampleIndices) {
       if (sampleIndices.length === 0) {
         throw new Error("sampleIndices must not be empty.");
       }
+      validatedSampleIndices = new Uint32Array(sampleIndices.length);
       for (let i = 0; i < sampleIndices.length; i += 1) {
         const index = sampleIndices[i];
         if (!Number.isInteger(index) || index < 0 || index >= X.length) {
           throw new Error(`sampleIndices contains invalid index: ${index}.`);
         }
+        validatedSampleIndices[i] = index;
       }
-      rootIndices = Array.from(sampleIndices);
+    }
+
+    if (isZigTreeBackendEnabled() && this.tryFitWithZig(X.length, validatedSampleIndices)) {
+      return this;
+    }
+
+    let rootIndices: number[];
+    if (validatedSampleIndices) {
+      rootIndices = Array.from(validatedSampleIndices);
     } else {
       rootIndices = new Array<number>(X.length);
       for (let idx = 0; idx < X.length; idx += 1) {
@@ -123,11 +144,13 @@ export class DecisionTreeClassifier implements ClassificationModel {
     }
 
     this.root = this.buildTree(rootIndices, 0);
+    this.fitBackend_ = "js";
+    this.fitBackendLibrary_ = null;
     return this;
   }
 
   predict(X: Matrix): Vector {
-    if (!this.root || this.featureCount === 0) {
+    if ((this.root === null && this.zigModelHandle === null) || this.featureCount === 0) {
       throw new Error("DecisionTreeClassifier has not been fitted.");
     }
 
@@ -140,7 +163,34 @@ export class DecisionTreeClassifier implements ClassificationModel {
       );
     }
 
-    return X.map((sample) => this.predictOne(sample, this.root!));
+    if (this.zigModelHandle !== null) {
+      const kernels = getZigKernels();
+      const nativePredict = kernels?.decisionTreeModelPredict;
+      if (nativePredict) {
+        const flattenedX = this.flattenTrainingMatrix(X);
+        const outLabels = new Uint8Array(X.length);
+        const status = nativePredict(
+          this.zigModelHandle,
+          flattenedX,
+          X.length,
+          this.featureCount,
+          outLabels,
+        );
+        if (status === 1) {
+          return Array.from(outLabels);
+        }
+      }
+      if (!this.root) {
+        throw new Error("Native DecisionTree predict failed and no JS fallback tree is available.");
+      }
+    }
+
+    const predictions = new Array<number>(X.length);
+    const root = this.root!;
+    for (let i = 0; i < X.length; i += 1) {
+      predictions[i] = this.predictOne(X[i], root);
+    }
+    return predictions;
   }
 
   score(X: Matrix, y: Vector): number {
@@ -148,6 +198,13 @@ export class DecisionTreeClassifier implements ClassificationModel {
     return accuracyScore(y, this.predict(X));
   }
 
+  dispose(): void {
+    this.destroyZigModel();
+    this.root = null;
+    this.flattenedXTrain = null;
+    this.yBinaryTrain = null;
+  }
+
   private predictOne(sample: Vector, node: TreeNode): 0 | 1 {
     let current: TreeNode = node;
     while (
@@ -228,9 +285,107 @@ export class DecisionTreeClassifier implements ClassificationModel {
     if (this.maxFeatures === "log2") {
       return Math.max(1, Math.floor(Math.log2(featureCount)));
     }
+    if (!Number.isFinite(this.maxFeatures)) {
+      return featureCount;
+    }
     return Math.max(1, Math.min(featureCount, Math.floor(this.maxFeatures)));
   }
 
+  private resolveNativeMaxFeatures(featureCount: number): {
+    mode: 0 | 1 | 2 | 3;
+    value: number;
+  } {
+    if (this.maxFeatures === null || this.maxFeatures === undefined) {
+      return { mode: 0, value: 0 };
+    }
+    if (this.maxFeatures === "sqrt") {
+      return { mode: 1, value: 0 };
+    }
+    if (this.maxFeatures === "log2") {
+      return { mode: 2, value: 0 };
+    }
+    const value = Number.isFinite(this.maxFeatures)
+      ? Math.max(1, Math.min(featureCount, Math.floor(this.maxFeatures)))
+      : featureCount;
+    return { mode: 3, value };
+  }
+
+  private tryFitWithZig(
+    sampleCount: number,
+    sampleIndices: Uint32Array | null,
+  ): boolean {
+    const kernels = getZigKernels();
+    const create = kernels?.decisionTreeModelCreate;
+    const fit = kernels?.decisionTreeModelFit;
+    const destroy = kernels?.decisionTreeModelDestroy;
+    if (!create || !fit || !destroy) {
+      return false;
+    }
+
+    const { mode, value } = this.resolveNativeMaxFeatures(this.featureCount);
+    const useRandomState = this.randomState === undefined ? 0 : 1;
+    const randomState = this.randomState ?? 0;
+    const handle = create(
+      this.maxDepth,
+      this.minSamplesSplit,
+      this.minSamplesLeaf,
+      mode,
+      value,
+      randomState >>> 0,
+      useRandomState,
+      this.featureCount,
+    );
+    if (handle === 0n) {
+      return false;
+    }
+
+    let shouldDestroy = true;
+    try {
+      const emptySampleIndices = new Uint32Array(0);
+      const status = fit(
+        handle,
+        this.flattenedXTrain!,
+        this.yBinaryTrain!,
+        sampleCount,
+        this.featureCount,
+        sampleIndices ?? emptySampleIndices,
+        sampleIndices?.length ?? 0,
+      );
+      if (status !== 1) {
+        return false;
+      }
+
+      this.zigModelHandle = handle;
+      this.root = null;
+      this.fitBackend_ = "zig";
+      this.fitBackendLibrary_ = kernels.libraryPath;
+      shouldDestroy = false;
+      return true;
+    } catch {
+      return false;
+    } finally {
+      if (shouldDestroy) {
+        destroy(handle);
+      }
+    }
+  }
+
+  private destroyZigModel(): void {
+    if (this.zigModelHandle === null) {
+      return;
+    }
+    const kernels = getZigKernels();
+    const destroy = kernels?.decisionTreeModelDestroy;
+    if (destroy) {
+      try {
+        destroy(this.zigModelHandle);
+      } catch {
+        // no-op: cleanup best effort
+      }
+    }
+    this.zigModelHandle = null;
+  }
+
   private selectFeatureIndices(featureCount: number): number[] {
     const k = this.resolveMaxFeatures(featureCount);
     if (k >= featureCount) {