omnius 1.0.641 → 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/ocr-advanced.py

@@ -179,11 +179,17 @@ SMALL_CROP_AREA_PX = 512_000
 MEDIUM_IMAGE_AREA_PX = 2_000_000
 MAX_PIPELINE_DEADLINE_MS = 80_000
 MAX_TESSERACT_ATTEMPT_SECONDS = 12.0
+# Small conditioned crops normally complete in well under a second. A
+# six-second cap still permits a busy Tesseract child, while keeping a failed
+# recovery pair from consuming most of the REST deadline.
+SMALL_CROP_TESSERACT_ATTEMPT_SECONDS = 6.0
 MIN_TESSERACT_ATTEMPT_SECONDS = 0.25
 MIN_ACCEPTED_CONFIDENCE = 50.0
 MIN_SUBSTANTIVE_TEXT_CHARS = 12
 HIGH_VOLUME_GARBAGE_CHARS = 64
 HIGH_VOLUME_GARBAGE_CONFIDENCE = 35.0
+TERMINAL_SYMBOL_GARBAGE_CHARS = 24
+TERMINAL_SYMBOL_GARBAGE_ALNUM_RATIO = 0.20
 ACTIVE_DEADLINE = None
 
 
@@ -211,11 +217,11 @@ class OcrDeadline:
         if self.remaining_seconds() <= 0:
             raise OcrPipelineTimeout(f"OCR deadline exceeded during {stage}")
 
-    def tesseract_timeout_seconds(self):
+    def tesseract_timeout_seconds(self, attempt_cap_seconds=MAX_TESSERACT_ATTEMPT_SECONDS):
         self.check("Tesseract scheduling")
         return max(
             MIN_TESSERACT_ATTEMPT_SECONDS,
-            min(MAX_TESSERACT_ATTEMPT_SECONDS, self.remaining_seconds()),
+            min(attempt_cap_seconds, self.remaining_seconds()),
         )
 
 
@@ -251,7 +257,8 @@ def text_from_tesseract_data(data):
     return "\n".join(" ".join(words) for words in lines.values()).strip()
 
 
-def run_tesseract(binary_img, deadline, language="eng", psm=6):
+def run_tesseract(binary_img, deadline, language="eng", psm=6,
+                  attempt_cap_seconds=MAX_TESSERACT_ATTEMPT_SECONDS):
     """Run one bounded Tesseract TSV pass and derive text plus confidence."""
     deadline.check("Tesseract")
     pil_img = Image.fromarray(binary_img)
@@ -261,7 +268,7 @@ def run_tesseract(binary_img, deadline, language="eng", psm=6):
         lang=language,
         config=config,
         output_type=pytesseract.Output.DICT,
-        timeout=deadline.tesseract_timeout_seconds(),
+        timeout=deadline.tesseract_timeout_seconds(attempt_cap_seconds),
     )
     text = text_from_tesseract_data(data)
     confs = []
@@ -331,6 +338,24 @@ def assess_ocr_evidence(text, confidence, line_count):
     }
 
 
+def is_terminal_small_crop_rejection(evidence):
+    """Whether a first small-crop pass proves another recovery pass is futile.
+
+    Blanks and plausible alphanumeric low-confidence text remain recoverable
+    through the second variant. A large very-low-confidence transcript or a
+    distinctly symbol-heavy stream cannot become safe evidence through another
+    PSM6 pass, and should not make callers wait for one.
+    """
+    if evidence.get("state") != "rejected":
+        return False
+    if evidence.get("reason") == "high_volume_low_confidence_text":
+        return True
+    return (
+        evidence.get("chars", 0) >= TERMINAL_SYMBOL_GARBAGE_CHARS
+        and evidence.get("alnum_ratio", 1.0) < TERMINAL_SYMBOL_GARBAGE_ALNUM_RATIO
+    )
+
+
 def compute_score(text, confidence, line_count, evidence=None):
     """Combined scoring heuristic:
       - confidence * sqrt(char_count)  — rewards quality and coverage
@@ -451,15 +476,18 @@ def write_all_outputs(text, base_name, output_dir):
 # Main pipeline
 # ---------------------------------------------------------------------------
 
-def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefix="full"):
+def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefix="full",
+                     attempt_cap_seconds=MAX_TESSERACT_ATTEMPT_SECONDS,
+                     stop_on_terminal_rejection=False):
     """Run a bounded plan, stopping early once a legible result is proven."""
     all_results = {}
     ocr_errors = []
     best_key = None
     best_score = -1
     early_exit = False
+    terminal_rejection = False
 
-    for vname, psm in plan:
+    for attempt_index, (vname, psm) in enumerate(plan):
         deadline.check("preprocessing")
         key = f"{vname}_psm{psm}"
         try:
@@ -471,7 +499,9 @@ def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefi
             os.makedirs(debug_dir, exist_ok=True)
             cv2.imwrite(os.path.join(debug_dir, f"{debug_prefix}_{vname}.png"), binary)
         try:
-            text, confidence, line_count = run_tesseract(binary, deadline, language, psm)
+            text, confidence, line_count = run_tesseract(
+                binary, deadline, language, psm, attempt_cap_seconds
+            )
         except OcrPipelineTimeout:
             raise
         except OcrPipelineCancelled:
@@ -496,8 +526,15 @@ def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefi
         if has_sufficient_evidence(text, confidence, line_count):
             early_exit = True
             break
+        if (
+            stop_on_terminal_rejection
+            and attempt_index == 0
+            and is_terminal_small_crop_rejection(evidence)
+        ):
+            terminal_rejection = True
+            break
 
-    return all_results, ocr_errors, best_key, early_exit
+    return all_results, ocr_errors, best_key, early_exit, terminal_rejection
 
 
 def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_dir=None,
@@ -522,10 +559,22 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
     deadline.check("image conditioning")
     gray_2x = upscale_2x(gray)
     plan = build_ocr_plan(effective_area, single_psm)
+    is_small_crop = effective_area <= SMALL_CROP_AREA_PX
+    attempt_cap_seconds = (
+        SMALL_CROP_TESSERACT_ATTEMPT_SECONDS
+        if is_small_crop
+        else MAX_TESSERACT_ATTEMPT_SECONDS
+    )
     attempts_completed = 0
     try:
-        all_results, ocr_errors, best_key, early_exit = run_variant_plan(
-            gray_2x, plan, deadline, language, debug_dir
+        all_results, ocr_errors, best_key, early_exit, terminal_rejection = run_variant_plan(
+            gray_2x,
+            plan,
+            deadline,
+            language,
+            debug_dir,
+            attempt_cap_seconds=attempt_cap_seconds,
+            stop_on_terminal_rejection=is_small_crop,
         )
         attempts_completed = len(all_results)
         if not best_key:
@@ -545,6 +594,8 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
                     "diagnostic": {
                         **diagnostic("ocr_evidence_rejected", message, deadline, "evidence_quality", attempts_completed, len(plan)),
                         "evidence": evidence,
+                        "terminal_small_crop_rejection": terminal_rejection,
+                        "attempt_cap_seconds": attempt_cap_seconds,
                     },
                 }
             # Empty or tiny non-substantive detections are valid observations:
@@ -579,6 +630,8 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
                     "attempts_planned": len(plan),
                     "attempts_completed": attempts_completed,
                     "early_exit": False,
+                    "terminal_small_crop_rejection": terminal_rejection,
+                    "attempt_cap_seconds": attempt_cap_seconds,
                     "deadline_ms": deadline.deadline_ms,
                 },
             }
@@ -615,6 +668,8 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
                 "attempts_planned": len(plan),
                 "attempts_completed": attempts_completed,
                 "early_exit": early_exit,
+                "terminal_small_crop_rejection": terminal_rejection,
+                "attempt_cap_seconds": attempt_cap_seconds,
                 "deadline_ms": deadline.deadline_ms,
             },
         }
@@ -627,9 +682,22 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
                 region_gray = extract_region(gray_2x, y_start, y_end)
                 # Region requests use at most two high-yield attempts. The
                 # main result already provides full-frame coverage.
-                region_plan = build_ocr_plan(region_gray.shape[0] * region_gray.shape[1], single_psm)[:2]
-                region_results, _errors, region_best_key, _early_exit = run_variant_plan(
-                    region_gray, region_plan, deadline, language, debug_dir, f"region_{rname}"
+                region_area = region_gray.shape[0] * region_gray.shape[1]
+                region_plan = build_ocr_plan(region_area, single_psm)[:2]
+                region_is_small = region_area <= SMALL_CROP_AREA_PX
+                region_results, _errors, region_best_key, _early_exit, _terminal_rejection = run_variant_plan(
+                    region_gray,
+                    region_plan,
+                    deadline,
+                    language,
+                    debug_dir,
+                    f"region_{rname}",
+                    attempt_cap_seconds=(
+                        SMALL_CROP_TESSERACT_ATTEMPT_SECONDS
+                        if region_is_small
+                        else MAX_TESSERACT_ATTEMPT_SECONDS
+                    ),
+                    stop_on_terminal_rejection=region_is_small,
                 )
                 regions[rname] = region_results[region_best_key]["text"] if region_best_key else ""
             result["regions"] = regions

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();