@agorapete/wllama 3.5.1-q2.0

package/scripts/build_source_map.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+// Usage: node scripts/build_source_map.js [--input name:buildDir] [--output out.ts]
+// All flags are optional — defaults point to build/ and src/wasm/source-map.ts.
+// Reads *.js.symbols from each build dir and produces cleaned function names.
+
+import { readFileSync, writeFileSync, readdirSync } from 'fs';
+import { resolve, join } from 'path';
+import { gzipSync } from 'zlib';
+
+const DEFAULT_INPUTS = [
+  { name: 'default', symbolsPath: 'build' },
+  { name: 'compat',  symbolsPath: 'build-compat' },
+];
+const DEFAULT_OUTPUT = 'src/wasm/source-map.ts';
+
+const args = process.argv.slice(2);
+const inputs = [];
+let outputFile = null;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--input') {
+    const next = args[++i];
+    if (!next) { console.error('--input must be name:buildDir'); process.exit(1); }
+    const [name, symbolsPath] = next.split(':');
+    if (!name || !symbolsPath) { console.error('--input must be name:buildDir'); process.exit(1); }
+    inputs.push({ name, symbolsPath: resolve(symbolsPath) });
+  } else if (args[i] === '--output') {
+    const next = args[++i];
+    if (!next) { console.error('--output requires a path'); process.exit(1); }
+    outputFile = resolve(next);
+  }
+}
+
+if (!inputs.length) {
+  for (const { name, symbolsPath } of DEFAULT_INPUTS) {
+    const resolved = resolve(symbolsPath);
+    try { readdirSync(resolved); inputs.push({ name, symbolsPath: resolved }); } catch { /* skip */ }
+  }
+}
+if (!outputFile) outputFile = resolve(DEFAULT_OUTPUT);
+if (!inputs.length) { console.error('No build directories found.'); process.exit(1); }
+
+// -- wasm binary: extract [firstFuncId, funcCount] ----------------------------
+
+function readUleb(buf, pos) {
+  let result = 0, shift = 0;
+  while (true) {
+    const b = buf[pos++];
+    result |= (b & 0x7F) << shift;
+    if (!(b & 0x80)) break;
+    shift += 7;
+  }
+  return [result, pos];
+}
+
+function skipLimits(buf, pos) {
+  const kind = buf[pos++];
+  [, pos] = readUleb(buf, pos);
+  if (kind === 0x01 || kind === 0x03 || kind === 0x05 || kind === 0x07)
+    [, pos] = readUleb(buf, pos);
+  return pos;
+}
+
+function parseFuncIds(wasmBuf) {
+  let pos = 8, importCount = 0;
+  while (pos < wasmBuf.length) {
+    const sectionId = wasmBuf[pos++];
+    let sectionSize;
+    [sectionSize, pos] = readUleb(wasmBuf, pos);
+    const sectionEnd = pos + sectionSize;
+    if (sectionId === 2) {
+      let count; [count, pos] = readUleb(wasmBuf, pos);
+      for (let i = 0; i < count; i++) {
+        let nl;
+        [nl, pos] = readUleb(wasmBuf, pos); pos += nl;
+        [nl, pos] = readUleb(wasmBuf, pos); pos += nl;
+        const kind = wasmBuf[pos++];
+        if (kind === 0)      { [, pos] = readUleb(wasmBuf, pos); importCount++; }
+        else if (kind === 1) { pos++; pos = skipLimits(wasmBuf, pos); }
+        else if (kind === 2) { pos = skipLimits(wasmBuf, pos); }
+        else if (kind === 3) { pos += 2; }
+      }
+    } else if (sectionId === 10) {
+      let funcCount; [funcCount, pos] = readUleb(wasmBuf, pos);
+      return [importCount, funcCount];
+    } else {
+      pos = sectionEnd;
+    }
+  }
+  throw new Error('No code section found');
+}
+
+// -- name simplification ------------------------------------------------------
+
+function truncateTemplates(name, maxLen) {
+  let result = '', i = 0;
+  while (i < name.length) {
+    if (name[i] !== '<') { result += name[i++]; continue; }
+    // find matching >
+    let depth = 1, j = i + 1;
+    while (j < name.length && depth > 0) {
+      if (name[j] === '<') depth++;
+      else if (name[j] === '>') depth--;
+      j++;
+    }
+    const content = name.slice(i + 1, j - 1);
+    result += content.length > maxLen
+      ? '<' + content.slice(0, maxLen) + '...>'
+      : '<' + content + '>';
+    i = j;
+  }
+  return result;
+}
+
+function stripParams(name) {
+  // Find first top-level '(' (not inside <>) and strip from there.
+  // If params are empty "()", keep them; otherwise drop entirely.
+  let depth = 0;
+  for (let i = 0; i < name.length; i++) {
+    const c = name[i];
+    if (c === '<') { depth++; continue; }
+    if (c === '>') { depth--; continue; }
+    if (c === '(' && depth === 0) {
+      const base = name.slice(0, i);
+      return (name[i + 1] === ')') ? base + '()' : base;
+    }
+  }
+  return name;
+}
+
+const STD_HINT = 'std::...';
+
+function simplifyName(raw) {
+  if (!raw) return null;
+  let name = raw;
+
+  // Rule 0: collapse all std:: into a hint
+  if (/^std::/.test(name)) return STD_HINT;
+
+  // Rule 1: lambda / closure types
+  // Handles ::$_N, ::'lambda'(), 'lambda'()
+  // Strategy: find the marker, take everything inside the nearest enclosing <..> before it
+  const lambdaRe = /::[$']_?\d*|::'lambda'/;
+  const lambdaMatch = lambdaRe.exec(name);
+  if (lambdaMatch) {
+    const before = name.slice(0, lambdaMatch.index);
+    // Extract the innermost meaningful context: look for the last '<' before the marker
+    const lastAngle = before.lastIndexOf('<');
+    let parent = lastAngle >= 0 ? before.slice(lastAngle + 1) : before;
+    // Strip trailing qualifiers
+    parent = parent.replace(/\s+(const|volatile|noexcept|&&?)\s*$/, '').trim();
+    name = parent;
+    // fall through to further cleanup below
+  }
+
+  // Rule 2: strip parameter list
+  name = stripParams(name);
+
+  // Rule 3: remove libc++ internal sub-namespaces (::__2::, ::__1::, etc.)
+  name = name.replace(/::__\d+::/g, '::');
+
+  // Rule 4: remove ABI tags
+  name = name.replace(/\[abi:[^\]]+\]/g, '');
+
+  // Rule 5: truncate template args to 10 chars
+  name = truncateTemplates(name, 10);
+
+  // Rule 6: final cleanup
+  name = name.replace(/::::/g, '::').replace(/\s+/g, ' ').trim();
+
+  return name || null;
+}
+
+// -- binary encoder -----------------------------------------------------------
+
+function encodeNames(funcCount, firstId, symbols) {
+  // Build deduplicated name table
+  const nameToIdx = new Map(); // string -> u16 index
+  const nameTable = [];        // array of Buffer
+  const indices = new Uint16Array(funcCount); // 0xFFFF = unknown
+  indices.fill(0xFFFF);
+
+  let mapped = 0;
+  for (let i = 0; i < funcCount; i++) {
+    const raw = symbols.get(firstId + i) ?? null;
+    const cleaned = raw ? simplifyName(raw) : null;
+    if (!cleaned) continue;
+    let idx = nameToIdx.get(cleaned);
+    if (idx === undefined) {
+      idx = nameTable.length;
+      const b = Buffer.from(cleaned.slice(0, 254));
+      nameTable.push(Buffer.concat([Buffer.from([b.length]), b]));
+      nameToIdx.set(cleaned, idx);
+    }
+    indices[i] = idx;
+    mapped++;
+  }
+
+  const numNames = nameTable.length;
+  process.stderr.write(`    ${mapped}/${funcCount} named, ${numNames} unique names\n`);
+
+  // u32 numNames + name table + u16 index array
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(numNames, 0);
+  const indexBuf = Buffer.from(indices.buffer);
+  return Buffer.concat([header, ...nameTable, indexBuf]);
+}
+
+// -- resolve symbolsPath (dir or file) ----------------------------------------
+
+function resolveSymbolsFile(symbolsPath) {
+  if (symbolsPath.endsWith('.js.symbols')) return symbolsPath;
+  for (const entry of readdirSync(symbolsPath))
+    if (entry.endsWith('.js.symbols')) return join(symbolsPath, entry);
+  throw new Error(`No .js.symbols file in ${symbolsPath}`);
+}
+
+// -- per-build processing -----------------------------------------------------
+
+function processBuild(symbolsPath) {
+  const resolvedSymbols = resolveSymbolsFile(symbolsPath);
+  const wasmPath = resolvedSymbols.replace(/\.js\.symbols$/, '.wasm');
+
+  process.stderr.write(`  Parsing wasm binary...\n`);
+  const [firstId, funcCount] = parseFuncIds(readFileSync(wasmPath));
+  process.stderr.write(`    ${funcCount} functions starting at index ${firstId}\n`);
+
+  process.stderr.write(`  Loading symbols...\n`);
+  const symbols = new Map();
+  for (const line of readFileSync(resolvedSymbols, 'utf8').split('\n')) {
+    const colon = line.indexOf(':');
+    if (colon < 0) continue;
+    const id = parseInt(line.slice(0, colon));
+    if (!isNaN(id)) symbols.set(id, line.slice(colon + 1).trim());
+  }
+  process.stderr.write(`    ${symbols.size} raw symbols\n`);
+
+  const header = Buffer.alloc(8);
+  header.writeUInt32LE(firstId, 0);
+  header.writeUInt32LE(funcCount, 4);
+
+  const nameData  = encodeNames(funcCount, firstId, symbols);
+  const binary    = Buffer.concat([header, nameData]);
+  const compressed = gzipSync(binary);
+  process.stderr.write(`    ${binary.length.toLocaleString()} bytes -> ${compressed.length.toLocaleString()} bytes gzipped\n`);
+
+  return compressed.toString('base64');
+}
+
+// -- main ---------------------------------------------------------------------
+
+const entries_ts = [];
+for (const { name, symbolsPath } of inputs) {
+  process.stderr.write(`\n[${name}] ${symbolsPath}\n`);
+  entries_ts.push(`  "${name}": "${processBuild(symbolsPath)}"`);
+}
+
+const tsContent = [
+  `// Auto-generated by scripts/build_source_map.js — do not edit`,
+  `// Format: gzip-compressed binary name table, base64-encoded`,
+  `// Structure: u32 firstId, u32 funcCount, u32 numNames, then name table (u8 len + bytes each), then u16 index array (0xFFFF = unknown)`,
+  `export const WASM_SOURCE_MAP: Record<string, string> = {`,
+  entries_ts.join(',\n'),
+  `};`,
+  ``,
+].join('\n');
+
+writeFileSync(outputFile, tsContent);
+process.stderr.write(`\nWrote ${outputFile}\n`);

package/scripts/build_wasm.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+#set -e
+
+export EMSDK_IMAGE_TAG="4.0.20"
+
+CURRENT_PATH="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+cd $CURRENT_PATH
+
+export D_UID=$UID
+export D_GID=$GID
+
+if [[ $(uname -m) == "arm64" ]]; then
+  echo "Running on ARM64 processor"
+  export DOCKER_DEFAULT_PLATFORM="linux/arm64"
+  export EMSDK_IMAGE_TAG="${EMSDK_IMAGE_TAG}-arm64"
+fi
+
+docker compose up llamacpp-wasm-builder --exit-code-from llamacpp-wasm-builder

package/scripts/build_worker.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+set -e
+
+CURRENT_PATH="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+
+# change to the llama.cpp directory
+cd $CURRENT_PATH
+cd ../llama.cpp
+BUILD_NUMBER="$(git rev-list --count HEAD)"
+SHORT_HASH="$(git rev-parse --short=7 HEAD)"
+
+# change to the root of the project
+cd $CURRENT_PATH
+cd ..
+
+echo "// This file is auto-generated" > ./src/workers-code/generated.ts
+echo "// To re-generate it, run: npm run build:worker" >> ./src/workers-code/generated.ts
+echo "" >> ./src/workers-code/generated.ts
+echo "export const LIBLLAMA_VERSION = 'b${BUILD_NUMBER}-${SHORT_HASH}';" >> ./src/workers-code/generated.ts
+echo "" >> ./src/workers-code/generated.ts
+
+process_file() {
+  local file="$1"
+  local content
+  content=$(node -e "console.log(JSON.stringify(require('fs').readFileSync('$file', 'utf8').toString()))")
+  echo "export const $2 = $content;" >> ./src/workers-code/generated.ts
+  echo "" >> ./src/workers-code/generated.ts
+}
+
+process_file ./src/workers-code/llama-cpp.js  LLAMA_CPP_WORKER_CODE
+process_file ./src/workers-code/opfs-utils.js OPFS_UTILS_WORKER_CODE
+
+# emscripten
+process_file ./src/wasm/wllama.js             WLLAMA_EMSCRIPTEN_CODE
+
+# build CDN paths
+node ./scripts/generate_wasm_from_cdn.js

package/scripts/check_debug_build.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+const WASM_PATHS = [
+  'src/wasm/wllama.wasm',
+  'compat/src/wasm/wllama.wasm',
+];
+const DEBUG_MARKER = 'test-backend-ops.cpp';
+
+export function checkDebugBuild() {
+  for (const relPath of WASM_PATHS) {
+    const absPath = resolve(ROOT, relPath);
+    if (!existsSync(absPath)) continue;
+    const contents = readFileSync(absPath);
+    if (contents.includes(DEBUG_MARKER)) {
+      console.error(`ERROR: ${relPath} contains "${DEBUG_MARKER}" - this is a debug build and cannot be merged to master or be published`);
+      process.exit(1);
+    }
+  }
+}
+
+// Run directly when invoked as a script
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  checkDebugBuild();
+}

package/scripts/check_package_size.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { checkDebugBuild } from './check_debug_build.js';
+
+checkDebugBuild();
+
+const MAX_SIZE = 20 * 1024 * 1024; // 20 MB
+const MAX_FILES = 90;
+
+const result = JSON.parse(execSync('npm pack --dry-run --json 2>/dev/null'));
+const { unpackedSize, entryCount } = result[0];
+
+console.log(`Unpacked size: ${(unpackedSize / 1024 / 1024).toFixed(2)} MB`);
+console.log(`Total files: ${entryCount}`);
+
+if (unpackedSize > MAX_SIZE) {
+  console.error(`ERROR: Unpacked size exceeds 20 MB limit`);
+  process.exit(1);
+}
+
+if (entryCount > MAX_FILES) {
+  console.error(`ERROR: Total files (${entryCount}) exceeds limit of ${MAX_FILES}`);
+  process.exit(1);
+}

package/scripts/docker-compose.yml

@@ -0,0 +1,76 @@
+services:
+  llamacpp-wasm-builder:
+    container_name: llamacpp-wasm-builder
+    build:
+      context: .
+      dockerfile_inline: |
+        ARG EMSDK_IMAGE_TAG=none  # modify it in build_wasm.sh
+        FROM emscripten/emsdk:$${EMSDK_IMAGE_TAG}
+        RUN apt update && apt install -y git
+      args:
+        EMSDK_IMAGE_TAG: ${EMSDK_IMAGE_TAG}
+    user: "${D_UID}:${D_GID}"
+    environment:
+      - WLLAMA_TEST_BACKEND=${WLLAMA_TEST_BACKEND:-}
+      - SKIP_COMPAT=${SKIP_COMPAT:-}
+    volumes:
+      - ..:/source:Z
+    entrypoint: /bin/bash
+    command:
+      - -c
+      - |
+        set -e
+        cd /source
+
+        mkdir -p build
+        cd build
+        mkdir -p emdawn
+
+        DAWN_TAG=v20260317.182325
+        EMDAWN_PKG="emdawnwebgpu_pkg-$${DAWN_TAG}.zip"
+        EMDAWNWEBGPU_DIR="/source/build/emdawn/emdawnwebgpu_pkg"
+        echo "Downloading $${EMDAWN_PKG}"
+        curl -L -o emdawn.zip \
+          "https://github.com/google/dawn/releases/download/$${DAWN_TAG}/$${EMDAWN_PKG}"
+        python3 -c "import zipfile; zf=zipfile.ZipFile('emdawn.zip','r'); zf.extractall('/source/build/emdawn'); zf.close()"
+
+        CMAKE_EXTRA_FLAGS="-DWLLAMA_TEST_BACKEND=OFF"
+        if [ -n "${WLLAMA_TEST_BACKEND}" ]; then
+          CMAKE_EXTRA_FLAGS="-DWLLAMA_TEST_BACKEND=ON";
+        fi
+
+        emcmake cmake .. -DGGML_WEBGPU=ON -DGGML_WEBGPU_JSPI=ON -DEMDAWNWEBGPU_DIR="$${EMDAWNWEBGPU_DIR}" $${CMAKE_EXTRA_FLAGS}
+        emmake make wllama -j
+
+        # go back to root
+        cd ..
+
+        # copy output files
+        mkdir -p src/wasm
+        cp build/wllama.js   src/wasm
+        cp build/wllama.wasm src/wasm
+
+        # build compat package (skip if SKIP_COMPAT=1)
+        if [ -z "${SKIP_COMPAT}" ]; then
+          mkdir -p build-compat
+          cd build-compat
+          emcmake cmake .. -DWLLAMA_COMPAT=ON -DLLAMA_WASM_MEM64=OFF -DGGML_WEBGPU=ON -DGGML_WEBGPU_JSPI=OFF -DEMDAWNWEBGPU_DIR="$${EMDAWNWEBGPU_DIR}" $${CMAKE_EXTRA_FLAGS}
+          emmake make wllama -j
+
+          # go back to root
+          cd ..
+
+          # copy output files (compat build)
+          mkdir -p compat/wasm
+          cp build-compat/wllama.js   compat/wasm
+          cp build-compat/wllama.wasm compat/wasm
+        fi
+
+        # generate source map
+        node scripts/build_source_map.js
+
+        # list files (optional, for verification)
+        ls -lh build
+        if [ -d build-compat ]; then
+          ls -lh build-compat
+        fi

package/scripts/generate_wasm_from_cdn.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+
+const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
+const outputPath = './src/wasm-from-cdn.ts';
+
+const version = packageJson.version;
+const outputContent = `
+// This file is generated by scripts/generate_wasm_from_cdn.js
+// Do not edit this file directly
+
+const WasmFromCDN = {
+  default: 'https://cdn.jsdelivr.net/npm/@wllama/wllama@${version}/src/wasm/wllama.wasm',
+};
+
+export const WasmCompatFromCDN = {
+  worker: 'https://cdn.jsdelivr.net/npm/@wllama/wllama-compat@${version}/wasm/wllama.js',
+  wasm: 'https://cdn.jsdelivr.net/npm/@wllama/wllama-compat@${version}/wasm/wllama.wasm',
+};
+
+export default WasmFromCDN;
+`.trim();
+
+fs.writeFileSync(outputPath, outputContent);

package/scripts/http_server.js

@@ -0,0 +1,44 @@
+import express from 'express';
+import path from 'path';
+import mime from 'mime-types';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const app = express();
+
+// Serve static files
+app.use(express.static(path.join(__dirname, '..'), {
+ setHeaders: (res) => {
+    if (process.env.MULTITHREAD) {
+      // add required security header to enable SharedArrayBuffer, needed to run multithread
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements
+      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
+      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+    }
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+    res.setHeader('Pragma', 'no-cache');
+    res.setHeader('Expires', '0');
+ }
+}));
+
+if (!process.env.MULTITHREAD) {
+  console.log('WARN: Running server without MULTITHREAD=1, this will effectively disable multithreading');
+}
+
+app.get("/", (req, res) => {
+  res.send(`
+    Examples:<br/>
+    <a href="/examples/basic">Basic</a><br/>
+    <a href="/examples/embeddings">Embeddings</a><br/>
+    <a href="/examples/multimodal">Multimodal</a><br/>
+    <a href="/examples/tools">Tools</a><br/>
+    <a href="/examples/test-backend-ops">Test Backend Ops (FOR DEBUGGING ONLY)</a><br/>
+  `);
+});
+
+// Start the server
+const PORT = 8080;
+app.listen(PORT, () => console.log(`Server running on http://localhost:${PORT}`));

package/scripts/post_build.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+set -e
+
+CURRENT_PATH="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+cd $CURRENT_PATH/..
+
+mkdir -p esm/wasm
+cp src/wasm/wllama.wasm esm/wasm
+
+# https://stackoverflow.com/questions/62619058/appending-js-extension-on-relative-import-statements-during-typescript-compilat
+
+function patch_esm_import_js {
+  if [[ "$OSTYPE" == "darwin"* ]]; then
+    find $1 -name "*.js" -exec sed -i '' -E "s#export (.*) from '\.(.*)';#export \1 from '.\2\.js';#g" {} +;
+    find $1 -name "*.js" -exec sed -i '' -E "s#import (.*) from '\.(.*)';#import \1 from '.\2\.js';#g" {} +;
+  else
+    find $1 -name "*.js" -exec sed -i -E "s#export (.*) from '\.(.*)';#export \1 from '.\2\.js';#g" {} +;
+    find $1 -name "*.js" -exec sed -i -E "s#import (.*) from '\.(.*)';#import \1 from '.\2\.js';#g" {} +;
+  fi
+}
+
+patch_esm_import_js "./esm"
+
+# sync compat/package.json version with root package.json
+node -e "
+  const fs = require('fs');
+  const version = JSON.parse(fs.readFileSync('package.json', 'utf8')).version;
+  const compat = JSON.parse(fs.readFileSync('compat/package.json', 'utf8'));
+  compat.version = version;
+  fs.writeFileSync('compat/package.json', JSON.stringify(compat, null, 2) + '\n');
+"