@vectojs/core 1.27.0 → 1.27.1

package/dist/index.js

@@ -3640,10 +3640,24 @@ var Scene = (_class7 = class _Scene {
    * resume when it returns — instead of running the full update/render every
    * frame for a scene nobody can see. No-op (stays "on screen") where
    * `IntersectionObserver` is unavailable, so SSR/jsdom behavior is unchanged.
+   *
+   * Also a no-op for a canvas that is not in the document. An offscreen canvas
+   * used purely as a texture source — `@vectojs/three`'s `ThreeAdapter` wraps
+   * one in a `CanvasTexture`, and the same pattern shows up in any
+   * render-to-texture setup — is never appended anywhere, and an
+   * `IntersectionObserver` reports a detached element as not intersecting.
+   * Observing it would therefore set `_canvasOnScreen = false` on the first
+   * callback, and since {@link loop} returns without rescheduling in that
+   * state, the loop would stop permanently: the only resume path is an
+   * `isIntersecting` transition, which a detached element can never produce.
+   * Such a canvas is always "visible" as far as this scene is concerned,
+   * because whether its output is seen depends on the consumer sampling the
+   * texture, which this scene cannot observe.
    */
   watchCanvasVisibility() {
     if (this._canvasObserver || typeof IntersectionObserver === "undefined") return;
     if (!this.canvas || typeof this.canvas.getBoundingClientRect !== "function") return;
+    if (this.canvas.isConnected === false) return;
     this._canvasObserver = new IntersectionObserver((entries) => {
       const entry = entries[entries.length - 1];
       if (!entry) return;

package/dist/index.mjs

@@ -3639,10 +3639,24 @@ var Scene = class _Scene {
    * resume when it returns — instead of running the full update/render every
    * frame for a scene nobody can see. No-op (stays "on screen") where
    * `IntersectionObserver` is unavailable, so SSR/jsdom behavior is unchanged.
+   *
+   * Also a no-op for a canvas that is not in the document. An offscreen canvas
+   * used purely as a texture source — `@vectojs/three`'s `ThreeAdapter` wraps
+   * one in a `CanvasTexture`, and the same pattern shows up in any
+   * render-to-texture setup — is never appended anywhere, and an
+   * `IntersectionObserver` reports a detached element as not intersecting.
+   * Observing it would therefore set `_canvasOnScreen = false` on the first
+   * callback, and since {@link loop} returns without rescheduling in that
+   * state, the loop would stop permanently: the only resume path is an
+   * `isIntersecting` transition, which a detached element can never produce.
+   * Such a canvas is always "visible" as far as this scene is concerned,
+   * because whether its output is seen depends on the consumer sampling the
+   * texture, which this scene cannot observe.
    */
   watchCanvasVisibility() {
     if (this._canvasObserver || typeof IntersectionObserver === "undefined") return;
     if (!this.canvas || typeof this.canvas.getBoundingClientRect !== "function") return;
+    if (this.canvas.isConnected === false) return;
     this._canvasObserver = new IntersectionObserver((entries) => {
       const entry = entries[entries.length - 1];
       if (!entry) return;

package/dist/tree/Scene.d.ts

@@ -1168,6 +1168,19 @@ export declare class Scene {
      * resume when it returns — instead of running the full update/render every
      * frame for a scene nobody can see. No-op (stays "on screen") where
      * `IntersectionObserver` is unavailable, so SSR/jsdom behavior is unchanged.
+     *
+     * Also a no-op for a canvas that is not in the document. An offscreen canvas
+     * used purely as a texture source — `@vectojs/three`'s `ThreeAdapter` wraps
+     * one in a `CanvasTexture`, and the same pattern shows up in any
+     * render-to-texture setup — is never appended anywhere, and an
+     * `IntersectionObserver` reports a detached element as not intersecting.
+     * Observing it would therefore set `_canvasOnScreen = false` on the first
+     * callback, and since {@link loop} returns without rescheduling in that
+     * state, the loop would stop permanently: the only resume path is an
+     * `isIntersecting` transition, which a detached element can never produce.
+     * Such a canvas is always "visible" as far as this scene is concerned,
+     * because whether its output is seen depends on the consumer sampling the
+     * texture, which this scene cannot observe.
      */
     private watchCanvasVisibility;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectojs/core",
-  "version": "1.27.0",
+  "version": "1.27.1",
   "publishConfig": {
     "access": "public"
   },