@supersoniks/concorde 4.9.98-visual-stack.1 → 5.0.1

package/src/core/mixins/FormElement.ts

@@ -1,55 +1,73 @@
 import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy";
 import { property } from "lit/decorators.js";
-import { SubscriberInterface } from "@supersoniks/concorde/core/mixins/Subscriber";
 import Objects from "@supersoniks/concorde/core/utils/Objects";
 import { traverseDotNotation } from "@supersoniks/concorde/core/utils/Objects";
+import HTML from "@supersoniks/concorde/core/utils/HTML";
+import { LitElement } from "lit";
 import {
   PublisherInterface,
   HTMLFormControl,
   CoreJSType,
+  MixinArgsType,
 } from "../_types/types";
-import { MixinArgsType } from "../_types/types";
+
 type Constructor<T> = new (...args: MixinArgsType[]) => T;
+
 export type FormElementValue = string | string[] | object | null | undefined;
-export interface FormElementInterface extends SubscriberInterface {
-  getFormPublisher(): PublisherInterface;
+
+export interface FormElementInterface {
+  getFormPublisher(): PublisherInterface | null;
   updateDataValue(): void;
   handleChange(e?: Event): void;
   handleBlur(e?: Event): void;
   getValueForFormPublisher(): FormElementValue;
-  setValueFromPublisher(value: FormElementValue): void;
   setFormPublisherValue(value: FormElementValue): void;
   getFormPublisherValue(): FormElementValue;
+  setFormValueFromPublisher(value: FormElementValue): void;
   unsetOnDisconnect(): boolean;
   unset(): void;
-
   validateFormElement(): void;
   focus?: () => void;
   forceAutoFill: boolean;
-  shadowRoot?: ShadowRoot;
+  shadowRoot: ShadowRoot | null;
   error: boolean;
   autofocus: boolean;
   required: boolean;
   disabled: boolean;
   formDataProvider: string;
-  ariaLabelledby?: string;
-  ariaLabel?: string;
+  ariaLabel: string | null;
+  ariaLabelledby: string | null;
   _value: FormElementValue;
   get value(): FormElementValue;
   set value(value: FormElementValue);
   _name: string;
   get name(): string;
   set name(value: string);
+  getAncestorAttributeValue(attributeName: string): string;
+  hasAncestorAttribute(attributeName: string): boolean;
+  isConnected: boolean;
+  requestUpdate(): void;
+  getAttribute(name: string): string | null;
+  hasAttribute(attributeName: string): boolean;
+  setAttribute(name: string, value: string): void;
+  removeAttribute(name: string): void;
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void;
+  dispatchEvent(event: Event): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
 }
+
 const keyboardLoops = new Map<string, Array<FormElementInterface>>();
-const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
+
+const Form = <T extends Constructor<LitElement>>(superClass: T) => {
   /**
-   * ## FormElement est la mixin utilisée par les éléments de formulaire de concorde ainsi que par le composant sonic-button.
-   * * La propriété value est remplie automatiquement a l'aide de l'attribut name renseigné, ceci en prenant la valeur de la propriété du même nom dans les données du dataprovider associé.
-   * * Par défault lorsque l'on édite l'input, la valeur est également mise à jour via le même dataprovider
-   * * On peut cependant décider de mettre à jour la donnée à une autre adresse en renseignent l'attribut *formDataProvider*.
-   * * Par conséquent, on peut par exemple le lier à un composant *queue* (via sa propriété *dataFilterProvider*) de manière à appeller en auto une api avec des filtres.
-   *
+   * ## FormElement — mixin des champs de formulaire Concorde (et sonic-button).
+   * Synchronise `value` avec `formDataProvider` + `name` uniquement
+   * (plus de canal `dataProvider` / mixin Subscriber).
    */
   class FormElement extends superClass implements FormElementInterface {
     @property({ type: Boolean, reflect: true }) touched = false;
@@ -61,19 +79,16 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
 
     /* Attribut data-aria-label pour passer aria-label */
     @property({ type: String, attribute: "data-aria-label" })
-    ariaLabel?: string;
+    ariaLabel: string | null = null;
     @property({ type: String, attribute: "data-aria-labelledby" })
-    ariaLabelledby?: string;
+    ariaLabelledby: string | null = null;
 
-    onValueAssign?: (v: string) => void;
     onFormValueAssign?: (v: string) => void;
     onFormDataInValidate?: VoidFunction;
+
     constructor(...args: MixinArgsType[]) {
       super();
       args;
-      this.onValueAssign = (value) => {
-        this.setValueFromPublisher(value);
-      };
       this.onFormValueAssign = async (value) => {
         this.setFormValueFromPublisher(value);
       };
@@ -85,24 +100,41 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
         this.validateFormElement();
       };
     }
+
+    @property({ type: String })
     formDataProvider = "";
 
-    /**
-     * Le nom du champ avec des caractéristiques similaire à un input html classique.
-     */
+    hasAncestorAttribute(attributeName: string) {
+      return HTML.getAncestorAttributeValue(
+        this as unknown as HTMLElement,
+        attributeName
+      ) != null;
+    }
+
+    getAncestorAttributeValue(attributeName: string) {
+      return (
+        HTML.getAncestorAttributeValue(
+          this as unknown as HTMLElement,
+          attributeName
+        ) || ""
+      );
+    }
+
     _name = "";
     @property() get name(): string {
       return this._name;
     }
     set name(value: string) {
       if (this.hasAttribute("name") && !this.forceAutoFill)
-        value = this.getAttribute("name");
+        value = this.getAttribute("name") as string;
       this._name = value;
       this.requestUpdate();
     }
+
     validateFormElement() {
-      //Implémentation dans une sous classe
+      // Implémentation dans une sous-classe
     }
+
     unsetOnDisconnect() {
       return this.hasAttribute("unsetOnDisconnect");
     }
@@ -117,15 +149,15 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
         }
       }
     }
+
     getFormPublisher() {
       if (!this.formDataProvider)
         this.formDataProvider =
-          this.getAncestorAttributeValue("formDataProvider");
+          this.getAncestorAttributeValue("formDataProvider") || "";
       if (this.formDataProvider) {
         return PublisherManager.get(this.formDataProvider);
       }
       return null;
-      //else return this.publisher;
     }
 
     setFormPublisherValue(value: FormElementValue): void {
@@ -143,31 +175,14 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
       return null;
     }
 
-    /**
-     * Mise en forme de la valeur fournie au formPublisher associé au composant
-     * Destinée à être surchargée si besoin (cf Form-checkable)
-     */
     getValueForFormPublisher() {
       return this.value;
     }
-    /**
-     * Mise à jour de la valeur interne du composant en fonction de la valeur venant du publisher associé au composant
-     * Destinée à être surchargée si besoin (cf Form-checkable)
-     */
-    setValueFromPublisher(value: FormElementValue) {
-      this.value = value;
-    }
 
-    /**
-     * Mise à jour de la valeur interne du composant en fonction de la valeur venant du formPublisher associé au composant
-     * Destinée à être surchargée si besoin (cf Form-checkable)
-     */
     setFormValueFromPublisher(value: FormElementValue) {
       this.value = value;
     }
-    /**
-     * La valeur du champ avec des caractéristiques similaire à un input html classique :
-     */
+
     _value: FormElementValue = "";
     @property() get value() {
       return this._value;
@@ -188,7 +203,8 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
       this.updateDataValue();
       this.requestUpdate();
     }
-    initPublisher() {
+
+    initFormPublisher() {
       let formPublisher = this.getFormPublisher();
       const value =
         this.hasAncestorAttribute("initFromPublisher") &&
@@ -196,22 +212,12 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
         this.getFormPublisherValue()
           ? this.getFormPublisherValue()
           : this.getAttribute("value");
-      if (this._name && this.publisher)
-        traverseDotNotation(this.publisher, this._name).offAssign(
-          this.onValueAssign
-        );
       if (this._name && formPublisher)
         traverseDotNotation(formPublisher, this._name).offAssign(
           this.onFormValueAssign
         );
-      super.initPublisher();
-      if (!this.name) this._name = this.getAttribute("name");
+      if (!this.name) this._name = this.getAttribute("name") || "";
       if (!this.value) this._value = this.getAttribute("value");
-      if (this.publisher && this._name) {
-        traverseDotNotation(this.publisher, this._name).onAssign(
-          this.onValueAssign
-        );
-      }
       formPublisher = this.getFormPublisher();
       if (this._name && formPublisher) {
         traverseDotNotation(formPublisher, this._name).onAssign(
@@ -225,7 +231,6 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
 
     handleBlur() {
       this.touched = true;
-      // this.validateFormElement();
     }
 
     handleChange(e: Event) {
@@ -233,16 +238,10 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
       const event = new Event("change");
       this.dispatchEvent(event);
     }
-    /**
-     * Ajoute un comportement de navigation au clavier pour les éléments de formulaire
-     * data-keyboard-nav peut contenir plusieurs valeurs qui identifient les boucles de navigation auquelles est attaché cet élément.
-     * Les valeurs sont séparées par des espaces.
-     * En appuyant sur la touche "Down", le composant va se déplacer dans la boucle de navigation correspondante en suivant le flux.
-     * En appuyant sur la touche "Up", le déplacement inverse est effectué.
-     */
+
     addKeyboardNavigation() {
       const keyboardLoopIds: string =
-        this.getAncestorAttributeValue("data-keyboard-nav");
+        this.getAncestorAttributeValue("data-keyboard-nav") || "";
       if (!keyboardLoopIds) return;
 
       const split = keyboardLoopIds.split(" ");
@@ -277,7 +276,7 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
           );
         });
 
-        let next: SubscriberInterface | null = null;
+        let next: FormElementInterface | null = null;
         if (keyboardEvent.key == "ArrowDown" && loop) {
           const index = loop.indexOf(this);
           if (index == loop.length - 1) {
@@ -317,13 +316,16 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
     }
 
     connectedCallback(): void {
-      this.formDataProvider = this.getAncestorAttributeValue(
-        "formDataProvider"
-      ) as string;
+      if (!this.formDataProvider) {
+        this.formDataProvider =
+          this.getAncestorAttributeValue("formDataProvider") || "";
+      }
 
       super.connectedCallback();
+      this.initFormPublisher();
       this.addKeyboardNavigation();
     }
+
     unset() {
       this.value = null;
     }
@@ -333,10 +335,6 @@ const Form = <T extends Constructor<SubscriberInterface>>(superClass: T) => {
         this.unset();
       }
       super.disconnectedCallback();
-      if (this._name && this.publisher)
-        traverseDotNotation(this.publisher, this._name).offAssign(
-          this.onValueAssign
-        );
       const formPublisher = this.getFormPublisher();
       if (this._name && formPublisher) {
         traverseDotNotation(formPublisher, this._name).offAssign(

package/src/core/utils/HTML.ts

@@ -1,29 +1,12 @@
-/* eslint no-async-promise-executor: 0 */
+// on désactive une regle eslint pour ce fichier
+/* eslint no-async-promise-executor: 0 */ // --> OFF
 export type SearchableDomElement = HTMLElement | ShadowRoot;
 
 import { APIConfiguration } from "./api";
-
-/** Marqueur dataset : script déjà chargé avec succès via `loadJS`. */
-const SCRIPT_LOADED_FLAG = "1";
-
-/** http(s), relatif, blob — refuse javascript: / data: / etc. */
-function isAllowedScriptSrc(src: string): boolean {
-  const trimmed = src.trim();
-  if (!trimmed) return false;
-  try {
-    const url = new URL(trimmed, "https://example.invalid/");
-    return (
-      url.protocol === "http:" ||
-      url.protocol === "https:" ||
-      url.protocol === "blob:"
-    );
-  } catch {
-    return false;
-  }
-}
-
 class HTML {
-  /** Langue page : `SonicSelectedLanguage` localStorage, sinon `<html lang>`. */
+  /**
+   * retourne la langue de la page courante telle que défini via l'attribut lang de la balise html
+   */
   static getLanguage(): string {
     const documentLanguage = document.documentElement.lang;
     const selectedLanguage = localStorage.getItem("SonicSelectedLanguage");
@@ -57,13 +40,13 @@ class HTML {
 
   static everyAncestors(
     node: SearchableDomElement,
-    callback: (node: SearchableDomElement) => boolean,
+    callback: (node: SearchableDomElement) => /*continue ?*/ boolean
   ) {
-    let current: SearchableDomElement | null = node;
-    while (current) {
-      if (!callback(current)) return;
-      current = (current.parentNode ||
-        (current as ShadowRoot).host) as SearchableDomElement;
+    while (node) {
+      const result = callback(node);
+      if (!result) return;
+      node = (node.parentNode ||
+        (node as ShadowRoot).host) as SearchableDomElement;
     }
   }
 
@@ -132,19 +115,22 @@ class HTML {
   }
 
   /**
-   * Première valeur d'attribut trouvée en remontant (parentNode / shadow host).
-   * Ne traverse pas les slots — volontairement distinct de `nextComposedAncestor`.
+   * Va de parent en parent en partant de node pour trouver un attribut.
+   * @param attributeName nom de l'attribut
+   * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
    */
   static getAncestorAttributeValue(
     node: SearchableDomElement | null,
-    attributeName: string,
+    attributeName: string
   ): string | null {
     if (!node) return null;
     let current: SearchableDomElement | null = node;
     while (current) {
       if (current instanceof HTMLElement) {
         const value = HTML.readScopeAttributeOnElement(current, attributeName);
-        if (value != null) return value;
+        if (value != null) {
+          return value;
+        }
       }
       const parent = current.parentNode || (current as ShadowRoot).host;
       if (!parent) break;
@@ -193,34 +179,43 @@ class HTML {
     };
   }
 
-  /** Ancêtre dont le `nodeName` (minuscules) égale `selector` (ex. `"form"`). */
+  /**
+   * Va de parent en parent en partant de node pour trouver un attribut
+   * @param attributeName nom de l'attribut
+   * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
+   */
   static getClosestElement(node: SearchableDomElement, selector: string) {
-    let current: SearchableDomElement | null = node;
-    while (
-      current &&
-      !(current.nodeName && current.nodeName.toLowerCase() === selector)
-    ) {
-      const parent = current.parentNode || (current as ShadowRoot).host;
-      if (!parent) {
-        current = null;
-        break;
-      }
-      current = parent as SearchableDomElement;
+    while (!(node.nodeName && node.nodeName.toLowerCase() === selector)) {
+      const newNode = node.parentNode || (node as ShadowRoot).host;
+      if (!newNode) break;
+      node = (node.parentNode ||
+        (node as ShadowRoot).host) as SearchableDomElement;
     }
-    if (!current?.nodeName) return null;
-    return current;
+    if (!node.nodeName) {
+      return null;
+    }
+    return node;
   }
 
+  /**
+   * Va de parent en parent en partant de node pour trouver un attribut
+   * @param attributeName nom de l'attribut
+   * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
+   */
   static getClosestForm(node: SearchableDomElement) {
     return HTML.getClosestElement(node, "form");
   }
 
   /**
-   * Ancêtres dont le tagName matche (insensible à la casse), via parentNode / shadow host.
+   * Parcourt les ancêtres (parentNode / shadow host) et collecte ceux dont le tagName
+   * correspond à l'un des noms fournis (comparaison insensible à la casse).
+   * @param node Élément de départ
+   * @param tagNames Noms de balises à rechercher (ex: ['sonic-subscriber', 'sonic-sdui'])
+   * @returns Tableau des ancêtres correspondants
    */
   static getAncestorsByTagNames(
     node: SearchableDomElement,
-    tagNames: string[],
+    tagNames: string[]
   ): Element[] {
     const normalized = new Set(tagNames.map((t) => t.toLowerCase()));
     const result: Element[] = [];
@@ -240,11 +235,15 @@ class HTML {
   }
 
   /**
-   * Ancêtres qui matchent l'un des sélecteurs CSS (`element.matches`), via parentNode / shadow host.
+   * Parcourt les ancêtres (parentNode / shadow host) et collecte ceux qui matchent
+   * l'un des sélecteurs CSS fournis (element.matches(selector)).
+   * @param node Élément de départ
+   * @param selectors Sélecteurs CSS (ex: ['sonic-subscriber', 'sonic-sdui', 'div.container'])
+   * @returns Tableau des ancêtres correspondants
    */
   static getAncestorsBySelectors(
     node: SearchableDomElement,
-    selectors: string[],
+    selectors: string[]
   ): Element[] {
     const result: Element[] = [];
     let current = (node.parentNode ||
@@ -258,7 +257,7 @@ class HTML {
               break;
             }
           } catch {
-            /* sélecteur CSS invalide */
+            // Invalid selector, skip
           }
         }
       }
@@ -269,65 +268,24 @@ class HTML {
   }
 
   /**
-   * Charge un JS ; true si succès, false sinon.
-   * `.es.js` / `?module` → `type="module"`. Déduplique sur `script.src` absolu.
-   * Refuse les schémas non scriptables (`javascript:`, `data:`, …).
-   */
+   * Lance le chargement d'un js et retourne une promise qui resoud à true lorsque le chargement à réussi et à false, sinon.
+   * */
   static async loadJS(src: string) {
-    if (!isAllowedScriptSrc(src)) return false;
-    const absolute =
-      typeof document !== "undefined"
-        ? new URL(src, document.baseURI).href
-        : src;
-    const existing = Array.from(document.scripts).find(
-      (script) => script.src === absolute,
-    );
-    if (existing) {
-      if (existing.dataset.concordeLoaded === SCRIPT_LOADED_FLAG) return true;
-      return new Promise<boolean>((resolve) => {
-        let settled = false;
-        const finish = (ok: boolean) => {
-          if (settled) return;
-          settled = true;
-          if (ok) existing.dataset.concordeLoaded = SCRIPT_LOADED_FLAG;
-          resolve(ok);
-        };
-        existing.addEventListener("load", () => finish(true), { once: true });
-        existing.addEventListener("error", () => finish(false), {
-          once: true,
-        });
-        // Scripts déjà exécutés (injectés ailleurs) ne re-émettent pas `load`.
-        const rs = (existing as HTMLScriptElement & { readyState?: string })
-          .readyState;
-        if (rs === "complete" || rs === "loaded") {
-          finish(true);
-          return;
-        }
-        void Promise.resolve().then(() => {
-          void Promise.resolve().then(() => {
-            if (!settled) finish(true);
-          });
-        });
-      });
-    }
-    const asModule =
-      /\.es\.js(\?|#|$)/.test(src) || /[?&]module(?:&|=|$)/.test(src);
-    return new Promise((resolve) => {
+    const p = new Promise(async (resolve) => {
       const script = document.createElement("script");
       script.src = src;
-      if (asModule) script.type = "module";
-      script.onload = () => {
-        script.dataset.concordeLoaded = SCRIPT_LOADED_FLAG;
-        resolve(true);
-      };
-      script.onerror = () => resolve(false);
+      script.onload = () => resolve(true);
+      script.onerror = () => resolve(true);
       document.head.appendChild(script);
     });
+    return p;
   }
 
-  /** Charge un CSS ; résout toujours `true` (historique, y compris en erreur). */
+  /**
+   * Lance le chargement d'un css et retourne une promise qui resoud à true lorsque le chargement à réussi et à false, sinon.
+   * */
   static async loadCSS(src: string) {
-    return new Promise((resolve) => {
+    const p = new Promise(async (resolve) => {
       const cssnode = document.createElement("link");
       cssnode.type = "text/css";
       cssnode.rel = "stylesheet";
@@ -336,20 +294,29 @@ class HTML {
       cssnode.onerror = () => resolve(true);
       document.head.appendChild(cssnode);
     });
+    return p;
   }
 }
 export default HTML;
 export const detecHTMLLanguageChange = (handler: () => void) => {
+  // Select the <html> element
   const htmlElement = document.documentElement;
+
+  // Create a new MutationObserver instance
   const observer = new MutationObserver((mutationsList) => {
-    for (const mutation of mutationsList) {
+    for (let mutation of mutationsList) {
       if (mutation.type === "attributes" && mutation.attributeName === "lang") {
         handler();
       }
     }
   });
-  observer.observe(htmlElement, {
-    attributes: true,
-    attributeFilter: ["lang"],
-  });
+
+  // Observer configuration: watch for changes to attributes
+  const config = {
+    attributes: true, // Watch for attribute changes
+    attributeFilter: ["lang"], // Only watch for changes to the lang attribute
+  };
+
+  // Start observing the <html> element for changes
+  observer.observe(htmlElement, config);
 };

package/src/core/utils/PublisherProxy.ts

@@ -786,37 +786,10 @@ export class PublisherManager {
     return new TextDecoder().decode(result);
   }
 }
-/**
- * Partage le singleton entre le bundle core et les addons CDN (3d / shader / hf).
- * Sans cela, chaque IIFE aurait sa propre classe `PublisherManager` et des
- * dataProviders isolés.
- */
 if (typeof window !== "undefined") {
   const win = window as any;
-  const sharedKey = sonicClassPrefix + "PublisherManager";
-  const Shared = (win[sharedKey] || PublisherManager) as typeof PublisherManager;
-  if (!win[sharedKey]) win[sharedKey] = PublisherManager;
-  if (Shared !== PublisherManager) {
-    const syncKeys = [
-      "instance",
-      "instances",
-      "changed",
-      "saving",
-      "saveId",
-      "pageShowHandlerInitialized",
-    ] as const;
-    for (const key of syncKeys) {
-      Object.defineProperty(PublisherManager, key, {
-        configurable: true,
-        get() {
-          return (Shared as any)[key];
-        },
-        set(value) {
-          (Shared as any)[key] = value;
-        },
-      });
-    }
-  }
+  win[sonicClassPrefix + "PublisherManager"] =
+    win[sonicClassPrefix + "PublisherManager"] || PublisherManager;
 }
 
 const internalProps: Set<string> = new Set([
@@ -1052,6 +1025,10 @@ export type Publisher<T = any> = DataProvider<T>;
 
 // if (typeof module != "undefined") module.exports = {DataProvider: DataProvider, PublisherManager: PublisherManager};
 
+// /**
+//  * A custom webcomponent wich will be linked to a publisher via its attribute "publisher"
+//  * the publisher will be found via PublisherManager.get(publisherId) and will be used to fill the component using the onAssign method
+//  */
 class PublisherWebComponent extends HTMLElement {
   publisherId = "";
   publisher: any;

package/src/core/utils/jsonataHelpers.ts

@@ -1,7 +1,5 @@
 import type { Expression } from "jsonata";
 import Format from "@supersoniks/concorde/core/utils/Format";
-import { toMediaUrl } from "@supersoniks/concorde/core/utils/mediaRef";
-import { cosine, rankBySimilarity } from "@supersoniks/concorde/core/utils/similarity";
 
 export type ChartDataset = {
   label?: string;
@@ -99,38 +97,4 @@ export function registerJsonataHelpers(expression: Expression): void {
       };
     },
   );
-
-  /** Similarité cosinus entre deux vecteurs (embeddings) : `$cosine(a, b)`. */
-  expression.registerFunction("cosine", (a: unknown, b: unknown) => cosine(a, b));
-
-  /**
-   * Classe des éléments par similarité : `$rankBySimilarity(items, vectors, query, topN?, minScore?)`.
-   * `vectors` est aligné sur `items` (sortie liste de `sonic-hugging-face-infer`).
-   * Chaque élément reçoit `_score`.
-   */
-  expression.registerFunction(
-    "rankBySimilarity",
-    (
-      items: unknown,
-      vectors: unknown,
-      query: unknown,
-      topN: unknown = 10,
-      minScore: unknown = -1,
-    ) =>
-      rankBySimilarity(
-        items as unknown[],
-        vectors as number[][],
-        query as number[],
-        Number(topN),
-        Number(minScore),
-      ),
-  );
-
-  /**
-   * URL média pour chaînage DP : `$mediaUrl(x)`.
-   * Accepte string | `{ url }` | `{ blobUrl }` — ne crée pas d’ObjectURL.
-   */
-  expression.registerFunction("mediaUrl", (value: unknown) =>
-    toMediaUrl(value),
-  );
 }