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

package/src/core/components/functional/3d/updated.ts

@@ -1,86 +0,0 @@
-import { ensure } from "./ensure";
-import type { LifeHost } from "./life";
-import { life } from "./life";
-import { parse } from "./parse";
-import { playback } from "./playback";
-import { postBind } from "./post-bind";
-import { reload } from "./reload";
-
-function hasAny(
-  changed: Map<string | number | symbol, unknown>,
-  keys: string[],
-): boolean {
-  return keys.some((k) => changed.has(k));
-}
-
-function applyCameraProps(
-  host: LifeHost,
-  changed: Map<string | number | symbol, unknown>,
-) {
-  if (!host.runtime) return;
-  if (changed.has("camera")) {
-    host.runtime.applyCameraMode(parse.cameraMode(host.camera));
-  }
-  if (changed.has("fov")) host.runtime.setFov(host.fov);
-  if (changed.has("exposure")) host.runtime.setExposure(host.exposure);
-  if (changed.has("dprMax")) {
-    host.runtime.setDprMax(host.dprMax);
-    ensure.syncSize(host as never);
-  }
-  if (changed.has("fit")) host.runtime.setFit(host.fit);
-  if (
-    hasAny(changed, [
-      "minDistance",
-      "maxDistance",
-      "minPolar",
-      "maxPolar",
-      "camera",
-    ])
-  ) {
-    reload.applyOrbitLimits(host as never);
-  }
-}
-
-function bindProvidersIfNeeded(
-  host: LifeHost,
-  changed: Map<string | number | symbol, unknown>,
-) {
-  if (changed.has("aspectRatio")) life.applyAspectRatio(host);
-  if (changed.has("dataProvider") || changed.has("outDataProvider")) {
-    life.bindFormProvider(host);
-    life.bindOutPublisher(host);
-  }
-}
-
-function updated(
-  host: LifeHost,
-  changed: Map<string | number | symbol, unknown>,
-) {
-  bindProvidersIfNeeded(host, changed);
-  if (!host.runtime) return;
-  applyCameraProps(host, changed);
-  if (changed.has("autoRotate") || changed.has("play")) {
-    playback.syncAutoRotate(host as never);
-  }
-  if (
-    changed.has("play") ||
-    changed.has("playOnHover") ||
-    changed.has("playOffscreen")
-  ) {
-    host.syncPlayback();
-  }
-  if (changed.has("playOffscreen") || changed.has("releaseOffscreen")) {
-    ensure.syncVisibility(host as never);
-  }
-  if (changed.has("damping") && host.runtime) {
-    host.runtime.setDamping(
-      (host as unknown as { damping: number }).damping,
-    );
-  }
-  if (changed.has("src") || changed.has("asset")) void reload.run(host as never);
-  if (postBind.propsChanged(changed)) {
-    postBind.applyConfig(host as never);
-  }
-}
-
-export const propUpdate = { updated } as const;

package/src/core/components/functional/3d/view.ts

@@ -1,63 +0,0 @@
-import * as THREE from "three";
-import { OrbitControls } from "three/addons/controls/OrbitControls.js";
-import { Sonic3dCameraMode } from "./constants";
-import { orbit, type OrbitLimits } from "./orbit";
-
-export type ViewCtx = {
-  canvas: HTMLCanvasElement;
-  perspCam: THREE.PerspectiveCamera;
-  orthoCam: THREE.OrthographicCamera;
-  activeCam: THREE.Camera;
-  controls: OrbitControls | null;
-  target: THREE.Vector3;
-  limits: OrbitLimits;
-  mode: Sonic3dCameraMode;
-  dprMax: number;
-  renderer: THREE.WebGLRenderer;
-  unbindWheelRelay: (() => void) | null;
-};
-
-function applyCameraMode(ctx: ViewCtx, mode: Sonic3dCameraMode) {
-  ctx.mode = mode;
-  const prevPos = ctx.activeCam.position.clone();
-  const prevTarget = ctx.target.clone();
-  ctx.activeCam =
-    mode === Sonic3dCameraMode.Ortho ? ctx.orthoCam : ctx.perspCam;
-  ctx.activeCam.position.copy(prevPos);
-  ctx.controls?.dispose();
-  ctx.controls = new OrbitControls(ctx.activeCam, ctx.canvas);
-  ctx.controls.enableDamping = true;
-  ctx.controls.dampingFactor = 0.08;
-  ctx.controls.target.copy(prevTarget);
-  ctx.controls.enablePan = true;
-  orbit.applyLimitsToControls(ctx.controls, ctx.limits);
-  ctx.controls.update();
-  if (!ctx.unbindWheelRelay) {
-    ctx.unbindWheelRelay = orbit.bindWheelPageScrollRelay(
-      ctx.canvas,
-      () => ctx.controls,
-    );
-  }
-}
-
-function resize(ctx: ViewCtx, cssW: number, cssH: number) {
-  const w = Math.max(1, cssW);
-  const h = Math.max(1, cssH);
-  const dpr = Math.min(
-    typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
-    ctx.dprMax,
-  );
-  ctx.renderer.setPixelRatio(dpr);
-  ctx.renderer.setSize(w, h, false);
-  const aspect = w / h;
-  ctx.perspCam.aspect = aspect;
-  ctx.perspCam.updateProjectionMatrix();
-  const frustum = 1.2;
-  ctx.orthoCam.left = -frustum * aspect;
-  ctx.orthoCam.right = frustum * aspect;
-  ctx.orthoCam.top = frustum;
-  ctx.orthoCam.bottom = -frustum;
-  ctx.orthoCam.updateProjectionMatrix();
-}
-
-export const view = { applyCameraMode, resize } as const;

package/src/core/components/functional/3d/wire.ts

@@ -1,65 +0,0 @@
-import { frameCapture } from "./frame-capture";
-import { life, type LifeHost } from "./life";
-import { playback } from "./playback";
-
-type WireHost = LifeHost & {
-  addEventListener: (
-    type: string,
-    listener: EventListenerOrEventListenerObject | null,
-    options?: boolean | AddEventListenerOptions,
-  ) => void;
-  removeEventListener: (
-    type: string,
-    listener: EventListenerOrEventListenerObject | null,
-    options?: boolean | EventListenerOptions,
-  ) => void;
-  onPointerMove: (e: PointerEvent) => void;
-  onPointerDown: (e: PointerEvent) => void;
-  onDblClick: () => void;
-  onPointerLeave: () => void;
-  onPointerEnter: () => void;
-  loadToken: number;
-  ready: boolean;
-  releasing: boolean;
-  runtime: { dispose: (lose: boolean) => void } | null;
-  outPublisher: unknown;
-  snapshotBusy: boolean;
-  lastSnapshotAt: number;
-  frameUrls: string[];
-  snapshotSeq: number;
-  snapshotInterval: number;
-  frameOut: boolean;
-};
-
-function connect(host: WireHost) {
-  host.addEventListener("pointermove", host.onPointerMove as EventListener);
-  host.addEventListener("pointerdown", host.onPointerDown as EventListener);
-  host.addEventListener("dblclick", host.onDblClick);
-  host.addEventListener("pointerleave", host.onPointerLeave);
-  host.addEventListener("pointerenter", host.onPointerEnter);
-  life.bindFormProvider(host);
-  life.bindOutPublisher(host);
-}
-
-function disconnect(host: WireHost) {
-  host.removeEventListener("pointermove", host.onPointerMove as EventListener);
-  host.removeEventListener("pointerdown", host.onPointerDown as EventListener);
-  host.removeEventListener("dblclick", host.onDblClick);
-  host.removeEventListener("pointerleave", host.onPointerLeave);
-  host.removeEventListener("pointerenter", host.onPointerEnter);
-  life.unbindFormProvider(host);
-  playback.stopLoop(host as never);
-  host.resizeObserver?.disconnect();
-  host.intersectionObserver?.disconnect();
-  host.loadToken++;
-  host.ready = false;
-  host.releasing = true;
-  frameCapture.revokeAll(host as never);
-  host.runtime?.dispose(true);
-  host.runtime = null;
-  host.outPublisher = null;
-  host.releasing = false;
-}
-
-/** Pointer + DP wire on connect/disconnect. */
-export const wire = { connect, disconnect } as const;

package/src/core/components/functional/infer/hugging-face/hf-cache.ts

@@ -1,198 +0,0 @@
-/**
- * Mémoïsation des résultats.
- *
- * - en mémoire pour la session (petit LRU) ;
- * - optionnellement en IndexedDB (`persistResults`), plafonnée (LRU en octets).
- *
- * Clé = hachage de (entrée normalisée, alias, révision, version du moteur,
- * options d'appel) : changer l'un d'eux invalide automatiquement le résultat.
- * Les résultats contenant des Blob (images) ne sont pas persistés.
- */
-
-const DB_NAME = "concorde-hf-results";
-const STORE = "results";
-const MEMORY_ENTRIES = 64;
-
-type Row = { key: string; value: unknown; bytes: number; at: number };
-
-/* ---------------- hachage ---------------- */
-
-async function digestBytes(bytes: Uint8Array): Promise<string> {
-  const subtle = globalThis.crypto?.subtle;
-  if (subtle) {
-    const hash = await subtle.digest("SHA-256", bytes as BufferSource);
-    return [...new Uint8Array(hash)]
-      .map((b) => b.toString(16).padStart(2, "0"))
-      .join("");
-  }
-  // Repli (contextes non sécurisés) : FNV-1a 64 bits sur deux moitiés.
-  let h1 = 0x811c9dc5;
-  let h2 = 0x01000193;
-  for (let i = 0; i < bytes.length; i++) {
-    h1 = Math.imul(h1 ^ bytes[i], 0x01000193) >>> 0;
-    h2 = Math.imul(h2 ^ bytes[bytes.length - 1 - i], 0x811c9dc5) >>> 0;
-  }
-  return `fnv-${h1.toString(16)}${h2.toString(16)}-${bytes.length}`;
-}
-
-/** Représentation stable (clés triées ; Blob et tableaux typés hachés par contenu). */
-async function stable(value: unknown): Promise<unknown> {
-  if (value instanceof Blob) {
-    return {
-      $blob: await digestBytes(new Uint8Array(await value.arrayBuffer())),
-      type: value.type,
-    };
-  }
-  if (ArrayBuffer.isView(value)) {
-    return {
-      $typed: value.constructor.name,
-      hash: await digestBytes(
-        new Uint8Array(value.buffer, value.byteOffset, value.byteLength),
-      ),
-    };
-  }
-  if (Array.isArray(value)) return Promise.all(value.map(stable));
-  if (value && typeof value === "object") {
-    const out: Record<string, unknown> = {};
-    for (const key of Object.keys(value).sort())
-      out[key] = await stable((value as Record<string, unknown>)[key]);
-    return out;
-  }
-  return value;
-}
-
-export async function resultKey(parts: Record<string, unknown>): Promise<string> {
-  const json = JSON.stringify(await stable(parts));
-  return digestBytes(new TextEncoder().encode(json));
-}
-
-function containsBlob(value: unknown): boolean {
-  if (value instanceof Blob) return true;
-  if (Array.isArray(value)) return value.some(containsBlob);
-  if (value && typeof value === "object")
-    return Object.values(value).some(containsBlob);
-  return false;
-}
-
-/* ---------------- mémoire ---------------- */
-
-const memory = new Map<string, unknown>();
-
-function remember(key: string, value: unknown): void {
-  memory.delete(key);
-  memory.set(key, value);
-  while (memory.size > MEMORY_ENTRIES) {
-    const oldest = memory.keys().next().value;
-    if (oldest === undefined) break;
-    memory.delete(oldest);
-  }
-}
-
-/* ---------------- IndexedDB ---------------- */
-
-let dbPromise: Promise<IDBDatabase | null> | null = null;
-
-function openDb(): Promise<IDBDatabase | null> {
-  if (dbPromise) return dbPromise;
-  dbPromise = new Promise((resolve) => {
-    try {
-      if (typeof indexedDB === "undefined") return resolve(null);
-      const request = indexedDB.open(DB_NAME, 1);
-      request.onupgradeneeded = () => {
-        const store = request.result.createObjectStore(STORE, { keyPath: "key" });
-        store.createIndex("at", "at");
-      };
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => resolve(null);
-      request.onblocked = () => resolve(null);
-    } catch {
-      resolve(null);
-    }
-  });
-  return dbPromise;
-}
-
-function tx<T>(
-  db: IDBDatabase,
-  mode: IDBTransactionMode,
-  run: (store: IDBObjectStore) => IDBRequest<T> | void,
-): Promise<T | undefined> {
-  return new Promise((resolve) => {
-    try {
-      const transaction = db.transaction(STORE, mode);
-      const request = run(transaction.objectStore(STORE));
-      transaction.oncomplete = () =>
-        resolve(request ? (request.result as T) : undefined);
-      transaction.onerror = () => resolve(undefined);
-      transaction.onabort = () => resolve(undefined);
-    } catch {
-      resolve(undefined);
-    }
-  });
-}
-
-export async function readResult(
-  key: string,
-  persisted: boolean,
-  ttlMs?: number,
-): Promise<{ hit: true; value: unknown } | { hit: false }> {
-  if (memory.has(key)) {
-    const value = memory.get(key);
-    remember(key, value);
-    return { hit: true, value };
-  }
-  if (!persisted) return { hit: false };
-  const db = await openDb();
-  if (!db) return { hit: false };
-  const row = await tx<Row | undefined>(db, "readonly", (s) => s.get(key));
-  if (!row) return { hit: false };
-  if (ttlMs && Date.now() - row.at > ttlMs) return { hit: false };
-  remember(key, row.value);
-  void tx(db, "readwrite", (s) => s.put({ ...row, at: Date.now() }));
-  return { hit: true, value: row.value };
-}
-
-export async function writeResult(
-  key: string,
-  value: unknown,
-  persisted: boolean,
-  capBytes: number,
-): Promise<void> {
-  remember(key, value);
-  if (!persisted || containsBlob(value)) return;
-  const db = await openDb();
-  if (!db) return;
-  let bytes = 0;
-  try {
-    bytes = JSON.stringify(value).length;
-  } catch {
-    return;
-  }
-  if (bytes > capBytes) return;
-  await tx(db, "readwrite", (s) => s.put({ key, value, bytes, at: Date.now() } satisfies Row));
-  await prune(db, capBytes);
-}
-
-async function prune(db: IDBDatabase, capBytes: number): Promise<void> {
-  const rows =
-    (await tx<Row[]>(db, "readonly", (s) => s.getAll() as IDBRequest<Row[]>)) ?? [];
-  let total = rows.reduce((sum, r) => sum + r.bytes, 0);
-  if (total <= capBytes) return;
-  rows.sort((a, b) => a.at - b.at);
-  const doomed: string[] = [];
-  for (const row of rows) {
-    if (total <= capBytes) break;
-    doomed.push(row.key);
-    total -= row.bytes;
-  }
-  await tx(db, "readwrite", (s) => {
-    for (const key of doomed) s.delete(key);
-  });
-}
-
-/** Vide les résultats mémorisés (mémoire + IndexedDB). */
-export async function clearResults(): Promise<void> {
-  memory.clear();
-  const db = await openDb();
-  if (db) await tx(db, "readwrite", (s) => s.clear());
-}

package/src/core/components/functional/infer/hugging-face/hf-config.ts

@@ -1,188 +0,0 @@
-/**
- * Configuration applicative : moteur figé, liste blanche de modèles (alias),
- * valeurs par défaut. Rien de tout cela n'est réglable depuis un descripteur
- * SDUI : seules les options d'appel le sont (voir `schema.ts`).
- */
-import type {
-  HfCallOptions,
-  HfDevice,
-  HfExact,
-  HfLoadOptions,
-  HfTask,
-} from "./types";
-import type { HfEngine } from "./hf-engine";
-
-/* ------------------------------------------------------------------ */
-/* Modèles                                                             */
-/* ------------------------------------------------------------------ */
-
-export type HfModelDefinition<T extends HfTask = HfTask> = {
-  task: T;
-  /** Dépôt Hugging Face (ou chemin sous `remoteHost`), ex. `Xenova/opus-mt-fr-en`. */
-  repo: string;
-  /** Révision figée : sha de commit de préférence, jamais une branche mouvante en production. */
-  revision: string;
-  /** Options de chargement passées à `pipeline()` (dtype, session_options, config…). */
-  options?: HfLoadOptions;
-  /** Exécutions autorisées, par ordre de préférence. Défaut : `["webgpu", "wasm"]`. */
-  devices?: readonly HfDevice[];
-  /** Taille déclarée (octets), utilisée si le serveur ne la donne pas. */
-  sizeBytes?: number;
-  license?: string;
-  /** Libellé et description montrés dans l'UI de consentement. */
-  label?: string;
-  description?: string;
-  /** Options d'appel par défaut, typées selon `task`. */
-  defaults?: HfCallOptions<T>;
-};
-
-/** Union discriminée par `task` : `defaults` est vérifié selon la tâche du modèle. */
-export type HfAnyModelDefinition = {
-  [T in HfTask]: HfModelDefinition<T>;
-}[HfTask];
-
-export type HfModels = { readonly [alias: string]: HfAnyModelDefinition };
-
-/** Déclare la liste blanche en gardant les littéraux (alias, tâches) pour le typage. */
-type ModelCheck<D> = D extends { task: infer T extends HfTask }
-  ? HfModelDefinition<T> & {
-      [P in Exclude<keyof D, keyof HfModelDefinition<T>>]: never;
-    } & (D extends { defaults: infer X }
-        ? { defaults: HfExact<X, HfCallOptions<T>> }
-        : unknown)
-  : HfAnyModelDefinition;
-
-export function defineHuggingFaceModels<const M extends HfModels>(
-  models: M & { readonly [K in keyof M]: ModelCheck<M[K]> },
-): M {
-  return models;
-}
-
-/* ------------------------------------------------------------------ */
-/* Politiques                                                          */
-/* ------------------------------------------------------------------ */
-
-/** Quand télécharger / charger le modèle. */
-export const HF_LOAD_POLICIES = [
-  "auto",
-  "idle",
-  "visible",
-  "first-use",
-  "consent",
-  "manual",
-] as const;
-export type HfLoadPolicy = (typeof HF_LOAD_POLICIES)[number];
-
-/** Quand calculer. */
-export const HF_TRIGGERS = ["mutation", "demand"] as const;
-export type HfTrigger = (typeof HF_TRIGGERS)[number];
-
-export type HfDefaults = {
-  load: HfLoadPolicy;
-  trigger: HfTrigger;
-  /** Anti-rebond (ms) du mode `mutation`. */
-  debounceMs: number;
-  /** Au-delà, les politiques automatiques basculent en `consent`. */
-  consentAboveMB: number;
-  /** Plafond de taille pour autoriser l'exécution CPU (WASM) quand WebGPU manque. */
-  allowWasmUpToMB: number;
-  /** Délai de garde d'un calcul. */
-  timeoutMs: number;
-  /** Nombre max d'éléments dans une entrée liste. */
-  maxItems: number;
-  /** Longueur max d'un texte (tronqué au-delà). */
-  maxChars: number;
-  /** Demander `navigator.storage.persist()` après le premier téléchargement. */
-  persist: boolean;
-  /** Plafond (octets) du cache IndexedDB des résultats. */
-  resultsCacheBytes: number;
-};
-
-export const HF_DEFAULTS: HfDefaults = {
-  load: "first-use",
-  trigger: "mutation",
-  debounceMs: 50,
-  consentAboveMB: 30,
-  allowWasmUpToMB: 50,
-  timeoutMs: 60_000,
-  maxItems: 2_000,
-  maxChars: 2_000,
-  persist: false,
-  resultsCacheBytes: 20 * 1024 * 1024,
-};
-
-/* ------------------------------------------------------------------ */
-/* Moteur (Transformers.js)                                            */
-/* ------------------------------------------------------------------ */
-
-export type HfRuntime =
-  /**
-   * Worker « blob » qui importe Transformers.js depuis une URL à version
-   * exacte (CDN Supersoniks conseillé). Rien n'est ajouté au bundle.
-   * CSP : `worker-src blob:`, `script-src <cdn>`, `wasm-unsafe-eval`.
-   */
-  | {
-      source: "cdn";
-      /** URL du module, ex. `https://cdn…/vendor/hf-transformers/4.3.0/transformers.min.js`. */
-      url: string;
-      /** Version exacte (sert de clé de cache). */
-      version: string;
-      /** Binaires ONNX Runtime ; défaut : même dossier que `url`. */
-      wasmPaths?: string | { mjs: string; wasm: string };
-    }
-  /**
-   * Worker construit par l'application avec son bundler (dépendance npm
-   * `@huggingface/transformers` installée, version exacte), qui appelle
-   * `serveHuggingFaceWorker(transformers)`.
-   */
-  | {
-      source: "worker";
-      createWorker: () => Worker;
-      version: string;
-      wasmPaths?: string | { mjs: string; wasm: string };
-    }
-  /** Moteur fourni tel quel (tests, transport maison). */
-  | { source: "engine"; engine: HfEngine; version: string };
-
-export type HuggingFaceConfig<M extends HfModels = HfModels> = {
-  runtime: HfRuntime;
-  models: M;
-  /** Hôte des modèles. Défaut : le Hub Hugging Face. Conseillé : CDN Supersoniks. */
-  remoteHost?: string;
-  /** Gabarit de chemin sous `remoteHost`. Défaut Transformers.js : `{model}/resolve/{revision}/`. */
-  remotePathTemplate?: string;
-  defaults?: Partial<HfDefaults>;
-  logLevel?: "error" | "warning" | "info" | "debug";
-};
-
-type ResolvedConfig = Omit<HuggingFaceConfig, "defaults"> & {
-  defaults: HfDefaults;
-};
-
-let current: ResolvedConfig | null = null;
-const listeners = new Set<(config: ResolvedConfig) => void>();
-
-/** Enregistre la configuration (une fois, au démarrage de l'application). */
-export function setHuggingFaceConfig(config: HuggingFaceConfig): void {
-  current = { ...config, defaults: { ...HF_DEFAULTS, ...config.defaults } };
-  for (const listener of listeners) listener(current);
-}
-
-export function getHuggingFaceConfig(): ResolvedConfig | null {
-  return current;
-}
-
-/** Appelé quand la configuration change (les composants déjà connectés redémarrent). */
-export function onHuggingFaceConfig(
-  listener: (config: ResolvedConfig) => void,
-): () => void {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-
-/** Tests uniquement. */
-export function resetHuggingFaceConfig(): void {
-  current = null;
-}
-
-export type { ResolvedConfig as HfResolvedConfig };