transcribe-cpp-native 0.0.4__tar.gz → 0.0.6__tar.gz

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/CMakeLists.txt

@@ -352,7 +352,16 @@ if(TRANSCRIBE_GGML_BACKEND_DL)
     # `NOT GGML_BACKEND_DIR` treats an empty/unset value as "ours to set" while
     # still respecting a non-empty caller-provided path.
     if(NOT GGML_BACKEND_DIR)
-        set(GGML_BACKEND_DIR "${CMAKE_INSTALL_LIBDIR}" CACHE PATH "" FORCE)
+        # The directory that holds libtranscribe itself — which is where the
+        # package-local loader scans. That's bin/ on Windows (a DLL is a RUNTIME
+        # artifact installed to bin, so transcribe.dll lives there) and lib/
+        # elsewhere. Using lib/ unconditionally would strand the modules away
+        # from transcribe.dll on Windows, where the loader can't find them.
+        if(WIN32)
+            set(GGML_BACKEND_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH "" FORCE)
+        else()
+            set(GGML_BACKEND_DIR "${CMAKE_INSTALL_LIBDIR}" CACHE PATH "" FORCE)
+        endif()
     endif()
     # ggml hard-errors on GGML_NATIVE + GGML_BACKEND_DL (x86): native tuning
     # is incompatible with feature-scored modules. A module build is a

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/Cargo.lock

@@ -315,7 +315,7 @@ dependencies = [
 
 [[package]]
 name = "transcribe-cpp"
-version = "0.0.4"
+version = "0.0.6"
 dependencies = [
  "hound",
  "log",
@@ -325,7 +325,7 @@ dependencies = [
 
 [[package]]
 name = "transcribe-cpp-sys"
-version = "0.0.4"
+version = "0.0.6"
 dependencies = [
  "cmake",
  "serde_json",

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/Cargo.toml

@@ -11,7 +11,7 @@
 
 [package]
 name = "transcribe-cpp-sys"
-version = "0.0.4"
+version = "0.0.6"
 edition = "2021"
 rust-version = "1.74"
 description = "Native FFI bindings for transcribe.cpp, a C/C++ speech-to-text library built on ggml"

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: transcribe-cpp-native
-Version: 0.0.4
+Version: 0.0.6
 Summary: Prebuilt native library for transcribe-cpp (speech-to-text, ggml)
 Keywords: transcription,speech-to-text,asr,ggml,native
 Author: The transcribe.cpp authors
 License-Expression: MIT
 License-File: LICENSE
 License-File: ggml/LICENSE
+License-File: src/third_party/miniz/LICENSE
 Classifier: Development Status :: 1 - Planning
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/README.md

@@ -138,10 +138,13 @@ tools/transcribe-quantize/ Quantization tool source
 docs/                      Porting and validation guidance
 scripts/                   Python converter + test tooling
 ggml/                      Vendored ggml (see ggml/UPSTREAM for pinned SHA)
+src/third_party/miniz/     Vendored miniz deflate codec (see its UPSTREAM file)
 samples/                   Test audio files
 tests/                     Unit and smoke tests
 ```
 
 ## License
 
-transcribe.cpp is MIT-licensed. See [LICENSE](LICENSE) for details.
+transcribe.cpp is MIT-licensed. See [LICENSE](LICENSE) for details. Vendored
+third-party components (ggml, miniz — both MIT) are attributed in
+[THIRD-PARTY-LICENSES.md](THIRD-PARTY-LICENSES.md).

transcribe_cpp_native-0.0.6/THIRD-PARTY-LICENSES.md

@@ -0,0 +1,83 @@
+# Third-party licenses
+
+transcribe.cpp is MIT-licensed (see [`LICENSE`](LICENSE)). It vendors and links
+the third-party components below, each under its own permissive license. The
+authoritative license text for each ships in-tree at the path noted; copies are
+reproduced here for convenience.
+
+| Component | License | Vendored at | Pin |
+|-----------|---------|-------------|-----|
+| ggml      | MIT     | [`ggml/LICENSE`](ggml/LICENSE) | see [`ggml/UPSTREAM`](ggml/UPSTREAM) |
+| miniz     | MIT     | [`src/third_party/miniz/LICENSE`](src/third_party/miniz/LICENSE) | see [`src/third_party/miniz/UPSTREAM`](src/third_party/miniz/UPSTREAM) |
+
+Prebuilt artifacts (the Swift xcframework, the native Python wheels, and the
+npm platform packages) carry these same texts alongside the binaries — see each
+binding's packaging for the bundled `LICENSE.ggml` / `LICENSE.miniz` files.
+
+---
+
+## ggml
+
+The tensor library underlying transcribe.cpp. Vendored under `ggml/`.
+
+```
+MIT License
+
+Copyright (c) 2023-2026 The ggml authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+---
+
+## miniz
+
+A single-file deflate/inflate (zlib-subset) codec. transcribe.cpp uses it only
+for Whisper's temperature-fallback compression-ratio heuristic; it replaces the
+previous system-zlib dependency. Vendored under `src/third_party/miniz/`.
+
+miniz is MIT-licensed. (The comment block at the top of the amalgamated
+`miniz.c` / `miniz.h` still reads "public domain" — a stale artifact from the
+project's pre-relicensing history; upstream's current and authoritative license
+is the MIT text below, also shipped at `src/third_party/miniz/LICENSE`.)
+
+```
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "transcribe-cpp"
-version = "0.0.4"
+version = "0.0.6"
 description = "Python bindings for transcribe.cpp"
 readme = "README.md"
 # 3.8 is EOL (2024-10); 3.9 is the floor. The binding is ctypes-only, so there
@@ -34,13 +34,13 @@ classifiers = [
 # packaging fix still resolves); the import-time version/header-hash check in
 # _library.py is the runtime backstop. check_version_sync.py gates this pin
 # against include/transcribe.h.
-dependencies = ["transcribe-cpp-native==0.0.4.*"]
+dependencies = ["transcribe-cpp-native==0.0.6.*"]
 
 [project.optional-dependencies]
 # Opt-in accelerator providers — ADDITIVE: they install alongside the default
 # provider and the best one wins at runtime. Same base-version pin contract
 # as the hard dependency (gated by check_version_sync.py).
-cu12 = ["transcribe-cpp-native-cu12==0.0.4.*"]
+cu12 = ["transcribe-cpp-native-cu12==0.0.6.*"]
 # Test-only deps. Run with: uv run --extra test pytest (from bindings/python).
 # numpy is here so the numpy PCM-input tests run in every lane instead of
 # silently skipping wherever numpy happens to be absent.

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/python/src/transcribe_cpp/__init__.py

@@ -46,7 +46,7 @@ from .errors import (
     raise_for_status,
 )
 
-__version__ = "0.0.4"
+__version__ = "0.0.6"
 
 # String-enum types, exported so callers (and type checkers) can name them.
 Backend = Literal["auto", "cpu", "metal", "vulkan", "cpu_accel", "cuda"]

transcribe_cpp_native-0.0.6/bindings/python-native-cu12/LICENSE-miniz

@@ -0,0 +1,22 @@
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/python-native-cu12/pyproject.toml

@@ -36,9 +36,9 @@ description = "CUDA 12 native provider for transcribe-cpp (speech-to-text, ggml)
 readme = "README.md"
 requires-python = ">=3.9"
 license = "MIT"
-# Copies of the repo + ggml licenses (PEP 639 paths cannot escape the
+# Copies of the repo + ggml + miniz licenses (PEP 639 paths cannot escape the
 # project directory; texts are static).
-license-files = ["LICENSE", "LICENSE-ggml"]
+license-files = ["LICENSE", "LICENSE-ggml", "LICENSE-miniz"]
 authors = [{ name = "The transcribe.cpp authors" }]
 keywords = ["transcription", "speech-to-text", "asr", "ggml", "cuda"]
 classifiers = [

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/rust/sys/README.md

@@ -18,12 +18,10 @@ this crate.
 
 ## Build prerequisites
 
-A C++ toolchain, **CMake**, and **zlib**. zlib is system-provided on Linux
-(`zlib1g-dev`) and macOS; on Windows install it with
-`vcpkg install zlib:x64-windows-static-md` (static lib against the dynamic CRT,
-matching Rust's default `/MD` on `x86_64-pc-windows-msvc`) and point
-`CMAKE_PREFIX_PATH` at the vcpkg install tree. The static link is the default;
-the `shared` feature links a shared library instead.
+A C++ toolchain and **CMake**. There is no external compression dependency —
+the deflate codec (miniz) is vendored into the library, so no system zlib /
+vcpkg setup is required on any platform. The static link is the default; the
+`shared` feature links a shared library instead.
 
 ## Features
 

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/rust/sys/build.rs

@@ -258,8 +258,9 @@ fn emit_link_lines(prefix: &Path, manifest_path: &Path) {
         stage_windows_dlls(prefix);
     }
 
-    // Metadata for the safe crate's build script (available as
-    // DEP_TRANSCRIBE_* because this crate sets `links = "transcribe"`).
+    // Metadata for the safe crate's build script (DEP_TRANSCRIBE_* because this
+    // crate sets `links = "transcribe"`). The wrapper re-emits these one more hop
+    // as DEP_TRANSCRIBE_CPP_* for downstream packaging — see its build.rs.
     println!(
         "cargo:include_dir={}",
         prefix
@@ -267,6 +268,28 @@ fn emit_link_lines(prefix: &Path, manifest_path: &Path) {
             .display()
     );
     println!("cargo:lib_dir={}", lib_dir.display());
+
+    // Runtime-artifact dirs for downstream PACKAGING. Only a shared posture
+    // produces separate runtime files to ship next to a consumer's executable;
+    // a static build bakes everything into the consumer binary, so these stay
+    // unset and the consumer reads their absence as "nothing to bundle".
+    if shared {
+        let bin_dir = prefix.join("bin");
+        // The ONE directory a consumer copies into their installer. Windows keeps
+        // the runtime DLLs in bin/; on Unix the .so/.dylib live in lib_dir. A
+        // single value so the consumer needs no per-OS cfg — `bin_dir` alone
+        // would be too Windows-specific.
+        let runtime_dir = if is_windows { &bin_dir } else { &lib_dir };
+        println!("cargo:runtime_dir={}", runtime_dir.display());
+        println!("cargo:bin_dir={}", bin_dir.display());
+        // dynamic-backends: the loadable compute modules (a ggml backend subdir,
+        // or bin/ on Windows). The manifest already records the install-relative
+        // path; forward it so a consumer bundles the modules too — without them a
+        // relocated DL build registers zero compute devices.
+        if let Some(rel) = json["module_dir"].as_str() {
+            println!("cargo:module_dir={}", prefix.join(rel).display());
+        }
+    }
 }
 
 /// Copy the installed runtime DLLs (`<prefix>/bin/*.dll` — transcribe.dll plus

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/rust/transcribe-cpp/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "transcribe-cpp"
-version = "0.0.4"
+version = "0.0.6"
 edition = "2021"
 rust-version = "1.74"
 description = "Rust bindings for transcribe.cpp, a C/C++ speech-to-text library built on ggml"
@@ -10,6 +10,10 @@ repository = "https://github.com/handy-computer/transcribe.cpp"
 homepage = "https://github.com/handy-computer/transcribe.cpp"
 keywords = ["transcription", "speech", "asr", "stt", "ggml"]
 categories = ["multimedia::audio", "api-bindings"]
+# A unique `links` name so build.rs can re-emit the -sys crate's location
+# metadata one more hop (as DEP_TRANSCRIBE_CPP_*) for downstream packaging. No
+# native linking happens here — that lives in -sys. See build.rs.
+links = "transcribe_cpp"
 
 [lib]
 name = "transcribe_cpp"
@@ -36,7 +40,7 @@ dynamic-backends = ["shared", "transcribe-cpp-sys/dynamic-backends"]
 # `transcribe-cpp --no-default-features`, silently re-enabling Metal. The backend
 # features below forward explicitly, so the default (`metal`) still reaches sys
 # via `metal = ["transcribe-cpp-sys/metal"]`.
-transcribe-cpp-sys = { version = "0.0.4", path = "../../..", default-features = false }
+transcribe-cpp-sys = { version = "0.0.6", path = "../../..", default-features = false }
 thiserror = "2"
 log = "0.4"
 

transcribe_cpp_native-0.0.6/bindings/rust/transcribe-cpp/README.md

@@ -0,0 +1,141 @@
+# transcribe-cpp
+
+Safe, idiomatic Rust bindings for
+[transcribe.cpp](https://github.com/handy-computer/transcribe.cpp), a C/C++
+speech-to-text library built on ggml.
+
+> **Status: in development (0.0.1).** Core model, session, run, stream,
+> cancellation, backend, and family-extension APIs are implemented and tested.
+
+## Install
+
+```sh
+cargo add transcribe-cpp
+```
+
+The native library is compiled from source by the `transcribe-cpp-sys` crate, so
+a first build needs a C++ toolchain and **CMake**. There is no external
+compression dependency (the deflate codec is vendored), so no system zlib /
+vcpkg setup is required on any platform. No prebuilt download and no environment
+variables on the happy path.
+
+## Quickstart
+
+```rust
+use transcribe_cpp::{Model, RunOptions};
+
+let mut session = Model::load("model.gguf")?.session()?;
+// pcm: 16 kHz mono f32 in [-1, 1]
+let result = session.run(&pcm, &RunOptions::default())?;
+println!("{}", result.text);
+# Ok::<(), transcribe_cpp::Error>(())
+```
+
+Runnable examples:
+
+```sh
+cargo run --example transcribe-file
+cargo run --example streaming
+cargo run --example batch
+cargo run --example backend-select
+cargo run --example error-handling
+```
+
+The raw FFI layer is
+[`transcribe-cpp-sys`](https://crates.io/crates/transcribe-cpp-sys); this crate
+is the safe wrapper.
+
+## Backends
+
+Backends are selected with cargo features forwarded to `transcribe-cpp-sys`:
+`metal` (default on Apple), `vulkan`, `cuda`, and `openmp`.
+
+The default link is static and self-contained. Advanced packaging modes are
+available through `shared` and `dynamic-backends`; see the `transcribe-cpp-sys`
+README if you need runtime-loaded backend modules or custom
+`TRANSCRIBE_CMAKE_ARGS`.
+
+## Packaging a distributable (`shared` / `dynamic-backends`)
+
+With the **default static** build there is nothing to do — the native code is
+baked into your binary. But if you enable `shared` or `dynamic-backends`, your
+installer must ship the runtime libraries (and, for `dynamic-backends`, the
+backend modules) next to your executable. Bundling for distribution (e.g. a
+Tauri/Electron installer) happens at *build* time, so a runtime lookup is the
+wrong tool — you need the artifact path while you build.
+
+This crate forwards the native build's output directories to **your** build
+script as `DEP_TRANSCRIBE_CPP_*` env vars. The one you usually want is
+`DEP_TRANSCRIBE_CPP_RUNTIME_DIR`: a single directory holding the shared objects
+to copy beside your exe (the DLLs on Windows, the `.so`/`.dylib` on Unix — no
+per-OS logic needed). Also available: `DEP_TRANSCRIBE_CPP_LIB_DIR`,
+`_BIN_DIR`, `_MODULE_DIR` (the `dynamic-backends` modules), and `_INCLUDE_DIR`.
+The runtime keys are present only in a shared posture; in a static build they
+are unset (nothing to bundle).
+
+In your application's `build.rs`:
+
+```rust
+use std::{env, fs, path::{Path, PathBuf}};
+
+fn main() {
+    // Present only for shared / dynamic-backends builds.
+    let Some(runtime_dir) = env::var_os("DEP_TRANSCRIBE_CPP_RUNTIME_DIR") else {
+        return; // static build — nothing to ship
+    };
+
+    // A stable folder your bundler references with a STATIC path (e.g.
+    // tauri.conf.json `"resources": { "transcribe-libs/*": "." }`).
+    let dest = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("transcribe-libs");
+    fs::create_dir_all(&dest).unwrap();
+
+    // Match by NAME, not extension: Linux versions its libs (libtranscribe.so.0,
+    // .so.0.0.4) and the loader needs the SONAME, so an extension filter would
+    // copy only the bare dev symlink and ship a broken installer. `fs::copy`
+    // dereferences the version symlinks into real files. Returns the count.
+    fn copy_libs(src: &Path, dest: &Path) -> usize {
+        let mut n = 0;
+        for entry in fs::read_dir(src).unwrap_or_else(|e| panic!("read {}: {e}", src.display())) {
+            let path = entry.unwrap().path();
+            let name = path.file_name().and_then(|s| s.to_str()).unwrap_or("");
+            let is_lib = name.ends_with(".dll")
+                || name.ends_with(".dylib")  // macOS versions before the ext: libfoo.0.dylib
+                || name.ends_with(".so")
+                || name.contains(".so.");    // Linux SONAME/version: libfoo.so.0[.0.4]
+            if is_lib {
+                fs::copy(&path, dest.join(name)).unwrap();
+                n += 1;
+            }
+        }
+        n
+    }
+
+    // HARD-FAIL if a dir was advertised but holds no libraries: better to break
+    // the build than ship a silently broken installer (missing libs at runtime).
+    let runtime_dir = PathBuf::from(runtime_dir);
+    assert!(copy_libs(&runtime_dir, &dest) > 0, "no runtime libraries in {}", runtime_dir.display());
+    println!("cargo:rerun-if-env-changed=DEP_TRANSCRIBE_CPP_RUNTIME_DIR");
+
+    // dynamic-backends only: also ship the loadable compute modules (often a
+    // different directory than the library). Unset in a plain `shared` build.
+    println!("cargo:rerun-if-env-changed=DEP_TRANSCRIBE_CPP_MODULE_DIR");
+    if let Some(module_dir) = env::var_os("DEP_TRANSCRIBE_CPP_MODULE_DIR") {
+        let module_dir = PathBuf::from(module_dir);
+        assert!(copy_libs(&module_dir, &dest) > 0, "no backend modules in {}", module_dir.display());
+        // At runtime, before the first model load, point the library at the
+        // bundled modules: `init_backends(<dir next to your exe>)`, or
+        // `init_backends_default()` when they sit right beside the executable.
+    }
+}
+```
+
+## Threading
+
+- `Model` is `Send + Sync` and cheap to clone (`Arc`-backed); the native model
+  is freed only after the last handle and every `Session` drop.
+- `Session` is `Send` but not `Sync`; mutating calls take `&mut self`.
+- In 0.x the C library allows at most one in-flight run across all sessions of a
+  model; this crate enforces it with a per-model mutex, so concurrent calls
+  queue rather than race. For real parallelism, use one `Model` per worker.
+
+- License: MIT

transcribe_cpp_native-0.0.6/bindings/rust/transcribe-cpp/build.rs

@@ -0,0 +1,59 @@
+//! Build script for the safe `transcribe-cpp` crate.
+//!
+//! The native build and link live entirely in `transcribe-cpp-sys`. This script
+//! does two things, both rooted in the same cargo rule: a dependency's metadata
+//! reaches only its IMMEDIATE dependent (us), never a crate that depends on us.
+//!
+//! 1. **shared-lib rpath.** In the `shared` posture an rpath to the sys crate's
+//!    lib dir (`DEP_TRANSCRIBE_LIB_DIR`) lets this crate's own tests/examples
+//!    find `libtranscribe` at runtime — `rustc-link-arg` doesn't propagate from
+//!    a dependency, so the rpath sys emits for itself doesn't reach here. Windows
+//!    has no rpath (DLLs resolve via PATH / the exe dir), so nothing is emitted.
+//!
+//! 2. **Forward the location metadata one more hop.** A consumer packaging a
+//!    distributable (a Tauri/Electron installer) needs the sys crate's output
+//!    paths (`DEP_TRANSCRIBE_*`) at BUILD time, but only sees `DEP_*` from its
+//!    direct dependency — this crate. So we claim `links = "transcribe_cpp"` and
+//!    re-emit each value as `DEP_TRANSCRIBE_CPP_*`. See the README packaging section.
+//!
+//! In the default static posture the runtime keys are unset (nothing to ship)
+//! and the rpath branch is inert; `include_dir`/`lib_dir` still forward.
+
+use std::env;
+use std::path::Path;
+
+fn main() {
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    // `shared` is set whenever the lib is a separate file — both the plain
+    // `shared` feature and `dynamic-backends` (which enables `shared` here).
+    let shared = env::var_os("CARGO_FEATURE_SHARED").is_some();
+
+    // (1) Mirror the sys crate's runtime rpath onto THIS crate's binaries (tests,
+    // examples), which the dependency's rustc-link-arg cannot reach.
+    if shared && target_os != "windows" {
+        if let Some(lib_dir) = env::var_os("DEP_TRANSCRIBE_LIB_DIR") {
+            println!(
+                "cargo:rustc-link-arg=-Wl,-rpath,{}",
+                Path::new(&lib_dir).display()
+            );
+        }
+    }
+
+    // (2) Forward the sys crate's location metadata one more hop (see above).
+    // Each key is present only when the build produced it: `runtime_dir`/`bin_dir`
+    // need `shared`, `module_dir` needs `dynamic-backends`; `include_dir`/`lib_dir`
+    // are always set. The lowercase key becomes DEP_TRANSCRIBE_CPP_<KEY> upstack.
+    for key in [
+        "include_dir",
+        "lib_dir",
+        "runtime_dir",
+        "bin_dir",
+        "module_dir",
+    ] {
+        let dep_var = format!("DEP_TRANSCRIBE_{}", key.to_uppercase());
+        println!("cargo:rerun-if-env-changed={dep_var}");
+        if let Some(val) = env::var_os(&dep_var) {
+            println!("cargo:{key}={}", Path::new(&val).display());
+        }
+    }
+}

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/swift/Sources/TranscribeCpp/TranscribeCpp.swift

@@ -17,7 +17,7 @@ public enum Transcribe {
     /// Version this binding was built against. Pinned here for the pre-1.0
     /// base-version load gate; the version-sync milestone will generate it from
     /// `include/transcribe.h` (the single source of truth) rather than hardcode.
-    public static let compiledVersion = "0.0.4"
+    public static let compiledVersion = "0.0.6"
 
     /// `MAJOR.MINOR.PATCH` of the linked native library.
     public static func version() -> String { String(cString: transcribe_version()) }

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/swift/THIRD-PARTY-LICENSES.md

@@ -2,7 +2,7 @@
 
 The prebuilt native artifact (`TranscribeCpp.xcframework`) statically links the
 following third-party code. Their license texts travel inside the xcframework
-(`LICENSE.ggml`) and are reproduced here.
+(`LICENSE.ggml`, `LICENSE.miniz`) and are reproduced here.
 
 ## ggml
 
@@ -33,4 +33,34 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
+## miniz
+
+`miniz` (the vendored single-file deflate codec used for Whisper's
+compression-ratio heuristic) is compiled into the native artifact.
+
+```
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```
+
 transcribe.cpp itself is MIT-licensed; see `LICENSE`.

{transcribe_cpp_native-0.0.4 → transcribe_cpp_native-0.0.6}/bindings/typescript/README.md

@@ -200,6 +200,45 @@ N-API addon, so `cmake-js` does not apply) and installs into `prebuilds/<tuple>/
 which the loader finds automatically. Requires `cmake` and a C/C++ toolchain.
 You can also point `TRANSCRIBE_LIBRARY` at any `libtranscribe` you built.
 
+## Packaging an app (Electron / Tauri)
+
+The native code ships as a self-contained `@transcribe-cpp/<platform>` package
+(the shared library plus its sibling ggml libs / backend modules, in one
+directory). Because npm resolution is transitive, your app can locate that
+directory at *build* time — there is nothing special to wire through.
+`artifactDir()` returns it **without loading the library** (no dlopen), which is
+exactly what a bundler/pack step needs:
+
+```js
+import { artifactDir } from "transcribe-cpp";
+import * as fs from "node:fs";
+
+const dir = artifactDir();
+const lib =
+  process.platform === "win32" ? "transcribe.dll"
+  : process.platform === "darwin" ? "libtranscribe.dylib"
+  : "libtranscribe.so";
+
+// HARD-FAIL if the artifact is missing/empty: better to break the build than
+// ship a silently broken installer that crashes at first transcribe() call.
+if (!fs.existsSync(`${dir}/${lib}`)) {
+  throw new Error(`native library not found in ${dir}; the platform package is not bundled`);
+}
+// copy `dir` into your app resources, or feed it to your bundler config…
+```
+
+The native files are real binaries, so they must not be packed into an asar
+archive. With **electron-builder**, unpack the platform packages:
+
+```jsonc
+// package.json → "build"
+{ "asarUnpack": ["node_modules/@transcribe-cpp/**"] }
+```
+
+For a **Tauri** app whose native bits come from the Rust crate instead, see that
+crate's "Packaging a distributable" section — there the artifact dir is exposed
+to your `build.rs` as `DEP_TRANSCRIBE_CPP_RUNTIME_DIR`.
+
 ## Waived requirements
 
 - **Per-field ABI layout is not waived** (unlike Rust/Swift): TypeScript has no
@@ -211,5 +250,5 @@ You can also point `TRANSCRIBE_LIBRARY` at any `libtranscribe` you built.
 
 ## License
 
-MIT. Bundled native packages include third-party license texts (ggml and any
-bundled backend runtimes).
+MIT. Bundled native packages include third-party license texts (ggml, miniz,
+and any bundled backend runtimes).