@pixel-point/toolcraft 0.0.14 → 0.0.15

package/templates/runtime/testing/performance-renderer-coverage.test.ts

@@ -0,0 +1,325 @@
+import { describe, expect, it } from "vitest";
+
+import { defineToolcraft } from "../schema/define-toolcraft";
+import {
+  collectToolcraftPerformanceSensitiveControls,
+  collectToolcraftUnclassifiedPerformanceControls,
+  defineToolcraftPerformance,
+  defaultToolcraftBrowserCheckPolicy,
+  type ToolcraftBrowserCheckPolicy,
+  validateToolcraftPerformanceCoverage,
+} from "./performance";
+import {
+  createAnimatedVectorRendererConfig,
+  createAnimatedVectorRendererPipeline,
+  createAnimationFrameScenario,
+  createAnimationViewportDragScenario,
+  createCombinedRendererStressFixture,
+  createCustomStressFixture,
+  createDenseCanvasPipeline,
+  createMainThreadCanvasCompositePipeline,
+  createMaxValueStressFixture,
+  createMeasuredWebglEvidence,
+  createMediaRendererPipeline,
+  createMediaStressFixture,
+  createPixelRendererPipeline,
+  createTextRendererPipeline,
+  createTextRendererScenarios,
+  createViewportZoomStressScenario,
+  mediaUploadSchema,
+  ordinarySliderSchema,
+  testSchema,
+} from "./performance-test-fixtures";
+
+describe("Toolcraft performance renderer coverage contract", () => {
+  it("rejects visible controls without performance scenarios", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "none",
+      rendererWorkload: "none",
+      scenarios: [
+        {
+          automated: true,
+          automatedTestName: "perf: density drag stays responsive",
+          browser: true,
+          browserTestName: "browser perf: density drag stays responsive",
+          budget: { maxFrameGapMs: 80, maxInteractionMs: 500 },
+          controlLabel: "Density",
+          expectedObservable: "Dragging Density updates the product without blocking the UI.",
+          fixture: "runtime density fixture",
+          id: "density-drag",
+          interaction: "control-drag",
+          target: "render.density",
+          values: { default: 4, max: 12, min: 1 },
+          workload: true,
+        },
+      ],
+      usesCustomRenderer: false,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      "render.mode must have a performance scenario because every visible control can affect app responsiveness.",
+    );
+  });
+
+  it("allows text-output renderers without forcing a GPU strategy", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["glyph metrics must stay crisp at product output size"],
+        performanceRisks: ["large glyph grids can be expensive during drag"],
+        previewRenderer: "canvas-2d",
+        productRepresentation: "text",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "text-output",
+        sourceRepresentation: "dom-text",
+        whyNotAlternativeStrategies: ["webgl texture output would rasterize text too early"],
+      },
+      rendererWorkload: "text-output",
+      rendererPipeline: createTextRendererPipeline(),
+      scenarios: createTextRendererScenarios(),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toEqual([]);
+  });
+
+  it("rejects main-thread Canvas 2D raster/composite pipelines misclassified as text output", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["rasterized text must preserve the shader-style composite"],
+        layers: [
+          {
+            content: ["text", "noise"],
+            exportMode: "composited",
+            id: "product-text-composite",
+            intentionalRasterizationReason:
+              "The product text is warped, tinted, and exported as final pixels.",
+            kind: "product-foreground",
+            primitiveCount: "medium",
+            renderer: "canvas-2d",
+            uiSelector: '[data-toolcraft-renderer-layer="product-text-composite"]',
+          },
+        ],
+        performanceRisks: [
+          "WebGL measured stress evidence was reviewed before keeping the text composite on Canvas 2D.",
+        ],
+        previewRenderer: "canvas-2d",
+        productRepresentation: "mixed",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "text-output",
+        sourceRepresentation: "dom-text",
+        whyNotAlternativeStrategies: [
+          "WebGL measured stress evidence showed text atlas uploads dominated this fixture.",
+        ],
+      },
+      rendererWorkload: "text-output",
+      rendererPipeline: createMainThreadCanvasCompositePipeline(),
+      scenarios: createTextRendererScenarios(),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      'Canvas 2D pipelines with main-thread rasterize/composite preview pressure must use rendererWorkload "pixel-output" or move expensive passes off the main thread; received "text-output".',
+    );
+  });
+
+  it("requires animated custom renderers to test viewport dragging during animation", () => {
+    const config = createAnimatedVectorRendererConfig({ includeViewportDrag: false });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      "Animated custom renderers must include an animation-viewport-drag performance scenario that samples frames while physically moving the canvas viewport.",
+    );
+  });
+
+  it("requires detail-heavy custom renderers to test real viewport zoom stress", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["glyph metrics must stay crisp at product output size"],
+        performanceRisks: ["large glyph grids can shake or jank during canvas zoom"],
+        previewRenderer: "canvas-2d",
+        productRepresentation: "text",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "text-output",
+        sourceRepresentation: "dom-text",
+        whyNotAlternativeStrategies: ["webgl texture output would rasterize text too early"],
+      },
+      rendererWorkload: "text-output",
+      scenarios: createTextRendererScenarios({ includeViewportZoomStress: false }),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      "Detail-heavy or animated custom renderers must include a viewport-zoom-stress performance scenario that uses real zoom controls while sampling frame gaps and long tasks.",
+    );
+  });
+
+  it("requires detail-heavy custom renderers to prove worst-case preview or animation stress", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["dense texture output must stay visually stable"],
+        layers: [
+          {
+            content: ["dense-pattern"],
+            exportMode: "included",
+            id: "dense-pattern",
+            kind: "product-foreground",
+            primitiveCount: "high",
+            renderer: "canvas-2d",
+            uiSelector: '[data-toolcraft-renderer-layer="dense-pattern"]',
+          },
+          {
+            content: ["geometry"],
+            exportMode: "included",
+            id: "foreground-geometry",
+            kind: "product-foreground",
+            primitiveCount: "low",
+            renderer: "svg",
+            uiSelector: '[data-toolcraft-renderer-layer="foreground-geometry"]',
+          },
+        ],
+        performanceRisks: ["maximum density may overload the renderer"],
+        previewRenderer: "canvas-2d",
+        productRepresentation: "mixed",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "simple-composition",
+        sourceRepresentation: "procedural-data",
+        whyNotAlternativeStrategies: ["canvas is simple"],
+      },
+      rendererWorkload: "simple-composition",
+      scenarios: createTextRendererScenarios({ includeStressPreview: false }),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toEqual(
+      expect.arrayContaining([
+        "Detail-heavy custom renderers must include a stress preview-render or animation-frame scenario for the largest product canvas and heaviest workload values.",
+      ]),
+    );
+  });
+
+  it("requires high-count Canvas 2D semantic or dense layers to carry measurable stress evidence", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["glyphs must stay legible"],
+        layers: [
+          {
+            content: ["text", "dense-pattern"],
+            exportMode: "included",
+            id: "dense-text-field",
+            intentionalRasterizationReason:
+              "The product exports raster video and PNG, so text is drawn into one canvas frame.",
+            kind: "product-foreground",
+            primitiveCount: "high",
+            renderer: "canvas-2d",
+            uiSelector: '[data-toolcraft-renderer-layer="dense-text-field"]',
+          },
+        ],
+        performanceRisks: ["maximum density may redraw many text runs per frame"],
+        previewRenderer: "canvas-2d",
+        productRepresentation: "text",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "text-output",
+        sourceRepresentation: "dom-text",
+        whyNotAlternativeStrategies: ["webgl texture output would rasterize text too early"],
+      },
+      rendererWorkload: "text-output",
+      scenarios: createTextRendererScenarios({ includeStressPreview: false }),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toEqual(
+      expect.arrayContaining([
+        "High-count Canvas 2D renderer layers must include stress preview-render or animation-frame evidence before delivery. If that stress evidence fails, revise renderer strategy instead of only lowering product workload.",
+      ]),
+    );
+  });
+
+  it("requires detail-heavy Canvas 2D renderers to document measured WebGL/WebGPU evaluation", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["dense texture output must match source media colors"],
+        layers: [
+          {
+            content: ["bitmap-media", "noise"],
+            exportMode: "included",
+            id: "media-effect",
+            kind: "product-foreground",
+            primitiveCount: "high",
+            renderer: "canvas-2d",
+            uiSelector: '[data-toolcraft-renderer-layer="media-effect"]',
+          },
+        ],
+        performanceRisks: ["large uploaded media can require millions of pixel operations"],
+        previewRenderer: "canvas-2d",
+        productRepresentation: "pixel",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "pixel-output",
+        sourceRepresentation: "image-media",
+        whyNotAlternativeStrategies: ["canvas is convenient"],
+      },
+      rendererWorkload: "pixel-output",
+      scenarios: createTextRendererScenarios(),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      "Detail-heavy Canvas 2D renderers must include rendererTechnique.measuredAlternativeEvidence for WebGL/WebGPU stress comparison before keeping the pixel work on CPU.",
+    );
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      'rendererWorkload "pixel-output" should use rendererStrategy "webgl" or "webgpu", received "canvas-2d". Keeping a CPU renderer requires rendererTechnique.measuredAlternativeEvidence for WebGL/WebGPU stress comparison.',
+    );
+  });
+
+  it("allows pixel-output Canvas 2D only with measured WebGL/WebGPU evidence", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["pixel output must preserve exact color stops"],
+        performanceRisks: [
+          "Measured WebGL stress evidence showed setup overhead exceeded cached Canvas 2D worker output for this static fixture.",
+        ],
+        measuredAlternativeEvidence: createMeasuredWebglEvidence(),
+        previewRenderer: "canvas-2d",
+        productRepresentation: "pixel",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "pixel-output",
+        sourceRepresentation: "procedural-data",
+        whyNotAlternativeStrategies: [
+          "WebGL measured stress evidence stayed within budget but did not improve interaction latency for this renderer.",
+        ],
+      },
+      rendererWorkload: "pixel-output",
+      rendererPipeline: createPixelRendererPipeline(),
+      scenarios: createTextRendererScenarios(),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toEqual([]);
+  });
+
+  it("accepts animated custom renderers with stress coverage while dragging the viewport", () => {
+    const config = createAnimatedVectorRendererConfig({ includeViewportDrag: true });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toEqual([]);
+  });
+});

package/templates/runtime/testing/performance-renderer-pipeline-coverage.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  defineToolcraftPerformance,
+  validateToolcraftPerformanceCoverage,
+} from "./performance";
+import {
+  createMediaRendererPipeline,
+  createTextRendererPipeline,
+  createTextRendererScenarios,
+  testSchema,
+} from "./performance-test-fixtures";
+
+describe("Toolcraft performance renderer pipeline coverage contract", () => {
+  it("requires media decoding pipelines to include media-import coverage", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "webgl",
+      rendererTechnique: {
+        exportRenderer: "webgl",
+        fidelityRisks: ["large source media must preserve color"],
+        performanceRisks: ["source decode can be expensive"],
+        previewRenderer: "webgl",
+        productRepresentation: "pixel",
+        rendererStrategy: "webgl",
+        rendererWorkload: "pixel-output",
+        sourceRepresentation: "image-media",
+        whyNotAlternativeStrategies: ["canvas-2d would run per-pixel work on the main thread"],
+      },
+      rendererWorkload: "pixel-output",
+      rendererPipeline: createMediaRendererPipeline(),
+      scenarios: createTextRendererScenarios(),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      'rendererPipeline pass "source-decode" decodes media, so performance scenarios must include media-import coverage.',
+    );
+  });
+
+  it("requires workload targets to appear in renderer pipeline invalidation targets", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["text output must stay crisp"],
+        performanceRisks: ["density changes can relayout text"],
+        previewRenderer: "canvas-2d",
+        productRepresentation: "text",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "text-output",
+        sourceRepresentation: "dom-text",
+        whyNotAlternativeStrategies: ["dom output cannot preserve export composition"],
+      },
+      rendererWorkload: "text-output",
+      rendererPipeline: {
+        ...createTextRendererPipeline(),
+        interactionInvalidation: [
+          {
+            interaction: "control-change",
+            invalidates: ["text-layout"],
+            targets: ["render.mode"],
+          },
+        ],
+      },
+      scenarios: createTextRendererScenarios(),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      "Performance workload target render.density must appear in rendererPipeline interactionInvalidation targets.",
+    );
+  });
+
+  it("requires performance scenario interactions to appear in renderer pipeline invalidation", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "canvas-2d",
+      rendererTechnique: {
+        exportRenderer: "canvas-2d",
+        fidelityRisks: ["text output must stay crisp"],
+        performanceRisks: ["density changes can relayout text"],
+        previewRenderer: "canvas-2d",
+        productRepresentation: "text",
+        rendererStrategy: "canvas-2d",
+        rendererWorkload: "text-output",
+        sourceRepresentation: "dom-text",
+        whyNotAlternativeStrategies: ["dom output cannot preserve export composition"],
+      },
+      rendererWorkload: "text-output",
+      rendererPipeline: {
+        ...createTextRendererPipeline(),
+        interactionInvalidation: [
+          {
+            interaction: "control-drag",
+            invalidates: ["text-layout"],
+            targets: ["render.density"],
+          },
+          {
+            interaction: "control-change",
+            invalidates: ["text-layout"],
+            targets: ["render.mode"],
+          },
+        ],
+      },
+      scenarios: createTextRendererScenarios(),
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      "Performance scenario viewport-zoom-stress exercises viewport-zoom, so rendererPipeline.interactionInvalidation must declare that interaction.",
+    );
+  });
+});

package/templates/runtime/testing/performance-renderer-pipeline-interactions.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  defineToolcraftPerformance,
+  validateToolcraftPerformanceCoverage,
+} from "./performance";
+import {
+  createAnimatedVectorRendererPipeline,
+  createCombinedRendererStressFixture,
+  createTextRendererScenarios,
+  testSchema,
+} from "./performance-test-fixtures";
+
+describe("Toolcraft performance renderer pipeline interaction contract", () => {
+  it("requires timeline playback scenarios to appear in renderer pipeline invalidation", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "svg",
+      rendererTechnique: {
+        exportRenderer: "svg",
+        fidelityRisks: ["timeline playback must preserve vector motion"],
+        performanceRisks: ["timeline playback can jank at high density"],
+        previewRenderer: "svg",
+        productRepresentation: "vector",
+        rendererStrategy: "svg",
+        rendererWorkload: "vector-output",
+        sourceRepresentation: "procedural-data",
+        whyNotAlternativeStrategies: ["svg preserves semantic vector output"],
+      },
+      rendererWorkload: "vector-output",
+      rendererPipeline: {
+        ...createAnimatedVectorRendererPipeline(),
+        interactionInvalidation: createAnimatedVectorRendererPipeline().interactionInvalidation.filter(
+          (entry) => entry.interaction !== "timeline-playback",
+        ),
+      },
+      scenarios: [
+        ...createTextRendererScenarios(),
+        {
+          automated: true,
+          automatedTestName: "perf: timeline playback stays smooth",
+          browser: true,
+          browserTestName: "browser perf: timeline playback stays smooth",
+          budget: { maxFrameGapMs: 80, maxLongTaskMs: 80 },
+          expectedObservable: "Timeline playback advances without blocking frames.",
+          fixture: "timeline playback fixture",
+          id: "timeline-playback",
+          interaction: "timeline-playback",
+          stress: true,
+          stressFixture: createCombinedRendererStressFixture(),
+          target: "timeline.currentTime",
+          uiSelector: '[data-slot="timeline-playback-handle"]',
+          workload: false,
+        },
+      ],
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      "Performance scenario timeline-playback exercises timeline-playback, so rendererPipeline.interactionInvalidation must declare that interaction.",
+    );
+  });
+
+  it("validates timeline scrub scenarios through renderer pipeline invalidation", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "svg",
+      rendererTechnique: {
+        exportRenderer: "svg",
+        fidelityRisks: ["timeline scrub must preserve vector motion"],
+        performanceRisks: ["timeline scrub can jank at high density"],
+        previewRenderer: "svg",
+        productRepresentation: "vector",
+        rendererStrategy: "svg",
+        rendererWorkload: "vector-output",
+        sourceRepresentation: "procedural-data",
+        whyNotAlternativeStrategies: ["svg preserves semantic vector output"],
+      },
+      rendererWorkload: "vector-output",
+      rendererPipeline: createAnimatedVectorRendererPipeline(),
+      scenarios: [
+        ...createTextRendererScenarios(),
+        {
+          automated: true,
+          automatedTestName: "perf: timeline scrub stays responsive",
+          browser: true,
+          browserTestName: "browser perf: timeline scrub stays responsive",
+          budget: { maxFrameGapMs: 80, maxInteractionMs: 500, maxLongTaskMs: 80 },
+          expectedObservable: "Timeline scrub updates output without blocking frames.",
+          fixture: "timeline scrub fixture",
+          id: "timeline-scrub",
+          interaction: "timeline-scrub",
+          stress: true,
+          stressFixture: createCombinedRendererStressFixture(),
+          target: "timeline.currentTime",
+          uiSelector: '[data-slot="timeline-playback-handle"]',
+          workload: false,
+        },
+      ],
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toEqual([]);
+  });
+
+  it("requires timeline performance scenarios to name the real timeline UI", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "svg",
+      rendererTechnique: {
+        exportRenderer: "svg",
+        fidelityRisks: ["timeline scrub must preserve vector motion"],
+        performanceRisks: ["timeline scrub can jank at high density"],
+        previewRenderer: "svg",
+        productRepresentation: "vector",
+        rendererStrategy: "svg",
+        rendererWorkload: "vector-output",
+        sourceRepresentation: "procedural-data",
+        whyNotAlternativeStrategies: ["svg preserves semantic vector output"],
+      },
+      rendererWorkload: "vector-output",
+      rendererPipeline: createAnimatedVectorRendererPipeline(),
+      scenarios: [
+        ...createTextRendererScenarios(),
+        {
+          automated: true,
+          automatedTestName: "perf: timeline scrub stays responsive",
+          browser: true,
+          browserTestName: "browser perf: timeline scrub stays responsive",
+          budget: { maxFrameGapMs: 80, maxInteractionMs: 500, maxLongTaskMs: 80 },
+          expectedObservable: "Timeline scrub updates output without blocking frames.",
+          fixture: "timeline scrub fixture",
+          id: "timeline-scrub",
+          interaction: "timeline-scrub",
+          stress: true,
+          stressFixture: createCombinedRendererStressFixture(),
+          target: "timeline.currentTime",
+          workload: false,
+        },
+      ],
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toContain(
+      "timeline-scrub timeline-scrub scenario must declare controlLabel or uiSelector for its real browser interaction.",
+    );
+  });
+
+  it("validates mask drag scenarios through renderer pipeline invalidation", () => {
+    const config = defineToolcraftPerformance({
+      rendererStrategy: "svg",
+      rendererTechnique: {
+        exportRenderer: "svg",
+        fidelityRisks: ["mask handles must stay aligned with vector output"],
+        performanceRisks: ["dragging a mask handle can rebuild output too often"],
+        previewRenderer: "svg",
+        productRepresentation: "vector",
+        rendererStrategy: "svg",
+        rendererWorkload: "vector-output",
+        sourceRepresentation: "procedural-data",
+        whyNotAlternativeStrategies: ["svg preserves semantic handle geometry"],
+      },
+      rendererWorkload: "vector-output",
+      rendererPipeline: {
+        ...createAnimatedVectorRendererPipeline(),
+        interactionInvalidation: [
+          ...createAnimatedVectorRendererPipeline().interactionInvalidation,
+          {
+            interaction: "mask-drag",
+            invalidates: ["animation-composite"],
+            mustNotInvalidate: ["vector-build"],
+            targets: ["mask.anchor"],
+          },
+        ],
+      },
+      scenarios: [
+        ...createTextRendererScenarios(),
+        {
+          automated: true,
+          automatedTestName: "perf: mask drag stays responsive",
+          browser: true,
+          browserTestName: "browser perf: mask drag stays responsive",
+          budget: { maxFrameGapMs: 80, maxInteractionMs: 500, maxLongTaskMs: 80 },
+          expectedObservable: "Dragging the mask handle updates output without blocking frames.",
+          fixture: "mask drag fixture",
+          id: "mask-drag",
+          interaction: "mask-drag",
+          stress: true,
+          stressFixture: createCombinedRendererStressFixture(),
+          target: "mask.anchor",
+          uiSelector: '[data-toolcraft-canvas-handle][data-testid="mask-anchor"]',
+          workload: false,
+        },
+      ],
+      usesCustomRenderer: true,
+      workloadTargets: ["render.density"],
+    });
+
+    expect(validateToolcraftPerformanceCoverage(testSchema, config)).toEqual([]);
+  });
+});