omnius 1.0.633 → 1.0.636

package/dist/scripts/audio-yamnet-tensorrt-worker.py

@@ -154,7 +154,12 @@ def read_wav(path: str, np):
         raise RuntimeError(
             f"Expected at most 6 seconds of caller-conditioned audio, received {waveform.size / sample_rate:.3f} seconds"
         )
-    return waveform, sample_rate, (time.perf_counter() - started) * 1000
+    return (
+        waveform,
+        sample_rate,
+        (time.perf_counter() - started) * 1000,
+        "sha256:" + hashlib.sha256(raw).hexdigest(),
+    )
 
 
 class YAMNetTensorRT:
@@ -193,6 +198,8 @@ class YAMNetTensorRT:
                 self.output_names.append(name)
         if self.input_name is None or not self.output_names:
             raise RuntimeError("YAMNet TensorRT engine did not expose input and output tensors")
+        self.score_output_name = self._unique_output_name(521, "AudioSet score")
+        self.embedding_output_name = self._unique_output_name(1024, "YAMNet embedding")
         with open(class_map_path, newline="", encoding="utf8") as handle:
             self.classes = [row["display_name"] for row in csv.DictReader(handle)]
         if len(self.classes) != 521:
@@ -205,13 +212,28 @@ class YAMNetTensorRT:
         # namespace to exactly the approved Jetson GPU before process launch.
         return self.cuda.device_metadata()
 
+    def _unique_output_name(self, width: int, label: str):
+        matches = []
+        for name in self.output_names:
+            shape = tuple(self.engine.get_tensor_shape(name))
+            if shape and int(shape[-1]) == width:
+                matches.append(name)
+        if len(matches) != 1:
+            raise RuntimeError(
+                f"YAMNet TensorRT engine must expose exactly one {label} output with width {width}; found {matches}"
+            )
+        return matches[0]
+
     def warm(self):
         # YAMNet needs >=0.975 seconds.  This is a model-load probe, not a
         # captured-audio classification, and it verifies the TensorRT path is
         # actually executable before readiness is reported.
-        self.infer(self.np.zeros(15600, dtype=self.np.float32), 1)
+        # Exercise and validate both exported model heads before reporting the
+        # persistent worker as ready.  A stale score-only plan must fail here,
+        # rather than after an embedding caller has acquired the queue slot.
+        self.infer(self.np.zeros(15600, dtype=self.np.float32), 1, include_embedding=True)
 
-    def infer(self, waveform, top_k: int):
+    def infer(self, waveform, top_k: int | None = None, include_embedding: bool = False):
         started = time.perf_counter()
         np = self.np
         if waveform.ndim != 1 or waveform.size < 15600:
@@ -246,16 +268,34 @@ class YAMNetTensorRT:
             for name, (host, device) in host_outputs.items():
                 self.cuda.d2h(host, device, self.stream, name)
             self.cuda.synchronize(self.stream)
-            # The converted Google model exposes output_0 with AudioSet scores.
-            scores = next((value[0] for name, value in host_outputs.items() if value[0].shape[-1] == 521), None)
-            if scores is None:
-                raise RuntimeError("TensorRT YAMNet engine did not produce a 521-class score tensor")
-            mean_scores = np.mean(scores, axis=0)
-            indices = np.argsort(mean_scores)[-top_k:][::-1]
-            return [
-                {"label": self.classes[int(index)], "confidence": float(mean_scores[int(index)])}
-                for index in indices
-            ], (time.perf_counter() - started) * 1000
+            result = {}
+            if top_k is not None:
+                scores = host_outputs[self.score_output_name][0]
+                if scores.ndim != 2 or scores.shape[-1] != 521:
+                    raise RuntimeError(f"YAMNet score output shape is invalid: {scores.shape}")
+                mean_scores = np.mean(scores, axis=0)
+                indices = np.argsort(mean_scores)[-top_k:][::-1]
+                result["classifications"] = [
+                    {"label": self.classes[int(index)], "confidence": float(mean_scores[int(index)])}
+                    for index in indices
+                ]
+            if include_embedding:
+                frame_embeddings = host_outputs[self.embedding_output_name][0]
+                if frame_embeddings.ndim != 2 or frame_embeddings.shape[-1] != 1024 or frame_embeddings.shape[0] < 1:
+                    raise RuntimeError(f"YAMNet embedding output shape is invalid: {frame_embeddings.shape}")
+                vector = np.mean(frame_embeddings.astype(np.float32, copy=False), axis=0)
+                norm = float(np.linalg.norm(vector))
+                if not np.isfinite(norm) or norm <= 0.0:
+                    raise RuntimeError("YAMNet embedding has an invalid L2 norm")
+                result["embedding"] = {
+                    "dimension": 1024,
+                    "frame_count": int(frame_embeddings.shape[0]),
+                    "pooling": "mean_l2",
+                    "dtype": "float32",
+                    "normalization": "l2",
+                    "values": (vector / norm).astype(np.float32).tolist(),
+                }
+            return result, (time.perf_counter() - started) * 1000
         finally:
             for allocation in allocations:
                 try:
@@ -307,40 +347,48 @@ def main() -> int:
             if request.get("type") == "shutdown":
                 emit({"type": "stopped"})
                 return 0
-            if request.get("type") != "classify":
-                raise RuntimeError("unknown request type")
+            action = str(request.get("action") or request.get("type") or "").strip().lower()
+            if action not in ("classify", "embed"):
+                raise RuntimeError("unknown audio analysis action")
             request_id = str(request.get("id") or "")
             file_path = str(request.get("file") or "")
             if not request_id or not file_path:
-                raise RuntimeError("classify requires id and file")
-            waveform, sample_rate, decode_ms = read_wav(file_path, worker.np)
+                raise RuntimeError("audio analysis requires id and file")
+            waveform, sample_rate, decode_ms, input_digest = read_wav(file_path, worker.np)
             rms = float(worker.np.sqrt(worker.np.mean(worker.np.square(waveform)))) if waveform.size else 0.0
             peak = float(worker.np.max(worker.np.abs(waveform))) if waveform.size else 0.0
             # Do not force YAMNet to invent an AudioSet label for digital or
             # near-digital silence. This remains a valid, grounded result.
             low_information = rms < 0.0005 and peak < 0.002
             if low_information:
-                classifications, inference_ms = [], 0.0
+                result, inference_ms = (
+                    {"classifications": []} if action == "classify" else {"embedding": None},
+                    0.0,
+                )
             else:
-                classifications, inference_ms = worker.infer(
+                result, inference_ms = worker.infer(
                     waveform,
-                    max(1, min(int(request.get("top_k", 5)), 25)),
+                    top_k=max(1, min(int(request.get("top_k", 5)), 25)) if action == "classify" else None,
+                    include_embedding=action == "embed",
                 )
             emit({
                 "type": "result",
                 "id": request_id,
+                "action": action,
                 "success": True,
                 "sample_rate_hz": sample_rate,
                 "duration_seconds": round(float(waveform.size) / sample_rate, 6),
-                "classifications": classifications,
+                "input_digest": input_digest,
                 "low_information": low_information,
                 "acoustic": {"rms": round(rms, 8), "peak": round(peak, 8)},
                 "timings_ms": {"decode": round(decode_ms, 3), "inference": round(inference_ms, 3)},
+                **result,
             })
         except Exception as exc:  # keep the persistent worker alive per request
             emit({
                 "type": "result",
                 "id": str(locals().get("request", {}).get("id", "")),
+                "action": str(locals().get("action", "")),
                 "success": False,
                 "error": str(exc),
             })

package/dist/scripts/embed-image.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+import sys, json, base64, io
+try:
+    import torch
+    import open_clip
+    from PIL import Image
+except Exception as e:
+    print(json.dumps({"error":"deps_missing","message":str(e)}))
+    sys.exit(0)
+
+def load_image_from_input(data):
+    if data.get('path'):
+        return Image.open(data['path']).convert('RGB')
+    if data.get('bytesBase64'):
+        b = base64.b64decode(data['bytesBase64'])
+        return Image.open(io.BytesIO(b)).convert('RGB')
+    raise RuntimeError('no input provided')
+
+def main():
+    raw = sys.stdin.read()
+    data = json.loads(raw) if raw.strip() else {}
+    image = load_image_from_input(data)
+    model, _, preprocess = open_clip.create_model_and_transforms('ViT-B-32', pretrained='laion2b_s34b_b79k')
+    model.eval()
+    with torch.no_grad():
+        img_t = preprocess(image).unsqueeze(0)
+        emb = model.encode_image(img_t)
+        emb = emb / emb.norm(dim=-1, keepdim=True)
+        arr = emb.squeeze(0).cpu().numpy().astype('float32').tolist()
+    print(json.dumps({"embedding": arr}))
+
+if __name__ == '__main__':
+    main()
+

package/dist/scripts/embed-text.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+import sys, json
+try:
+    import torch
+    import open_clip
+except Exception as e:
+    print(json.dumps({"error":"deps_missing","message":str(e)}))
+    sys.exit(0)
+
+def main():
+    raw = sys.stdin.read()
+    data = json.loads(raw) if raw.strip() else {}
+    text = data.get('text') or ''
+    model, _, preprocess = open_clip.create_model_and_transforms('ViT-B-32', pretrained='laion2b_s34b_b79k')
+    tokenizer = open_clip.get_tokenizer('ViT-B-32')
+    model.eval()
+    with torch.no_grad():
+        tokens = tokenizer([text])
+        emb = model.encode_text(tokens)
+        emb = emb / emb.norm(dim=-1, keepdim=True)
+        arr = emb.squeeze(0).cpu().numpy().astype('float32').tolist()
+    print(json.dumps({"embedding": arr}))
+
+if __name__ == '__main__':
+    main()
+

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

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Offline, line-delimited workers for Omnius managed speaker diarization.
+
+The parent process supplies an already-verified local artifact and forces
+offline Hugging Face mode.  This worker deliberately has no setup/download
+branch and never reads a token: a request can only use a model proven during
+the admin setup path.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import wave
+from pathlib import Path
+from typing import Any
+
+
+def emit(payload: dict[str, Any]) -> None:
+    print(json.dumps(payload, separators=(",", ":")), flush=True)
+
+
+def validate_live_wav(path: str) -> None:
+    """Live Sortformer is a bounded retained 16k mono PCM16 window."""
+    try:
+        with wave.open(path, "rb") as wav:
+            channels = wav.getnchannels()
+            width = wav.getsampwidth()
+            rate = wav.getframerate()
+            duration = wav.getnframes() / float(rate) if rate else 0.0
+    except Exception as exc:  # wave errors are intentionally surfaced to caller
+        raise ValueError(f"live diarization requires readable WAV: {exc}") from exc
+    if channels != 1 or width != 2 or rate != 16000:
+        raise ValueError("live diarization requires retained mono PCM16/16 kHz WAV")
+    if duration <= 0 or duration > 6.0:
+        raise ValueError("live diarization accepts retained audio windows greater than 0 and at most 6 seconds")
+
+
+def number(value: Any) -> float | None:
+    try:
+        result = float(value)
+        return result if result == result and result not in (float("inf"), float("-inf")) else None
+    except Exception:
+        return None
+
+
+def append_segment(result: list[dict[str, Any]], start: Any, end: Any, speaker: Any, confidence: Any = None) -> None:
+    start_s = number(start)
+    end_s = number(end)
+    label = str(speaker or "").strip()
+    if start_s is None or end_s is None or end_s <= start_s or not label:
+        return
+    confidence_value = number(confidence)
+    result.append({
+        "start_ms": round(start_s * 1000),
+        "end_ms": round(end_s * 1000),
+        "speaker": label,
+        "confidence": confidence_value,
+    })
+
+
+def normalize_sortformer(value: Any) -> list[dict[str, Any]]:
+    """Accept NeMo's current tuple/list result variants without inventing data."""
+    while isinstance(value, list) and len(value) == 1 and isinstance(value[0], (list, tuple)):
+        value = value[0]
+    result: list[dict[str, Any]] = []
+    if not isinstance(value, (list, tuple)):
+        raise RuntimeError("Sortformer returned an unsupported diarization result shape")
+    for item in value:
+        if isinstance(item, dict):
+            append_segment(result, item.get("start", item.get("start_time")), item.get("end", item.get("end_time")), item.get("speaker", item.get("label")), item.get("confidence"))
+        elif isinstance(item, (tuple, list)) and len(item) >= 3:
+            append_segment(result, item[0], item[1], item[2], item[3] if len(item) > 3 else None)
+        elif isinstance(item, str):
+            # Some NeMo surfaces return RTTM lines. Parse only the standard
+            # SPEAKER fields; malformed lines are ignored rather than guessed.
+            fields = item.split()
+            if len(fields) >= 8 and fields[0].upper() == "SPEAKER":
+                start = number(fields[3])
+                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:
+        raise RuntimeError("Sortformer result contained no parseable speaker turns")
+    return result
+
+
+def load_live(args: argparse.Namespace):
+    import torch
+    from nemo.collections.asr.models import SortformerEncLabelModel
+
+    if not torch.cuda.is_available() or tuple(torch.cuda.get_device_capability(0)) != (8, 7):
+        raise RuntimeError("live Sortformer requires Jetson Orin CUDA:0 (compute capability 8.7)")
+    model = SortformerEncLabelModel.restore_from(
+        args.artifact_path, map_location=torch.device("cuda:0"), strict=False
+    )
+    model.eval()
+
+    def diarize(path: str) -> list[dict[str, Any]]:
+        validate_live_wav(path)
+        with torch.inference_mode():
+            return normalize_sortformer(model.diarize(audio=[path], batch_size=1))
+
+    return model, diarize, "nemo-sortformer-python-cuda"
+
+
+def load_reconcile(args: argparse.Namespace):
+    # Community-1's supported offline workflow is Pipeline.from_pretrained on
+    # a local clone.  HF token/terms are setup concerns and intentionally never
+    # appear here. CPU protects the live CUDA sidecar on Jetson.
+    import torch
+    from pyannote.audio import Pipeline
+
+    pipeline = Pipeline.from_pretrained(args.snapshot_path)
+    if pipeline is None:
+        raise RuntimeError("pyannote failed to load the local Community-1 snapshot")
+    pipeline.to(torch.device("cpu"))
+
+    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)
+        annotation = getattr(output, "speaker_diarization", output)
+        turns = getattr(annotation, "itertracks", None)
+        if not callable(turns):
+            raise RuntimeError("pyannote Community-1 result has no speaker_diarization tracks")
+        result: list[dict[str, Any]] = []
+        for segment, _track, speaker in annotation.itertracks(yield_label=True):
+            append_segment(result, getattr(segment, "start", None), getattr(segment, "end", None), speaker)
+        return result
+
+    return pipeline, diarize, "pyannote-community-python-cpu"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--mode", choices=["live", "reconcile"], required=True)
+    parser.add_argument("--snapshot-path", required=True)
+    parser.add_argument("--artifact-path", required=True)
+    parser.add_argument("--revision", required=True)
+    parser.add_argument("--model-digest", required=True)
+    args = parser.parse_args()
+
+    # Do not allow an accidentally inherited setup token to become a request
+    # time credential or network fallback.
+    os.environ["HF_HUB_OFFLINE"] = "1"
+    os.environ["TRANSFORMERS_OFFLINE"] = "1"
+    os.environ.pop("HF_TOKEN", None)
+    os.environ.pop("HUGGING_FACE_HUB_TOKEN", None)
+    try:
+        _model, diarize, backend = load_live(args) if args.mode == "live" else load_reconcile(args)
+        model = "nvidia/diar_streaming_sortformer_4spk-v2" if args.mode == "live" else "pyannote/speaker-diarization-community-1"
+        emit({
+            "type": "ready",
+            "pid": os.getpid(),
+            "mode": args.mode,
+            "model": model,
+            "revision": args.revision,
+            "model_digest": args.model_digest,
+            "backend": backend,
+            "warmed": True,
+        })
+    except Exception as exc:
+        emit({"type": "fatal", "error": str(exc)})
+        return 2
+
+    for line in sys.stdin:
+        try:
+            message = json.loads(line)
+            if message.get("type") != "diarize" or not isinstance(message.get("id"), str):
+                continue
+            started = time.perf_counter()
+            segments = diarize(str(message.get("file", "")))
+            emit({
+                "type": "result",
+                "id": message["id"],
+                "success": True,
+                "segments": segments,
+                "timings_ms": {"inference": round((time.perf_counter() - started) * 1000)},
+            })
+        except Exception as exc:
+            emit({"type": "result", "id": message.get("id", "unknown") if "message" in locals() else "unknown", "success": False, "error": str(exc)})
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Explicit-setup OpenCLIP vision embedding worker.
+
+`--setup` is the only mode allowed to obtain model artifacts. `--embed` runs
+with outbound sockets denied and checks the setup manifest digest before it
+loads the model, so a REST embedding request can never silently provision.
+"""
+
+import argparse
+import base64
+import hashlib
+import io
+import json
+import os
+import socket
+import sys
+
+MODEL = "ViT-B-32"
+PRETRAINED = "laion2b_s34b_b79k"
+EMBEDDING_DIMENSION = 512
+
+
+def emit(value):
+    print(json.dumps(value, separators=(",", ":")), flush=True)
+
+
+def deny_network():
+    def denied(*_args, **_kwargs):
+        raise RuntimeError("OpenCLIP inference is offline; run explicit vision setup to obtain artifacts")
+    socket.create_connection = denied
+    socket.socket.connect = denied
+    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):
+    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()
+
+
+def load_model(cache_dir, offline):
+    if offline:
+        deny_network()
+        os.environ["HF_HUB_OFFLINE"] = "1"
+        os.environ["TRANSFORMERS_OFFLINE"] = "1"
+    import torch
+    import open_clip
+    if not torch.cuda.is_available():
+        raise RuntimeError("JetPack CUDA Torch is unavailable for OpenCLIP")
+    device = torch.device("cuda:0")
+    model, _, preprocess = open_clip.create_model_and_transforms(
+        MODEL,
+        pretrained=PRETRAINED,
+        cache_dir=cache_dir,
+        device=device,
+    )
+    model.eval()
+    return torch, model, preprocess, device
+
+
+def setup(cache_dir):
+    torch, model, _preprocess, device = load_model(cache_dir, False)
+    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,
+        "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),
+        "artifacts": entries,
+        "model_digest": artifact_digest(entries),
+    })
+
+
+def image_from_input(input_):
+    from PIL import Image
+    path = input_.get("path")
+    encoded = input_.get("bytesBase64")
+    if isinstance(path, str) and path:
+        return Image.open(path).convert("RGB")
+    if isinstance(encoded, str) and encoded:
+        return Image.open(io.BytesIO(base64.b64decode(encoded, validate=True))).convert("RGB")
+    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")
+    input_ = json.loads(sys.stdin.read() or "{}")
+    torch, model, preprocess, device = load_model(cache_dir, True)
+    image = image_from_input(input_)
+    with torch.inference_mode():
+        tensor = preprocess(image).unsqueeze(0).to(device)
+        vector = model.encode_image(tensor).float()
+        vector = vector / vector.norm(dim=-1, keepdim=True).clamp_min(1e-12)
+        values = vector[0].detach().cpu().numpy().astype("float32").tolist()
+    if len(values) != EMBEDDING_DIMENSION or not all(isinstance(value, float) for value in values):
+        raise RuntimeError("OpenCLIP returned an invalid image embedding")
+    emit({
+        "type": "embedding",
+        "success": True,
+        "model": MODEL,
+        "pretrained": PRETRAINED,
+        "backend": "open-clip",
+        "model_digest": actual,
+        "embedding": values,
+        "dimension": EMBEDDING_DIMENSION,
+        "normalization": "l2",
+    })
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--setup", action="store_true")
+    parser.add_argument("--embed", action="store_true")
+    parser.add_argument("--cache-dir", required=True)
+    parser.add_argument("--model-digest")
+    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 __name__ == "__main__":
+    try:
+        main()
+    except Exception as error:
+        emit({"type": "error", "success": False, "error": str(error)})
+        raise SystemExit(1)

package/dist/update-worker.js

@@ -245085,6 +245085,26 @@ var MODEL_URL = `https://huggingface.co/zeropointnine/yamnet-onnx/resolve/${MODE
 var CLASS_MAP_URL = `https://huggingface.co/zeropointnine/yamnet-onnx/resolve/${MODEL_REVISION}/yamnet_class_map.csv`;
 var SETUP_TIMEOUT_MS = 20 * 6e4;
 
+// packages/execution/dist/speaker-diarization-runtime.js
+init_model_store();
+init_process_async();
+
+// packages/execution/dist/audio-semantic-embedding-runtime.js
+init_process_async();
+init_jetson_monitor();
+init_model_store();
+init_venv_paths();
+var SETUP_TIMEOUT_MS2 = 30 * 6e4;
+
+// packages/execution/dist/speaker-embedding-runtime.js
+init_jetson_monitor();
+init_process_async();
+init_model_store();
+init_venv_paths();
+var MODEL_REVISION2 = "acf623ad8ca746e50baa432255cf8fc57c669c45";
+var MODEL_URL2 = `https://huggingface.co/Wespeaker/wespeaker-voxceleb-campplus/resolve/${MODEL_REVISION2}/voxceleb_CAM%2B%2B.onnx`;
+var SETUP_TIMEOUT_MS3 = 10 * 6e4;
+
 // packages/execution/dist/ocr-advanced-runtime.js
 init_process_async();
 init_jetson_monitor();
@@ -290433,6 +290453,21 @@ except Exception as exc:
     sys.exit(1)
 `;
 
+// packages/memory/dist/audioNoveltyPrototype.js
+var AUDIO_NOVELTY_WEIGHTS = Object.freeze({
+  distance: 0.6,
+  uncertainty: 0.1,
+  recurrence: 0.15,
+  direction: 0.075,
+  scene: 0.075
+});
+
+// packages/memory/dist/speakerIdentityStore.js
+var DEFAULT_THRESHOLDS = Object.freeze({
+  provisional: 0.78,
+  ambiguityMargin: 0.04
+});
+
 // packages/memory/dist/crl/index.js
 var CRL_SYMBOLS = {
   // Logical operators (Core)