@openfluke/welvet 0.3.0 → 0.75.0

package/dist/src/index.js

@@ -0,0 +1,207 @@
+/**
+ * @openfluke/welvet — M-POLY-VTD AI Engine
+ *
+ * Isomorphic TypeScript wrapper for the Loom v0.73.0 WASM module.
+ * Supports Node.js and browser environments.
+ *
+ * @example
+ * ```ts
+ * import { init, createNetwork, DType } from "@openfluke/welvet";
+ *
+ * await init();
+ *
+ * const net = createNetwork({
+ *   layers: [
+ *     { type: "dense", input_height: 4, output_height: 8 },
+ *     { type: "dense", input_height: 8, output_height: 2 },
+ *   ]
+ * });
+ *
+ * const output = net.sequentialForward(new Float32Array([1, 0, 0, 1]));
+ * console.log(output); // Float32Array [...]
+ * ```
+ */
+import { DType, LayerType, Activation } from "./types.js";
+import { loadLoomWASMBrowser } from "./loader.browser.js";
+// Re-export all types and constants
+export * from "./types.js";
+export { loadLoomWASMBrowser };
+// ──────────────────────────────────────────────────────────────────────────────
+// Initialization
+// ──────────────────────────────────────────────────────────────────────────────
+/**
+ * Initialize the welvet WASM module.
+ * Auto-detects Node.js vs browser environment.
+ *
+ * @param wasmUrl Optional custom URL for browser WASM loading (default: /dist/main.wasm)
+ */
+export async function init(wasmUrl) {
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+        return loadLoomWASMBrowser(wasmUrl);
+    }
+    const mod = await import("./loader.js");
+    return mod.loadLoomWASM();
+}
+/**
+ * Initialize explicitly for browser environments.
+ * @param wasmUrl Optional custom URL for WASM binary
+ */
+export async function initBrowser(wasmUrl) {
+    return loadLoomWASMBrowser(wasmUrl);
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// Network Lifecycle
+// ──────────────────────────────────────────────────────────────────────────────
+/**
+ * Build a VolumetricNetwork from a JSON configuration object or string.
+ *
+ * @example
+ * ```ts
+ * const net = createNetwork({
+ *   layers: [
+ *     { type: "dense", input_height: 784, output_height: 256 },
+ *     { type: "dense", input_height: 256, output_height: 10, activation: "silu" },
+ *   ]
+ * });
+ * ```
+ */
+export function createNetwork(config) {
+    const jsonConfig = typeof config === "string" ? config : JSON.stringify(config);
+    return createLoomNetwork(jsonConfig);
+}
+/**
+ * Load a pre-trained network from a SafeTensors file path.
+ * (Node.js only — requires file system access)
+ *
+ * @param path Absolute or relative path to a .safetensors file
+ */
+export function loadNetwork(path) {
+    return loadLoomNetwork(path);
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// WebGPU
+// ──────────────────────────────────────────────────────────────────────────────
+/**
+ * Initialize WebGPU (browser only).
+ * Sets window.webgpuAdapter, window.webgpuDevice, window.webgpuQueue.
+ */
+export async function setupWebGPU() {
+    // @ts-ignore — setupWebGPU is injected by the WASM module
+    return setupWebGPU();
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// DNA / Introspection
+// ──────────────────────────────────────────────────────────────────────────────
+/**
+ * Compare the architectural DNA of two networks.
+ *
+ * @param dnaA JSON string from network.extractDNA()
+ * @param dnaB JSON string from network.extractDNA()
+ * @returns DNACompareResult
+ */
+export function compareDNA(dnaA, dnaB) {
+    return JSON.parse(compareLoomDNA(dnaA, dnaB));
+}
+/**
+ * Get the default TargetPropConfig.
+ */
+export function defaultTargetPropConfig() {
+    return JSON.parse(getDefaultTargetPropConfig());
+}
+/**
+ * Get the internal parity symbol list from Go.
+ * Used for audits and verification.
+ */
+export function getInternalParity() {
+    if (typeof getLoomInternalParity === "function") {
+        return getLoomInternalParity();
+    }
+    return [];
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// Training Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+/**
+ * Convenience wrapper for network.train() that handles JSON serialization.
+ *
+ * @param network The network to train
+ * @param batches Array of {input, target} training pairs
+ * @param epochs Number of training epochs
+ * @param lr Learning rate
+ */
+export function trainNetwork(network, batches, epochs, lr) {
+    const serialized = batches.map((b) => {
+        const inp = b.input instanceof Float32Array ? b.input : new Float32Array(b.input);
+        const tgt = b.target instanceof Float32Array ? b.target : new Float32Array(b.target);
+        const inShape = b.inputShape ?? [1, inp.length];
+        const tgtShape = b.targetShape ?? [1, tgt.length];
+        return {
+            input: { shape: inShape, data: Array.from(inp) },
+            target: { shape: tgtShape, data: Array.from(tgt) },
+        };
+    });
+    return JSON.parse(network.train(JSON.stringify(serialized), epochs, lr));
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// Evolution / DNA
+// ──────────────────────────────────────────────────────────────────────────────
+/** Get the default SpliceConfig as a plain object. */
+export function getSpliceConfig() {
+    return JSON.parse(globalThis["defaultSpliceConfig"]());
+}
+/** Get the default NEATConfig as a plain object. */
+export function getNEATConfig(dModel) {
+    return JSON.parse(globalThis["defaultNEATConfig"](dModel));
+}
+/**
+ * Create a NEAT population from a seed network.
+ * @param network Seed network (its _id is used)
+ * @param size Population size
+ * @param cfg NEATConfig object or JSON string (defaults to getNEATConfig(64))
+ */
+export function createNEATPopulation(network, size, cfg) {
+    const cfgJSON = cfg
+        ? (typeof cfg === "string" ? cfg : JSON.stringify(cfg))
+        : globalThis["defaultNEATConfig"](64);
+    return globalThis["createLoomNEATPopulation"](network._id, size, cfgJSON);
+}
+/**
+ * Create a Transformer wrapper.
+ * @param network Network to use as the base
+ * @param embeddings Float32Array of embedding weights
+ * @param lmHead Float32Array of LM head weights
+ * @param finalNorm Float32Array of final norm weights
+ */
+export function createTransformer(network, embeddings, lmHead, finalNorm) {
+    return createLoomTransformer(network._id, embeddings, lmHead, finalNorm);
+}
+/**
+ * Save a network to a SafeTensors byte array.
+ */
+export function saveNetwork(network) {
+    // @ts-ignore
+    return network.saveSafetensors();
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// Default export
+// ──────────────────────────────────────────────────────────────────────────────
+export default {
+    init,
+    initBrowser,
+    createNetwork,
+    loadNetwork,
+    saveNetwork,
+    setupWebGPU,
+    compareDNA,
+    defaultTargetPropConfig,
+    getInternalParity,
+    trainNetwork,
+    getSpliceConfig,
+    getNEATConfig,
+    createNEATPopulation,
+    createTransformer,
+    // Re-export constants for convenience
+    DType,
+    LayerType,
+    Activation,
+};

package/dist/src/loader.browser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * welvet WASM Browser Loader
+ * Loads the Go runtime and WASM module in a browser environment.
+ */
+export declare function loadLoomWASMBrowser(wasmUrl?: string): Promise<void>;

package/dist/src/loader.browser.js

@@ -0,0 +1,24 @@
+/**
+ * welvet WASM Browser Loader
+ * Loads the Go runtime and WASM module in a browser environment.
+ */
+export async function loadLoomWASMBrowser(wasmUrl) {
+    // Inject wasm_exec.js if the Go runtime is not yet available
+    if (typeof globalThis["Go"] === "undefined") {
+        const script = document.createElement("script");
+        script.src = "/dist/wasm_exec.js";
+        await new Promise((resolve, reject) => {
+            script.onload = () => resolve();
+            script.onerror = () => reject(new Error("Failed to load wasm_exec.js"));
+            document.head.appendChild(script);
+        });
+    }
+    const response = await fetch(wasmUrl ?? "/dist/main.wasm");
+    const wasmBuffer = await response.arrayBuffer();
+    // @ts-ignore — Go is injected by wasm_exec.js
+    const go = new Go();
+    const { instance } = await WebAssembly.instantiate(wasmBuffer, go.importObject);
+    go.run(instance);
+    // Allow Go goroutines to settle
+    await new Promise((resolve) => setTimeout(resolve, 100));
+}

package/dist/src/loader.d.ts

@@ -0,0 +1,5 @@
+/**
+ * welvet WASM Loader — Node.js
+ * Loads and initializes the welvet WebAssembly module.
+ */
+export declare function loadLoomWASM(): Promise<void>;

package/dist/src/loader.js

@@ -0,0 +1,26 @@
+/**
+ * welvet WASM Loader — Node.js
+ * Loads and initializes the welvet WebAssembly module.
+ */
+export async function loadLoomWASM() {
+    const fs = await import("fs");
+    const url = await import("url");
+    const path = await import("path");
+    const __filename = url.fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    // Resolve root: dist/ in production, or one level up from src/
+    const root = __dirname.endsWith("dist")
+        ? __dirname
+        : path.join(__dirname, "..", "dist");
+    // Bootstrap Go runtime
+    const wasmExecCode = fs.readFileSync(path.join(root, "wasm_exec.js"), "utf-8");
+    eval(wasmExecCode);
+    // Load and instantiate the WASM module
+    const wasmBuffer = fs.readFileSync(path.join(root, "main.wasm"));
+    // @ts-ignore — Go is injected by wasm_exec.js
+    const go = new Go();
+    const { instance } = await WebAssembly.instantiate(wasmBuffer, go.importObject);
+    go.run(instance);
+    // Allow Go goroutines to settle
+    await new Promise((resolve) => setTimeout(resolve, 100));
+}

package/dist/src/types.d.ts

@@ -0,0 +1,354 @@
+/**
+ * welvet — Type Definitions for the M-POLY-VTD AI Engine
+ *
+ * Wraps the Loom v0.73.0 WASM module which supports 21 numerical types,
+ * systolic grid propagation, target propagation, and WebGPU acceleration.
+ */
+export declare const DType: {
+    readonly FLOAT64: 0;
+    readonly FLOAT32: 1;
+    readonly FLOAT16: 2;
+    readonly BFLOAT16: 3;
+    readonly FP8_E4M3: 4;
+    readonly FP8_E5M2: 5;
+    readonly INT64: 6;
+    readonly INT32: 7;
+    readonly INT16: 8;
+    readonly INT8: 9;
+    readonly UINT64: 10;
+    readonly UINT32: 11;
+    readonly UINT16: 12;
+    readonly UINT8: 13;
+    readonly INT4: 14;
+    readonly UINT4: 15;
+    readonly FP4: 16;
+    readonly INT2: 17;
+    readonly UINT2: 18;
+    readonly TERNARY: 19;
+    readonly BINARY: 20;
+};
+export type DTypeValue = typeof DType[keyof typeof DType];
+export declare const LayerType: {
+    readonly DENSE: 0;
+    readonly RMS_NORM: 1;
+    readonly LAYER_NORM: 2;
+    readonly MHA: 3;
+    readonly SOFTMAX: 4;
+    readonly SWIGLU: 5;
+    readonly EMBEDDING: 6;
+    readonly RESIDUAL: 7;
+    readonly KMEANS: 8;
+    readonly RNN: 9;
+    readonly LSTM: 10;
+    readonly CNN1: 11;
+    readonly CNN2: 12;
+    readonly CNN3: 13;
+    readonly CONV_TRANSPOSED_1D: 14;
+    readonly CONV_TRANSPOSED_2D: 15;
+    readonly CONV_TRANSPOSED_3D: 16;
+};
+export type LayerTypeValue = typeof LayerType[keyof typeof LayerType];
+export declare const Activation: {
+    readonly RELU: 0;
+    readonly SILU: 1;
+    readonly GELU: 2;
+    readonly TANH: 3;
+    readonly SIGMOID: 4;
+    readonly LINEAR: 5;
+};
+export type ActivationValue = typeof Activation[keyof typeof Activation];
+export interface LayerSpec {
+    /** Layer type (use LayerType constants) */
+    type: string | number;
+    /** Numerical precision (use DType constants, default: FLOAT32) */
+    dtype?: number;
+    /** Activation function (use Activation constants) */
+    activation?: string | number;
+    input_height?: number;
+    input_width?: number;
+    input_depth?: number;
+    output_height?: number;
+    output_width?: number;
+    output_depth?: number;
+    input_channels?: number;
+    filters?: number;
+    kernel_size?: number;
+    stride?: number;
+    padding?: number;
+    num_heads?: number;
+    num_kv_heads?: number;
+    d_model?: number;
+    seq_length?: number;
+    vocab_size?: number;
+    embedding_dim?: number;
+    z?: number;
+    y?: number;
+    x?: number;
+    l?: number;
+    tile_size?: number;
+}
+export interface NetworkConfig {
+    /** Grid depth (number of z-planes). Default: 1 */
+    depth?: number;
+    /** Grid rows (y-dimension). Default: 1 */
+    rows?: number;
+    /** Grid columns (x-dimension). Default: 1 */
+    cols?: number;
+    /** Layers per cell. Default: number of layers */
+    layers_per_cell?: number;
+    /** Layer definitions (flat list, laid out z→y→x→l) */
+    layers: LayerSpec[];
+}
+export interface TrainingBatch {
+    input: number[] | Float32Array;
+    target: number[] | Float32Array;
+    /** Optional batch shape for input, e.g. [batchSize, features]. Defaults to [1, length]. */
+    inputShape?: number[];
+    /** Optional batch shape for target, e.g. [batchSize, outputs]. Defaults to [1, length]. */
+    targetShape?: number[];
+}
+export interface TrainingResult {
+    final_loss: number;
+    duration_ms: number;
+    epochs_completed: number;
+    loss_history?: number[];
+}
+export interface SystolicState {
+    /**
+     * Inject input into the first layer of the grid.
+     * @param data Float32Array or number[] of input values
+     */
+    setInput(data: Float32Array | number[]): void;
+    /**
+     * Advance the systolic grid by one clock cycle.
+     * @param captureHistory Whether to store history for backpropagation
+     * @returns Duration of the step in milliseconds
+     */
+    step(captureHistory?: boolean): number;
+    /**
+     * Read the output of a layer (default: last active layer).
+     * @param layerIdx Optional layer index (0-based)
+     */
+    getOutput(layerIdx?: number): Float32Array;
+    /**
+     * Backpropagate gradients through the stored history.
+     * @param gradients Output gradient (Float32Array or number[])
+     * @returns Input gradient as Float32Array
+     */
+    backward(gradients: Float32Array | number[]): Float32Array;
+    /**
+     * Apply target propagation (gradient-free alternative to backward).
+     * @param target Global target tensor
+     * @param lr Learning rate
+     */
+    applyTargetProp(target: Float32Array | number[], lr: number): void;
+    /** Total number of systolic steps executed. */
+    stepCount(): number;
+    /** Release resources (no-op in WASM, included for API parity). */
+    free(): void;
+}
+export interface TargetPropState {
+    /**
+     * Forward pass through all layers, storing local targets.
+     * @param input Input data
+     * @returns Output as Float32Array
+     */
+    forward(input: Float32Array | number[]): Float32Array;
+    /**
+     * Backward pass using target propagation (gap-based, no chain rule).
+     * @param target Desired output
+     */
+    backward(target: Float32Array | number[]): void;
+    /**
+     * Backward pass using the chain rule (standard backprop via TP state).
+     * @param target Desired output
+     */
+    backwardChainRule(target: Float32Array | number[]): void;
+    /**
+     * Apply accumulated gap gradients to all layer weights.
+     * @param lr Learning rate
+     */
+    applyGaps(lr?: number): void;
+    /** Release resources (no-op in WASM). */
+    free(): void;
+}
+export interface Transformer {
+    /** Internal handle ID. */
+    _id: number;
+    /**
+     * Run a full prefill/inference pass.
+     * @param tokens Array of token IDs
+     * @returns Predicted logit tensor as Float32Array
+     */
+    forwardFull(tokens: number[] | Uint32Array): Float32Array;
+    /**
+     * Run inference using WebGPU acceleration.
+     * @param tokens Array of token IDs
+     * @returns Predicted logit tensor as Float32Array
+     */
+    forwardTokenIDsWGPU(tokens: number[] | Uint32Array): Promise<Float32Array>;
+    /**
+     * High-level prefill on GPU.
+     * @param tokens Array of token IDs
+     */
+    forwardWGPU(tokens: number[] | Uint32Array): Promise<void>;
+    /**
+     * Convert tokens to a tensor representation using the embedding layer.
+     * @param tokens Array of token IDs
+     */
+    tokensToTensor(tokens: number[] | Uint32Array): Float32Array;
+    /** Release resources. */
+    free(): void;
+}
+export interface NEATPopulation {
+    /** Internal handle ID. */
+    _id: number;
+    /** Number of networks in the population. */
+    size: number;
+    /** Get a network wrapper by index. */
+    getNetwork(index: number): Network;
+    /** Run one generation given pre-computed fitnesses (length must equal size). */
+    evolveWithFitnesses(fitnesses: number[]): void;
+    /** Return the best-performing network wrapper. */
+    best(): Network;
+    /** Return the best fitness score. */
+    bestFitness(): number;
+    /** Human-readable generation summary. */
+    summary(generation: number): string;
+    /** Release resources. */
+    free(): void;
+}
+export interface Network {
+    /**
+     * Full sequential forward pass through the network.
+     * @param input Float32Array or number[] of inputs
+     * @returns Output as Float32Array
+     */
+    sequentialForward(input: Float32Array | number[]): Float32Array;
+    /**
+     * Returns a JSON string with network shape info.
+     * {depth, rows, cols, layers_per_cell, total_layers, use_gpu, default_dtype}
+     */
+    getInfo(): string;
+    /**
+     * Extract the network's DNA fingerprint as a JSON string.
+     * Use compareLoomDNA() to compare two fingerprints.
+     */
+    extractDNA(): string;
+    /**
+     * Extract the network's full blueprint as a JSON string.
+     * @param modelID Optional model identifier
+     */
+    extractBlueprint(modelID?: string): string;
+    /** Total number of layers in the network. */
+    getLayerCount(): number;
+    /**
+     * Get the specification of a single layer.
+     * @param layerIdx 0-based layer index
+     * @returns JSON string with layer spec
+     */
+    getLayerSpec(layerIdx: number): string;
+    /**
+     * Switch a layer's numerical type at runtime (zero-cost when cached).
+     * @param layerIdx 0-based layer index
+     * @param dtype DType constant
+     * @returns JSON status/error
+     */
+    morphLayer(layerIdx: number, dtype: DTypeValue): string;
+    /**
+     * Initialize WebGPU for this network.
+     * @returns Promise that resolves with status JSON
+     */
+    initGPU(): Promise<string>;
+    /**
+     * Upload all layer weights to GPU buffers.
+     * @returns Promise that resolves with status JSON
+     */
+    syncToGPU(): Promise<string>;
+    /** Download weights back to CPU and disable GPU mode. */
+    syncToCPU(): void;
+    /**
+     * High-level supervised training loop.
+     * @param batchesJSON JSON string of TrainingBatch[]
+     * @param epochs Number of epochs
+     * @param lr Learning rate
+     * @returns JSON string with TrainingResult
+     */
+    train(batchesJSON: string, epochs: number, lr: number): string;
+    /**
+     * Create a SystolicState for the stepping API.
+     */
+    createSystolicState(): SystolicState;
+    /**
+     * Create a TargetPropState for gradient-free learning.
+     * @param useChainRule If true, uses chain-rule backprop instead of gap-based TP
+     */
+    createTargetPropState(useChainRule?: boolean): TargetPropState;
+    /**
+     * Genetic crossover with another network.
+     * @param otherID The `_id` of the other parent network
+     * @param cfgJSON JSON string from defaultSpliceConfig()
+     */
+    spliceDNA(otherID: number, cfgJSON: string): Network;
+    /**
+     * NEAT-style structural mutation.
+     * @param cfgJSON JSON string from defaultNEATConfig()
+     */
+    neatMutate(cfgJSON: string): Network;
+    /** Internal handle ID — required for spliceDNA and population operations. */
+    _id: number;
+    /** Release resources (no-op in WASM, included for API parity). */
+    free(): void;
+    /**
+     * Low-level polymorphic forward pass.
+     * @param input Input tensor data
+     */
+    forwardPolymorphic(input: Float32Array | number[]): Float32Array;
+    /**
+     * Get an individual layer wrapper.
+     * @param index 0-based layer index
+     */
+    getLayer(index: number): Layer;
+}
+export interface Layer {
+    /** Internal handle ID. */
+    _id: number;
+    /**
+     * Dispatch a forward pass through this layer only.
+     * @param input Input tensor
+     */
+    dispatch(input: Float32Array | number[]): Float32Array;
+    /** Sync weights to GPU. */
+    syncToGPU(): Promise<void>;
+    /** Release resources. */
+    free(): void;
+}
+export interface DNACompareResult {
+    similarity: number;
+    layer_count_match: boolean;
+    depth_match: boolean;
+    architecture_match: boolean;
+    [key: string]: unknown;
+}
+declare global {
+    /** Build a VolumetricNetwork from a JSON config string. */
+    function createLoomNetwork(jsonConfig: string): Network;
+    /** Load a network from a SafeTensors file path. */
+    function loadLoomNetwork(path: string): Network;
+    /** Initialize WebGPU (returns a Promise). */
+    function setupWebGPU(): Promise<string>;
+    /** Compare two DNA JSON strings for architectural similarity. */
+    function compareLoomDNA(dnaA: string, dnaB: string): string;
+    /** Get the default TargetPropConfig. */
+    function getDefaultTargetPropConfig(): string;
+    /** Get the default SpliceConfig JSON string. */
+    function defaultSpliceConfig(): string;
+    /** Get the default NEATConfig JSON string for a given model dimension. */
+    function defaultNEATConfig(dModel: number): string;
+    /** Create a NEAT population from a seed network. */
+    function createLoomNEATPopulation(seedID: number, size: number, cfgJSON: string): NEATPopulation;
+    /** Create a Transformer from a network and weights. */
+    function createLoomTransformer(networkID: number, embeddings: Float32Array | number[], lmHead: Float32Array | number[], finalNorm: Float32Array | number[]): Transformer;
+    /** Get the internal parity symbol list from Go. */
+    function getLoomInternalParity(): string[];
+}

package/dist/src/types.js

@@ -0,0 +1,65 @@
+/**
+ * welvet — Type Definitions for the M-POLY-VTD AI Engine
+ *
+ * Wraps the Loom v0.73.0 WASM module which supports 21 numerical types,
+ * systolic grid propagation, target propagation, and WebGPU acceleration.
+ */
+// ──────────────────────────────────────────────────────────────────────────────
+// Numerical Type Constants (matches poly.DType)
+// ──────────────────────────────────────────────────────────────────────────────
+export const DType = {
+    FLOAT64: 0,
+    FLOAT32: 1,
+    FLOAT16: 2,
+    BFLOAT16: 3,
+    FP8_E4M3: 4,
+    FP8_E5M2: 5,
+    INT64: 6,
+    INT32: 7,
+    INT16: 8,
+    INT8: 9,
+    UINT64: 10,
+    UINT32: 11,
+    UINT16: 12,
+    UINT8: 13,
+    INT4: 14,
+    UINT4: 15,
+    FP4: 16,
+    INT2: 17,
+    UINT2: 18,
+    TERNARY: 19,
+    BINARY: 20,
+};
+// ──────────────────────────────────────────────────────────────────────────────
+// Layer Type Constants (matches poly.LayerType)
+// ──────────────────────────────────────────────────────────────────────────────
+export const LayerType = {
+    DENSE: 0,
+    RMS_NORM: 1,
+    LAYER_NORM: 2,
+    MHA: 3,
+    SOFTMAX: 4,
+    SWIGLU: 5,
+    EMBEDDING: 6,
+    RESIDUAL: 7,
+    KMEANS: 8,
+    RNN: 9,
+    LSTM: 10,
+    CNN1: 11,
+    CNN2: 12,
+    CNN3: 13,
+    CONV_TRANSPOSED_1D: 14,
+    CONV_TRANSPOSED_2D: 15,
+    CONV_TRANSPOSED_3D: 16,
+};
+// ──────────────────────────────────────────────────────────────────────────────
+// Activation Type Constants (matches poly.ActivationType)
+// ──────────────────────────────────────────────────────────────────────────────
+export const Activation = {
+    RELU: 0,
+    SILU: 1,
+    GELU: 2,
+    TANH: 3,
+    SIGMOID: 4,
+    LINEAR: 5,
+};