perf(core): PRD-564 retain render targets across scale changes

biome.json

@@ -210,6 +210,37 @@
       "formatter": {
         "enabled": false
       }
+    },
+    {
+      "include": ["examples/procedural-animals/src/render/donor/core/motion/quadruped.js"],
+      "linter": {
+        "rules": {
+          "style": {
+            "useNamingConvention": {
+              "level": "error",
+              "options": {
+                "conventions": [
+                  {
+                    "selector": {
+                      "kind": "interface"
+                    },
+                    "match": "I(.*)"
+                  },
+                  {
+                    "selector": {
+                      "kind": "objectLiteralProperty"
+                    },
+                    "match": "(?:D|DL|T|F|H|W|U|Lf|(.+))",
+                    "formats": ["camelCase"]
+                  }
+                ],
+                "strictCase": false,
+                "requireAscii": false
+              }
+            }
+          }
+        }
+      }
     }
   ]
 }

packages/assets/__tests__/bake-receipt.spec.ts

@@ -278,34 +278,69 @@ describe("bake receipt", () => {
     );
   });
 
-  it.each([false, true])(
-    "should throw when a pass writes a file under the output root it did not declare (preserved old timestamp: %s)",
-    async (preserveTimestamp) => {
-      const root = await makeTempDir("threenative-receipt-stray-");
-      await mkdir(path.join(root, "assets"));
-      await writeFile(path.join(root, "assets", "rock.png"), rgbaPng({ height: 32, width: 32 }));
-
-      await expect(
-        compileAssets({
-          cwd: root,
-          transcoder: TRANSCODER,
-          passes: [
-            {
-              name: "stray-writer",
-              apply: async (input: Buffer) => {
-                await mkdir(path.join(root, "public"), { recursive: true });
-                const strayPath = path.join(root, "public", "stray.bin");
-                await writeFile(strayPath, "undeclared");
-                // A copied output can retain its source's timestamp despite being new to public/.
-                if (preserveTimestamp) await utimes(strayPath, new Date(0), new Date(0));
-                return input;
-              },
+  it.each([
+    ["ordinary", false],
+    ["backdated", true],
+  ])("should throw when a pass writes an undeclared file (%s)", async (_label, backdate) => {
+    const root = await makeTempDir("threenative-receipt-stray-");
+    await mkdir(path.join(root, "assets"));
+    await writeFile(path.join(root, "assets", "rock.png"), rgbaPng({ height: 32, width: 32 }));
+
+    await expect(
+      compileAssets({
+        cwd: root,
+        transcoder: TRANSCODER,
+        passes: [
+          {
+            name: "stray-writer",
+            apply: async (input: Buffer) => {
+              await mkdir(path.join(root, "public"), { recursive: true });
+              await writeFile(path.join(root, "public", "stray.bin"), "undeclared");
+              if (backdate) {
+                await utimes(
+                  path.join(root, "public", "stray.bin"),
+                  new Date("2000-01-01T00:00:00Z"),
+                  new Date("2000-01-01T00:00:00Z"),
+                );
+              }
+              return input;
+            },
+          },
+        ],
+      }),
+    ).rejects.toThrow(/TN_ASSETS_UNDECLARED_OUTPUT.*stray\.bin/su);
+  });
+
+  it("should throw when a pass overwrites a pre-existing undeclared file", async () => {
+    const root = await makeTempDir("threenative-receipt-stray-overwrite-");
+    await mkdir(path.join(root, "assets"));
+    await mkdir(path.join(root, "public"));
+    await writeFile(path.join(root, "public", "stray.bin"), "old");
+    await utimes(
+      path.join(root, "public", "stray.bin"),
+      new Date("2000-01-01T00:00:00Z"),
+      new Date("2000-01-01T00:00:00Z"),
+    );
+    await writeFile(path.join(root, "assets", "rock.png"), rgbaPng({ height: 32, width: 32 }));
+
+    await expect(
+      compileAssets({
+        cwd: root,
+        transcoder: TRANSCODER,
+        passes: [
+          {
+            name: "stray-writer",
+            apply: async (input: Buffer) => {
+              await writeFile(path.join(root, "public", "stray.bin"), "undeclared");
+              const future = new Date(Date.now() + 1000);
+              await utimes(path.join(root, "public", "stray.bin"), future, future);
+              return input;
             },
-          ],
-        }),
-      ).rejects.toThrow(/TN_ASSETS_UNDECLARED_OUTPUT.*stray\.bin/su);
-    },
-  );
+          },
+        ],
+      }),
+    ).rejects.toThrow(/TN_ASSETS_UNDECLARED_OUTPUT.*stray\.bin/su);
+  });
 
   it("should leave a static file the project authored alone", async () => {
     const root = await makeTempDir("threenative-receipt-static-");

packages/core/__tests__/render-chain.spec.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from "vitest";
 import {
   type IRenderChainStage,
+  RENDER_CHAIN_STAGE_ORDER,
   RenderChain,
   readRenderChainObservation,
 } from "../src/render/chain.js";
@@ -896,3 +897,40 @@ describe("RenderChain", () => {
     ).toThrow(/afterOutputTransform/u);
   });
 });
+
+describe("subrect stage admission", () => {
+  it.each(RENDER_CHAIN_STAGE_ORDER)("requires explicit sampling support for %s", (name) => {
+    for (const supported of [false, true]) {
+      const adapter = renderer("webgpu");
+      const install = vi.fn();
+      adapter.setOutputNode = install;
+      const handle = {} as import("../src/render/resolution-subrect.js").ResolutionSubrect;
+      const report = vi.fn();
+      const chain = new RenderChain({
+        renderer: adapter,
+        input: {},
+        resolutionSubrect: handle,
+        report,
+        request: { stages: [name], tier: "high" },
+        stages: [
+          {
+            name,
+            requiresVelocity: false,
+            supportsResolutionSubrect: supported,
+            build: (input) => input,
+          },
+        ],
+      });
+      expect(install.mock.calls[0]?.[2]?.resolutionSubrect).toBe(supported ? handle : undefined);
+      expect(
+        report.mock.calls.some(
+          ([line]) =>
+            line.includes("TN_RESOLUTION_SUBRECT") &&
+            line.includes(supported ? "applied" : "refused") &&
+            line.includes(name),
+        ),
+      ).toBe(true);
+      chain.dispose();
+    }
+  });
+});