omnius 1.0.642 → 1.0.643

package/dist/postinstall-daemon.cjs

@@ -618,10 +618,28 @@ function installSystemd(nodeBin, omniusScript, user) {
 
   var unitDir = path.join(userHome, ".config", "systemd", "user");
   var unitPath = path.join(unitDir, SERVICE_LABEL + ".service");
+  var envDir = path.join(userHome, ".config", "omnius");
+  var envPath = path.join(envDir, "daemon.env");
   var logDir = path.join(userHome, ".omnius");
 
   try { fs.mkdirSync(unitDir, { recursive: true }); } catch (e) {}
+  try { fs.mkdirSync(envDir, { recursive: true }); } catch (e) {}
   try { fs.mkdirSync(logDir, { recursive: true }); } catch (e) {}
+  try {
+    if (!fs.existsSync(envPath)) {
+      fs.writeFileSync(envPath, [
+        "# Optional Omnius daemon runtime overrides (KEY=value).",
+        "# OMNIUS_AUDIO_PYTHON=/absolute/path/to/jetpack/python",
+        "# OMNIUS_HF_TOKEN=hf_setup_only_token",
+        "# OMNIUS_PYANNOTE_TERMS_ACCEPTED=1",
+        "",
+      ].join("\n"), { encoding: "utf8", mode: 0o600 });
+    } else {
+      try { fs.chmodSync(envPath, 0o600); } catch (e) {}
+    }
+  } catch (e) {
+    warn("Could not create optional daemon environment file: " + (e && e.message));
+  }
 
   // The unit runs: <node> <omniusScript> serve --daemon --quiet
   // with OMNIUS_DAEMON=1 so the serve command picks the daemon path.
@@ -639,6 +657,7 @@ function installSystemd(nodeBin, omniusScript, user) {
     "Environment=OMNIUS_DAEMON=1",
     "Environment=OMNIUS_PORT=" + PORT,
     "Environment=NODE_ENV=production",
+    "EnvironmentFile=-" + envPath,
     "ExecStart=" + nodeBin + " " + omniusScript + " serve --daemon --quiet",
     // Restart=always (was on-failure) — also relaunch on clean exit.
     // Some upgrade flows trigger process.exit(0) (e.g. /update reload,

package/dist/scripts/audio-clap-semantic-worker.py

@@ -16,6 +16,8 @@ import wave
 
 if os.environ.get("HF_HUB_OFFLINE") != "1" or os.environ.get("TRANSFORMERS_OFFLINE") != "1":
     raise RuntimeError("CLAP worker must be started with offline model access enabled")
+if os.environ.get("PYTHONNOUSERSITE") != "1":
+    raise RuntimeError("CLAP worker must run from the isolated managed venv without user-site packages")
 
 import numpy as np
 import torch

package/dist/scripts/speaker-diarization-worker.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import subprocess
 import sys
 import time
 import wave
@@ -39,6 +40,33 @@ def validate_live_wav(path: str) -> None:
         raise ValueError("live diarization accepts retained audio windows greater than 0 and at most 6 seconds")
 
 
+def load_pcm16_waveform(path: str):
+    """Decode locally without TorchCodec, which has no CPython 3.10/aarch64 wheel."""
+    import numpy as np
+    import torch
+
+    try:
+        with wave.open(path, "rb") as wav:
+            if wav.getcomptype() != "NONE" or wav.getsampwidth() != 2:
+                raise ValueError("offline reconciliation requires uncompressed PCM16 WAV")
+            channels = wav.getnchannels()
+            sample_rate = wav.getframerate()
+            frames = wav.readframes(wav.getnframes())
+    except Exception as exc:
+        raise ValueError(f"offline reconciliation requires readable PCM16 WAV: {exc}") from exc
+    if channels < 1 or sample_rate < 1 or not frames:
+        raise ValueError("offline reconciliation WAV is empty or invalid")
+    samples = np.frombuffer(frames, dtype="<i2")
+    if samples.size % channels:
+        raise ValueError("offline reconciliation WAV has an incomplete PCM frame")
+    waveform = samples.reshape(-1, channels).T.astype(np.float32) / 32768.0
+    return {
+        "waveform": torch.from_numpy(waveform),
+        "sample_rate": sample_rate,
+        "uri": Path(path).stem,
+    }
+
+
 def number(value: Any) -> float | None:
     try:
         result = float(value)
@@ -64,6 +92,9 @@ def append_segment(result: list[dict[str, Any]], start: Any, end: Any, speaker:
 
 def normalize_sortformer(value: Any) -> list[dict[str, Any]]:
     """Accept NeMo's current tuple/list result variants without inventing data."""
+    rttm_text = isinstance(value, str)
+    if isinstance(value, str):
+        value = [line for line in value.splitlines() if line.strip()]
     while isinstance(value, list) and len(value) == 1 and isinstance(value[0], (list, tuple)):
         value = value[0]
     result: list[dict[str, Any]] = []
@@ -83,12 +114,60 @@ def normalize_sortformer(value: Any) -> list[dict[str, Any]]:
                 duration = number(fields[4])
                 if start is not None and duration is not None:
                     append_segment(result, start, start + duration, fields[7])
-    if not result and value:
+    # A native RTTM command may emit diagnostics but no SPEAKER rows for a
+    # genuine silent window. Structured NeMo objects that are non-empty yet
+    # unparseable remain a hard contract failure.
+    if not result and value and not rttm_text:
         raise RuntimeError("Sortformer result contained no parseable speaker turns")
     return result
 
 
 def load_live(args: argparse.Namespace):
+    if args.native_binary:
+        binary = Path(args.native_binary)
+        if not binary.is_file() or not os.access(binary, os.X_OK):
+            raise RuntimeError("managed nemo-speech binary is missing or not executable")
+        # Metadata inspection validates that this exact Q8 artifact is readable
+        # without keeping a second Python/Torch stack on JetPack.
+        inspected = subprocess.run(
+            [str(binary), "model", "info", args.artifact_path],
+            text=True,
+            capture_output=True,
+            timeout=60,
+            check=False,
+        )
+        if inspected.returncode != 0:
+            raise RuntimeError(
+                f"nemo-speech rejected the pinned Sortformer model: {(inspected.stderr or inspected.stdout)[-1000:]}"
+            )
+
+        def diarize_native(path: str) -> list[dict[str, Any]]:
+            validate_live_wav(path)
+            completed = subprocess.run(
+                [
+                    str(binary),
+                    "diarize",
+                    path,
+                    "--model",
+                    args.artifact_path,
+                    "--device",
+                    "cuda:0",
+                    "--format",
+                    "rttm",
+                ],
+                text=True,
+                capture_output=True,
+                timeout=90,
+                check=False,
+            )
+            if completed.returncode != 0:
+                raise RuntimeError(
+                    f"nemo-speech diarization failed: {(completed.stderr or completed.stdout)[-2000:]}"
+                )
+            return normalize_sortformer(completed.stdout)
+
+        return binary, diarize_native, "nemo-speech-cpp-q8-cuda"
+
     import torch
     from nemo.collections.asr.models import SortformerEncLabelModel
 
@@ -122,7 +201,10 @@ def load_reconcile(args: argparse.Namespace):
     def diarize(path: str) -> list[dict[str, Any]]:
         if not Path(path).is_file():
             raise ValueError("offline reconciliation audio file does not exist")
-        output = pipeline(path)
+        # pyannote.audio officially supports in-memory waveform mappings. This
+        # avoids its optional TorchCodec decoder, which has no aarch64 wheel,
+        # without weakening the model or touching JetPack CUDA Torch.
+        output = pipeline(load_pcm16_waveform(path))
         annotation = getattr(output, "speaker_diarization", output)
         turns = getattr(annotation, "itertracks", None)
         if not callable(turns):
@@ -142,6 +224,7 @@ def main() -> int:
     parser.add_argument("--artifact-path", required=True)
     parser.add_argument("--revision", required=True)
     parser.add_argument("--model-digest", required=True)
+    parser.add_argument("--native-binary")
     args = parser.parse_args()
 
     # Do not allow an accidentally inherited setup token to become a request

package/dist/scripts/vision-open-clip-worker.py

@@ -17,6 +17,12 @@ import sys
 
 MODEL = "ViT-B-32"
 PRETRAINED = "laion2b_s34b_b79k"
+MODEL_REPOSITORY = "laion/CLIP-ViT-B-32-laion2B-s34B-b79K"
+MODEL_REVISION = "1a25a446712ba5ee05982a381eed697ef9b435cf"
+MODEL_WEIGHTS_FILENAME = "open_clip_pytorch_model.bin"
+MODEL_WEIGHTS_BYTES = 605219813
+MODEL_WEIGHTS_SHA256 = "1bd3c7172de5b207ceac554f5ab5266166f3b9baccc9af5989bc801016d080ad"
+MODEL_DIGEST = "sha256:" + MODEL_WEIGHTS_SHA256
 EMBEDDING_DIMENSION = 512
 
 
@@ -32,36 +38,75 @@ def deny_network():
     socket.socket.connect_ex = denied
 
 
-def artifact_entries(cache_dir):
-    entries = []
-    for root, _dirs, names in os.walk(cache_dir):
-        for name in sorted(names):
-            path = os.path.join(root, name)
-            if not os.path.isfile(path) or os.path.getsize(path) < 1024:
-                continue
-            relative = os.path.relpath(path, cache_dir).replace(os.sep, "/")
-            digest = hashlib.sha256()
-            with open(path, "rb") as source:
-                while True:
-                    block = source.read(1024 * 1024)
-                    if not block:
-                        break
-                    digest.update(block)
-            entries.append({"path": relative, "bytes": os.path.getsize(path), "sha256": digest.hexdigest()})
-    return sorted(entries, key=lambda item: item["path"])
-
-
-def artifact_digest(entries):
+def sha256_file(path):
     digest = hashlib.sha256()
-    for entry in entries:
-        digest.update(entry["path"].encode("utf-8"))
-        digest.update(b"\0")
-        digest.update(entry["sha256"].encode("ascii"))
-        digest.update(b"\n")
-    return "sha256:" + digest.hexdigest()
+    with open(path, "rb") as source:
+        while True:
+            block = source.read(1024 * 1024)
+            if not block:
+                break
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def model_weights_path(cache_dir):
+    return os.path.join(cache_dir, MODEL_WEIGHTS_FILENAME)
+
+
+def verify_model_weights(cache_dir):
+    path = model_weights_path(cache_dir)
+    if not os.path.isfile(path):
+        raise RuntimeError("Pinned OpenCLIP weight is missing; run explicit vision setup")
+    actual_bytes = os.path.getsize(path)
+    if actual_bytes != MODEL_WEIGHTS_BYTES:
+        raise RuntimeError(
+            "Pinned OpenCLIP weight has an unexpected size "
+            "(expected %d bytes, got %d); run explicit vision setup" % (MODEL_WEIGHTS_BYTES, actual_bytes)
+        )
+    actual_sha256 = sha256_file(path)
+    if actual_sha256 != MODEL_WEIGHTS_SHA256:
+        raise RuntimeError(
+            "Pinned OpenCLIP weight checksum mismatch "
+            "(expected %s, got %s); run explicit vision setup" % (MODEL_WEIGHTS_SHA256, actual_sha256)
+        )
+    return path
+
+
+def artifact_entries(cache_dir):
+    path = verify_model_weights(cache_dir)
+    return [{
+        "path": MODEL_WEIGHTS_FILENAME,
+        "bytes": os.path.getsize(path),
+        "sha256": MODEL_WEIGHTS_SHA256,
+    }]
+
+
+def download_pinned_model_weights(cache_dir):
+    os.makedirs(cache_dir, exist_ok=True)
+    try:
+        verified = verify_model_weights(cache_dir)
+    except RuntimeError:
+        # An interrupted/corrupt setup may leave a file at the managed target.
+        # Only explicit setup is permitted to replace it.
+        force_download = True
+    else:
+        return verified
+    from huggingface_hub import hf_hub_download
+    downloaded = hf_hub_download(
+        repo_id=MODEL_REPOSITORY,
+        filename=MODEL_WEIGHTS_FILENAME,
+        revision=MODEL_REVISION,
+        local_dir=cache_dir,
+        local_files_only=False,
+        force_download=force_download,
+    )
+    expected_path = model_weights_path(cache_dir)
+    if os.path.abspath(downloaded) != os.path.abspath(expected_path):
+        raise RuntimeError("Pinned OpenCLIP download did not materialize in the managed cache")
+    return verify_model_weights(cache_dir)
 
 
-def load_model(cache_dir, offline):
+def load_model(weights_path, offline):
     if offline:
         deny_network()
         os.environ["HF_HUB_OFFLINE"] = "1"
@@ -70,11 +115,14 @@ def load_model(cache_dir, offline):
     import open_clip
     if not torch.cuda.is_available():
         raise RuntimeError("JetPack CUDA Torch is unavailable for OpenCLIP")
+    if os.environ.get("CUDA_VISIBLE_DEVICES") != "0":
+        raise RuntimeError("OpenCLIP requires CUDA_VISIBLE_DEVICES=0")
+    if torch.cuda.current_device() != 0:
+        raise RuntimeError("OpenCLIP did not bind to logical CUDA device 0")
     device = torch.device("cuda:0")
     model, _, preprocess = open_clip.create_model_and_transforms(
         MODEL,
-        pretrained=PRETRAINED,
-        cache_dir=cache_dir,
+        pretrained=weights_path,
         device=device,
     )
     model.eval()
@@ -82,27 +130,33 @@ def load_model(cache_dir, offline):
 
 
 def setup(cache_dir):
-    torch, model, _preprocess, device = load_model(cache_dir, False)
+    _weights_path = download_pinned_model_weights(cache_dir)
+    import torch
+    if not torch.cuda.is_available():
+        raise RuntimeError("JetPack CUDA Torch is unavailable for OpenCLIP")
+    if os.environ.get("CUDA_VISIBLE_DEVICES") != "0":
+        raise RuntimeError("OpenCLIP setup requires CUDA_VISIBLE_DEVICES=0")
+    if torch.cuda.current_device() != 0:
+        raise RuntimeError("OpenCLIP setup did not bind to logical CUDA device 0")
     entries = artifact_entries(cache_dir)
-    if not entries:
-        raise RuntimeError("OpenCLIP setup did not create verifiable model artifacts")
-    with torch.inference_mode():
-        # Model loading is setup verification, not a user inference request.
-        torch.cuda.synchronize(device)
     major, minor = torch.cuda.get_device_capability(0)
     emit({
         "type": "setup",
         "success": True,
         "model": MODEL,
         "pretrained": PRETRAINED,
+        "model_repository": MODEL_REPOSITORY,
+        "model_revision": MODEL_REVISION,
+        "model_weights_sha256": MODEL_WEIGHTS_SHA256,
         "backend": "open-clip",
         "embedding_dimension": EMBEDDING_DIMENSION,
         "normalization": "l2",
         "device": torch.cuda.get_device_name(0),
         "compute_capability": "%d.%d" % (major, minor),
         "torch_cuda_version": str(torch.version.cuda),
+        "cuda_visible_devices": os.environ.get("CUDA_VISIBLE_DEVICES"),
         "artifacts": entries,
-        "model_digest": artifact_digest(entries),
+        "model_digest": MODEL_DIGEST,
     })
 
 
@@ -117,13 +171,12 @@ def image_from_input(input_):
     raise ValueError("Provide path or bytesBase64")
 
 
-def embed(cache_dir, expected_digest):
-    entries = artifact_entries(cache_dir)
-    actual = artifact_digest(entries)
-    if actual != expected_digest:
-        raise RuntimeError("OpenCLIP model artifacts are missing or changed; run explicit vision setup")
+def embed(cache_dir, expected_digest, expected_revision):
+    if expected_digest != MODEL_DIGEST or expected_revision != MODEL_REVISION:
+        raise RuntimeError("OpenCLIP model identity does not match the pinned setup contract")
+    weights_path = verify_model_weights(cache_dir)
     input_ = json.loads(sys.stdin.read() or "{}")
-    torch, model, preprocess, device = load_model(cache_dir, True)
+    torch, model, preprocess, device = load_model(weights_path, True)
     image = image_from_input(input_)
     with torch.inference_mode():
         tensor = preprocess(image).unsqueeze(0).to(device)
@@ -137,8 +190,11 @@ def embed(cache_dir, expected_digest):
         "success": True,
         "model": MODEL,
         "pretrained": PRETRAINED,
+        "model_repository": MODEL_REPOSITORY,
+        "model_revision": MODEL_REVISION,
+        "model_weights_sha256": MODEL_WEIGHTS_SHA256,
         "backend": "open-clip",
-        "model_digest": actual,
+        "model_digest": MODEL_DIGEST,
         "embedding": values,
         "dimension": EMBEDDING_DIMENSION,
         "normalization": "l2",
@@ -151,15 +207,16 @@ def main():
     parser.add_argument("--embed", action="store_true")
     parser.add_argument("--cache-dir", required=True)
     parser.add_argument("--model-digest")
+    parser.add_argument("--model-revision")
     args = parser.parse_args()
     if args.setup == args.embed:
         raise ValueError("Choose exactly one of --setup or --embed")
     if args.setup:
         setup(args.cache_dir)
     else:
-        if not args.model_digest:
-            raise ValueError("--model-digest is required for offline embedding")
-        embed(args.cache_dir, args.model_digest)
+        if not args.model_digest or not args.model_revision:
+            raise ValueError("--model-digest and --model-revision are required for offline embedding")
+        embed(args.cache_dir, args.model_digest, args.model_revision)
 
 
 if __name__ == "__main__":

package/dist/update-worker.js

@@ -245088,6 +245088,7 @@ var SETUP_TIMEOUT_MS = 20 * 6e4;
 // packages/execution/dist/speaker-diarization-runtime.js
 init_model_store();
 init_process_async();
+init_venv_paths();
 
 // packages/execution/dist/audio-semantic-embedding-runtime.js
 init_process_async();
@@ -245095,6 +245096,27 @@ init_jetson_monitor();
 init_model_store();
 init_venv_paths();
 var SETUP_TIMEOUT_MS2 = 30 * 6e4;
+var CLAP_RUNTIME_WHEELS = [
+  { distribution: "numpy", version: "1.26.4", importName: "numpy", filename: "numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", source: "https://files.pythonhosted.org/packages/fc/a5/4beee6488160798683eed5bdb7eead455892c3b4e1f78d79d8d3f3b084ac/numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", sha256: "d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4" },
+  { distribution: "transformers", version: "4.57.3", importName: "transformers", filename: "transformers-4.57.3-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/6a/6b/2f416568b3c4c91c96e5a365d164f8a4a4a88030aa8ab4644181fdadce97/transformers-4.57.3-py3-none-any.whl", sha256: "c77d353a4851b1880191603d36acb313411d3577f6e2897814f333841f7003f4" },
+  { distribution: "huggingface-hub", version: "0.36.0", importName: "huggingface_hub", filename: "huggingface_hub-0.36.0-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/cb/bd/1a875e0d592d447cbc02805fd3fe0f497714d6a2583f59d14fa9ebad96eb/huggingface_hub-0.36.0-py3-none-any.whl", sha256: "7bcc9ad17d5b3f07b57c78e79d527102d08313caa278a641993acddcb894548d" },
+  { distribution: "hf-xet", version: "1.1.5", importName: "hf_xet", filename: "hf_xet-1.1.5-cp37-abi3-manylinux_2_28_aarch64.whl", source: "https://files.pythonhosted.org/packages/d0/54/0fcf2b619720a26fbb6cc941e89f2472a522cd963a776c089b189559447f/hf_xet-1.1.5-cp37-abi3-manylinux_2_28_aarch64.whl", sha256: "dbba1660e5d810bd0ea77c511a99e9242d920790d0e63c0e4673ed36c4022d18" },
+  { distribution: "tokenizers", version: "0.22.1", importName: "tokenizers", filename: "tokenizers-0.22.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", source: "https://files.pythonhosted.org/packages/1e/3b/55e64befa1e7bfea963cf4b787b2cea1011362c4193f5477047532ce127e/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", sha256: "19d2962dd28bc67c1f205ab180578a78eef89ac60ca7ef7cbe9635a46a56422a" },
+  { distribution: "safetensors", version: "0.5.3", importName: "safetensors", filename: "safetensors-0.5.3-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", source: "https://files.pythonhosted.org/packages/5d/9a/add3e6fef267658075c5a41573c26d42d80c935cdc992384dfae435feaef/safetensors-0.5.3-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", sha256: "11bce6164887cd491ca75c2326a113ba934be596e22b28b1742ce27b1d076467" },
+  { distribution: "filelock", version: "3.16.1", importName: "filelock", filename: "filelock-3.16.1-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", sha256: "2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0" },
+  { distribution: "fsspec", version: "2024.10.0", importName: "fsspec", filename: "fsspec-2024.10.0-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/c6/b2/454d6e7f0158951d8a78c2e1eb4f69ae81beb8dca5fee9809c6c99e9d0d0/fsspec-2024.10.0-py3-none-any.whl", sha256: "03b9a6785766a4de40368b88906366755e2819e758b83705c88cd7cb5fe81871" },
+  { distribution: "packaging", version: "24.2", importName: "packaging", filename: "packaging-24.2-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", sha256: "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" },
+  { distribution: "PyYAML", version: "6.0.2", importName: "yaml", filename: "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", source: "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", sha256: "8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237" },
+  { distribution: "regex", version: "2024.11.6", importName: "regex", filename: "regex-2024.11.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", source: "https://files.pythonhosted.org/packages/78/a2/6dd36e16341ab95e4c6073426561b9bfdeb1a9c9b63ab1b579c2e96cb105/regex-2024.11.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", sha256: "d3660c82f209655a06b587d55e723f0b813d3a7db2e32e5e7dc64ac2a9e86fde" },
+  { distribution: "requests", version: "2.32.3", importName: "requests", filename: "requests-2.32.3-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", sha256: "70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6" },
+  { distribution: "tqdm", version: "4.67.1", importName: "tqdm", filename: "tqdm-4.67.1-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", sha256: "26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2" },
+  { distribution: "typing-extensions", version: "4.12.2", importName: "typing_extensions", filename: "typing_extensions-4.12.2-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", sha256: "04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d" },
+  { distribution: "certifi", version: "2024.8.30", importName: "certifi", filename: "certifi-2024.8.30-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", sha256: "922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8" },
+  { distribution: "charset-normalizer", version: "3.4.0", importName: "charset_normalizer", filename: "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", source: "https://files.pythonhosted.org/packages/c2/72/12a7f0943dd71fb5b4e7b55c41327ac0a1663046a868ee4d0d8e9c369b85/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", sha256: "40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca" },
+  { distribution: "idna", version: "3.10", importName: "idna", filename: "idna-3.10-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", sha256: "946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3" },
+  { distribution: "urllib3", version: "2.2.3", importName: "urllib3", filename: "urllib3-2.2.3-py3-none-any.whl", source: "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", sha256: "ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac" }
+];
+var CLAP_PYTHON_REQUIREMENTS = CLAP_RUNTIME_WHEELS.map((wheel) => `${wheel.distribution}==${wheel.version}`);
 
 // packages/execution/dist/speaker-embedding-runtime.js
 init_jetson_monitor();