@isidorus/cpu 0.0.0-alpha.0

package/dist/ts/ops/variable_ops.js

@@ -0,0 +1,267 @@
+import { DType, shapeToTF } from "@isidorus/core";
+import { constant } from "./array_ops.js";
+// ---------------------------------------------------------------------------
+// variable_ops — variable lifecycle and initialisation
+//
+// TF variable lifecycle in the graph-first model:
+//
+//   1. variable()       → adds a VarHandleOp to the graph
+//                         returns a Tensor (the variable handle)
+//   2. initializer()    → adds an AssignVariableOp feeding the handle
+//                         returns the assign op name (run as a target)
+//   3. readVariable()   → adds a ReadVariableOp
+//                         returns the current value as a Tensor
+//   4. assignVariable() → adds an AssignVariableOp for a new value
+//                         returns the assign op name (run as a target)
+//
+// In a Session:
+//   sess.run([], [], ["init_all"])     ← run initializer targets
+//   sess.run([[x, feed]], [y])         ← inference
+//   sess.run([[x, feed]], [], ["step"]) ← training step (assign ops)
+// ---------------------------------------------------------------------------
+// ── Variable handle ───────────────────────────────────────────────────────────
+/**
+ * Variable handle — a VarHandleOp that identifies a resource variable.
+ *
+ * The handle itself holds no data. Use initializer() to set the initial
+ * value, readVariable() to read it, and assignVariable() to update it.
+ *
+ * @param shape     Shape of the variable (null dims = dynamic)
+ * @param dtype     Element type
+ * @param varName   Logical name for the variable (used in checkpoints)
+ */
+export function variable(g, shape, dtype, varName) {
+    const [handle] = g.addOp("VarHandleOp", [], {
+        dtype: { kind: "type", value: dtype },
+        shape: { kind: "shape", value: shapeToTF(shape) },
+        // container and shared_name are string attrs — we use the op name
+        // as the variable name which TF uses for checkpoint key resolution.
+    }, varName);
+    return handle;
+}
+/**
+ * readVariable — emits a ReadVariableOp to read the current value.
+ * The returned Tensor can be used as input to any op.
+ */
+export function readVariable(g, handle, dtype, name) {
+    const [t] = g.addOp("ReadVariableOp", [handle], {
+        dtype: { kind: "type", value: dtype },
+    }, name);
+    return t;
+}
+/**
+ * assignVariable — adds an AssignVariableOp that writes `value` into
+ * the variable identified by `handle`.
+ *
+ * Returns the op name — pass it as a target in sess.run() to execute
+ * the assignment as a side-effect.
+ *
+ * @example
+ * const updateOp = ops.assignVariable(g, wHandle, newW, DType.FLOAT32);
+ * await sess.run(feeds, [], [updateOp]);
+ */
+export function assignVariable(g, handle, value, dtype, name) {
+    const opName = name ?? `AssignVariableOp_${handle.opName}`;
+    g.addOp("AssignVariableOp", [handle, value], {
+        dtype: { kind: "type", value: dtype },
+    }, opName);
+    return opName;
+}
+/**
+ * assignAdd — adds an AssignAddVariableOp: variable += delta.
+ * Returns the op name.
+ */
+export function assignAdd(g, handle, delta, dtype, name) {
+    const opName = name ?? `AssignAddVariableOp_${handle.opName}`;
+    g.addOp("AssignAddVariableOp", [handle, delta], {
+        dtype: { kind: "type", value: dtype },
+    }, opName);
+    return opName;
+}
+/**
+ * assignSub — adds an AssignSubVariableOp: variable -= delta.
+ * Returns the op name.
+ */
+export function assignSub(g, handle, delta, dtype, name) {
+    const opName = name ?? `AssignSubVariableOp_${handle.opName}`;
+    g.addOp("AssignSubVariableOp", [handle, delta], {
+        dtype: { kind: "type", value: dtype },
+    }, opName);
+    return opName;
+}
+// ── Initializers ──────────────────────────────────────────────────────────────
+/**
+ * zerosInitializer — creates a constant zero tensor matching `shape` and `dtype`.
+ * Use with initializer() to zero-initialise a variable.
+ */
+export function zerosInitializer(g, shape, dtype, name) {
+    const itemSize = dtype === DType.FLOAT64
+        ? 8
+        : dtype === DType.INT64 || dtype === DType.UINT64
+            ? 8
+            : dtype === DType.INT16 || dtype === DType.UINT16
+                ? 2
+                : dtype === DType.INT8 || dtype === DType.UINT8
+                    ? 1
+                    : 4;
+    const n = shape.reduce((a, b) => a * b, 1);
+    const buf = Buffer.alloc(n * itemSize, 0);
+    return constant(g, buf, shape, dtype, name);
+}
+/**
+ * onesInitializer — constant one tensor.
+ */
+export function onesInitializer(g, shape, dtype, name) {
+    const n = shape.reduce((a, b) => a * b, 1);
+    const buf = Buffer.allocUnsafe(n * 4);
+    for (let i = 0; i < n; i++)
+        buf.writeFloatLE(1, i * 4);
+    return constant(g, buf, shape, dtype, name);
+}
+/**
+ * truncatedNormalInitializer — samples from a truncated normal distribution.
+ * Values more than 2 stddevs from the mean are resampled.
+ * This is Xavier/Glorot-style initialisation when stddev = sqrt(2/fan_in).
+ *
+ * NOTE: TF's TruncatedNormal op produces a different value on every run
+ * unless a fixed seed is provided. For reproducible initialisation, run
+ * the init op once and save the checkpoint.
+ */
+export function truncatedNormalInitializer(g, shape, dtype = DType.FLOAT32, options = {}, name) {
+    const shapeBuf = Buffer.allocUnsafe(shape.length * 4);
+    shape.forEach((d, i) => shapeBuf.writeInt32LE(d, i * 4));
+    const shapeConst = constant(g, shapeBuf, [shape.length], DType.INT32);
+    const [t] = g.addOp("TruncatedNormal", [shapeConst], {
+        dtype: { kind: "type", value: dtype },
+        mean: { kind: "float", value: options.mean ?? 0.0 },
+        stddev: { kind: "float", value: options.stddev ?? 1.0 },
+        seed: { kind: "int", value: options.seed ?? 0 },
+        seed2: { kind: "int", value: 0 },
+    }, name);
+    return t;
+}
+/**
+ * glorotUniformInitializer — samples from Uniform(-limit, limit)
+ * where limit = sqrt(6 / (fan_in + fan_out)).
+ *
+ * For a weight matrix [fan_in, fan_out]:
+ *   fan_in  = shape[0]
+ *   fan_out = shape[1]
+ */
+export function glorotUniformInitializer(g, shape, // [fan_in, fan_out]
+dtype = DType.FLOAT32, name) {
+    const [fanIn, fanOut] = shape;
+    const limit = Math.sqrt(6 / (fanIn + fanOut));
+    const n = fanIn * fanOut;
+    const buf = Buffer.allocUnsafe(n * 4);
+    for (let i = 0; i < n; i++) {
+        buf.writeFloatLE(Math.random() * 2 * limit - limit, i * 4);
+    }
+    return constant(g, buf, shape, dtype, name);
+}
+// ── Variable + initializer convenience ───────────────────────────────────────
+/**
+ * variableWithInit — creates a variable handle and its initialisation op
+ * in one call.
+ *
+ * @returns { handle, initOp }
+ *   handle:  the VarHandleOp tensor (use with readVariable / assignVariable)
+ *   initOp:  op name to pass as a target in sess.run() to initialise
+ *
+ * @example
+ * const { handle: w, initOp: wInit } = ops.variableWithInit(
+ *   g, [784, 128], DType.FLOAT32, "weights",
+ *   ops.glorotUniformInitializer(g, [784, 128])
+ * );
+ * const { handle: b, initOp: bInit } = ops.variableWithInit(
+ *   g, [128], DType.FLOAT32, "bias",
+ *   ops.zerosInitializer(g, [128], DType.FLOAT32)
+ * );
+ *
+ * // Run init once before first training step:
+ * await sess.run([], [], [wInit, bInit]);
+ */
+export function variableWithInit(g, shape, dtype, varName, initialValue) {
+    const handle = variable(g, shape, dtype, varName);
+    const initOp = assignVariable(g, handle, initialValue, dtype, `${varName}/init`);
+    return { handle, initOp };
+}
+/**
+ * globalVariablesInitializer — groups all init ops into a single NoOp target.
+ *
+ * @param initOps  Array of init op names returned by variableWithInit()
+ * @returns        Op name to pass as a single target to sess.run()
+ *
+ * @example
+ * const initAll = ops.globalVariablesInitializer(g, [wInit, bInit]);
+ * await sess.run([], [], [initAll]);
+ */
+export function globalVariablesInitializer(g, initOps, name = "init_all_variables") {
+    // NoOp with control dependencies on all init ops.
+    // TF runs all control deps before executing the NoOp target.
+    const [t] = g.addOp("NoOp", [], {
+    // Control dependencies are added via the native addOp control_inputs param.
+    // The fourth arg to g.addOp is the op name; control edges are the fifth.
+    // For now, document the pattern — the addOp signature needs control_inputs
+    // support added to graph.cc to wire this up completely.
+    }, name);
+    return t.opName;
+}
+// ── Optimizer update ops ──────────────────────────────────────────────────────
+//
+// These are low-level building blocks. High-level optimizers (SGD, Adam)
+// are built on top in a separate optimizers/ module once the gradient
+// infrastructure is in place.
+//
+// Each returns an op name to run as a target (side-effect, no output).
+/**
+ * applyGradientDescent — w -= lr * grad.
+ * The simplest parameter update step.
+ */
+export function applyGradientDescent(g, handle, lr, // scalar learning rate
+grad, dtype, name) {
+    const opName = name ?? `ApplyGradientDescent_${handle.opName}`;
+    g.addOp("ResourceApplyGradientDescent", [handle, lr, grad], {
+        T: { kind: "type", value: dtype },
+        use_locking: { kind: "bool", value: false },
+    }, opName);
+    return opName;
+}
+/**
+ * applyAdam — one Adam parameter update step.
+ *
+ * Requires four variable handles: var, m (first moment), v (second moment),
+ * and beta1_power, beta2_power scalars (updated separately).
+ */
+export function applyAdam(g, handle, mHandle, vHandle, beta1Power, beta2Power, lr, beta1, beta2, epsilon, grad, dtype, name) {
+    const opName = name ?? `ApplyAdam_${handle.opName}`;
+    g.addOp("ResourceApplyAdam", [
+        handle,
+        mHandle,
+        vHandle,
+        beta1Power,
+        beta2Power,
+        lr,
+        beta1,
+        beta2,
+        epsilon,
+        grad,
+    ], {
+        T: { kind: "type", value: dtype },
+        use_locking: { kind: "bool", value: false },
+        use_nesterov: { kind: "bool", value: false },
+    }, opName);
+    return opName;
+}
+/**
+ * applyRMSProp — one RMSProp parameter update step.
+ */
+export function applyRMSProp(g, handle, msHandle, momHandle, lr, rho, momentum, epsilon, grad, dtype, name) {
+    const opName = name ?? `ApplyRMSProp_${handle.opName}`;
+    g.addOp("ResourceApplyRMSProp", [handle, msHandle, momHandle, lr, rho, momentum, epsilon, grad], {
+        T: { kind: "type", value: dtype },
+        use_locking: { kind: "bool", value: false },
+    }, opName);
+    return opName;
+}
+//# sourceMappingURL=variable_ops.js.map

package/dist/ts/ops/variable_ops.js.map

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

package/dist/ts/session.d.ts

@@ -0,0 +1,83 @@
+import type { Tensor } from "@isidorus/core";
+import { DType } from "@isidorus/core";
+/**
+ * Options for Session construction.
+ *
+ * Thread counts control how TensorFlow uses CPU cores internally.
+ * The right values depend on how many concurrent runAsync() calls you expect:
+ *
+ *   Single inference (Worker thread):
+ *     intraOpThreads: 0, interOpThreads: 0  — let TF use all cores
+ *
+ *   Concurrent runAsync() on main thread (default):
+ *     intraOpThreads: 2, interOpThreads: 2  — share cores across requests
+ *
+ *   Formula for N concurrent requests on C cores:
+ *     intraOpThreads = Math.max(1, Math.floor(C / N))
+ *     interOpThreads = Math.max(1, Math.floor(C / N))
+ */
+export interface SessionOptions {
+    /**
+     * Per-op parallelism — threads used within a single op (e.g. matmul tiles).
+     * Default: 2. Set to 0 to let TF choose automatically.
+     */
+    intraOpThreads?: number;
+    /**
+     * Graph-level parallelism — threads used to run independent ops concurrently.
+     * Default: 2. Set to 0 to let TF choose automatically.
+     */
+    interOpThreads?: number;
+}
+/** Raw tensor value passed as a feed. */
+export interface FeedValue {
+    dtype: DType;
+    shape: number[];
+    data: Buffer | Uint8Array;
+}
+/** Result from a fetched tensor output. */
+export interface TensorValue {
+    dtype: DType;
+    shape: number[];
+    data: Buffer;
+}
+/**
+ * Session — executes a Graph.
+ *
+ * A Session holds a TF_Session backed by the graph passed at construction.
+ * Once created the graph's structure should not change (new ops may be added
+ * for initialisation ops, but existing ops should not be removed).
+ *
+ * @example
+ * const sess = new Session(graph);
+ * await sess.run([], [], ["init"]);          // run init op (side-effect)
+ * const [output] = await sess.runAsync(     // fetch result
+ *   [[x, inputFeed]],
+ *   [y],
+ * );
+ */
+export declare class Session {
+    /** @internal */
+    readonly _native: any;
+    constructor(native: any);
+    /**
+     * Synchronous inference — blocks the event loop during TF_SessionRun.
+     * Use on Worker threads. On the main thread prefer runAsync().
+     *
+     * @param feeds    Array of [Tensor, FeedValue] pairs
+     * @param fetches  Tensors to compute and return
+     * @param targets  Op names to run for side-effects only (e.g. "init_all")
+     */
+    run(feeds: [Tensor, FeedValue][], fetches: Tensor[], targets?: string[]): Promise<TensorValue[]>;
+    /**
+     * Non-blocking inference — TF_SessionRun on the libuv thread pool.
+     * The event loop stays free for I/O and timers during compute.
+     *
+     * @param feeds    Array of [Tensor, FeedValue] pairs
+     * @param fetches  Tensors to compute and return
+     * @param targets  Op names to run for side-effects only
+     */
+    runAsync(feeds: [Tensor, FeedValue][], fetches: Tensor[], targets?: string[]): Promise<TensorValue[]>;
+    /** Close the session and release all C++ resources. */
+    destroy(): void;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/ts/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/ts/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,yCAAyC;AACzC,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AAED,2CAA2C;AAC3C,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AA+BD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,OAAO;IAClB,gBAAgB;IAChB,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC;gBAEV,MAAM,EAAE,GAAG;IAIvB;;;;;;;OAOG;IACG,GAAG,CACP,KAAK,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,EAC5B,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,GAAE,MAAM,EAAO,GACrB,OAAO,CAAC,WAAW,EAAE,CAAC;IAWzB;;;;;;;OAOG;IACG,QAAQ,CACZ,KAAK,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,EAC5B,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,GAAE,MAAM,EAAO,GACrB,OAAO,CAAC,WAAW,EAAE,CAAC;IAWzB,uDAAuD;IACvD,OAAO,IAAI,IAAI;CAGhB"}

package/dist/ts/session.js

@@ -0,0 +1,81 @@
+/** Convert a Tensor to the native feed format. */
+function toNativeFeed(t, v) {
+    return {
+        opName: t.opName,
+        index: t.index,
+        tensor: {
+            dtype: Number(v.dtype),
+            shape: v.shape,
+            data: Buffer.isBuffer(v.data)
+                ? v.data
+                : Buffer.from(v.data.buffer, v.data.byteOffset, v.data.byteLength),
+        },
+    };
+}
+/** Convert a Tensor to the native fetch format. */
+function toNativeFetch(t) {
+    return { opName: t.opName, index: t.index };
+}
+/** Parse native output back to TensorValue. */
+function fromNativeOutput(raw) {
+    return {
+        dtype: raw.dtype,
+        shape: raw.shape,
+        data: raw.data,
+    };
+}
+/**
+ * Session — executes a Graph.
+ *
+ * A Session holds a TF_Session backed by the graph passed at construction.
+ * Once created the graph's structure should not change (new ops may be added
+ * for initialisation ops, but existing ops should not be removed).
+ *
+ * @example
+ * const sess = new Session(graph);
+ * await sess.run([], [], ["init"]);          // run init op (side-effect)
+ * const [output] = await sess.runAsync(     // fetch result
+ *   [[x, inputFeed]],
+ *   [y],
+ * );
+ */
+export class Session {
+    /** @internal */
+    _native;
+    constructor(native) {
+        this._native = native;
+    }
+    /**
+     * Synchronous inference — blocks the event loop during TF_SessionRun.
+     * Use on Worker threads. On the main thread prefer runAsync().
+     *
+     * @param feeds    Array of [Tensor, FeedValue] pairs
+     * @param fetches  Tensors to compute and return
+     * @param targets  Op names to run for side-effects only (e.g. "init_all")
+     */
+    async run(feeds, fetches, targets = []) {
+        const nativeFeeds = feeds.map(([t, v]) => toNativeFeed(t, v));
+        const nativeFetches = fetches.map(toNativeFetch);
+        const raw = (await this._native.run(nativeFeeds, nativeFetches, targets));
+        return raw.map(fromNativeOutput);
+    }
+    /**
+     * Non-blocking inference — TF_SessionRun on the libuv thread pool.
+     * The event loop stays free for I/O and timers during compute.
+     *
+     * @param feeds    Array of [Tensor, FeedValue] pairs
+     * @param fetches  Tensors to compute and return
+     * @param targets  Op names to run for side-effects only
+     */
+    async runAsync(feeds, fetches, targets = []) {
+        const nativeFeeds = feeds.map(([t, v]) => toNativeFeed(t, v));
+        const nativeFetches = fetches.map(toNativeFetch);
+        const raw = (await this._native.runAsync(nativeFeeds, nativeFetches, targets));
+        return raw.map(fromNativeOutput);
+    }
+    /** Close the session and release all C++ resources. */
+    destroy() {
+        this._native.destroy();
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/ts/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/ts/session.ts"],"names":[],"mappings":"AA+CA,kDAAkD;AAClD,SAAS,YAAY,CAAC,CAAS,EAAE,CAAY;IAC3C,OAAO;QACL,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,KAAK,EAAE,CAAC,CAAC,KAAK;QACd,MAAM,EAAE;YACN,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;YACtB,KAAK,EAAE,CAAC,CAAC,KAAK;YACd,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;gBAC3B,CAAC,CAAC,CAAC,CAAC,IAAI;gBACR,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;SACrE;KACF,CAAC;AACJ,CAAC;AAED,mDAAmD;AACnD,SAAS,aAAa,CAAC,CAAS;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;AAC9C,CAAC;AAED,+CAA+C;AAC/C,SAAS,gBAAgB,CAAC,GAAQ;IAChC,OAAO;QACL,KAAK,EAAE,GAAG,CAAC,KAAc;QACzB,KAAK,EAAE,GAAG,CAAC,KAAiB;QAC5B,IAAI,EAAE,GAAG,CAAC,IAAc;KACzB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,OAAO;IAClB,gBAAgB;IACP,OAAO,CAAM;IAEtB,YAAY,MAAW;QACrB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,GAAG,CACP,KAA4B,EAC5B,OAAiB,EACjB,UAAoB,EAAE;QAEtB,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC9D,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACjD,MAAM,GAAG,GAAG,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CACjC,WAAW,EACX,aAAa,EACb,OAAO,CACR,CAAU,CAAC;QACZ,OAAO,GAAG,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,QAAQ,CACZ,KAA4B,EAC5B,OAAiB,EACjB,UAAoB,EAAE;QAEtB,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC9D,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACjD,MAAM,GAAG,GAAG,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CACtC,WAAW,EACX,aAAa,EACb,OAAO,CACR,CAAU,CAAC;QACZ,OAAO,GAAG,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IACnC,CAAC;IAED,uDAAuD;IACvD,OAAO;QACL,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IACzB,CAAC;CACF"}

package/package.json

@@ -0,0 +1,63 @@
+{
+    "name": "@isidorus/cpu",
+    "version": "0.0.0-alpha.0",
+    "description": "Tensorflow CPU graph construction, training, and inference for Node.js",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist",
+        "prebuilds",
+        "src/native",
+        "binding.gyp",
+        "package.json",
+        "scripts"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "scripts": {
+        "install": "node scripts/install.js",
+        "test": "node scripts/test.js",
+        "test:clean": "node -e \"require('fs').rmSync('./test/test.db', { force: true })\" && npm test",
+        "test:install": "node scripts/test-install.js",
+        "build:ts": "tsc -b",
+        "build:native": "npx --yes --package node-gyp node-gyp rebuild",
+        "build": "npm run build:ts && npm run build:native",
+        "prebuildify": "prebuildify --napi --strip --target 18.0.0 --target 20.0.0 --target 22.0.0 --target 24.0.0"
+    },
+    "binary": {
+        "napi_versions": [
+            8
+        ]
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/A-KGeorge/isidorus.git"
+    },
+    "publishConfig": {
+        "access": "public",
+        "provenance": true,
+        "registry": "https://registry.npmjs.org/"
+    },
+    "dependencies": {
+        "@isidorus/core": "*",
+        "jude-map": "*",
+        "jude-tf": "*",
+        "node-addon-api": "^8.6.0",
+        "node-gyp-build": "^4.8.4"
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.0",
+        "node-gyp": "^10.0.0",
+        "prebuildify": "^6.0.0",
+        "tsx": "^4.0.0",
+        "typescript": "^5.4.0"
+    },
+    "author": "Alan Kochukalam George",
+    "license": "Apache-2.0"
+}

package/scripts/install.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+/**
+ * Smart installation script for @isidorus/cpu native addon
+ *
+ * Strategy:
+ * - ARM architectures: Always compile locally (better performance tuning)
+ * - x64/ia32: Use prebuilt binaries from node-gyp-build (avoids C++ toolchain requirement)
+ *
+ * This ensures:
+ * 1. Most users (x64) get fast installs without needing build tools
+ * 2. ARM users get optimized builds for their specific hardware
+ */
+
+import { arch, platform } from "os";
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, "..");
+
+// Detect architecture
+const architecture = arch();
+const isArm = architecture.includes("arm") || architecture.includes("aarch");
+
+console.log(
+  `\nDetected platform: ${platform()}, architecture: ${architecture}`,
+);
+
+if (isArm) {
+  console.log(
+    "ARM architecture detected - compiling native addon locally for optimal performance...",
+  );
+
+  try {
+    // Check if node-gyp is available
+    try {
+      execSync("npx --yes --package node-gyp node-gyp --version", {
+        stdio: "ignore",
+      });
+    } catch (e) {
+      console.log("Installing node-gyp...");
+      execSync("npm install -g node-gyp", { stdio: "inherit" });
+    }
+
+    // Compile the native addon
+    console.log("Building native addon...");
+    execSync("npx --yes --package node-gyp node-gyp rebuild", {
+      cwd: projectRoot,
+      stdio: "inherit",
+      env: { ...process.env },
+    });
+
+    console.log("Native addon compiled successfully!");
+  } catch (error) {
+    console.error("Failed to compile native addon:");
+    console.error(error.message);
+    console.error("\nMake sure you have C++ build tools installed:");
+    console.error("   - macOS: xcode-select --install");
+    console.error("   - Linux: sudo apt-get install build-essential");
+    console.error("   - Windows: npm install --global windows-build-tools");
+    process.exit(1);
+  }
+} else {
+  console.log("x64 architecture detected - using prebuilt binary...");
+
+  // Check if prebuild exists
+  const prebuildsDir = join(projectRoot, "prebuilds");
+
+  if (!existsSync(prebuildsDir)) {
+    console.warn(
+      "No prebuilds directory found. Falling back to local compilation...",
+    );
+
+    try {
+      execSync("npx --yes --package node-gyp node-gyp rebuild", {
+        cwd: projectRoot,
+        stdio: "inherit",
+      });
+      console.log("Native addon compiled successfully!");
+    } catch (error) {
+      console.error("Failed to compile native addon:");
+      console.error(error.message);
+      console.error(
+        "\nThis package requires prebuilt binaries or a C++ toolchain.",
+      );
+      console.error(
+        "   Please report this issue at: https://github.com/A-KGeorge/isidorus/issues",
+      );
+      process.exit(1);
+    }
+  } else {
+    console.log("Using prebuilt binary - no compilation needed!");
+  }
+}
+
+console.log("Installation complete!\n");