@neuralforge/core 0.9.0

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@neuralforge/core",
+  "version": "0.9.0",
+  "description": "ML inference SDK for JavaScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "lint": "eslint src/"
+  },
+  "dependencies": {
+    "typescript": "^5.4.0"
+  },
+  "devDependencies": {
+    "vitest": "^1.6.0",
+    "eslint": "^8.57.0"
+  }
+}

package/src/backend/cpu.ts

@@ -0,0 +1,22 @@
+/**
+ * CPU backend
+ */
+
+export interface BackendOptions {
+  device?: string;
+  precision?: 'float32' | 'float16';
+}
+
+export class CPUBackend {
+  private options: BackendOptions;
+
+  constructor(options: BackendOptions = {}) {
+    this.options = options;
+  }
+
+  async initialize(): Promise<void> { /* CPU init */ }
+  isSupported(): boolean { return true; }
+  getName(): string { return 'CPU'; }
+  dispose(): void { /* cleanup */ }
+}
+

package/src/backend/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Backend registry
+ */
+
+export { WebGLBackend } from './webgl';
+export { WebGPUBackend } from './webgpu';
+export { WasmBackend } from './wasm';
+export { CPUBackend } from './cpu';
+

package/src/backend/wasm.ts

@@ -0,0 +1,22 @@
+/**
+ * WASM backend
+ */
+
+export interface BackendOptions {
+  device?: string;
+  precision?: 'float32' | 'float16';
+}
+
+export class WasmBackend {
+  private options: BackendOptions;
+
+  constructor(options: BackendOptions = {}) {
+    this.options = options;
+  }
+
+  async initialize(): Promise<void> { /* Wasm init */ }
+  isSupported(): boolean { return true; }
+  getName(): string { return 'Wasm'; }
+  dispose(): void { /* cleanup */ }
+}
+

package/src/backend/webgl.ts

@@ -0,0 +1,22 @@
+/**
+ * WebGL backend
+ */
+
+export interface BackendOptions {
+  device?: string;
+  precision?: 'float32' | 'float16';
+}
+
+export class WebGLBackend {
+  private options: BackendOptions;
+
+  constructor(options: BackendOptions = {}) {
+    this.options = options;
+  }
+
+  async initialize(): Promise<void> { /* WebGL init */ }
+  isSupported(): boolean { return true; }
+  getName(): string { return 'WebGL'; }
+  dispose(): void { /* cleanup */ }
+}
+

package/src/backend/webgpu.ts

@@ -0,0 +1,22 @@
+/**
+ * WebGPU backend
+ */
+
+export interface BackendOptions {
+  device?: string;
+  precision?: 'float32' | 'float16';
+}
+
+export class WebGPUBackend {
+  private options: BackendOptions;
+
+  constructor(options: BackendOptions = {}) {
+    this.options = options;
+  }
+
+  async initialize(): Promise<void> { /* WebGPU init */ }
+  isSupported(): boolean { return true; }
+  getName(): string { return 'WebGPU'; }
+  dispose(): void { /* cleanup */ }
+}
+

package/src/index.ts

@@ -0,0 +1,8 @@
+/**
+ * NeuralForge Core SDK
+ */
+
+export { Tensor } from './tensor';
+export { Model } from './model';
+export { InferenceSession } from './session';
+

package/src/model.ts

@@ -0,0 +1,28 @@
+/**
+ * Model loading and management
+ */
+
+import { Tensor } from './tensor';
+
+export interface ModelConfig {
+  inputShape: number[];
+  outputShape: number[];
+  weights?: Record<string, Tensor>;
+}
+
+export class Model {
+  private config: ModelConfig;
+  private weights: Map<string, Tensor> = new Map();
+
+  constructor(config: ModelConfig) {
+    this.config = config;
+    if (config.weights) {
+      Object.entries(config.weights).forEach(([k, v]) => this.weights.set(k, v));
+    }
+  }
+
+  predict(input: Tensor): Tensor { return input; }
+  getWeight(name: string): Tensor | undefined { return this.weights.get(name); }
+  summary(): string { return JSON.stringify(this.config); }
+}
+

package/src/ops/activation.ts

@@ -0,0 +1,7 @@
+/**
+ * Activation ops
+ */
+
+export function relu(x: Float32Array): Float32Array { return x.map(v => Math.max(0, v)) as unknown as Float32Array; }
+export function sigmoid(x: Float32Array): Float32Array { return x; }
+

package/src/ops/arithmetic.ts

@@ -0,0 +1,8 @@
+/**
+ * Arithmetic ops
+ */
+
+export function add(a: Float32Array, b: Float32Array): Float32Array { return a; }
+export function mul(a: Float32Array, b: Float32Array): Float32Array { return a; }
+export function sub(a: Float32Array, b: Float32Array): Float32Array { return a; }
+

package/src/ops/conv.ts

@@ -0,0 +1,6 @@
+/**
+ * Convolution ops
+ */
+
+export function conv2d(input: Float32Array, kernel: Float32Array, stride: number = 1): Float32Array { return input; }
+

package/src/ops/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Operations
+ */
+
+export * from './arithmetic';
+export * from './matrix';
+export * from './activation';
+export * from './conv';
+

package/src/ops/matrix.ts

@@ -0,0 +1,6 @@
+/**
+ * Matrix ops
+ */
+
+export function matmul(a: Float32Array, b: Float32Array, m: number, n: number, k: number): Float32Array { return new Float32Array(m * n); }
+

package/src/session.ts

@@ -0,0 +1,23 @@
+/**
+ * Inference session
+ */
+
+import { Model, ModelConfig } from './model';
+import { Tensor } from './tensor';
+
+export class InferenceSession {
+  private model: Model;
+  private initialized = false;
+
+  constructor(config: ModelConfig) {
+    this.model = new Model(config);
+  }
+
+  async initialize(): Promise<void> { this.initialized = true; }
+  run(inputs: Record<string, Tensor>): Record<string, Tensor> {
+    if (!this.initialized) throw new Error('Session not initialized');
+    return { output: this.model.predict(Object.values(inputs)[0]) };
+  }
+  dispose(): void { this.initialized = false; }
+}
+

package/src/tensor.ts

@@ -0,0 +1,23 @@
+/**
+ * Tensor implementation
+ */
+
+export type DType = 'float32' | 'float16' | 'int32';
+
+export class Tensor {
+  readonly data: Float32Array;
+  readonly shape: number[];
+  readonly dtype: DType;
+
+  constructor(data: Float32Array | number[], shape?: number[], dtype: DType = 'float32') {
+    this.data = data instanceof Float32Array ? data : new Float32Array(data);
+    this.shape = shape || [this.data.length];
+    this.dtype = dtype;
+  }
+
+  get size(): number { return this.data.length; }
+  reshape(newShape: number[]): Tensor { return new Tensor(this.data, newShape, this.dtype); }
+  slice(start: number, end: number): Tensor { return new Tensor(this.data.slice(start, end)); }
+  clone(): Tensor { return new Tensor(new Float32Array(this.data), [...this.shape], this.dtype); }
+}
+

package/src/utils/dtype.ts

@@ -0,0 +1,7 @@
+/**
+ * Data type utils
+ */
+
+export type DType = 'float32' | 'float16' | 'int32' | 'int8';
+export function inferDtype(data: ArrayBufferView): DType { return 'float32'; }
+

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Utilities
+ */
+
+export { inferDtype } from './dtype';
+export { validateShape } from './shape';
+

package/src/utils/shape.ts

@@ -0,0 +1,7 @@
+/**
+ * Shape validation
+ */
+
+export function validateShape(shape: number[]): boolean { return shape.every(d => d > 0); }
+export function computeStrides(shape: number[]): number[] { return shape; }
+

package/tests/model.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import { Model } from '../src';
+
+describe('Model', () => {
+  it('should be defined', () => {
+    expect(Model).toBeDefined();
+  });
+
+  it('should initialize correctly', () => {
+    const instance = new Model();
+    expect(instance).toBeInstanceOf(Model);
+  });
+});

package/tests/ops.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import { add } from '../src';
+
+describe('add', () => {
+  it('should be defined', () => {
+    expect(add).toBeDefined();
+  });
+
+  it('should initialize correctly', () => {
+    const instance = new add();
+    expect(instance).toBeInstanceOf(add);
+  });
+});

package/tests/tensor.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import { Tensor } from '../src';
+
+describe('Tensor', () => {
+  it('should be defined', () => {
+    expect(Tensor).toBeDefined();
+  });
+
+  it('should initialize correctly', () => {
+    const instance = new Tensor();
+    expect(instance).toBeInstanceOf(Tensor);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  }
+}