@isidorus/cpu 0.0.0-alpha.0

package/README.md

@@ -0,0 +1,47 @@
+# @isidorus/cpu
+
+High-performance TensorFlow CPU backend for Isidorus, enabling graph construction, training, and inference in Node.js environments.
+
+## Features
+
+- **Native Addon**: Uses a C++ native addon to interface directly with `libtensorflow`.
+- **Automatic Setup**: Automatically handles the download and installation of required TensorFlow libraries.
+- **Inference Pool**: Efficiently manage concurrent execution strategies (worker-pool vs tf-parallel).
+- **Ops Library**: Rich set of operations including Math, Array, NN, and Variable ops.
+
+## Installation
+
+```bash
+npm install @isidorus/cpu
+```
+
+_Note: The install script will automatically attempt to resolve and download `libtensorflow` if it is missing._
+
+## Quick Start
+
+```typescript
+import { graph, session, ops, DType } from "@isidorus/cpu";
+
+const g = graph();
+const x = ops.placeholder(g, "x", [null, 784], DType.FLOAT32);
+
+const sess = session(g, { strategy: "tf-parallel", reserveCores: 2 });
+```
+
+## Development
+
+### Native Builds
+
+To rebuild the native C++ addon:
+
+```bash
+npm run build:native
+```
+
+### Prebuilds
+
+To generate prebuilt binaries for multiple Node.js versions:
+
+```bash
+npm run prebuildify
+```

package/binding.gyp

@@ -0,0 +1,103 @@
+{
+  "targets": [
+    {
+      "target_name": "jude-tf",
+      "sources": [
+        "src/native/addon.cc",
+        "src/native/graph.cc",
+        "src/native/session.cc"
+      ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")",
+        "<!@(echo $LIBTENSORFLOW_PATH || echo /usr/local || true)/include"
+      ],
+      "dependencies": [
+          "<!(node -p \"require('node-addon-api').gyp\")"
+      ],
+      "libraries": [
+        "-ltensorflow"
+      ],
+      "library_dirs": [
+        "<!@(echo $LIBTENSORFLOW_PATH || echo /usr/local || true)/lib"
+      ],
+      "sources!": [
+      ],
+      "sources+": [
+      ],
+      "defines": [
+        "NAPI_VERSION=8",
+        "NAPI_DISABLE_CPP_EXCEPTIONS"
+      ],
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "cflags": [ "-O3", "-ffast-math" ],
+      "cflags_cc": [ "-std=c++17", "-O3", "-ffast-math" ],      
+      "msvs_settings": {
+        "VCCLCompilerTool": {
+          "ExceptionHandling": 1,
+          "AdditionalOptions": [ "/std:c++17", "/O2", "/fp:fast", "/arch:AVX2" ],
+          "Optimization": 3,
+          "FavorSizeOrSpeed": 1,
+          "InlineFunctionExpansion": 2
+        }
+      },
+      "xcode_settings": {
+        "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+        "CLANG_CXX_LIBRARY": "libc++",
+        "MACOSX_DEPLOYMENT_TARGET": "10.15",
+        "OTHER_CPLUSPLUSFLAGS": [ "-std=c++17", "-stdlib=libc++", "-O3", "-ffast-math"],
+        "GCC_OPTIMIZATION_LEVEL": "3"
+      },
+      "conditions": [
+        # Condition for Windows
+        ["OS=='win'", {
+          "defines": [ "_HAS_EXCEPTIONS=1", "__AVX2__=1", "__AVX__=1", "__SSE3__=1" ],
+          "include_dirs": [
+            "C:/libtensorflow/include"
+          ],
+          "library_dirs": [
+            "C:/libtensorflow/lib"
+          ]
+        }],
+        # Condition for x64 architecture (Linux/macOS)
+        ['target_arch=="x64"', {
+          "cflags+": [ "-msse3", "-mavx", "-mavx2" ],
+          "cflags_cc+": [ "-msse3", "-mavx", "-mavx2" ],
+          'xcode_settings': {
+            'OTHER_CPLUSPLUSFLAGS+': [ '-msse3', '-mavx', '-mavx2' ]
+          }
+        }],
+        # Condition for ia32 architecture (Linux/macOS - if you support 32-bit x86)
+        ['target_arch=="ia32"', {
+           "cflags+": [ "-msse3", "-mavx", "-mavx2" ], # Or adjust based on 32-bit support
+           "cflags_cc+": [ "-msse3", "-mavx", "-mavx2" ],
+          'xcode_settings': {
+            'OTHER_CPLUSPLUSFLAGS+': [ '-msse3', '-mavx', '-mavx2' ]
+          }
+        }],
+        # Condition for arm64 architecture (Android, iOS, M1/M2 Macs, etc.)
+        ['target_arch=="arm64"', {
+          # ARMv8-a baseline: NEON + FP support (compatible with all ARMv8 CPUs)
+          "cflags+": [ "-march=armv8-a+fp+simd" ],
+          "cflags_cc+": [ "-march=armv8-a+fp+simd" ],
+          'xcode_settings': {
+            'OTHER_CPLUSPLUSFLAGS+': [ '-march=armv8-a+fp+simd' ]
+          }
+          # Optional: Upgrade to ARMv8.2-a for newer CPUs (Tensor G4, Apple M2+, Graviton 3+)
+          # Enables FP16 arithmetic and additional optimizations
+          # Uncomment the lines below to enable ARMv8.2-a:
+          # "cflags+": [ "-march=armv8.2-a+fp16" ],
+          # "cflags_cc+": [ "-march=armv8.2-a+fp16" ],
+          # 'xcode_settings': {
+          #   'OTHER_CPLUSPLUSFLAGS+': [ '-march=armv8.2-a+fp16' ]
+          # }
+        }],
+        # Condition for 32-bit ARM (older Android devices)
+        ['target_arch=="arm"', {
+          "cflags+": [ "-mfpu=neon", "-mfloat-abi=hard" ],  # 32-bit ARM NEON
+          "cflags_cc+": [ "-mfpu=neon", "-mfloat-abi=hard" ],
+        }]
+      ]
+    }
+  ]
+}

package/dist/ts/_native.d.ts

@@ -0,0 +1,13 @@
+/**
+ * _native.ts — internal addon reference.
+ *
+ * Holds the loaded native addon so internal modules (inference-pool, etc.)
+ * can access it without importing from the package's own entry point
+ * (@isidorus/cpu), which would be a circular dependency.
+ *
+ * index.ts calls setAddon() once after node-gyp-build resolves.
+ * Any internal module that needs Graph or Session construction calls getAddon().
+ */
+export declare function setAddon(addon: any): void;
+export declare function getAddon(): any;
+//# sourceMappingURL=_native.d.ts.map

package/dist/ts/_native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_native.d.ts","sourceRoot":"","sources":["../../src/ts/_native.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI,CAEzC;AAED,wBAAgB,QAAQ,IAAI,GAAG,CAQ9B"}

package/dist/ts/_native.js

@@ -0,0 +1,22 @@
+/**
+ * _native.ts — internal addon reference.
+ *
+ * Holds the loaded native addon so internal modules (inference-pool, etc.)
+ * can access it without importing from the package's own entry point
+ * (@isidorus/cpu), which would be a circular dependency.
+ *
+ * index.ts calls setAddon() once after node-gyp-build resolves.
+ * Any internal module that needs Graph or Session construction calls getAddon().
+ */
+let _addon = null;
+export function setAddon(addon) {
+    _addon = addon;
+}
+export function getAddon() {
+    if (!_addon) {
+        throw new Error("[isidorus] Native addon not initialised. " +
+            "Ensure @isidorus/cpu is imported before calling InferencePool.create().");
+    }
+    return _addon;
+}
+//# sourceMappingURL=_native.js.map

package/dist/ts/_native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_native.js","sourceRoot":"","sources":["../../src/ts/_native.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,IAAI,MAAM,GAAQ,IAAI,CAAC;AAEvB,MAAM,UAAU,QAAQ,CAAC,KAAU;IACjC,MAAM,GAAG,KAAK,CAAC;AACjB,CAAC;AAED,MAAM,UAAU,QAAQ;IACtB,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CACb,2CAA2C;YACzC,yEAAyE,CAC5E,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/ts/graph.d.ts

@@ -0,0 +1,91 @@
+import type { Tensor } from "@isidorus/core";
+import { DType } from "@isidorus/core";
+export type AttrValue = {
+    kind: "int";
+    value: number;
+} | {
+    kind: "float";
+    value: number;
+} | {
+    kind: "bool";
+    value: boolean;
+} | {
+    kind: "type";
+    value: DType;
+} | {
+    kind: "shape";
+    value: number[];
+} | {
+    kind: "list_type";
+    value: DType[];
+} | {
+    kind: "list_int";
+    value: number[];
+} | {
+    kind: "tensor";
+    value: InlineTensor;
+};
+export interface InlineTensor {
+    dtype: DType;
+    shape: number[];
+    data: Buffer;
+}
+export type TFOutput = {
+    opName: string;
+    index: number;
+};
+/**
+ * Graph — builds a TensorFlow graph via the C API.
+ *
+ * This is the ground-level primitive. Every operation (placeholder, variable,
+ * matmul, relu, …) adds one or more ops to this graph. Symbolic Tensors
+ * reference op outputs but hold no data until a Session executes the graph.
+ *
+ * @example
+ * const g = new Graph();
+ * const x = g.placeholder("x", [null, 784], DType.FLOAT32);
+ * const w = g.variable("w", [784, 128], DType.FLOAT32);
+ * const y = g.matmul(x, g.readVariable(w));
+ */
+export declare class Graph {
+    /** @internal */
+    readonly _native: any;
+    constructor(native: any);
+    /**
+     * Add a raw op to the graph.
+     *
+     * @param type      TF op type string, e.g. "MatMul", "Placeholder"
+     * @param inputs    Output references from prior ops
+     * @param attrs     Op attributes
+     * @param name      Optional explicit op name (auto-generated if omitted)
+     * @returns         Array of output Tensors (one per op output)
+     */
+    addOp(type: string, inputs: TFOutput[], attrs?: Record<string, AttrValue>, name?: string): Tensor[];
+    /** Whether an op with the given name exists in this graph. */
+    hasOp(name: string): boolean;
+    /** Total number of ops in the graph. */
+    get numOps(): number;
+    /**
+     * Serialise the graph to a binary GraphDef proto.
+     * Useful for saving, inspecting with Netron, or freezing.
+     */
+    toGraphDef(): Buffer;
+    /**
+     * importGraphDef — deserialise a binary GraphDef proto into this graph.
+     *
+     * Used to load a frozen .pb model so it can be executed via the native
+     * Session (which applies ConfigProto thread config and CPU affinity).
+     * The graph must be empty before calling this.
+     *
+     * @param buffer  Raw bytes of a frozen GraphDef proto (.pb file contents)
+     *
+     * @example
+     * import { readFileSync } from "fs";
+     * const g = graph();
+     * g.importGraphDef(readFileSync("model.pb"));
+     * const sess = session(g, { strategy: "tf-parallel", reserveCores: 2 });
+     */
+    importGraphDef(buffer: Buffer): void;
+    getOp(name: string, index?: number): Tensor | null;
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/ts/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/ts/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAA2B,MAAM,gBAAgB,CAAC;AAGhE,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,KAAK,EAAE,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,CAAC;AAE5C,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,QAAQ,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD;;;;;;;;;;;;GAYG;AACH,qBAAa,KAAK;IAChB,gBAAgB;IAChB,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC;gBAEV,MAAM,EAAE,GAAG;IAIvB;;;;;;;;OAQG;IACH,KAAK,CACH,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,QAAQ,EAAE,EAClB,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAM,EACrC,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,EAAE;IAkCX,8DAA8D;IAC9D,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI5B,wCAAwC;IACxC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;OAGG;IACH,UAAU,IAAI,MAAM;IAIpB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKpC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,MAAM,GAAG,IAAI;CAW9C"}

package/dist/ts/graph.js

@@ -0,0 +1,95 @@
+import { makeTensor, ShapeFromTF } from "@isidorus/core";
+/**
+ * Graph — builds a TensorFlow graph via the C API.
+ *
+ * This is the ground-level primitive. Every operation (placeholder, variable,
+ * matmul, relu, …) adds one or more ops to this graph. Symbolic Tensors
+ * reference op outputs but hold no data until a Session executes the graph.
+ *
+ * @example
+ * const g = new Graph();
+ * const x = g.placeholder("x", [null, 784], DType.FLOAT32);
+ * const w = g.variable("w", [784, 128], DType.FLOAT32);
+ * const y = g.matmul(x, g.readVariable(w));
+ */
+export class Graph {
+    /** @internal */
+    _native;
+    constructor(native) {
+        this._native = native;
+    }
+    /**
+     * Add a raw op to the graph.
+     *
+     * @param type      TF op type string, e.g. "MatMul", "Placeholder"
+     * @param inputs    Output references from prior ops
+     * @param attrs     Op attributes
+     * @param name      Optional explicit op name (auto-generated if omitted)
+     * @returns         Array of output Tensors (one per op output)
+     */
+    addOp(type, inputs, attrs = {}, name) {
+        const nativeAttrs = {};
+        for (const [k, v] of Object.entries(attrs)) {
+            if (v.kind === "list_type") {
+                nativeAttrs[k] = { kind: "list_type", value: v.value.map(Number) };
+            }
+            else if (v.kind === "type") {
+                nativeAttrs[k] = { kind: "type", value: Number(v.value) };
+            }
+            else {
+                nativeAttrs[k] = v;
+            }
+        }
+        const result = this._native.addOp(type, inputs, nativeAttrs, name);
+        const { opName, numOutputs } = result;
+        const tensors = [];
+        for (let i = 0; i < numOutputs; i++) {
+            const tfDtype = this._native.opOutputType(opName, i);
+            const tfShape = this._native.opOutputShape(opName, i);
+            tensors.push(makeTensor(opName, i, tfDtype != null ? tfDtype : null, tfShape != null ? ShapeFromTF(tfShape) : null));
+        }
+        return tensors;
+    }
+    /** Whether an op with the given name exists in this graph. */
+    hasOp(name) {
+        return this._native.hasOp(name);
+    }
+    /** Total number of ops in the graph. */
+    get numOps() {
+        return this._native.numOps();
+    }
+    /**
+     * Serialise the graph to a binary GraphDef proto.
+     * Useful for saving, inspecting with Netron, or freezing.
+     */
+    toGraphDef() {
+        return this._native.toGraphDef();
+    }
+    /**
+     * importGraphDef — deserialise a binary GraphDef proto into this graph.
+     *
+     * Used to load a frozen .pb model so it can be executed via the native
+     * Session (which applies ConfigProto thread config and CPU affinity).
+     * The graph must be empty before calling this.
+     *
+     * @param buffer  Raw bytes of a frozen GraphDef proto (.pb file contents)
+     *
+     * @example
+     * import { readFileSync } from "fs";
+     * const g = graph();
+     * g.importGraphDef(readFileSync("model.pb"));
+     * const sess = session(g, { strategy: "tf-parallel", reserveCores: 2 });
+     */
+    importGraphDef(buffer) {
+        this._native.importGraphDef(buffer);
+    }
+    // graph.ts
+    getOp(name, index = 0) {
+        if (!this._native.hasOp(name))
+            return null;
+        const tfDtype = this._native.opOutputType(name, index);
+        const tfShape = this._native.opOutputShape(name, index);
+        return makeTensor(name, index, tfDtype != null ? tfDtype : null, tfShape != null ? ShapeFromTF(tfShape) : null);
+    }
+}
+//# sourceMappingURL=graph.js.map

package/dist/ts/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/ts/graph.ts"],"names":[],"mappings":"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"}

package/dist/ts/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @isidorus/cpu entry point.
+ *
+ * Resolves libtensorflow before loading the native addon, so users
+ * get a clear message and an install prompt rather than a cryptic
+ * "cannot find module" or DLL load error.
+ */
+export type { Tensor, Shape } from "@isidorus/core";
+export { DType, dtypeItemSize, dtypeName, makeTensor, tensorId, } from "@isidorus/core";
+export type { AttrValue, InlineTensor, TFOutput } from "./graph.js";
+export { Graph } from "./graph.js";
+export type { FeedValue, TensorValue } from "./session.js";
+export { Session } from "./session.js";
+import { Graph } from "./graph.js";
+import { Session } from "./session.js";
+/**
+ * Create a new empty Graph.
+ *
+ * @example
+ * const g = graph();
+ * const x = ops.placeholder(g, "x", [null, 784], DType.FLOAT32);
+ */
+export declare function graph(): Graph;
+/**
+ * Create a Session backed by the given Graph.
+ *
+ * @param g        The graph to execute.
+ * @param options  Thread and affinity configuration:
+ *   strategy?:       "worker-pool" | "tf-parallel"
+ *   intraOpThreads?: number   (explicit override)
+ *   interOpThreads?: number
+ *   reserveCores?:   number   (reserve N cores for event loop / other libs)
+ *
+ * @example
+ * // Leave 2 cores for the event loop and opencv — TF gets the rest
+ * const sess = session(g, { strategy: "tf-parallel", reserveCores: 2 });
+ */
+export declare function session(g: Graph, options?: {
+    strategy?: "worker-pool" | "tf-parallel";
+    intraOpThreads?: number;
+    interOpThreads?: number;
+    reserveCores?: number;
+}): Session;
+export * as ops from "./ops/index.js";
+export type { PoolOptions, PoolResult, ExecutionStrategy, } from "./inference-pool.js";
+export { InferencePool } from "./inference-pool.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ts/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAsBH,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EACL,KAAK,EACL,aAAa,EACb,SAAS,EACT,UAAU,EACV,QAAQ,GACT,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAgB,KAAK,IAAI,KAAK,CAE7B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,KAAK,EACR,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,EAAE,aAAa,GAAG,aAAa,CAAC;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GACA,OAAO,CAET;AAGD,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AAGtC,YAAY,EACV,WAAW,EACX,UAAU,EACV,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/ts/index.js

@@ -0,0 +1,58 @@
+/**
+ * @isidorus/cpu entry point.
+ *
+ * Resolves libtensorflow before loading the native addon, so users
+ * get a clear message and an install prompt rather than a cryptic
+ * "cannot find module" or DLL load error.
+ */
+import { ensureTf } from "./install-libtensorflow.js";
+import nodeGypBuild from "node-gyp-build";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+// ── Ensure libtensorflow is present before touching the native addon ─────────
+// This is the only await at module top level — it resolves synchronously
+// on the fast path (library already present) and only blocks for the
+// install prompt if the library is genuinely missing.
+await ensureTf();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const addon = nodeGypBuild(join(__dirname, "..", ".."));
+import { setAddon } from "./_native.js";
+setAddon(addon);
+export { DType, dtypeItemSize, dtypeName, makeTensor, tensorId, } from "@isidorus/core";
+export { Graph } from "./graph.js";
+export { Session } from "./session.js";
+// ── Factory functions ─────────────────────────────────────────────────────────
+import { Graph } from "./graph.js";
+import { Session } from "./session.js";
+/**
+ * Create a new empty Graph.
+ *
+ * @example
+ * const g = graph();
+ * const x = ops.placeholder(g, "x", [null, 784], DType.FLOAT32);
+ */
+export function graph() {
+    return new Graph(new addon.Graph());
+}
+/**
+ * Create a Session backed by the given Graph.
+ *
+ * @param g        The graph to execute.
+ * @param options  Thread and affinity configuration:
+ *   strategy?:       "worker-pool" | "tf-parallel"
+ *   intraOpThreads?: number   (explicit override)
+ *   interOpThreads?: number
+ *   reserveCores?:   number   (reserve N cores for event loop / other libs)
+ *
+ * @example
+ * // Leave 2 cores for the event loop and opencv — TF gets the rest
+ * const sess = session(g, { strategy: "tf-parallel", reserveCores: 2 });
+ */
+export function session(g, options) {
+    return new Session(new addon.Session(g._native, options));
+}
+// ── Ops namespace ─────────────────────────────────────────────────────────────
+export * as ops from "./ops/index.js";
+export { InferencePool } from "./inference-pool.js";
+//# sourceMappingURL=index.js.map

package/dist/ts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ts/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACtD,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAErC,gFAAgF;AAChF,yEAAyE;AACzE,qEAAqE;AACrE,sDAAsD;AACtD,MAAM,QAAQ,EAAE,CAAC;AAEjB,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAEtC,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAQ,CAAC;AAE/D,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAIhB,OAAO,EACL,KAAK,EACL,aAAa,EACb,SAAS,EACT,UAAU,EACV,QAAQ,GACT,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,iFAAiF;AAEjF,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,UAAU,KAAK;IACnB,OAAO,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CACrB,CAAQ,EACR,OAKC;IAED,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED,iFAAiF;AACjF,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AAQtC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/ts/inference-pool.d.ts

@@ -0,0 +1,84 @@
+/**
+ * InferencePool — strategy-aware inference execution with CPU affinity.
+ *
+ * Strategies:
+ *
+ *   worker-pool  N Workers × Session(intra=1, inter=1)
+ *                JS controls parallelism. Each Worker owns one Session.
+ *                N concurrent requests run on N cores simultaneously.
+ *                Best: small/medium models, high concurrency.
+ *
+ *   tf-parallel  1 Session × Session(intra=hw, inter=1)
+ *                TF's eigen threadpool owns all TF cores for one request.
+ *                Concurrent requests queue behind each other.
+ *                Best: large models where one matmul fills all cores.
+ *
+ *   auto         Probe-based selection:
+ *                  model < 150 MB                   → worker-pool (no probe)
+ *                  model ≥ 150 MB + probeShape       → warm probe → threshold
+ *                  model ≥ 150 MB, no probeShape     → tf-parallel (fallback)
+ *
+ * CPU affinity (reserveCores):
+ *   reserveCores = R pins TF computation to the LAST (N-R) cores.
+ *   The FIRST R cores stay free for the event loop, libuv I/O, opencv, etc.
+ *   The fence is applied in OnRunWork immediately before/after TF_SessionRun.
+ */
+export type ExecutionStrategy = "worker-pool" | "tf-parallel" | "auto";
+export interface PoolOptions {
+    modelPath: string;
+    inputOp?: string;
+    outputOps?: string[];
+    /**
+     * Reserve the first R cores for the event loop and other native libs.
+     * TF inference is pinned to the last (N-R) cores via OS affinity.
+     * Default: 0 (no reservation).
+     */
+    reserveCores?: number;
+    strategy?: ExecutionStrategy;
+    /** Worker thread count (worker-pool only). Default: os.availableParallelism(). */
+    concurrency?: number;
+    /** Input shape for auto probe. Required when model >= 150 MB. */
+    probeShape?: number[];
+    /** Crossover threshold for auto strategy (ms). Default: 20. */
+    autoThresholdMs?: number;
+}
+export interface PoolResult {
+    workerId: number;
+    strategy: "worker-pool" | "tf-parallel";
+    outputs: {
+        dtype: number;
+        shape: number[];
+        data: Buffer;
+    }[];
+    inferenceMs: number;
+}
+export declare class InferencePool {
+    readonly strategy: "worker-pool" | "tf-parallel";
+    readonly reserveCores: number;
+    private readonly workerSlots;
+    private readonly queue;
+    private readonly ctrlSab;
+    private tfParallelGraph;
+    private tfParallelSess;
+    private tfParallelBusy;
+    private readonly tfParallelQueue;
+    private readonly modelPath;
+    private readonly inputOp;
+    private readonly outputOps;
+    private constructor();
+    static create(opts: PoolOptions): Promise<InferencePool>;
+    private static createWorkerPool;
+    private static createTfParallel;
+    infer(inputBuf: Buffer, inputShape: number[], inputDtype?: number): Promise<PoolResult>;
+    private inferWorkerPool;
+    private dispatchToWorker;
+    /** Settle a worker slot's in-flight promise and drain the queue. */
+    private settleSlot;
+    private inferTfParallel;
+    private runTfParallel;
+    get busyCount(): number;
+    get queueDepth(): number;
+    get size(): number;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=inference-pool.d.ts.map

package/dist/ts/inference-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference-pool.d.ts","sourceRoot":"","sources":["../../src/ts/inference-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAqBH,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,aAAa,GAAG,MAAM,CAAC;AAEvE,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,aAAa,GAAG,aAAa,CAAC;IACxC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC5D,WAAW,EAAE,MAAM,CAAC;CACrB;AAiLD,qBAAa,aAAa;IACxB,QAAQ,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa,CAAC;IACjD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAe;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IAOnD,OAAO,CAAC,eAAe,CAAe;IACtC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAe;IAE/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IAErC,OAAO;WA4BM,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;mBAmFzC,gBAAgB;mBAyEhB,gBAAgB;IAmErC,KAAK,CACH,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAAE,EACpB,UAAU,SAAI,GACb,OAAO,CAAC,UAAU,CAAC;IAMtB,OAAO,CAAC,eAAe;IAsBvB,OAAO,CAAC,gBAAgB;IAgExB,oEAAoE;IACpE,OAAO,CAAC,UAAU;IA8BlB,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,aAAa;IA8IrB,IAAI,SAAS,IAAI,MAAM,CAItB;IAED,IAAI,UAAU,IAAI,MAAM,CAIvB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAIK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAkD/B"}