@supersoniks/concorde 4.9.96 → 4.9.97-visual-stack.0

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

@@ -0,0 +1,145 @@
+/**
+ * Types publics de `sonic-3d`.
+ *
+ * Contrat d’asset volontairement neutre (URL / blob) pour brancher plus tard
+ * fetch, upload ou exports HF sans coupler le viewer à la source.
+ */
+
+import type {
+  Sonic3dCameraMode,
+  Sonic3dFormControlKey,
+} from "./constants";
+
+export type { Sonic3dCameraMode, Sonic3dFormControlKey };
+
+/** Kind d’asset 3D (extension / hint — le loader se base surtout sur l’URL). */
+export type Sonic3dAssetKind = "gltf" | "glb" | "obj" | "ply" | "url";
+
+/**
+ * Asset publié vers / lu depuis un dataProvider.
+ * `url` suffit pour glTF/GLB ; `blob` permet un branchement auto (ex. HF).
+ */
+export type Sonic3dAsset = {
+  kind?: Sonic3dAssetKind;
+  url?: string;
+  blob?: Blob;
+  /** Morph targets optionnels (clip weights 0–1). */
+  morphTargets?: Record<string, number>;
+};
+
+/**
+ * API typée de `sonic-3d` (attributs / propriétés).
+ */
+export type Sonic3dConfig = {
+  /** URL glTF / GLB. Vide → cube de démo. */
+  src?: string;
+  /**
+   * Asset structuré (prioritaire sur `src` si `url` / `blob` présents).
+   * Peut aussi arriver via dataProvider (`asset` ou `src`).
+   */
+  asset?: Sonic3dAsset | null;
+
+  camera?: Sonic3dCameraMode;
+  /** FOV perspective (deg, défaut 45). */
+  fov?: number;
+  /** Exposition renderer (défaut 1). */
+  exposure?: number;
+  /** Distance orbit mini (défaut 0.5). */
+  minDistance?: number;
+  /** Distance orbit maxi (défaut 50). `0` / ∞ désactive le plafond. */
+  maxDistance?: number;
+  /** Polar mini en degrés (défaut 8). */
+  minPolar?: number;
+  /** Polar maxi en degrés (défaut 172). */
+  maxPolar?: number;
+  /** Rotation auto orbit (désactivée si prefers-reduced-motion). */
+  autoRotate?: boolean;
+  /** Fit caméra sur le bbox après load (défaut true). */
+  fit?: boolean;
+  /** Active le raycast au clic → hit* + event `pick`. */
+  pick?: boolean;
+
+  /** Boucle RAF (défaut true). Pause hors viewport / reduced-motion. */
+  play?: boolean;
+  /** N’anime (autoRotate / RAF) que pendant le hover. */
+  playOnHover?: boolean;
+  /** Libère le renderer hors viewport (défaut true). */
+  releaseOffscreen?: boolean;
+  dprMax?: number;
+  aspectRatio?: string;
+
+  /**
+   * Publisher entrée : `src`, `asset`, `fov`, `exposure`, `autoRotate`…
+   * Sinon ancêtre `dataProvider` / `formDataProvider`.
+   */
+  dataProvider?: string;
+  /**
+   * Publisher de sortie (défaut = dataProvider).
+   * Publication paresseuse — rien tant qu’aucun consommateur.
+   */
+  outDataProvider?: string;
+  /** Intervalle de publication ms (défaut 80). */
+  outInterval?: number;
+  /**
+   * Intervalle capture canvas → `frameUrl` / `snapshot` (défaut 250).
+   * Uniquement si `frame-out` ou un consommateur écoute ces champs.
+   */
+  snapshotInterval?: number;
+  /**
+   * Force la publication canvas (`frameUrl` + `snapshot`) même sans
+   * listener dédié — utile pour chaîner via `sonic-jsonata`.
+   */
+  frameOut?: boolean;
+};
+
+/** MediaRef canvas publié sur `snapshot` (ObjectURL + dimensions). */
+export type Sonic3dSnapshot = {
+  url: string;
+  width: number;
+  height: number;
+  mime?: string;
+  blob?: Blob;
+};
+
+/**
+ * Snapshot publié vers `outDataProvider` (et event `out`).
+ * Coords pointeur normalisées 0–1 ; hit en espace monde.
+ */
+export type Sonic3dOutput = {
+  time: number;
+  frame: number;
+  ready: number;
+  loading: number;
+  hovering: number;
+  pointerX: number;
+  pointerY: number;
+  camX: number;
+  camY: number;
+  camZ: number;
+  targetX: number;
+  targetY: number;
+  targetZ: number;
+  fov: number;
+  zoom: number;
+  distance: number;
+  yaw: number;
+  pitch: number;
+  /** Présents après un pick réussi. */
+  hitX?: number;
+  hitY?: number;
+  hitZ?: number;
+  hitObjectId?: string;
+  bboxMinX?: number;
+  bboxMinY?: number;
+  bboxMinZ?: number;
+  bboxMaxX?: number;
+  bboxMaxY?: number;
+  bboxMaxZ?: number;
+  /**
+   * ObjectURL du canvas (JPEG), publié seulement si un consommateur écoute
+   * `frameUrl` / `snapshot`. Alias pratique de `snapshot.url`.
+   */
+  frameUrl?: string;
+  /** MediaRef du canvas (url + dimensions) — chaînable vers `sonic-shader`. */
+  snapshot?: Sonic3dSnapshot;
+};

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

@@ -0,0 +1,70 @@
+import { ensure } from "./ensure";
+import type { LifeHost } from "./life";
+import { life } from "./life";
+import { parse } from "./parse";
+import { playback } from "./playback";
+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")) {
+    host.syncPlayback();
+  }
+  if (changed.has("src") || changed.has("asset")) void reload.run(host as never);
+}
+
+export const propUpdate = { updated } as const;

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,198 @@
+/**
+ * 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());
+}