@pixel-point/toolcraft 0.0.15 → 0.0.16

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

@@ -1,325 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,201 +0,0 @@
-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([]);
-  });
-});