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

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

@@ -1,96 +0,0 @@
-import { PublisherManager } from "@supersoniks/concorde/utils";
-import { asset } from "./asset";
-import type { FormOrbit } from "./form-params";
-import { frameSource } from "./frame-source";
-import { postBind } from "./post-bind";
-import { playback } from "./playback";
-import type { SceneRuntime } from "./runtime";
-import type { Sonic3dAsset } from "./types";
-
-function degToRad(deg: number): number {
-  return ((Number.isFinite(deg) ? deg : 0) * Math.PI) / 180;
-}
-
-export type ReloadHost = {
-  runtime: SceneRuntime | null;
-  loadToken: number;
-  errorMessage: string;
-  ready: boolean;
-  startTime: number;
-  frame: number;
-  frameSeq: number;
-  lastFormOrbit: FormOrbit | null;
-  formPublisher: ReturnType<typeof PublisherManager.get> | null;
-  outPublisher: ReturnType<typeof PublisherManager.get> | null;
-  asset: Sonic3dAsset | null;
-  src: string;
-  minDistance: number;
-  maxDistance: number;
-  minPolar: number;
-  maxPolar: number;
-  onFormMutation: () => void;
-  syncPlayback: () => void;
-  bindOutPublisher: () => void;
-  dispatchEvent: (event: Event) => boolean;
-};
-
-async function run(host: ReloadHost) {
-  if (!host.runtime) return;
-  const token = ++host.loadToken;
-  host.errorMessage = "";
-  try {
-    await host.runtime.load(asset.resolve(host, host.formPublisher));
-    if (token !== host.loadToken) return;
-    host.ready = true;
-    host.startTime = performance.now();
-    host.frame = 0;
-    host.lastFormOrbit = null;
-    host.onFormMutation();
-    playback.syncAutoRotate(host as never);
-    host.runtime.render();
-    host.frameSeq++;
-    host.syncPlayback();
-    postBind.applyConfig(host as never);
-    frameSource.maybePublish(host as never);
-    host.dispatchEvent(
-      new CustomEvent("ready", {
-        detail: { ready: true },
-        bubbles: true,
-        composed: true,
-      }),
-    );
-  } catch (err) {
-    if (token !== host.loadToken) return;
-    host.ready = !!host.runtime?.ready;
-    emitError(host, err);
-    host.syncPlayback();
-  }
-}
-
-function applyOrbitLimits(host: ReloadHost) {
-  host.runtime?.setOrbitLimits({
-    minDistance: host.minDistance,
-    maxDistance: host.maxDistance,
-    minPolar: degToRad(host.minPolar),
-    maxPolar: degToRad(host.maxPolar),
-  });
-}
-
-function emitError(host: ReloadHost, err: unknown) {
-  const message = err instanceof Error ? err.message : String(err);
-  host.errorMessage = message;
-  host.dispatchEvent(
-    new CustomEvent("error", {
-      detail: { message },
-      bubbles: true,
-      composed: true,
-    }),
-  );
-}
-
-export const reload = {
-  run,
-  applyOrbitLimits,
-  emitError,
-  degToRad,
-} as const;

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

@@ -1,237 +0,0 @@
-import * as THREE from "three";
-import type { OrbitControls } from "three/addons/controls/OrbitControls.js";
-import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
-import type { Sonic3dCameraMode } from "./constants";
-import { bootScene } from "./boot";
-import { ops, type OpsCtx } from "./ops";
-import type { SceneRuntimeOptions } from "./opts";
-import type { SceneHit } from "./pick";
-import {
-  PostFxCompileError,
-  PostFxPipeline,
-  type PostFxConfig,
-  type PostFxUniforms,
-} from "./post-fx";
-import { tune, type TuneCtx } from "./tune";
-import type { Sonic3dAsset, Sonic3dOutput } from "./types";
-import { view, type ViewCtx } from "./view";
-
-export type { SceneHit, SceneRuntimeOptions };
-export { PostFxCompileError };
-export type { PostFxConfig, PostFxUniforms };
-
-/**
- * Runtime Three.js encapsulé : renderer, scène, caméra, load, fit, pick, post FX.
- * Le composant Lit gère RAF / viewport / DP.
- */
-export class SceneRuntime {
-  readonly scene: THREE.Scene;
-  readonly renderer: THREE.WebGLRenderer;
-  private canvas: HTMLCanvasElement;
-  private perspCam: THREE.PerspectiveCamera;
-  private orthoCam: THREE.OrthographicCamera;
-  private activeCam: THREE.Camera;
-  private controls: OrbitControls | null = null;
-  private unbindWheelRelay: (() => void) | null = null;
-  private root: THREE.Group;
-  private content: THREE.Object3D | null = null;
-  private lights: THREE.Light[];
-  private loader = new GLTFLoader();
-  private loadToken = 0;
-  private blobUrl: string | null = null;
-  private dprMax: number;
-  private mode: Sonic3dCameraMode;
-  private fov: number;
-  private fitEnabled: boolean;
-  private limits: ReturnType<typeof bootScene>["limits"];
-  private bbox = new THREE.Box3();
-  private target = new THREE.Vector3();
-  private _ready = false;
-  private _loading = false;
-  private lastError: string | null = null;
-  private raycaster = new THREE.Raycaster();
-  private pointerNdc = new THREE.Vector2();
-  private highlighted: THREE.Mesh | null = null;
-  private prevEmissive = new THREE.Color();
-  private prevEmissiveIntensity = 0;
-  private postFx: PostFxPipeline;
-  private lastCssW = 1;
-  private lastCssH = 1;
-  private damping = 0.08;
-  private postFrame: PostFxUniforms = {
-    time: 0,
-    timeDelta: 1 / 60,
-    frame: 0,
-    mouse: [0, 0, 0, 0],
-    params: [0, 0, 0, 0],
-    near: 0.1,
-    far: 100,
-  };
-
-  constructor(opts: SceneRuntimeOptions) {
-    const b = bootScene(opts);
-    this.scene = b.scene;
-    this.renderer = b.renderer;
-    this.canvas = b.canvas;
-    this.perspCam = b.perspCam;
-    this.orthoCam = b.orthoCam;
-    this.activeCam = b.activeCam;
-    this.root = b.root;
-    this.lights = b.lights;
-    this.dprMax = b.dprMax;
-    this.mode = b.mode;
-    this.fov = b.fov;
-    this.fitEnabled = b.fitEnabled;
-    this.limits = b.limits;
-    this.postFx = new PostFxPipeline(this.renderer);
-    this.applyCameraMode(this.mode);
-    if (b.autoRotate) this.setAutoRotate(true);
-    void [
-      this.canvas,
-      this.perspCam,
-      this.orthoCam,
-      this.root,
-      this.content,
-      this.lights,
-      this.loader,
-      this.loadToken,
-      this.blobUrl,
-      this.dprMax,
-      this.fov,
-      this.fitEnabled,
-      this.limits,
-      this.bbox,
-      this.target,
-      this.raycaster,
-      this.pointerNdc,
-      this.highlighted,
-      this.prevEmissive,
-      this.prevEmissiveIntensity,
-      this.unbindWheelRelay,
-    ];
-  }
-
-  get ready() {
-    return this._ready;
-  }
-  get loading() {
-    return this._loading;
-  }
-  get error() {
-    return this.lastError;
-  }
-  get isLost() {
-    return this.renderer.getContext()?.isContextLost?.() ?? false;
-  }
-  get hasPostFx() {
-    return this.postFx.isEnabled;
-  }
-
-  setDprMax(v: number) {
-    tune.setDprMax(this.asTuneCtx(), v);
-  }
-  setExposure(v: number) {
-    tune.setExposure(this.asTuneCtx(), v);
-  }
-  setFov(v: number) {
-    tune.setFov(this.asTuneCtx(), v);
-  }
-  setFit(v: boolean) {
-    tune.setFit(this.asTuneCtx(), v);
-  }
-  setAutoRotate(v: boolean) {
-    tune.setAutoRotate(this.asTuneCtx(), v);
-  }
-  setDamping(v: number) {
-    this.damping = Number.isFinite(v) ? Math.max(0, v) : 0.08;
-    tune.setDamping(this.asTuneCtx(), this.damping);
-  }
-  /** Coupe autoRotate + inertie OrbitControls. */
-  stopMotion() {
-    tune.setAutoRotate(this.asTuneCtx(), false);
-    tune.stopMotion(this.asTuneCtx());
-  }
-  setOrbitLimits(opts: Parameters<typeof tune.setOrbitLimits>[1]) {
-    tune.setOrbitLimits(this.asTuneCtx(), opts);
-  }
-  setOrbitSpherical(yaw: number, pitch: number, distance: number) {
-    tune.setOrbitSpherical(this.asTuneCtx(), yaw, pitch, distance);
-  }
-
-  applyCameraMode(mode: Sonic3dCameraMode) {
-    view.applyCameraMode(this.asViewCtx(), mode);
-    tune.setDamping(this.asTuneCtx(), this.damping);
-  }
-  resize(cssW: number, cssH: number) {
-    this.lastCssW = cssW;
-    this.lastCssH = cssH;
-    view.resize(this.asViewCtx(), cssW, cssH);
-    const dpr = Math.min(
-      typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
-      this.dprMax,
-    );
-    this.postFx.resize(cssW * dpr, cssH * dpr);
-  }
-  async load(asset: Sonic3dAsset | null) {
-    return ops.runLoad(this.asOpsCtx(), asset);
-  }
-  fitToContent() {
-    ops.fitToContent(this.asOpsCtx());
-  }
-
-  setPostConfig(config: PostFxConfig | null) {
-    this.postFx.setConfig(config);
-    if (config && this.lastCssW > 0) {
-      this.resize(this.lastCssW, this.lastCssH);
-    }
-  }
-
-  setPostElementResolver(fn: ((key: string) => Element | null) | null) {
-    this.postFx.setElementResolver(fn);
-  }
-
-  setPostFrame(frame: Partial<PostFxUniforms>) {
-    Object.assign(this.postFrame, frame);
-    const cam = this.activeCam as THREE.PerspectiveCamera;
-    if ("near" in cam && "far" in cam) {
-      this.postFrame.near = cam.near;
-      this.postFrame.far = cam.far;
-    }
-  }
-
-  render() {
-    this.controls?.update();
-    if (this.postFx.isEnabled) {
-      this.postFx.render(this.scene, this.activeCam, this.postFrame);
-    } else {
-      this.renderer.render(this.scene, this.activeCam);
-    }
-  }
-  pick(normX: number, normY: number): SceneHit | null {
-    return ops.pick(this.asOpsCtx(), normX, normY);
-  }
-  setHoverAt(normX: number, normY: number): SceneHit | null {
-    return ops.setHoverAt(this.asOpsCtx(), normX, normY);
-  }
-  clearHighlight() {
-    ops.clearHighlight(this.asOpsCtx());
-  }
-  snapshot(base: {
-    time: number;
-    frame: number;
-    hovering: number;
-    pointerX: number;
-    pointerY: number;
-    hit?: SceneHit | null;
-  }): Sonic3dOutput {
-    return ops.buildSnapshot(this.asOpsCtx(), base);
-  }
-  dispose(loseContext = false) {
-    this.postFx.dispose();
-    ops.dispose(this.asOpsCtx(), loseContext);
-  }
-
-  private asTuneCtx = () => this as unknown as TuneCtx;
-  private asViewCtx = () => this as unknown as ViewCtx;
-  private asOpsCtx = () => this as unknown as OpsCtx;
-}

package/src/core/components/functional/3d/scene-runtime.ts

@@ -1,12 +0,0 @@
-/**
- * Entrée publique `@supersoniks/concorde/3d/scene-runtime`.
- * Implémentation : `runtime.ts` + helpers orbit/pick/load/….
- */
-export {
-  SceneRuntime,
-  PostFxCompileError,
-  type SceneHit,
-  type SceneRuntimeOptions,
-  type PostFxConfig,
-  type PostFxUniforms,
-} from "./runtime";

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

@@ -1,73 +0,0 @@
-import * as THREE from "three";
-import type { OrbitControls } from "three/addons/controls/OrbitControls.js";
-import { Sonic3dCameraMode } from "./constants";
-import type { SceneHit } from "./pick";
-import type { Sonic3dOutput } from "./types";
-
-export type SnapshotCtx = {
-  activeCam: THREE.Camera;
-  controls: OrbitControls | null;
-  target: THREE.Vector3;
-  mode: Sonic3dCameraMode;
-  perspCam: THREE.PerspectiveCamera;
-  orthoCam: THREE.OrthographicCamera;
-  bbox: THREE.Box3;
-  ready: boolean;
-  loading: boolean;
-};
-
-function build(
-  ctx: SnapshotCtx,
-  base: {
-    time: number;
-    frame: number;
-    hovering: number;
-    pointerX: number;
-    pointerY: number;
-    hit?: SceneHit | null;
-  },
-): Sonic3dOutput {
-  const cam = ctx.activeCam.position;
-  const t = ctx.controls?.target ?? ctx.target;
-  const offset = new THREE.Vector3().subVectors(cam, t);
-  const distance = offset.length();
-  const yaw = Math.atan2(offset.x, offset.z);
-  const pitch = Math.atan2(offset.y, Math.hypot(offset.x, offset.z));
-  const out: Sonic3dOutput = {
-    time: base.time,
-    frame: base.frame,
-    ready: ctx.ready ? 1 : 0,
-    loading: ctx.loading ? 1 : 0,
-    hovering: base.hovering,
-    pointerX: base.pointerX,
-    pointerY: base.pointerY,
-    camX: cam.x,
-    camY: cam.y,
-    camZ: cam.z,
-    targetX: t.x,
-    targetY: t.y,
-    targetZ: t.z,
-    fov: ctx.mode === Sonic3dCameraMode.Ortho ? 0 : ctx.perspCam.fov,
-    zoom: ctx.mode === Sonic3dCameraMode.Ortho ? ctx.orthoCam.zoom : 1,
-    distance,
-    yaw,
-    pitch,
-  };
-  if (!ctx.bbox.isEmpty()) {
-    out.bboxMinX = ctx.bbox.min.x;
-    out.bboxMinY = ctx.bbox.min.y;
-    out.bboxMinZ = ctx.bbox.min.z;
-    out.bboxMaxX = ctx.bbox.max.x;
-    out.bboxMaxY = ctx.bbox.max.y;
-    out.bboxMaxZ = ctx.bbox.max.z;
-  }
-  if (base.hit) {
-    out.hitX = base.hit.x;
-    out.hitY = base.hit.y;
-    out.hitZ = base.hit.z;
-    out.hitObjectId = base.hit.objectId;
-  }
-  return out;
-}
-
-export const snapshot = { build } as const;

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

@@ -1,38 +0,0 @@
-import { css } from "lit";
-
-export const sonic3dStyles = css`
-  :host {
-    display: block;
-    position: relative;
-    width: 100%;
-    max-width: 100%;
-    height: auto;
-    aspect-ratio: var(--sonic-3d-ar, 16 / 9);
-    overflow: hidden;
-    background: #0a0a0a;
-    color: #f87171;
-    font: 12px/1.4 ui-monospace, monospace;
-    touch-action: none;
-    cursor: grab;
-  }
-  :host(:active) {
-    cursor: grabbing;
-  }
-  canvas {
-    position: absolute;
-    inset: 0;
-    width: 100%;
-    height: 100%;
-    display: block;
-  }
-  .err {
-    position: absolute;
-    inset: 0;
-    z-index: 1;
-    padding: 0.75rem;
-    background: rgba(0, 0, 0, 0.85);
-    white-space: pre-wrap;
-    overflow: auto;
-    pointer-events: none;
-  }
-`;

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

@@ -1,93 +0,0 @@
-import { DEFAULT_EXPOSURE, DEFAULT_FOV } from "./constants";
-import { orbit, type OrbitLimits } from "./orbit";
-import type { OrbitControls } from "three/addons/controls/OrbitControls.js";
-import type * as THREE from "three";
-
-export type TuneCtx = {
-  dprMax: number;
-  renderer: THREE.WebGLRenderer;
-  fov: number;
-  perspCam: THREE.PerspectiveCamera;
-  fitEnabled: boolean;
-  controls: OrbitControls | null;
-  limits: OrbitLimits;
-  activeCam: THREE.Camera;
-  target: THREE.Vector3;
-};
-
-function setDprMax(ctx: TuneCtx, v: number) {
-  ctx.dprMax = Math.max(1, v || 2);
-}
-
-function setExposure(ctx: TuneCtx, v: number) {
-  ctx.renderer.toneMappingExposure = Number.isFinite(v) ? v : DEFAULT_EXPOSURE;
-}
-
-function setFov(ctx: TuneCtx, v: number) {
-  ctx.fov = Number.isFinite(v) && v > 0 ? v : DEFAULT_FOV;
-  ctx.perspCam.fov = ctx.fov;
-  ctx.perspCam.updateProjectionMatrix();
-}
-
-function setFit(ctx: TuneCtx, v: boolean) {
-  ctx.fitEnabled = v;
-}
-
-function setAutoRotate(ctx: TuneCtx, v: boolean) {
-  if (ctx.controls) ctx.controls.autoRotate = v;
-}
-
-function setDamping(ctx: TuneCtx, v: number) {
-  if (!ctx.controls) return;
-  const d = Number.isFinite(v) ? Math.max(0, v) : 0.08;
-  ctx.controls.enableDamping = d > 0;
-  ctx.controls.dampingFactor = d > 0 ? d : 0.08;
-}
-
-/** Coupe autoRotate + vide l’inertie OrbitControls. */
-function stopMotion(ctx: TuneCtx) {
-  if (!ctx.controls) return;
-  ctx.controls.autoRotate = false;
-  const wasDamping = ctx.controls.enableDamping;
-  const factor = ctx.controls.dampingFactor;
-  ctx.controls.enableDamping = false;
-  ctx.controls.update();
-  ctx.controls.enableDamping = wasDamping;
-  ctx.controls.dampingFactor = factor;
-}
-
-function setOrbitLimits(ctx: TuneCtx, opts: Partial<OrbitLimits>) {
-  ctx.limits = orbit.mergeLimits(ctx.limits, opts);
-  orbit.applyLimitsToControls(ctx.controls, ctx.limits);
-}
-
-function setOrbitSpherical(
-  ctx: TuneCtx,
-  yaw: number,
-  pitch: number,
-  distance: number,
-) {
-  orbit.setSpherical(
-    {
-      activeCam: ctx.activeCam,
-      controls: ctx.controls,
-      target: ctx.target,
-      limits: ctx.limits,
-    },
-    yaw,
-    pitch,
-    distance,
-  );
-}
-
-export const tune = {
-  setDprMax,
-  setExposure,
-  setFov,
-  setFit,
-  setAutoRotate,
-  setDamping,
-  stopMotion,
-  setOrbitLimits,
-  setOrbitSpherical,
-} as const;

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

@@ -1,159 +0,0 @@
-/**
- * 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;
-  /**
-   * Garde RAF / runtime hors viewport (pont live).
-   * Aussi auto via `registerFrameConsumer`.
-   */
-  playOffscreen?: boolean;
-  /** Inertie OrbitControls (défaut 0.08, 0 = off). */
-  damping?: number;
-  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;
-  /** 1 si la caméra bouge (orbit / inertie / autoRotate), sinon 0. */
-  moving?: 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;
-  /**
-   * Pont live (Lot 1) : `{ element: sonic-3d }` pour `channel0` sans JPEG.
-   * Publié une fois au ready si un lecteur écoute `frameSource`.
-   */
-  frameSource?: { element: Element };
-};