@hanzo/browser-extension 1.9.31 → 1.9.33

package/dist/browser-extension/webgpu-ai.js

@@ -1,568 +0,0 @@
-// src/webgpu-ai.ts
-var WebGPUAI = class {
-  constructor() {
-    this.device = null;
-    this.models = /* @__PURE__ */ new Map();
-    // ---------------------------------------------------------------------------
-    // BPE Tokenizer (byte-level, GPT-2 compatible)
-    // ---------------------------------------------------------------------------
-    this.byteEncoder = {};
-    this.byteDecoder = {};
-    this.byteEncoderInitialized = false;
-    // ---------------------------------------------------------------------------
-    // WGSL Compute Shaders
-    // ---------------------------------------------------------------------------
-    this.matmulShader = `
-    @group(0) @binding(0) var<storage, read> weights: array<f32>;
-    @group(0) @binding(1) var<storage, read> input_tokens: array<f32>;
-    @group(0) @binding(2) var<storage, read_write> output_logits: array<f32>;
-    @group(0) @binding(3) var<storage, read> params: array<u32>;
-
-    // params[0] = input_size
-    // params[1] = output_size (vocab_size)
-    // params[2] = weights_offset
-
-    @compute @workgroup_size(256)
-    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-      let out_idx = gid.x;
-      let input_size = params[0];
-      let output_size = params[1];
-      let w_offset = params[2];
-
-      if (out_idx >= output_size) {
-        return;
-      }
-
-      var sum: f32 = 0.0;
-      for (var j: u32 = 0u; j < input_size; j = j + 1u) {
-        let w_idx = w_offset + out_idx * input_size + j;
-        if (w_idx < arrayLength(&weights)) {
-          sum = sum + weights[w_idx] * input_tokens[j];
-        }
-      }
-      output_logits[out_idx] = sum;
-    }
-  `;
-    this.softmaxShader = `
-    @group(0) @binding(0) var<storage, read_write> data: array<f32>;
-    @group(0) @binding(1) var<storage, read> size_buf: array<u32>;
-
-    @compute @workgroup_size(1)
-    fn main() {
-      let size = size_buf[0];
-
-      var max_val: f32 = data[0];
-      for (var i: u32 = 1u; i < size; i = i + 1u) {
-        if (data[i] > max_val) {
-          max_val = data[i];
-        }
-      }
-
-      var sum: f32 = 0.0;
-      for (var i: u32 = 0u; i < size; i = i + 1u) {
-        let e = exp(data[i] - max_val);
-        data[i] = e;
-        sum = sum + e;
-      }
-
-      for (var i: u32 = 0u; i < size; i = i + 1u) {
-        data[i] = data[i] / sum;
-      }
-    }
-  `;
-  }
-  async initialize() {
-    if (!navigator.gpu) {
-      console.warn("[Hanzo AI] WebGPU not supported in this browser");
-      return false;
-    }
-    try {
-      const adapter = await navigator.gpu.requestAdapter({
-        powerPreference: "high-performance"
-      });
-      if (!adapter) {
-        console.warn("[Hanzo AI] No GPU adapter found");
-        return false;
-      }
-      this.device = await adapter.requestDevice({
-        requiredLimits: {
-          maxStorageBufferBindingSize: adapter.limits?.maxStorageBufferBindingSize || 134217728,
-          maxBufferSize: adapter.limits?.maxBufferSize || 268435456
-        }
-      });
-      this.device.lost.then((info) => {
-        console.error("[Hanzo AI] GPU device lost:", info.message);
-        this.device = null;
-      });
-      console.log("[Hanzo AI] WebGPU initialized successfully");
-      const features = adapter.features;
-      console.log("[Hanzo AI] GPU Features:", Array.from(features));
-      return true;
-    } catch (error) {
-      console.error("[Hanzo AI] WebGPU initialization failed:", error);
-      return false;
-    }
-  }
-  initByteEncoder() {
-    if (this.byteEncoderInitialized) return;
-    const bs = [];
-    for (let i = 33; i <= 126; i++) bs.push(i);
-    for (let i = 161; i <= 172; i++) bs.push(i);
-    for (let i = 174; i <= 255; i++) bs.push(i);
-    const cs = bs.slice();
-    let n = 0;
-    for (let b = 0; b < 256; b++) {
-      if (!bs.includes(b)) {
-        bs.push(b);
-        cs.push(256 + n);
-        n++;
-      }
-    }
-    for (let i = 0; i < bs.length; i++) {
-      this.byteEncoder[bs[i]] = String.fromCharCode(cs[i]);
-      this.byteDecoder[String.fromCharCode(cs[i])] = bs[i];
-    }
-    this.byteEncoderInitialized = true;
-  }
-  tokenize(text, model) {
-    this.initByteEncoder();
-    if (!model.vocab.length) {
-      const tokens2 = [];
-      for (let i = 0; i < text.length; i++) {
-        tokens2.push(text.charCodeAt(i));
-      }
-      return tokens2;
-    }
-    const bytes = new TextEncoder().encode(text);
-    let word = "";
-    for (const b of bytes) {
-      word += this.byteEncoder[b] || String.fromCharCode(b);
-    }
-    const tokens = [];
-    let pos = 0;
-    while (pos < word.length) {
-      let bestLen = 0;
-      let bestIdx = -1;
-      const maxLen = Math.min(word.length - pos, 50);
-      for (let len = maxLen; len >= 1; len--) {
-        const candidate = word.substring(pos, pos + len);
-        const idx = model.vocabIndex.get(candidate);
-        if (idx !== void 0) {
-          bestLen = len;
-          bestIdx = idx;
-          break;
-        }
-      }
-      if (bestIdx !== -1) {
-        tokens.push(bestIdx);
-        pos += bestLen;
-      } else {
-        tokens.push(word.charCodeAt(pos) % Math.max(model.vocab.length, 1));
-        pos++;
-      }
-    }
-    return tokens;
-  }
-  detokenize(tokenIds, model) {
-    this.initByteEncoder();
-    if (!model.vocab.length) {
-      const arr = tokenIds instanceof Int32Array ? Array.from(tokenIds) : tokenIds;
-      return String.fromCharCode(...arr.filter((t) => t > 0 && t < 65536));
-    }
-    let byteStr = "";
-    for (const id of tokenIds) {
-      if (id >= 0 && id < model.vocab.length) {
-        byteStr += model.vocab[id];
-      }
-    }
-    const decoded = [];
-    for (const ch of byteStr) {
-      if (ch in this.byteDecoder) {
-        decoded.push(this.byteDecoder[ch]);
-      } else {
-        decoded.push(ch.charCodeAt(0) & 255);
-      }
-    }
-    return new TextDecoder().decode(new Uint8Array(decoded));
-  }
-  // ---------------------------------------------------------------------------
-  // Model Loading
-  // ---------------------------------------------------------------------------
-  async loadModel(config) {
-    if (!this.device) {
-      throw new Error("WebGPU not initialized");
-    }
-    console.log(`[Hanzo AI] Loading model: ${config.name}`);
-    const modelData = await this._fetchWithCache(config.url, config.name);
-    const modelBuffer = this.device.createBuffer({
-      size: modelData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-      label: `model-${config.name}`
-    });
-    this.device.queue.writeBuffer(modelBuffer, 0, modelData);
-    let vocab = [];
-    const vocabIndex = /* @__PURE__ */ new Map();
-    if (config.vocabUrl) {
-      try {
-        const vocabResp = await fetch(config.vocabUrl);
-        if (vocabResp.ok) {
-          const vocabData = await vocabResp.json();
-          if (Array.isArray(vocabData)) {
-            vocab = vocabData;
-          } else if (typeof vocabData === "object") {
-            const entries = Object.entries(vocabData);
-            entries.sort((a, b) => a[1] - b[1]);
-            vocab = entries.map((e) => e[0]);
-          }
-          for (let i = 0; i < vocab.length; i++) {
-            vocabIndex.set(vocab[i], i);
-          }
-        }
-      } catch (e) {
-        console.warn(`[Hanzo AI] Vocabulary load failed for ${config.name}:`, e);
-      }
-    }
-    this.models.set(config.name, {
-      buffer: modelBuffer,
-      config,
-      vocab,
-      vocabIndex
-    });
-    console.log(`[Hanzo AI] Model ${config.name} loaded: ${modelData.byteLength} bytes, vocab: ${vocab.length}`);
-  }
-  // ---------------------------------------------------------------------------
-  // Inference
-  // ---------------------------------------------------------------------------
-  async runInference(modelName, input) {
-    const model = this.models.get(modelName);
-    if (!model || !this.device) {
-      throw new Error(`Model ${modelName} not loaded or GPU unavailable`);
-    }
-    const tokens = this.tokenize(input, model);
-    const vocabSize = Math.max(model.vocab.length, 256);
-    const inputSize = Math.min(tokens.length, 2048);
-    const maxTokens = model.config.maxTokens || 128;
-    const inputData = new Float32Array(inputSize);
-    for (let i = 0; i < inputSize; i++) {
-      inputData[i] = tokens[i] / vocabSize;
-    }
-    const inputBuffer = this.device.createBuffer({
-      size: inputData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-      label: "input"
-    });
-    this.device.queue.writeBuffer(inputBuffer, 0, inputData);
-    const outputByteSize = vocabSize * 4;
-    const outputBuffer = this.device.createBuffer({
-      size: outputByteSize,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
-      label: "output"
-    });
-    const paramsData = new Uint32Array([inputSize, vocabSize, 0]);
-    const paramsBuffer = this.device.createBuffer({
-      size: paramsData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-      label: "params"
-    });
-    this.device.queue.writeBuffer(paramsBuffer, 0, paramsData);
-    const readBuffer = this.device.createBuffer({
-      size: outputByteSize,
-      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-      label: "readback"
-    });
-    const matmulModule = this.device.createShaderModule({ code: this.matmulShader });
-    const matmulLayout = this.device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-        { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
-        { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } }
-      ]
-    });
-    const matmulPipeline = this.device.createComputePipeline({
-      layout: this.device.createPipelineLayout({ bindGroupLayouts: [matmulLayout] }),
-      compute: { module: matmulModule, entryPoint: "main" }
-    });
-    const matmulBindGroup = this.device.createBindGroup({
-      layout: matmulLayout,
-      entries: [
-        { binding: 0, resource: { buffer: model.buffer } },
-        { binding: 1, resource: { buffer: inputBuffer } },
-        { binding: 2, resource: { buffer: outputBuffer } },
-        { binding: 3, resource: { buffer: paramsBuffer } }
-      ]
-    });
-    const softmaxModule = this.device.createShaderModule({ code: this.softmaxShader });
-    const softmaxLayout = this.device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
-        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } }
-      ]
-    });
-    const sizeBuf = this.device.createBuffer({
-      size: 4,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-    });
-    this.device.queue.writeBuffer(sizeBuf, 0, new Uint32Array([vocabSize]));
-    const softmaxPipeline = this.device.createComputePipeline({
-      layout: this.device.createPipelineLayout({ bindGroupLayouts: [softmaxLayout] }),
-      compute: { module: softmaxModule, entryPoint: "main" }
-    });
-    const softmaxBindGroup = this.device.createBindGroup({
-      layout: softmaxLayout,
-      entries: [
-        { binding: 0, resource: { buffer: outputBuffer } },
-        { binding: 1, resource: { buffer: sizeBuf } }
-      ]
-    });
-    const generatedTokens = [];
-    const temperature = 0.7;
-    for (let step = 0; step < maxTokens; step++) {
-      const encoder = this.device.createCommandEncoder();
-      const matmulPass = encoder.beginComputePass();
-      matmulPass.setPipeline(matmulPipeline);
-      matmulPass.setBindGroup(0, matmulBindGroup);
-      matmulPass.dispatchWorkgroups(Math.ceil(vocabSize / 256));
-      matmulPass.end();
-      const softmaxPass = encoder.beginComputePass();
-      softmaxPass.setPipeline(softmaxPipeline);
-      softmaxPass.setBindGroup(0, softmaxBindGroup);
-      softmaxPass.dispatchWorkgroups(1);
-      softmaxPass.end();
-      encoder.copyBufferToBuffer(outputBuffer, 0, readBuffer, 0, outputByteSize);
-      this.device.queue.submit([encoder.finish()]);
-      await readBuffer.mapAsync(GPUMapMode.READ);
-      const probs = new Float32Array(readBuffer.getMappedRange().slice(0));
-      readBuffer.unmap();
-      const nextToken = this.sampleToken(probs, temperature);
-      generatedTokens.push(nextToken);
-      if (nextToken === 0 || nextToken === 2) break;
-      const newInput = new Float32Array([nextToken / vocabSize]);
-      this.device.queue.writeBuffer(inputBuffer, 0, newInput);
-      paramsData[0] = 1;
-      this.device.queue.writeBuffer(paramsBuffer, 0, paramsData);
-    }
-    inputBuffer.destroy();
-    outputBuffer.destroy();
-    paramsBuffer.destroy();
-    readBuffer.destroy();
-    sizeBuf.destroy();
-    return this.detokenize(generatedTokens, model);
-  }
-  sampleToken(probs, temperature) {
-    if (temperature <= 0) {
-      let maxIdx = 0;
-      let maxVal = probs[0];
-      for (let i = 1; i < probs.length; i++) {
-        if (probs[i] > maxVal) {
-          maxVal = probs[i];
-          maxIdx = i;
-        }
-      }
-      return maxIdx;
-    }
-    const scaled = new Float32Array(probs.length);
-    let sum = 0;
-    for (let i = 0; i < probs.length; i++) {
-      scaled[i] = Math.exp(Math.log(Math.max(probs[i], 1e-10)) / temperature);
-      sum += scaled[i];
-    }
-    for (let i = 0; i < scaled.length; i++) {
-      scaled[i] /= sum;
-    }
-    const r = Math.random();
-    let cumulative = 0;
-    for (let i = 0; i < scaled.length; i++) {
-      cumulative += scaled[i];
-      if (r < cumulative) return i;
-    }
-    return scaled.length - 1;
-  }
-  // ---------------------------------------------------------------------------
-  // Embedding computation (for DOM element analysis)
-  // ---------------------------------------------------------------------------
-  async computeEmbedding(modelName, text) {
-    const model = this.models.get(modelName);
-    if (!model || !this.device) {
-      throw new Error(`Model ${modelName} not loaded or GPU unavailable`);
-    }
-    const tokens = this.tokenize(text, model);
-    const inputSize = Math.min(tokens.length, 512);
-    const embeddingDim = 256;
-    const inputData = new Float32Array(inputSize);
-    for (let i = 0; i < inputSize; i++) {
-      inputData[i] = tokens[i];
-    }
-    const inputBuffer = this.device.createBuffer({
-      size: inputData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-    });
-    this.device.queue.writeBuffer(inputBuffer, 0, inputData);
-    const embeddingBuffer = this.device.createBuffer({
-      size: embeddingDim * 4,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
-    });
-    const paramData = new Uint32Array([inputSize, embeddingDim, 0]);
-    const paramBuffer = this.device.createBuffer({
-      size: paramData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-    });
-    this.device.queue.writeBuffer(paramBuffer, 0, paramData);
-    const shaderModule = this.device.createShaderModule({ code: this.matmulShader });
-    const layout = this.device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-        { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
-        { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } }
-      ]
-    });
-    const pipeline = this.device.createComputePipeline({
-      layout: this.device.createPipelineLayout({ bindGroupLayouts: [layout] }),
-      compute: { module: shaderModule, entryPoint: "main" }
-    });
-    const bindGroup = this.device.createBindGroup({
-      layout,
-      entries: [
-        { binding: 0, resource: { buffer: model.buffer } },
-        { binding: 1, resource: { buffer: inputBuffer } },
-        { binding: 2, resource: { buffer: embeddingBuffer } },
-        { binding: 3, resource: { buffer: paramBuffer } }
-      ]
-    });
-    const readBuffer = this.device.createBuffer({
-      size: embeddingDim * 4,
-      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-    });
-    const encoder = this.device.createCommandEncoder();
-    const pass = encoder.beginComputePass();
-    pass.setPipeline(pipeline);
-    pass.setBindGroup(0, bindGroup);
-    pass.dispatchWorkgroups(Math.ceil(embeddingDim / 256));
-    pass.end();
-    encoder.copyBufferToBuffer(embeddingBuffer, 0, readBuffer, 0, embeddingDim * 4);
-    this.device.queue.submit([encoder.finish()]);
-    await readBuffer.mapAsync(GPUMapMode.READ);
-    const embedding = new Float32Array(readBuffer.getMappedRange().slice(0));
-    readBuffer.unmap();
-    let norm = 0;
-    for (let i = 0; i < embedding.length; i++) {
-      norm += embedding[i] * embedding[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-      for (let i = 0; i < embedding.length; i++) {
-        embedding[i] /= norm;
-      }
-    }
-    inputBuffer.destroy();
-    embeddingBuffer.destroy();
-    paramBuffer.destroy();
-    readBuffer.destroy();
-    return embedding;
-  }
-  // ---------------------------------------------------------------------------
-  // Cached, progress-reporting fetch — used by loadModel().
-  // ---------------------------------------------------------------------------
-  /**
-   * Fetch a model blob with persistent caching. Backed by the service-worker
-   * Cache API so the bytes survive worker restarts and only download once
-   * per URL. Streams the body to log progress every ~5% so big artifacts
-   * (huggingface.co/<repo>/resolve/main/<file>) don't appear to hang.
-   *
-   * Cache invalidation: the URL is the key; bump the URL (e.g. point to a
-   * different revision sha) to force a re-fetch. Use ``WebGPUAI.evictCache``
-   * to wipe everything when models go bad.
-   */
-  async _fetchWithCache(url, label) {
-    const cacheName = "hanzo-webgpu-models-v1";
-    const cache = typeof caches !== "undefined" ? await caches.open(cacheName) : null;
-    if (cache) {
-      const hit = await cache.match(url);
-      if (hit) {
-        console.log(`[Hanzo AI] Cache hit: ${label} (${url})`);
-        return await hit.arrayBuffer();
-      }
-    }
-    console.log(`[Hanzo AI] Fetching: ${label} (${url})`);
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch ${label}: ${response.status} ${response.statusText}`);
-    }
-    const total = Number(response.headers.get("content-length") || 0);
-    let received = 0;
-    let nextLog = total > 0 ? Math.floor(total * 0.05) : Infinity;
-    const chunks = [];
-    if (response.body) {
-      const reader = response.body.getReader();
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        chunks.push(value);
-        received += value.byteLength;
-        if (total > 0 && received >= nextLog) {
-          const pct = Math.floor(received / total * 100);
-          console.log(`[Hanzo AI] ${label}: ${pct}% (${received}/${total} bytes)`);
-          nextLog = received + Math.floor(total * 0.05);
-        }
-      }
-    } else {
-      chunks.push(new Uint8Array(await response.arrayBuffer()));
-    }
-    const blob = new Uint8Array(received || chunks.reduce((n, c) => n + c.byteLength, 0));
-    let offset = 0;
-    for (const c of chunks) {
-      blob.set(c, offset);
-      offset += c.byteLength;
-    }
-    console.log(`[Hanzo AI] Fetched: ${label} (${blob.byteLength} bytes)`);
-    if (cache) {
-      try {
-        await cache.put(url, new Response(blob, {
-          headers: { "content-type": "application/octet-stream" }
-        }));
-        console.log(`[Hanzo AI] Cached: ${label}`);
-      } catch (e) {
-        console.warn(`[Hanzo AI] Cache write failed for ${label}:`, e);
-      }
-    }
-    return blob.buffer;
-  }
-  /** Build an HF resolve URL for a given repo / file / revision. */
-  static huggingFaceURL(repo, file, revision = "main") {
-    return `https://huggingface.co/${repo}/resolve/${revision}/${file}`;
-  }
-  /** Wipe every cached model blob. Useful when a model artifact is rotated. */
-  static async evictCache() {
-    if (typeof caches === "undefined") return;
-    await caches.delete("hanzo-webgpu-models-v1");
-    console.log("[Hanzo AI] WebGPU model cache evicted");
-  }
-  // ---------------------------------------------------------------------------
-  // Status / Cleanup
-  // ---------------------------------------------------------------------------
-  getStatus() {
-    return {
-      initialized: !!this.device,
-      models: Array.from(this.models.keys())
-    };
-  }
-  async unloadModel(name) {
-    const model = this.models.get(name);
-    if (model) {
-      model.buffer.destroy();
-      this.models.delete(name);
-      console.log(`[Hanzo AI] Model ${name} unloaded`);
-    }
-  }
-  destroy() {
-    for (const [name, model] of this.models) {
-      model.buffer.destroy();
-    }
-    this.models.clear();
-    this.device = null;
-  }
-};
-export {
-  WebGPUAI
-};