@agency-lang/whisper-local 0.0.1

package/dist/src/modelManager.js

@@ -0,0 +1,172 @@
+import * as fs from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { KNOWN_MODELS } from "./types.js";
+import { findPackageRoot } from "./packageRoot.js";
+export class ModelManagerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ModelManagerError";
+    }
+}
+export function resolveModelDir() {
+    const override = process.env.AGENCY_WHISPER_MODELS_DIR;
+    if (override)
+        return override;
+    return path.join(os.homedir(), ".agency/models/whisper");
+}
+export function resolveModelPath(name, dir = resolveModelDir()) {
+    if (!KNOWN_MODELS.includes(name)) {
+        throw new ModelManagerError(`unknown model "${name}". Choices: ${KNOWN_MODELS.join(", ")}`);
+    }
+    return path.join(dir, `ggml-${name}.bin`);
+}
+export async function isModelInstalled(name, dir = resolveModelDir()) {
+    const p = resolveModelPath(name, dir);
+    try {
+        const st = await fs.stat(p);
+        return st.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = findPackageRoot(__dirname);
+// Parse + validate lockfile text. Pulled out from loadLockfile so the
+// schema-rejection branch is testable without writing to PACKAGE_ROOT.
+export function parseLockfile(text, source = "<inline>") {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        throw new ModelManagerError(`failed to parse ${source}: ${err.message}`);
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        throw new ModelManagerError(`${source} is not a JSON object`);
+    }
+    const schemaVersion = parsed.schemaVersion;
+    if (schemaVersion !== 1) {
+        throw new ModelManagerError(`unsupported lockfile schema version ${String(schemaVersion)} in ${source}`);
+    }
+    const models = parsed.models;
+    if (typeof models !== "object" || models === null || Array.isArray(models)) {
+        throw new ModelManagerError(`${source} is missing a 'models' object (got ${models === null ? "null" : Array.isArray(models) ? "array" : typeof models})`);
+    }
+    return parsed;
+}
+export async function loadLockfile() {
+    const lockPath = path.join(PACKAGE_ROOT, "models.lock.json");
+    const text = await fs.readFile(lockPath, "utf8");
+    return parseLockfile(text, lockPath);
+}
+export async function sha256OfFile(filepath) {
+    const hash = crypto.createHash("sha256");
+    const fd = await fs.open(filepath, "r");
+    try {
+        const stream = fd.createReadStream();
+        for await (const chunk of stream)
+            hash.update(chunk);
+    }
+    finally {
+        await fd.close();
+    }
+    return hash.digest("hex");
+}
+function isAllowedScheme(url) {
+    // Allow https everywhere; allow http only for localhost test fixtures.
+    if (url.startsWith("https://"))
+        return true;
+    return /^http:\/\/(127\.0\.0\.1|localhost)(:|\/|$)/.test(url);
+}
+export async function downloadModel(entry, dest) {
+    // Defense in depth: even though the lockfile is committed and reviewed, refuse
+    // to fetch over plaintext. The SHA-256 check below would still catch tampering,
+    // but rejecting non-HTTPS up front avoids exposing the user's network to a
+    // downgrade attack and makes lockfile-tampering review easier.
+    // Allow http://127.0.0.1 and http://localhost for tests.
+    if (!isAllowedScheme(entry.url)) {
+        throw new ModelManagerError(`refusing to download model over non-HTTPS URL: ${entry.url}`);
+    }
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    const partial = `${dest}.partial`;
+    // Clean any leftover partial from a prior failed attempt.
+    await fs.rm(partial, { force: true });
+    const response = await fetch(entry.url);
+    if (!response.ok || !response.body) {
+        throw new ModelManagerError(`failed to download model from ${entry.url}: HTTP ${response.status}`);
+    }
+    // fetch() follows redirects by default. Re-check the *final* URL's scheme
+    // so a compromised endpoint can't downgrade us from https to http.
+    if (response.url && !isAllowedScheme(response.url)) {
+        throw new ModelManagerError(`refusing to follow redirect to non-HTTPS URL: ${response.url} (started from ${entry.url})`);
+    }
+    const hash = crypto.createHash("sha256");
+    const out = createWriteStream(partial);
+    // Helper: close the WriteStream cleanly before unlinking the partial file.
+    // On Windows an open handle can prevent fs.rm from deleting the file.
+    const closeStream = (err) => new Promise((resolve) => {
+        if (out.closed || out.destroyed) {
+            resolve();
+            return;
+        }
+        out.once("close", () => resolve());
+        out.destroy(err);
+    });
+    try {
+        const reader = response.body.getReader();
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            hash.update(value);
+            if (!out.write(value)) {
+                await new Promise((resolve) => out.once("drain", () => resolve()));
+            }
+        }
+        await new Promise((resolve, reject) => {
+            out.end((err) => (err ? reject(err) : resolve()));
+        });
+    }
+    catch (err) {
+        await closeStream(err);
+        await fs.rm(partial, { force: true });
+        throw err;
+    }
+    const actual = hash.digest("hex");
+    if (actual !== entry.sha256) {
+        await fs.rm(partial, { force: true });
+        throw new ModelManagerError(`SHA-256 mismatch (expected ${entry.sha256}, got ${actual}). ` +
+            `The downloaded file has been deleted. This may indicate a corrupted ` +
+            `download or compromised mirror.`);
+    }
+    await fs.rename(partial, dest);
+}
+export async function ensureModel(name, dir = resolveModelDir()) {
+    const target = resolveModelPath(name, dir);
+    if (await isModelInstalled(name, dir))
+        return target;
+    const lock = await loadLockfile();
+    const entry = lock.models[name];
+    if (!entry) {
+        throw new ModelManagerError(`no lockfile entry for model "${name}"`);
+    }
+    // Defensive: refuse to "download" a placeholder. KNOWN_MODELS is kept in
+    // sync with models.lock.json so this branch should be unreachable in
+    // shipped code; it stays as belt-and-suspenders against a future regression
+    // where a placeholder slips back into the lockfile.
+    if (entry.sha256 === "0".repeat(64)) {
+        throw new ModelManagerError(`model "${name}" has a placeholder hash in models.lock.json. ` +
+            `The lockfile has not been populated yet (this is a setup bug).`);
+    }
+    if (process.stderr.isTTY) {
+        process.stderr.write(`Downloading ${name} (~${Math.round(entry.sizeBytes / 1e6)} MB) ...\n`);
+    }
+    await downloadModel(entry, target);
+    return target;
+}

package/dist/src/packageRoot.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Walk up from startDir until we find a directory containing package.json.
+ * Same shape as agency-lang's lib/importPaths.ts:findPackageRoot — kept inline
+ * here so this package has no implementation dependency on agency-lang internals.
+ * Don't replace with `path.join(__dirname, "..", "..")` — that breaks if tsc
+ * outDir changes.
+ */
+export declare function findPackageRoot(startDir: string): string;

package/dist/src/packageRoot.js

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+/**
+ * Walk up from startDir until we find a directory containing package.json.
+ * Same shape as agency-lang's lib/importPaths.ts:findPackageRoot — kept inline
+ * here so this package has no implementation dependency on agency-lang internals.
+ * Don't replace with `path.join(__dirname, "..", "..")` — that breaks if tsc
+ * outDir changes.
+ */
+export function findPackageRoot(startDir) {
+    let dir = startDir;
+    for (;;) {
+        if (existsSync(path.join(dir, "package.json")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error(`Could not find package root walking up from ${startDir} (no package.json)`);
+        }
+        dir = parent;
+    }
+}

package/dist/src/transcribe.d.ts

@@ -0,0 +1,2 @@
+import type { ModelName } from "./types.js";
+export declare function transcribe(filepath: string, language?: string, model?: ModelName): Promise<string>;

package/dist/src/transcribe.js

@@ -0,0 +1,36 @@
+import { decodeToPcm } from "./ffmpeg.js";
+import { ensureModel } from "./modelManager.js";
+import { loadAddon } from "./addon.js";
+import { acquireHandle, isCached } from "./handleCache.js";
+export async function transcribe(filepath, language = "", model = "base.en") {
+    if (!filepath) {
+        throw new Error("transcribe: filepath is required");
+    }
+    const modelPath = await ensureModel(model);
+    const instance = acquireHandle(modelPath, () => {
+        const { WhisperModel } = loadAddon();
+        return new WhisperModel(modelPath);
+    });
+    // If caching is disabled (AGENCY_WHISPER_HANDLE_CACHE_MAX=0), the instance
+    // is not in the cache; we must free it ourselves once the transcribe
+    // resolves so the underlying whisper_context isn't leaked.
+    const owned = !isCached(modelPath);
+    try {
+        const pcm = await decodeToPcm(filepath);
+        const segments = await instance.transcribe(pcm, {
+            language,
+            translate: false,
+        });
+        return segments.join("").trim();
+    }
+    finally {
+        if (owned) {
+            try {
+                instance.free();
+            }
+            catch {
+                // Best-effort; if the instance is still busy somehow, leave it for GC.
+            }
+        }
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,11 @@
+export declare const KNOWN_MODELS: readonly ["tiny", "tiny.en", "base", "base.en", "small", "small.en", "medium", "medium.en", "large-v3", "large-v3-turbo"];
+export type ModelName = (typeof KNOWN_MODELS)[number];
+export type LockfileEntry = {
+    url: string;
+    sha256: string;
+    sizeBytes: number;
+};
+export type Lockfile = {
+    schemaVersion: 1;
+    models: Record<ModelName, LockfileEntry>;
+};

package/dist/src/types.js

@@ -0,0 +1,17 @@
+// Every entry here must have a real pinned URL + SHA-256 in
+// models.lock.json. To add another upstream model, run
+// `HF_COMMIT=<sha> MODELS="<name>" bash scripts/generate-lockfile.sh`,
+// confirm the printed SHA against the HuggingFace UI, then add the name
+// to this list and a row to README.md's Models table.
+export const KNOWN_MODELS = [
+    "tiny",
+    "tiny.en",
+    "base",
+    "base.en",
+    "small",
+    "small.en",
+    "medium",
+    "medium.en",
+    "large-v3",
+    "large-v3-turbo",
+];

package/index.agency

@@ -0,0 +1,32 @@
+/**
+## Installation
+
+```
+npm install @agency-lang/whisper-local
+npx -p @agency-lang/whisper-local agency-whisper build
+```
+
+Requires `cmake`, a C++17 compiler, and `ffmpeg` on PATH.
+
+## Usage
+
+```ts
+import { transcribe } from "pkg::@agency-lang/whisper-local"
+
+node main() {
+  const text = transcribe("interview.m4a", "en", "base.en")
+  print(text)
+}
+```
+
+The first call downloads the requested model (~150 MB for "base.en", less
+for "tiny" / "tiny.en") into `~/.agency/models/whisper/`. Subsequent calls
+reuse the local file with no network access.
+*/
+
+import { transcribe as transcribeImpl } from "./dist/src/transcribe.js"
+
+/// Transcribe an audio file locally using whisper.cpp. No network at runtime.
+export def transcribe(filepath: string, language: string = "", model: string = "base.en"): string {
+  return transcribeImpl(filepath, language, model)
+}

package/models.lock.json

@@ -0,0 +1,55 @@
+{
+  "schemaVersion": 1,
+  "models": {
+    "tiny": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-tiny.bin",
+      "sha256": "be07e048e1e599ad46341c8d2a135645097a538221678b7acdd1b1919c6e1b21",
+      "sizeBytes": 77691713
+    },
+    "tiny.en": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-tiny.en.bin",
+      "sha256": "921e4cf8686fdd993dcd081a5da5b6c365bfde1162e72b08d75ac75289920b1f",
+      "sizeBytes": 77704715
+    },
+    "base": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-base.bin",
+      "sha256": "60ed5bc3dd14eea856493d334349b405782ddcaf0028d4b5df4088345fba2efe",
+      "sizeBytes": 147951465
+    },
+    "base.en": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-base.en.bin",
+      "sha256": "a03779c86df3323075f5e796cb2ce5029f00ec8869eee3fdfb897afe36c6d002",
+      "sizeBytes": 147964211
+    },
+    "small": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-small.bin",
+      "sha256": "1be3a9b2063867b937e64e2ec7483364a79917e157fa98c5d94b5c1fffea987b",
+      "sizeBytes": 487601967
+    },
+    "small.en": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-small.en.bin",
+      "sha256": "c6138d6d58ecc8322097e0f987c32f1be8bb0a18532a3f88f734d1bbf9c41e5d",
+      "sizeBytes": 487614201
+    },
+    "medium": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-medium.bin",
+      "sha256": "6c14d5adee5f86394037b4e4e8b59f1673b6cee10e3cf0b11bbdbee79c156208",
+      "sizeBytes": 1533763059
+    },
+    "medium.en": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-medium.en.bin",
+      "sha256": "cc37e93478338ec7700281a7ac30a10128929eb8f427dda2e865faa8f6da4356",
+      "sizeBytes": 1533774781
+    },
+    "large-v3": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-large-v3.bin",
+      "sha256": "64d182b440b98d5203c4f9bd541544d84c605196c4f7b845dfa11fb23594d1e2",
+      "sizeBytes": 3095033483
+    },
+    "large-v3-turbo": {
+      "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/5359861c739e955e79d9a303bcbc70fb988958b1/ggml-large-v3-turbo.bin",
+      "sha256": "1fc70f774d38eb169993ac391eea357ef47c88757ef72ee5943879b7e8e2bc69",
+      "sizeBytes": 1624555275
+    }
+  }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@agency-lang/whisper-local",
+  "version": "0.0.1",
+  "description": "Local Whisper transcription for Agency using vendored whisper.cpp",
+  "type": "module",
+  "agency": "./index.agency",
+  "main": "./dist/src/transcribe.js",
+  "bin": {
+    "agency-whisper": "./dist/src/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/transcribe.d.ts",
+      "import": "./dist/src/transcribe.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "build/Release/whisper_addon.node",
+    "vendor/",
+    "CMakeLists.txt",
+    "index.agency",
+    "models.lock.json",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "agency-lang": "0.1.2"
+  },
+  "dependencies": {
+    "cmake-js": "^7.3.0",
+    "node-addon-api": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.6",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "author": "Aditya Bhargava",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/egonSchiele/agency-lang/issues"
+  },
+  "homepage": "https://github.com/egonSchiele/agency-lang",
+  "scripts": {
+    "build:ts": "tsc",
+    "build:native": "cmake-js compile --runtime=node",
+    "build": "pnpm run build:native && pnpm run build:ts",
+    "test": "vitest",
+    "test:run": "vitest run"
+  }
+}

package/vendor/whisper.cpp/CMakeLists.txt

@@ -0,0 +1,251 @@
+cmake_minimum_required(VERSION 3.5) # for add_link_options and implicit target directories.
+project("whisper.cpp" C CXX)
+project("whisper.cpp" VERSION 1.7.6)
+include(CheckIncludeFileCXX)
+
+set(SOVERSION 1)
+
+#set(CMAKE_WARN_DEPRECATED YES)
+set(CMAKE_WARN_UNUSED_CLI YES)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+if (NOT XCODE AND NOT MSVC AND NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+# Add path to modules
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    set(WHISPER_STANDALONE ON)
+
+    include(git-vars)
+
+    # configure project version
+    configure_file(${CMAKE_SOURCE_DIR}/bindings/javascript/package-tmpl.json ${CMAKE_SOURCE_DIR}/bindings/javascript/package.json @ONLY)
+else()
+    set(WHISPER_STANDALONE OFF)
+endif()
+
+if (EMSCRIPTEN)
+    set(BUILD_SHARED_LIBS_DEFAULT OFF)
+
+    option(WHISPER_WASM_SINGLE_FILE "whisper: embed WASM inside the generated whisper.js" ON)
+
+    # TODO: without these, we get the following error:
+    #       wasm-ld: error: --shared-memory is disallowed by whisper.cpp.o because it was not compiled with 'atomics' or 'bulk-memory' features.
+    set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -pthread")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s TOTAL_STACK=5242880")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -s TOTAL_STACK=5242880")
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
+else()
+    if (MINGW)
+        set(BUILD_SHARED_LIBS_DEFAULT OFF)
+    else()
+        set(BUILD_SHARED_LIBS_DEFAULT ON)
+    endif()
+endif()
+
+option(BUILD_SHARED_LIBS "build shared libraries" ${BUILD_SHARED_LIBS_DEFAULT})
+
+#
+# option list
+#
+
+# debug
+option(WHISPER_ALL_WARNINGS           "whisper: enable all compiler warnings"                   ON)
+option(WHISPER_ALL_WARNINGS_3RD_PARTY "whisper: enable all compiler warnings in 3rd party libs" OFF)
+
+# build
+option(WHISPER_FATAL_WARNINGS  "whisper: enable -Werror flag"               OFF)
+option(WHISPER_USE_SYSTEM_GGML "whisper: use system-installed GGML library" OFF)
+
+# sanitizers
+option(WHISPER_SANITIZE_THREAD    "whisper: enable thread sanitizer"    OFF)
+option(WHISPER_SANITIZE_ADDRESS   "whisper: enable address sanitizer"   OFF)
+option(WHISPER_SANITIZE_UNDEFINED "whisper: enable undefined sanitizer" OFF)
+
+# extra artifacts
+option(WHISPER_BUILD_TESTS    "whisper: build tests"          ${WHISPER_STANDALONE})
+option(WHISPER_BUILD_EXAMPLES "whisper: build examples"       ${WHISPER_STANDALONE})
+option(WHISPER_BUILD_SERVER   "whisper: build server example" ${WHISPER_STANDALONE})
+
+# 3rd party libs
+option(WHISPER_CURL "whisper: use libcurl to download model from an URL" OFF)
+option(WHISPER_SDL2 "whisper: support for libSDL2" OFF)
+
+if (CMAKE_SYSTEM_NAME MATCHES "Linux")
+    option(WHISPER_FFMPEG "whisper: support building and linking with ffmpeg libs (avcodec, swresample, ...)" OFF)
+endif()
+
+option(WHISPER_COREML                "whisper: enable Core ML framework"  OFF)
+option(WHISPER_COREML_ALLOW_FALLBACK "whisper: allow non-CoreML fallback" OFF)
+option(WHISPER_OPENVINO              "whisper: support for OpenVINO"      OFF)
+
+# Required for relocatable CMake package
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/build-info.cmake)
+
+# override ggml options
+set(GGML_SANITIZE_THREAD    ${WHISPER_SANITIZE_THREAD})
+set(GGML_SANITIZE_ADDRESS   ${WHISPER_SANITIZE_ADDRESS})
+set(GGML_SANITIZE_UNDEFINED ${WHISPER_SANITIZE_UNDEFINED})
+set(GGML_ALL_WARNINGS       ${WHISPER_ALL_WARNINGS})
+set(GGML_FATAL_WARNINGS     ${WHISPER_FATAL_WARNINGS})
+
+# transition helpers
+function (whisper_option_depr TYPE OLD NEW)
+    if (${OLD})
+        message(${TYPE} "${OLD} is deprecated and will be removed in the future.\nUse ${NEW} instead\n")
+        set(${NEW} ON)
+    endif()
+endfunction()
+
+whisper_option_depr(FATAL_ERROR WHISPER_CUBLAS              GGML_CUDA)
+whisper_option_depr(WARNING     WHISPER_CUDA                GGML_CUDA)
+whisper_option_depr(WARNING     WHISPER_KOMPUTE             GGML_KOMPUTE)
+whisper_option_depr(WARNING     WHISPER_METAL               GGML_METAL)
+whisper_option_depr(WARNING     WHISPER_METAL_EMBED_LIBRARY GGML_METAL_EMBED_LIBRARY)
+whisper_option_depr(WARNING     WHISPER_NATIVE              GGML_NATIVE)
+whisper_option_depr(WARNING     WHISPER_OPENMP              GGML_OPENMP)
+whisper_option_depr(WARNING     WHISPER_RPC                 GGML_RPC)
+whisper_option_depr(WARNING     WHISPER_SYCL                GGML_SYCL)
+whisper_option_depr(WARNING     WHISPER_SYCL_F16            GGML_SYCL_F16)
+whisper_option_depr(WARNING     WHISPER_CCACHE              GGML_CCACHE)
+
+if (GGML_CUDA AND NOT MSVC)
+    #GGML_CUDA enabled, add the necessary compile options -Wno-deprecated-gpu-targets
+    add_compile_options(-Wno-deprecated-gpu-targets)
+endif()
+
+#
+# build the library
+#
+
+if (NOT TARGET ggml)
+    if (WHISPER_USE_SYSTEM_GGML)
+        find_package(ggml REQUIRED)
+        if (NOT ggml_FOUND)
+            message(FATAL_ERROR "System-installed GGML library not found.")
+        endif()
+        add_library(ggml ALIAS ggml::ggml)
+    else()
+        add_subdirectory(ggml)
+        if(WIN32)
+            # The following adds a _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR macro and is a workaround for
+            # the Windows C++ standard library which does not support constexpr mutexes.
+            # From the release notes://github.com/microsoft/STL/wiki/Changelog
+            #  Disable constexpr mutex constructor on Windows
+            #  Fixed mutex's constructor to be constexpr. #3824 #4000 #4339
+            #  Note: Programs that aren't following the documented restrictions on binary compatibility may encounter
+            #  null dereferences in mutex machinery. You must follow this rule:
+            #  When you mix binaries built by different supported versions of the toolset, the Redistributable version
+            #  must be at least as new as the latest toolset used by any app component.
+            #  You can define _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR as an escape hatch.
+            #
+            # Specifically to whisper.cpp this would cause a crash when using the Java bindings.
+            # resulting in a Invalid memory access error.
+            target_compile_definitions(ggml-base PRIVATE _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
+        endif()
+    endif()
+    # ... otherwise assume ggml is added by a parent CMakeLists.txt
+endif()
+add_subdirectory(src)
+
+#
+# install
+#
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+set(WHISPER_BUILD_NUMBER        ${BUILD_NUMBER})
+set(WHISPER_BUILD_COMMIT        ${BUILD_COMMIT})
+set(WHISPER_INSTALL_VERSION     ${CMAKE_PROJECT_VERSION})
+
+set(WHISPER_INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH "Location of header  files")
+set(WHISPER_LIB_INSTALL_DIR     ${CMAKE_INSTALL_LIBDIR}     CACHE PATH "Location of library files")
+set(WHISPER_BIN_INSTALL_DIR     ${CMAKE_INSTALL_BINDIR}     CACHE PATH "Location of binary  files")
+
+get_directory_property(WHISPER_TRANSIENT_DEFINES COMPILE_DEFINITIONS)
+
+set_target_properties(whisper PROPERTIES PUBLIC_HEADER ${CMAKE_CURRENT_SOURCE_DIR}/include/whisper.h)
+install(TARGETS whisper LIBRARY PUBLIC_HEADER)
+
+configure_package_config_file(
+        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/whisper-config.cmake.in
+        ${CMAKE_CURRENT_BINARY_DIR}/whisper-config.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/whisper
+    PATH_VARS
+    WHISPER_INCLUDE_INSTALL_DIR
+    WHISPER_LIB_INSTALL_DIR
+    WHISPER_BIN_INSTALL_DIR )
+
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/whisper-version.cmake
+    VERSION ${WHISPER_INSTALL_VERSION}
+    COMPATIBILITY SameMajorVersion)
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/whisper-config.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/whisper-version.cmake
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/whisper)
+
+configure_file(cmake/whisper.pc.in
+        "${CMAKE_CURRENT_BINARY_DIR}/whisper.pc"
+        @ONLY)
+
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/whisper.pc"
+        DESTINATION lib/pkgconfig)
+
+#
+# programs, examples and tests
+#
+
+if (WHISPER_BUILD_TESTS AND NOT CMAKE_JS_VERSION)
+    include(CTest)
+    add_subdirectory(tests)
+endif ()
+
+if (WHISPER_BUILD_EXAMPLES)
+    add_subdirectory(examples)
+endif()
+
+if (MSVC)
+    set(MSVC_WARNING_FLAGS
+        /wd4101  # Unreferenced local variable
+        /wd4005  # Macro redefinition
+        /wd4065  # switch statement contains 'default' but no 'case' labels
+        /wd4267  # Conversion from 'size_t' to a smaller type, possible loss of data
+        /wd4244  # Conversion from one type to another type, possible loss of ata
+        /wd4805  # Unsafe mix of type
+        /wd4305  # Truncation from 'type1' to 'type2' (often double to float)
+        /wd4996  # Function or variable may be unsafe/deprecated
+    )
+    function(disable_msvc_warnings target_name)
+        if(TARGET ${target_name})
+            target_compile_options(${target_name} PRIVATE ${MSVC_WARNING_FLAGS})
+        endif()
+    endfunction()
+
+    if (WHISPER_BUILD_EXAMPLES)
+        disable_msvc_warnings(whisper)
+        disable_msvc_warnings(common)
+        disable_msvc_warnings(common-sdl)
+        disable_msvc_warnings(lsp)
+        disable_msvc_warnings(wchess-core)
+        disable_msvc_warnings(whisper-command)
+        disable_msvc_warnings(whisper-cli)
+        disable_msvc_warnings(whisper-server)
+        disable_msvc_warnings(whisper-stream)
+        disable_msvc_warnings(whisper-talk-llama)
+        disable_msvc_warnings(whisper-bench)
+        disable_msvc_warnings(quantize)
+        disable_msvc_warnings(vad-speech-segments)
+    endif()
+endif()