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

package/src/core/components/functional/shader/shader.spec.ts

@@ -8,6 +8,88 @@ import { buildFragmentSource } from "./shadertoy-prelude";
 import "./shader";
 import { SonicShader, channelFormValue } from "./shader";
 
+describe("parseBufferFormat", () => {
+  it("accepte rgba8 / rgba16f / rgba32f", async () => {
+    const { parseBufferFormat } = await import("./types");
+    expect(parseBufferFormat("rgba8")).toBe("rgba8");
+    expect(parseBufferFormat("rgba16f")).toBe("rgba16f");
+    expect(parseBufferFormat("half")).toBe("rgba16f");
+    expect(parseBufferFormat("rgba32f")).toBe("rgba32f");
+    expect(parseBufferFormat("float")).toBe("rgba32f");
+    expect(parseBufferFormat("")).toBe("rgba8");
+    expect(parseBufferFormat("nope")).toBe("rgba8");
+  });
+});
+
+describe("resolveBufferGlFormat", () => {
+  it("reste rgba8 sans extension float", async () => {
+    const { resolveBufferGlFormat, resetBufferFormatWarnFlag } = await import(
+      "./gl-runtime"
+    );
+    resetBufferFormatWarnFlag();
+    const gl = {
+      RGBA8: 0x8058,
+      RGBA16F: 0x881a,
+      RGBA32F: 0x8814,
+      RGBA: 0x1908,
+      UNSIGNED_BYTE: 0x1401,
+      HALF_FLOAT: 0x140b,
+      FLOAT: 0x1406,
+      LINEAR: 0x2601,
+      NEAREST: 0x2600,
+      getExtension: () => null,
+    } as unknown as WebGL2RenderingContext;
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fmt = resolveBufferGlFormat(gl, "rgba16f");
+    expect(fmt.active).toBe("rgba8");
+    expect(fmt.float).toBe(false);
+    expect(warn).toHaveBeenCalledOnce();
+    warn.mockRestore();
+  });
+
+  it("accepte rgba16f avec EXT_color_buffer_float", async () => {
+    const { resolveBufferGlFormat, resetBufferFormatWarnFlag } = await import(
+      "./gl-runtime"
+    );
+    resetBufferFormatWarnFlag();
+    const gl = {
+      RGBA8: 0x8058,
+      RGBA16F: 0x881a,
+      RGBA32F: 0x8814,
+      RGBA: 0x1908,
+      UNSIGNED_BYTE: 0x1401,
+      HALF_FLOAT: 0x140b,
+      FLOAT: 0x1406,
+      LINEAR: 0x2601,
+      NEAREST: 0x2600,
+      getExtension: (name: string) =>
+        name === "EXT_color_buffer_float" ? {} : null,
+    } as unknown as WebGL2RenderingContext;
+    const fmt = resolveBufferGlFormat(gl, "rgba16f");
+    expect(fmt.active).toBe("rgba16f");
+    expect(fmt.float).toBe(true);
+    expect(fmt.type).toBe(gl.HALF_FLOAT);
+  });
+});
+
+describe("findPeaks float", () => {
+  it("lit des scores Float32 déjà normalisés", async () => {
+    const { findPeaks } = await import("./types");
+    const w = 8;
+    const h = 8;
+    const data = new Float32Array(w * h * 4);
+    data[(3 * w + 3) * 4] = 0.9;
+    data[(3 * w + 4) * 4] = 0.4;
+    const peaks = findPeaks(data, w, h, {
+      threshold: 0.5,
+      maxCount: 2,
+      minDistance: 2,
+    });
+    expect(peaks.length).toBeGreaterThanOrEqual(1);
+    expect(peaks[0].score).toBeCloseTo(0.9, 5);
+  });
+});
+
 describe("parseChannelSource", () => {
   it("résout self / buffers / url / fallback", () => {
     expect(parseChannelSource("self", "")).toEqual({ kind: "self" });
@@ -224,6 +306,39 @@ describe("meanRgba", () => {
   });
 });
 
+describe("release-offscreen auto / self", () => {
+  it("parseReleaseOffscreen", async () => {
+    const { parseReleaseOffscreen } = await import("./types");
+    expect(parseReleaseOffscreen(null)).toBe("auto");
+    expect(parseReleaseOffscreen("auto")).toBe("auto");
+    expect(parseReleaseOffscreen("")).toBe(true);
+    expect(parseReleaseOffscreen("true")).toBe(true);
+    expect(parseReleaseOffscreen("false")).toBe(false);
+  });
+
+  it("shouldReleaseWhenOffscreen", async () => {
+    const { shouldReleaseWhenOffscreen } = await import("./types");
+    expect(shouldReleaseWhenOffscreen("auto", true)).toBe(false);
+    expect(shouldReleaseWhenOffscreen("auto", false)).toBe(true);
+    expect(shouldReleaseWhenOffscreen(true, true)).toBe(true);
+    expect(shouldReleaseWhenOffscreen(false, false)).toBe(false);
+  });
+
+  it("channelsUseSelf détecte self", async () => {
+    const { channelsUseSelf } = await import("./types");
+    expect(
+      channelsUseSelf([
+        [{ kind: "url", url: "/a.png" }, { kind: "none" }, { kind: "none" }, { kind: "none" }],
+      ]),
+    ).toBe(false);
+    expect(
+      channelsUseSelf([
+        [{ kind: "self" }, { kind: "none" }, { kind: "none" }, { kind: "none" }],
+      ]),
+    ).toBe(true);
+  });
+});
+
 describe("SonicShader", () => {
   afterEach(() => {
     document.body.innerHTML = "";
@@ -365,4 +480,156 @@ describe("SonicShader", () => {
       expect(el.shadowRoot?.querySelector("canvas")).toBeTruthy();
     }
   });
+
+  it("changement de canal → rebindChannels, pas rebuild", async () => {
+    const el = TestUtils.bootstrap(
+      `<sonic-shader style="width:32px;height:32px"></sonic-shader>`,
+      true,
+    )[0] as SonicShader;
+    el.image =
+      "void mainImage(out vec4 fragColor, in vec2 fragCoord){ fragColor=vec4(1.0); }";
+    await el.updateComplete;
+
+    const rt = {
+      isLost: false,
+      setPassChannels: vi.fn(),
+      ensureTextures: vi.fn(async () => {}),
+      ensureElementTexture: vi.fn(),
+      resize: vi.fn(),
+      dispose: vi.fn(),
+      setVideosPlaying: vi.fn(),
+    };
+    const internal = el as unknown as {
+      runtime: typeof rt;
+      ready: boolean;
+      rebuild: () => Promise<void>;
+      rebindChannels: () => Promise<void>;
+      drawFrame: (now: number) => void;
+    };
+    internal.runtime = rt;
+    internal.ready = true;
+    vi.spyOn(internal, "drawFrame").mockImplementation(() => {});
+
+    const rebuildSpy = vi.spyOn(internal, "rebuild");
+    const rebindSpy = vi.spyOn(internal, "rebindChannels");
+    rebuildSpy.mockClear();
+    rebindSpy.mockClear();
+    rt.setPassChannels.mockClear();
+
+    el.bufferACh1 = "#autre";
+    await el.updateComplete;
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(rebuildSpy).not.toHaveBeenCalled();
+    expect(rebindSpy).toHaveBeenCalled();
+    expect(rt.setPassChannels).toHaveBeenCalled();
+  });
+
+  it("release-offscreen=auto : conserve le runtime si self hors écran", async () => {
+    const el = TestUtils.bootstrap(
+      `<sonic-shader release-offscreen="auto" style="width:32px;height:32px"></sonic-shader>`,
+      true,
+    )[0] as SonicShader;
+    await el.updateComplete;
+    expect(el.releaseOffscreen).toBe("auto");
+
+    const dispose = vi.fn();
+    const rt = {
+      isLost: false,
+      dispose,
+      setVideosPlaying: vi.fn(),
+      setPassChannels: vi.fn(),
+      ensureTextures: vi.fn(async () => {}),
+      ensureElementTexture: vi.fn(),
+      resize: vi.fn(),
+    };
+    const internal = el as unknown as {
+      runtime: typeof rt | null;
+      ready: boolean;
+      inView: boolean;
+      syncVisibility: () => void;
+      drawFrame: (now: number) => void;
+    };
+    internal.runtime = rt;
+    internal.ready = true;
+    internal.inView = true;
+    vi.spyOn(internal, "drawFrame").mockImplementation(() => {});
+
+    el.bufferACh0 = "self";
+    await el.updateComplete;
+    await new Promise((r) => setTimeout(r, 0));
+
+    internal.inView = false;
+    internal.syncVisibility();
+    expect(dispose).not.toHaveBeenCalled();
+    expect(internal.runtime).toBe(rt);
+  });
+
+  it("release-offscreen=auto : libère hors écran sans self", async () => {
+    const el = TestUtils.bootstrap(
+      `<sonic-shader release-offscreen="auto" style="width:32px;height:32px"></sonic-shader>`,
+      true,
+    )[0] as SonicShader;
+    await el.updateComplete;
+    const dispose = vi.fn();
+    const rt = {
+      isLost: false,
+      dispose,
+      setVideosPlaying: vi.fn(),
+    };
+    const internal = el as unknown as {
+      runtime: typeof rt | null;
+      ready: boolean;
+      inView: boolean;
+      syncVisibility: () => void;
+      drawFrame: (now: number) => void;
+    };
+    internal.runtime = rt;
+    internal.ready = true;
+    internal.inView = false;
+    vi.spyOn(internal, "drawFrame").mockImplementation(() => {});
+    internal.syncVisibility();
+    expect(dispose).toHaveBeenCalledWith(false);
+    expect(internal.runtime).toBeNull();
+  });
+
+  it("release-offscreen=true : libère même avec self", async () => {
+    const el = TestUtils.bootstrap(
+      `<sonic-shader release-offscreen style="width:32px;height:32px"></sonic-shader>`,
+      true,
+    )[0] as SonicShader;
+    await el.updateComplete;
+    expect(el.releaseOffscreen).toBe(true);
+
+    const dispose = vi.fn();
+    const rt = {
+      isLost: false,
+      dispose,
+      setVideosPlaying: vi.fn(),
+      setPassChannels: vi.fn(),
+      ensureTextures: vi.fn(async () => {}),
+      ensureElementTexture: vi.fn(),
+      resize: vi.fn(),
+    };
+    const internal = el as unknown as {
+      runtime: typeof rt | null;
+      ready: boolean;
+      inView: boolean;
+      syncVisibility: () => void;
+      drawFrame: (now: number) => void;
+    };
+    internal.runtime = rt;
+    internal.ready = true;
+    internal.inView = true;
+    vi.spyOn(internal, "drawFrame").mockImplementation(() => {});
+
+    el.bufferACh0 = "self";
+    await el.updateComplete;
+    await new Promise((r) => setTimeout(r, 0));
+
+    internal.inView = false;
+    internal.syncVisibility();
+    expect(dispose).toHaveBeenCalledWith(false);
+    expect(internal.runtime).toBeNull();
+  });
 });

package/src/core/components/functional/shader/shader.ts

@@ -1,7 +1,7 @@
 import { css, html, LitElement } from "lit";
 import { customElement, property, state } from "lit/decorators.js";
 import HTML from "@supersoniks/concorde/core/utils/HTML";
-import { revokeMediaUrls, toMediaUrl, mediaElementKey, lookupLiveElement } from "@supersoniks/concorde/core/utils/mediaRef";
+import { revokeMediaUrls, toMediaUrl, mediaElementKey, lookupLiveElement, FrameConsumerRegistry } from "@supersoniks/concorde/core/utils/mediaRef";
 import { PublisherManager } from "@supersoniks/concorde/utils";
 import {
   parseChannelSource,
@@ -9,6 +9,8 @@ import {
 } from "./gl-runtime";
 import {
   PassChannels,
+  ReleaseOffscreen,
+  ShaderBufferFormat,
   ShaderCompileError,
   ShaderExtractItem,
   ShaderExtractOutput,
@@ -18,17 +20,61 @@ import {
   ShaderRoi,
   ShaderSources,
   SonicShaderOutput,
+  channelsUseSelf,
   findPeaks,
   meanRgba,
+  parseBufferFormat,
   parseExtractPass,
   parseHoverParam,
+  parseReleaseOffscreen,
   roiToPixels,
+  rgbaToUint8,
+  shouldReleaseWhenOffscreen,
 } from "./types";
 
 const tagName = "sonic-shader";
 
 const MAX_PATCH_PX = 128;
 
+/** Clés qui forcent une recompilation / recreate FBO. */
+const PROGRAM_KEYS = [
+  "image",
+  "bufferA",
+  "bufferB",
+  "bufferC",
+  "bufferD",
+  "common",
+  "bufferFormat",
+] as const;
+
+/** Clés qui ne font que re-lier les textures (pas de rebuild). */
+const CHANNEL_KEYS = [
+  "channel0",
+  "channel1",
+  "channel2",
+  "channel3",
+  "imageCh0",
+  "imageCh1",
+  "imageCh2",
+  "imageCh3",
+  "bufferACh0",
+  "bufferACh1",
+  "bufferACh2",
+  "bufferACh3",
+  "bufferBCh0",
+  "bufferBCh1",
+  "bufferBCh2",
+  "bufferBCh3",
+  "bufferCCh0",
+  "bufferCCh1",
+  "bufferCCh2",
+  "bufferCCh3",
+  "bufferDCh0",
+  "bufferDCh1",
+  "bufferDCh2",
+  "bufferDCh3",
+] as const;
+
 /**
  * Champs méta publiés vers le out-dataProvider.
  * `param0…3` sont exclus du gate « consommateur » : un `sonic-input name="param0"`
@@ -294,12 +340,32 @@ export class SonicShader extends LitElement {
   /** Vitesse d’easing hover on/off (1/s, défaut 10). */
   @property({ type: Number, attribute: "hover-speed" }) hoverSpeed = 10;
   /**
-   * Libère le contexte WebGL hors viewport (défaut true).
-   * Les navigateurs limitent ~8–16 contextes.
+   * Hors viewport : libère textures/FBO (garde le contexte).
+   * `auto` (défaut) : ne libère pas si une passe lit `self`.
+   * `true` / `false` forcent le comportement.
    */
-  @property({ type: Boolean, attribute: "release-offscreen" })
-  releaseOffscreen = true;
+  @property({
+    attribute: "release-offscreen",
+    converter: {
+      fromAttribute: (value: string | null) => parseReleaseOffscreen(value),
+      toAttribute: (value: ReleaseOffscreen) => {
+        if (value === "auto") return "auto";
+        if (value === false) return "false";
+        return "";
+      },
+    },
+  })
+  releaseOffscreen: ReleaseOffscreen = "auto";
   @property({ type: Number, attribute: "dpr-max" }) dprMax = 2;
+  /**
+   * Format des buffers A–D : `rgba8` (défaut) | `rgba16f` | `rgba32f`.
+   * Attribut reflété `active-buffer-format` = format réellement utilisé.
+   */
+  @property({ attribute: "buffer-format" })
+  bufferFormat: ShaderBufferFormat | string = "rgba8";
+  /** Format actif après repli éventuel (lecture seule, reflect). */
+  @property({ attribute: "active-buffer-format", reflect: true })
+  activeBufferFormat: ShaderBufferFormat = "rgba8";
 
   /** Generic float uniforms `uParam0`…`uParam3` (no shader rebuild). */
   @property({ type: Number, attribute: "param0" }) param0 = 0;
@@ -399,6 +465,9 @@ export class SonicShader extends LitElement {
   private resizeObserver: ResizeObserver | null = null;
   private intersectionObserver: IntersectionObserver | null = null;
   private rebuildToken = 0;
+  /** Annule un `rebindChannels` en vol si rebuild / release intervient. */
+  private rebindToken = 0;
+  private frameConsumers = new FrameConsumerRegistry();
   private ready = false;
   private formPublisher: ReturnType<typeof PublisherManager.get> | null = null;
   private outPublisher: ReturnType<typeof PublisherManager.get> | null = null;
@@ -479,9 +548,11 @@ export class SonicShader extends LitElement {
     }
     this.pendingRevokeUrls = [];
     this.stopLoop();
+    this.frameConsumers.clear();
     this.resizeObserver?.disconnect();
     this.intersectionObserver?.disconnect();
     this.rebuildToken++;
+    this.rebindToken++;
     this.ready = false;
     this.releasing = true;
     this.runtime?.dispose(true); // libère le slot navigateur
@@ -505,7 +576,7 @@ export class SonicShader extends LitElement {
     this.bindOutPublisher();
     this.bindExtractPublisher();
     requestAnimationFrame(() => {
-      if (this.inView || !this.releaseOffscreen) {
+      if (this.inView || !this.wantsReleaseOffscreen()) {
         void this.ensureRuntime();
       }
     });
@@ -513,44 +584,19 @@ export class SonicShader extends LitElement {
 
   protected updated(changed: Map<string, unknown>) {
     if (!this.runtime) return;
-    const shaderKeys = [
-      "image",
-      "bufferA",
-      "bufferB",
-      "bufferC",
-      "bufferD",
-      "common",
-      "channel0",
-      "channel1",
-      "channel2",
-      "channel3",
-      "imageCh0",
-      "imageCh1",
-      "imageCh2",
-      "imageCh3",
-      "bufferACh0",
-      "bufferACh1",
-      "bufferACh2",
-      "bufferACh3",
-      "bufferBCh0",
-      "bufferBCh1",
-      "bufferBCh2",
-      "bufferBCh3",
-      "bufferCCh0",
-      "bufferCCh1",
-      "bufferCCh2",
-      "bufferCCh3",
-      "bufferDCh0",
-      "bufferDCh1",
-      "bufferDCh2",
-      "bufferDCh3",
-    ];
-    if (shaderKeys.some((k) => changed.has(k))) {
+    const programChanged = PROGRAM_KEYS.some((k) => changed.has(k));
+    const channelChanged = CHANNEL_KEYS.some((k) => changed.has(k));
+    if (programChanged) {
       void this.rebuild();
+    } else if (channelChanged) {
+      void this.rebindChannels();
     }
     if (changed.has("play")) {
       this.syncPlayback();
     }
+    if (changed.has("releaseOffscreen") || channelChanged) {
+      this.syncVisibility();
+    }
     if (
       changed.has("dataProvider") ||
       changed.has("outDataProvider") ||
@@ -696,6 +742,7 @@ export class SonicShader extends LitElement {
    */
   private releaseRuntime() {
     this.rebuildToken++;
+    this.rebindToken++;
     this.stopLoop();
     this.ready = false;
     this.releasing = true;
@@ -752,6 +799,7 @@ export class SonicShader extends LitElement {
     e.preventDefault();
     if (this.releasing) return;
     this.rebuildToken++;
+    this.rebindToken++;
     this.stopLoop();
     this.ready = false;
     this.runtime = null;
@@ -766,7 +814,8 @@ export class SonicShader extends LitElement {
     if (this.runtime && !this.runtime.isLost) return;
     this.runtime = null;
     await this.updateComplete;
-    if (!this.isConnected || (!this.inView && this.releaseOffscreen)) return;
+    if (!this.isConnected || (!this.inView && this.wantsReleaseOffscreen()))
+      return;
 
     const canvas = this.getCanvas();
     if (!canvas) return;
@@ -775,6 +824,9 @@ export class SonicShader extends LitElement {
       this.errorMessage = "";
       this.runtime = new ShaderToyRuntime(canvas);
       this.runtime.setElementResolver((key) => this.lookupElement(key));
+      this.activeBufferFormat = this.runtime.setBufferFormat(
+        parseBufferFormat(this.bufferFormat),
+      );
       this.bindContextEvents();
       this.syncSize();
       await this.rebuild();
@@ -784,7 +836,7 @@ export class SonicShader extends LitElement {
   }
 
   private syncVisibility() {
-    if (!this.inView && this.releaseOffscreen) {
+    if (!this.inView && this.wantsReleaseOffscreen()) {
       this.releaseRuntime();
       return;
     }
@@ -871,8 +923,72 @@ export class SonicShader extends LitElement {
     return [...new Set(keys)];
   }
 
+  /** Enregistre les producteurs live (`sonic-3d`…) pour play-offscreen auto. */
+  private syncFrameConsumers(channels: Map<ShaderPassId, PassChannels>) {
+    const els = this.collectElementKeys(channels).map((k) =>
+      this.lookupElement(k),
+    );
+    this.frameConsumers.sync(els);
+  }
+
+  /** Map canaux courante (tous les passes). */
+  private collectPassChannels(): Map<ShaderPassId, PassChannels> {
+    const channels = new Map<ShaderPassId, PassChannels>();
+    for (const pass of [
+      "bufferA",
+      "bufferB",
+      "bufferC",
+      "bufferD",
+      "image",
+    ] as ShaderPassId[]) {
+      channels.set(pass, this.buildChannels(pass));
+    }
+    return channels;
+  }
+
+  /** `true` si hors viewport on doit libérer textures/FBO. */
+  private wantsReleaseOffscreen(): boolean {
+    return shouldReleaseWhenOffscreen(
+      this.releaseOffscreen,
+      channelsUseSelf(this.collectPassChannels().values()),
+    );
+  }
+
+  /**
+   * Re-lie les canaux sans recompiler ni vider les FBO (Vague A Lot 2).
+   */
+  private async rebindChannels() {
+    if (!this.runtime || this.runtime.isLost || !this.image.trim()) return;
+    if (!this.ready) {
+      void this.rebuild();
+      return;
+    }
+    const token = ++this.rebindToken;
+    const channels = this.collectPassChannels();
+    try {
+      const urls = this.collectUrls(channels);
+      await this.runtime.ensureTextures(urls);
+      for (const key of this.collectElementKeys(channels)) {
+        this.runtime.ensureElementTexture(key);
+      }
+      if (token !== this.rebindToken || !this.runtime || this.runtime.isLost) {
+        return;
+      }
+      this.syncFrameConsumers(channels);
+      const aspectHint =
+        this.channel0.startsWith("#") ? "" : this.channel0 || urls[0];
+      this.applyAspectRatio(aspectHint);
+      this.runtime.setPassChannels(channels);
+      this.syncSize();
+    } catch (err) {
+      if (token !== this.rebindToken) return;
+      this.emitError(err);
+    }
+  }
+
   private async rebuild() {
     if (!this.runtime || this.runtime.isLost || !this.image.trim()) return;
+    this.rebindToken++;
     const token = ++this.rebuildToken;
     this.errorMessage = "";
     const sources: ShaderSources = {
@@ -883,18 +999,12 @@ export class SonicShader extends LitElement {
       bufferC: this.bufferC,
       bufferD: this.bufferD,
     };
-    const channels = new Map<ShaderPassId, PassChannels>();
-    for (const pass of [
-      "bufferA",
-      "bufferB",
-      "bufferC",
-      "bufferD",
-      "image",
-    ] as ShaderPassId[]) {
-      channels.set(pass, this.buildChannels(pass));
-    }
+    const channels = this.collectPassChannels();
     try {
       this.syncSize();
+      this.activeBufferFormat = this.runtime.setBufferFormat(
+        parseBufferFormat(this.bufferFormat),
+      );
       const urls = this.collectUrls(channels);
       await this.runtime.ensureTextures(urls);
       for (const key of this.collectElementKeys(channels)) {
@@ -903,6 +1013,7 @@ export class SonicShader extends LitElement {
       if (token !== this.rebuildToken || !this.runtime || this.runtime.isLost) {
         return;
       }
+      this.syncFrameConsumers(channels);
       const aspectHint =
         this.channel0.startsWith("#") ? "" : this.channel0 || urls[0];
       this.applyAspectRatio(aspectHint);
@@ -1312,8 +1423,8 @@ export class SonicShader extends LitElement {
             : this.runtime.readBufferRect(pass, px.x, px.y, px.w, px.h);
         if (!rect) continue;
         // Copie : le buffer WebGL peut être réutilisé / invalidé ensuite
-        const rgba = new Uint8Array(rect.data);
-        const mean = meanRgba(rgba);
+        const rgba = rgbaToUint8(rect.data);
+        const mean = meanRgba(rect.data);
         const item: ShaderExtractItem = {
           id: roi.id || `${source}-${px.x}-${px.y}`,
           x: this.round3(rect.x / bufW),
@@ -1410,7 +1521,11 @@ export class SonicShader extends LitElement {
     if (typeof score === "number") item.score = this.round3(score);
     if (this.extractBitmaps) {
       const token = this.rebuildToken;
-      const url = await rgbaToBlobUrl(rect.data, rect.width, rect.height);
+      const url = await rgbaToBlobUrl(
+        rgbaToUint8(rect.data),
+        rect.width,
+        rect.height,
+      );
       if (token !== this.rebuildToken || !this.isConnected) {
         if (url) revokeMediaUrls([url]);
         return null;
@@ -1581,10 +1696,12 @@ export class SonicShader extends LitElement {
   }
 }
 
-export { parseChannelSource, ShaderToyRuntime, shouldUploadElementFrame } from "./gl-runtime";
+export { parseChannelSource, ShaderToyRuntime, shouldUploadElementFrame, resolveBufferGlFormat, resetBufferFormatWarnFlag } from "./gl-runtime";
 export { buildFragmentSource } from "./shadertoy-prelude";
 export type {
   ChannelSource,
+  ReleaseOffscreen,
+  ShaderBufferFormat,
   ShaderExtractItem,
   ShaderExtractOutput,
   ShaderExtractPass,
@@ -1609,11 +1726,16 @@ export {
   mediaElementKey,
 } from "@supersoniks/concorde/core/utils/mediaRef";
 export {
+  channelsUseSelf,
   findPeaks,
   meanRgba,
+  parseBufferFormat,
   parseExtractPass,
   parseHoverParam,
+  parseReleaseOffscreen,
   roiToPixels,
+  rgbaToUint8,
+  shouldReleaseWhenOffscreen,
   ShaderCompileError,
 } from "./types";