@pixel-point/toolcraft 0.0.14 → 0.0.15

package/templates/starter/src/app/starter-acceptance.product-output-export.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, it } from "vitest";
+
+import { starterProductReadiness, starterTransferMode } from "./starter-acceptance";
+import {
+  textLooksLikePngExport,
+  textLooksLikeVideoExport,
+} from "./starter-acceptance.export-test-utils";
+import {
+  getControlOptionValues,
+  getSchemaBackgroundControlTargets,
+  getSchemaImageExportSection,
+  getSchemaPanelActionSearchTexts,
+  getSchemaVideoExportSection,
+  getSectionControlByTarget,
+  getSectionControlIdByTarget,
+  schemaHasProductSurface,
+} from "./starter-acceptance.schema-test-utils";
+import { schemaRequiresVideoExport } from "./starter-acceptance.video-export-test-utils";
+import { starterSchema } from "./starter-schema";
+
+describe("Toolcraft output export acceptance contract", () => {
+  it("requires product output apps to expose export actions in the sticky footer", () => {
+    if (starterProductReadiness.mode !== "product" && !schemaHasProductSurface()) {
+      return;
+    }
+
+    const panelActionTexts = getSchemaPanelActionSearchTexts();
+    const backgroundColorTargets = getSchemaBackgroundControlTargets(new Set(["color"]));
+    const backgroundToggleTargets = getSchemaBackgroundControlTargets(
+      new Set(["checkbox", "select", "segmented", "switch"]),
+    );
+
+    expect(
+      panelActionTexts.length,
+      "Product apps must define panelActions in the controls panel sticky footer.",
+    ).toBeGreaterThan(0);
+    expect(
+      panelActionTexts.some(textLooksLikePngExport),
+      "Every product app must expose Export PNG or Download PNG through panelActions.",
+    ).toBe(true);
+    expect(
+      backgroundColorTargets.length,
+      "Every product app with Export PNG must expose a user-facing background color control.",
+    ).toBeGreaterThan(0);
+    expect(
+      backgroundToggleTargets.length,
+      'Every product app with Export PNG must expose export.includeBackground in the required "Background" section as a Switch labeled "Include".',
+    ).toBeGreaterThan(0);
+
+    const imageExportSection = getSchemaImageExportSection();
+    const imageFormatControl = getSectionControlByTarget(
+      imageExportSection,
+      "export.image.format",
+    );
+    const imageResolutionControl = getSectionControlByTarget(
+      imageExportSection,
+      "export.image.resolution",
+    );
+    const imageFormatOptionValues = getControlOptionValues(imageFormatControl);
+    const imageResolutionOptionValues = getControlOptionValues(imageResolutionControl);
+    const imageFormatControlId = getSectionControlIdByTarget(
+      imageExportSection,
+      "export.image.format",
+    );
+    const imageResolutionControlId = getSectionControlIdByTarget(
+      imageExportSection,
+      "export.image.resolution",
+    );
+    const imageExportHasInlinePair =
+      imageFormatControlId === undefined || imageResolutionControlId === undefined
+        ? false
+        : imageExportSection?.layoutGroups?.some(
+            (group) =>
+              group.layout === "inline" &&
+              group.columns === 2 &&
+              group.controls.includes(imageFormatControlId) &&
+              group.controls.includes(imageResolutionControlId),
+          ) === true;
+
+    expect(
+      imageExportSection,
+      'Apps with Export PNG must expose image settings in a separate controls section titled "Image Export".',
+    ).toBeDefined();
+    expect(
+      imageFormatControl,
+      'The separate "Image Export" section must include a format control with target "export.image.format".',
+    ).toBeDefined();
+    expect(
+      imageFormatControl?.type,
+      "Image Export format must use the same Select/dropdown structure as Video Export.",
+    ).toBe("select");
+    expect(
+      imageFormatOptionValues,
+      'Image format options must include "png" and "jpg".',
+    ).toEqual(expect.arrayContaining(["png", "jpg"]));
+    expect(
+      imageFormatControl?.defaultValue,
+      'Image format must default to "png".',
+    ).toBe("png");
+    expect(
+      imageResolutionControl,
+      'The separate "Image Export" section must include a resolution control with target "export.image.resolution".',
+    ).toBeDefined();
+    expect(
+      imageResolutionControl?.type,
+      "Image Export resolution must use the same Select/dropdown structure as Video Export.",
+    ).toBe("select");
+    expect(
+      imageResolutionOptionValues,
+      'Image resolution options must include "2k", "4k", and "8k".',
+    ).toEqual(expect.arrayContaining(["2k", "4k", "8k"]));
+    expect(
+      imageResolutionControl?.defaultValue,
+      'Image resolution must default to "4k".',
+    ).toBe("4k");
+    expect(
+      imageExportHasInlinePair,
+      "Image Export format and resolution must render as a compact inline pair.",
+    ).toBe(true);
+    if (!schemaRequiresVideoExport(starterSchema, starterTransferMode)) {
+      return;
+    }
+
+    const videoExportSection = getSchemaVideoExportSection();
+    const videoFormatControl = getSectionControlByTarget(
+      videoExportSection,
+      "export.video.format",
+    );
+    const videoResolutionControl = getSectionControlByTarget(
+      videoExportSection,
+      "export.video.resolution",
+    );
+    const videoFormatOptionValues = getControlOptionValues(videoFormatControl);
+    const videoResolutionOptionValues = getControlOptionValues(videoResolutionControl);
+    expect(
+      panelActionTexts.some(textLooksLikeVideoExport),
+      "Animated product apps must expose Export Video through panelActions in addition to Export PNG.",
+    ).toBe(true);
+    expect(
+      panelActionTexts.length,
+      "Animated product apps need separate footer delivery actions for Export Video and Export PNG.",
+    ).toBeGreaterThanOrEqual(2);
+    expect(
+      videoExportSection,
+      'Animated product apps with Export Video must expose video settings in a separate controls section titled "Video Export".',
+    ).toBeDefined();
+    expect(
+      videoFormatControl,
+      'The separate "Video Export" section must include a format control with target "export.video.format".',
+    ).toBeDefined();
+    expect(
+      ["select", "segmented"],
+      "Video format must be a Select or Segmented control so the user chooses a supported container instead of typing a freeform value.",
+    ).toContain(videoFormatControl?.type);
+    expect(
+      videoFormatOptionValues,
+      'Video format options must include safe browser baseline choices: "webm" and "mp4".',
+    ).toEqual(expect.arrayContaining(["webm", "mp4"]));
+    expect(
+      videoResolutionControl,
+      'The separate "Video Export" section must include a resolution control with target "export.video.resolution".',
+    ).toBeDefined();
+    expect(
+      ["select"],
+      "Video resolution must be a Select control with explicit output-size choices.",
+    ).toContain(videoResolutionControl?.type);
+    expect(
+      videoResolutionOptionValues,
+      'Video resolution options must include "current" and "4k".',
+    ).toEqual(expect.arrayContaining(["current", "4k"]));
+    expect(
+      videoResolutionControl?.defaultValue,
+      'Video resolution must default to "current".',
+    ).toBe("current");
+    expect(
+      videoFormatControl?.defaultValue,
+      'Video format must default to "mp4".',
+    ).toBe("mp4");
+    const videoFormatControlId = getSectionControlIdByTarget(
+      videoExportSection,
+      "export.video.format",
+    );
+    const videoResolutionControlId = getSectionControlIdByTarget(
+      videoExportSection,
+      "export.video.resolution",
+    );
+    const videoExportHasInlinePair =
+      videoFormatControlId === undefined || videoResolutionControlId === undefined
+        ? false
+        : videoExportSection?.layoutGroups?.some(
+            (group) =>
+              group.layout === "inline" &&
+              group.controls.includes(videoFormatControlId) &&
+              group.controls.includes(videoResolutionControlId),
+          ) === true;
+
+    expect(
+      videoExportHasInlinePair,
+      "Video Export format and resolution must render as a compact inline pair unless a documented fit fallback is used.",
+    ).toBe(true);
+  });
+});

package/templates/starter/src/app/starter-acceptance.product-readiness-rules.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+
+import { isNeutralTemplateProject } from "./starter-acceptance.product-readiness-test-utils";
+
+describe("Toolcraft product readiness rules", () => {
+  it("does not classify a generated app named starter as the source template", () => {
+    expect(
+      isNeutralTemplateProject({
+        hasGeneratedManifest: true,
+        projectName: "starter",
+      }),
+    ).toBe(false);
+  });
+});

package/templates/starter/src/app/starter-acceptance.product-readiness-test-utils.ts

@@ -0,0 +1,25 @@
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const appDir = dirname(fileURLToPath(import.meta.url));
+const projectDir = join(appDir, "../..");
+
+export type NeutralTemplateProjectSignals = {
+  hasGeneratedManifest: boolean;
+  projectName: string;
+};
+
+export function isNeutralTemplateProject(
+  signals: NeutralTemplateProjectSignals = {
+    hasGeneratedManifest: existsSync(
+      join(projectDir, "src/toolcraft/.toolcraft-manifest.json"),
+    ),
+    projectName: basename(projectDir),
+  },
+): boolean {
+  return (
+    !signals.hasGeneratedManifest &&
+    new Set(["starter", "toolcraft-template"]).has(signals.projectName)
+  );
+}

package/templates/starter/src/app/starter-acceptance.product-readiness.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  starterProductReadiness,
+  starterTransferMode,
+} from "./starter-acceptance";
+import { isNeutralTemplateProject } from "./starter-acceptance.product-readiness-test-utils";
+import { schemaHasProductSurface } from "./starter-acceptance.schema-test-utils";
+import { starterSchema } from "./starter-schema";
+
+describe("Toolcraft product readiness", () => {
+  it("defaults generated apps to new Toolcraft assembly mode", () => {
+    if (starterProductReadiness.mode !== "starter") {
+      return;
+    }
+
+    expect(starterTransferMode).toEqual({
+      animationIntent: { mode: "none" },
+      mode: "new-toolcraft-app",
+    });
+  });
+
+  it("allows neutral readiness only for the source starter/template folder", () => {
+    if (starterProductReadiness.mode === "product") {
+      expect(starterProductReadiness.productName.trim()).not.toBe("");
+      expect(starterProductReadiness.productSummary.trim()).not.toBe("");
+      expect(starterProductReadiness.requestedBehavior.trim()).not.toBe("");
+      expect(
+        schemaHasProductSurface(),
+        "Product readiness requires product surface: controls, layers, timeline, canvasContent, or acceptance coverage.",
+      ).toBe(true);
+      expect(
+        starterSchema.panels.controls,
+        "Generated product apps must define a controls panel so runtime Setup, product controls, background, export settings, and sticky export actions are visible.",
+      ).toBeTruthy();
+      expect(starterSchema.panels.controls?.sections[0]?.title).toBe("Setup");
+      return;
+    }
+
+    expect(starterProductReadiness.reason.trim()).not.toBe("");
+    expect(
+      isNeutralTemplateProject(),
+      "Renamed/generated product folders must switch product readiness from starter to product so an empty template cannot pass as an implemented app.",
+    ).toBe(true);
+    expect(
+      schemaHasProductSurface(),
+      "Neutral starter readiness must not be used after adding product controls, timeline, layers, canvasContent, or acceptance coverage.",
+    ).toBe(false);
+  });
+});

package/templates/starter/src/app/starter-acceptance.product-worklog.test.ts

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+import { starterProductReadiness } from "./starter-acceptance";
+import { schemaHasProductSurface } from "./starter-acceptance.schema-test-utils";
+import {
+  agentWorklogPath,
+  getAgentWorklogValidationErrors,
+} from "./starter-acceptance.worklog-test-utils";
+import { validateToolcraftPerformanceReceipt } from "../../scripts/toolcraft-verification-receipt.mjs";
+
+const projectDir = join(dirname(fileURLToPath(import.meta.url)), "../..");
+
+describe("Toolcraft product worklog", () => {
+  it("requires product apps to replace the starter worklog with decision evidence", async () => {
+    if (starterProductReadiness.mode !== "product" && !schemaHasProductSurface()) {
+      return;
+    }
+
+    expect(existsSync(agentWorklogPath)).toBe(true);
+    expect(getAgentWorklogValidationErrors(readFileSync(agentWorklogPath, "utf8"))).toEqual([]);
+    expect(await validateToolcraftPerformanceReceipt({ rootDir: projectDir })).toEqual([]);
+  });
+});

package/templates/starter/src/app/starter-acceptance.range-slider-rules.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+import { defineToolcraft } from "@repo/toolcraft-runtime";
+
+import { validateContractAcceptance } from "./starter-acceptance.contract-fixtures";
+import { makeControlAcceptance } from "./starter-acceptance.test-utils";
+
+describe("starter acceptance range slider rules", () => {
+  it("rejects range slider defaults where lower and upper start equal", () => {
+    const schema = defineToolcraft({
+      canvas: { enabled: true },
+      panels: {
+        controls: {
+          sections: [
+            {
+              controls: {
+                opacityRange: {
+                  defaultValue: [0, 0],
+                  label: "Opacity",
+                  max: 100,
+                  min: 0,
+                  step: 1,
+                  target: "field.opacityRange",
+                  type: "rangeSlider",
+                  unit: "%",
+                },
+              },
+              title: "Field",
+            },
+          ],
+          title: "Controls",
+        },
+      },
+    });
+
+    expect(
+      validateContractAcceptance({
+        schema: schema,
+        acceptance: [
+          {
+            automated: true,
+            automatedTestName: "opacity range lower and upper change field output",
+            browser: true,
+            browserTestName: "browser: opacity range lower and upper change field output",
+            componentType: "rangeSlider",
+            controlPartCoverage: ["rangeSlider.lower", "rangeSlider.upper"],
+            evidence: "product-output",
+            expectedObservable: "Changing the lower and upper opacity handles changes field alpha output.",
+            fixture: "field opacity range fixture",
+            id: "field.opacityRange",
+            kind: "control",
+            target: "field.opacityRange",
+            userAction: "Drag both Opacity handles.",
+          },
+        ],
+      }),
+    ).toEqual(
+      expect.arrayContaining([
+        "Field / opacityRange (field.opacityRange) rangeSlider defaultValue must start with different lower and upper values so the two-thumb control does not collapse into a single-value slider.",
+      ]),
+    );
+  });
+
+  it("rejects inline layout groups that include range sliders", () => {
+    const schema = defineToolcraft({
+      canvas: { enabled: true },
+      panels: {
+        controls: {
+          sections: [
+            {
+              controls: {
+                opacityRange: {
+                  defaultValue: [10, 80],
+                  label: "Opacity",
+                  max: 100,
+                  min: 0,
+                  step: 1,
+                  target: "field.opacityRange",
+                  type: "rangeSlider",
+                  unit: "%",
+                },
+                speed: {
+                  defaultValue: 1,
+                  label: "Speed",
+                  max: 5,
+                  min: 0,
+                  step: 0.1,
+                  target: "field.speed",
+                  type: "slider",
+                },
+              },
+              layoutGroups: [
+                {
+                  columns: 2,
+                  controls: ["opacityRange", "speed"],
+                  layout: "inline",
+                },
+              ],
+              title: "Field",
+            },
+          ],
+          title: "Controls",
+        },
+      },
+    });
+
+    expect(
+      validateContractAcceptance({
+        schema: schema,
+        acceptance: [
+          {
+            automated: true,
+            automatedTestName: "opacity range lower and upper change field output",
+            browser: true,
+            browserTestName: "browser: opacity range lower and upper change field output",
+            componentType: "rangeSlider",
+            controlPartCoverage: ["rangeSlider.lower", "rangeSlider.upper"],
+            evidence: "product-output",
+            expectedObservable: "Changing the lower and upper opacity handles changes field alpha output.",
+            fixture: "field opacity range fixture",
+            id: "field.opacityRange",
+            kind: "control",
+            target: "field.opacityRange",
+            userAction: "Drag both Opacity handles.",
+          },
+          {
+            automated: true,
+            automatedTestName: "speed changes field output",
+            browser: true,
+            browserTestName: "browser: speed changes field output",
+            componentType: "slider",
+            evidence: "product-output",
+            expectedObservable: "Changing Speed changes field animation output.",
+            fixture: "field speed fixture",
+            id: "field.speed",
+            kind: "control",
+            target: "field.speed",
+            userAction: "Drag the Speed slider.",
+          },
+        ],
+      }),
+    ).toEqual(
+      expect.arrayContaining([
+        'Field layoutGroups inline row "opacityRange, speed" includes rangeSlider opacityRange. RangeSlider is a full-width two-thumb control and must not share a row with another slider or range slider.',
+      ]),
+    );
+  });
+});

package/templates/starter/src/app/starter-acceptance.reference-custom-timeline.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  contractAcceptanceFixture,
+  contractSchemaFixture,
+  validateContractAcceptance,
+} from "./starter-acceptance.contract-fixtures";
+import {
+  makeReferenceFeatureInventory,
+  referenceStudyEvidence,
+} from "./starter-acceptance.reference-test-utils";
+
+describe("starter acceptance custom reference timeline contract", () => {
+  it("rejects downgrading custom reference timeline behavior to Toolcraft playback", () => {
+    expect(
+      validateContractAcceptance({
+        schema: contractSchemaFixture,
+        acceptance: contractAcceptanceFixture,
+        transferMode: {
+          behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
+          mode: "reference-runtime-clone",
+          referenceName: "legacy state timeline",
+          referenceTimeline: {
+            behaviorCoverage: ["state-jump", "trim-range"],
+            mode: "toolcraft-playback",
+          },
+          sourceOfTruth: "reference-runtime",
+        },
+      }),
+    ).toEqual(
+      expect.arrayContaining([
+        'referenceTimeline mode "toolcraft-playback" cannot preserve custom reference timeline behavior "state-jump". Use mode "custom-reference-timeline" and browser-backed referenceTimelineCoverage instead.',
+        'referenceTimeline mode "toolcraft-playback" cannot preserve custom reference timeline behavior "trim-range". Use mode "custom-reference-timeline" and browser-backed referenceTimelineCoverage instead.',
+        'referenceTimeline behaviorCoverage "state-jump" is missing an acceptance entry with referenceTimelineCoverage "state-jump".',
+        'referenceTimeline behaviorCoverage "trim-range" is missing an acceptance entry with referenceTimelineCoverage "trim-range".',
+      ]),
+    );
+  });
+
+  it("accepts custom reference timeline behavior only when it is test-backed", () => {
+    expect(
+      validateContractAcceptance({
+        schema: contractSchemaFixture,
+        acceptance: [
+          ...contractAcceptanceFixture,
+          {
+            automated: true,
+            automatedTestName: "reference canvas size matches legacy renderer",
+            browser: true,
+            browserTestName: "browser: reference canvas size matches legacy renderer",
+            componentType: "custom-renderer",
+            evidence: "rendered-pixels",
+            expectedObservable: "The Toolcraft renderer uses the same output dimensions as the reference runtime.",
+            fixture: "legacy renderer fixture",
+            id: "reference.canvasSizing",
+            kind: "runtime",
+            referenceCoverage: "canvas-sizing",
+            userAction: "Render the reference-sized output.",
+          },
+          {
+            automated: true,
+            automatedTestName: "reference control mapping preserves legacy output",
+            browser: true,
+            browserTestName: "browser: reference control mapping preserves legacy output",
+            componentType: "custom-renderer",
+            evidence: "product-output",
+            expectedObservable: "Changing each mapped control updates the same renderer parameter as the reference app.",
+            fixture: "legacy controls fixture",
+            id: "reference.controlMapping",
+            kind: "runtime",
+            referenceCoverage: "control-mapping",
+            userAction: "Change mapped controls and compare reference output behavior.",
+          },
+          {
+            automated: true,
+            automatedTestName: "reference renderer state preserves legacy lifecycle",
+            browser: true,
+            browserTestName: "browser: reference renderer state preserves legacy lifecycle",
+            componentType: "custom-renderer",
+            evidence: "product-output",
+            expectedObservable: "The renderer preserves the reference runtime mutable state lifecycle across frames.",
+            fixture: "legacy renderer state fixture",
+            id: "reference.rendererState",
+            kind: "runtime",
+            referenceCoverage: "renderer-state",
+            userAction: "Run the renderer across frames and compare stateful output.",
+          },
+          {
+            automated: true,
+            automatedTestName: "reference timeline state buttons preserve legacy jumps",
+            browser: true,
+            browserTestName: "browser: reference timeline state buttons preserve legacy jumps",
+            componentType: "custom-timeline",
+            evidence: "timeline-output",
+            expectedObservable: "Clicking each reference timeline state renders the matching legacy state.",
+            fixture: "legacy state timeline fixture",
+            id: "reference.timeline.stateJump",
+            kind: "runtime",
+            referenceTimelineCoverage: "state-jump",
+            userAction: "Click each reference timeline state button.",
+          },
+          {
+            automated: true,
+            automatedTestName: "reference timeline trim handles preserve legacy range",
+            browser: true,
+            browserTestName: "browser: reference timeline trim handles preserve legacy range",
+            componentType: "custom-timeline",
+            evidence: "timeline-output",
+            expectedObservable: "Dragging trim handles changes the same start/end state range as the reference.",
+            fixture: "legacy trim timeline fixture",
+            id: "reference.timeline.trimRange",
+            kind: "runtime",
+            referenceTimelineCoverage: "trim-range",
+            userAction: "Drag reference timeline trim handles.",
+          },
+        ],
+        transferMode: {
+          behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
+          mode: "reference-runtime-clone",
+          referenceFeatureInventory: makeReferenceFeatureInventory([
+            {
+              acceptanceId: "reference.timeline.stateJump",
+              behaviorEvidence: "Clicked the reference timeline state buttons and observed discrete renderer state jumps.",
+              featureName: "Timeline state jump",
+              id: "timeline-state-jump",
+              referenceBehavior: "The reference timeline state buttons jump to discrete renderer states.",
+              sourceEvidence: "Inspected reference timeline state button handlers.",
+              status: "ported",
+              toolcraftMapping: "The custom reference timeline control keeps the same state-jump behavior.",
+            },
+            {
+              acceptanceId: "reference.timeline.trimRange",
+              behaviorEvidence: "Dragged the reference trim handles and observed the active playback/render range change.",
+              featureName: "Timeline trim range",
+              id: "timeline-trim-range",
+              referenceBehavior: "The reference trim handles edit the active playback/render range.",
+              sourceEvidence: "Inspected reference trim handle drag behavior.",
+              status: "ported",
+              toolcraftMapping: "The custom reference timeline control keeps the same trim range behavior.",
+            },
+          ]),
+          referenceName: "legacy state timeline",
+          referenceStudy: referenceStudyEvidence,
+          referenceTimeline: {
+            behaviorCoverage: ["state-jump", "trim-range"],
+            mode: "custom-reference-timeline",
+          },
+          sourceOfTruth: "reference-runtime",
+        },
+      }),
+    ).toEqual([]);
+  });
+
+  it("rejects reference coverage entries outside reference-runtime-clone mode", () => {
+    expect(
+      validateContractAcceptance({
+        schema: contractSchemaFixture,
+        acceptance: [
+          ...contractAcceptanceFixture,
+          {
+            automated: true,
+            automatedTestName: "reference renderer state preserves legacy lifecycle",
+            browser: true,
+            browserTestName: "browser: reference renderer state preserves legacy lifecycle",
+            componentType: "custom-renderer",
+            evidence: "product-output",
+            expectedObservable: "The renderer preserves the reference runtime mutable state lifecycle across frames.",
+            fixture: "legacy renderer state fixture",
+            id: "reference.rendererState",
+            kind: "runtime",
+            referenceCoverage: "renderer-state",
+            userAction: "Run the renderer across frames and compare stateful output.",
+          },
+          {
+            automated: true,
+            automatedTestName: "reference timeline trim handles preserve legacy range",
+            browser: true,
+            browserTestName: "browser: reference timeline trim handles preserve legacy range",
+            componentType: "custom-timeline",
+            evidence: "timeline-output",
+            expectedObservable: "Dragging trim handles changes the same start/end state range as the reference.",
+            fixture: "legacy trim timeline fixture",
+            id: "reference.timeline.trimRange",
+            kind: "runtime",
+            referenceTimelineCoverage: "trim-range",
+            userAction: "Drag reference timeline trim handles.",
+          },
+        ],
+      }),
+    ).toEqual(
+      expect.arrayContaining([
+        'reference.rendererState declares referenceCoverage "renderer-state" but transferMode is not "reference-runtime-clone".',
+        'reference.timeline.trimRange declares referenceTimelineCoverage "trim-range" but transferMode is not "reference-runtime-clone".',
+      ]),
+    );
+  });
+});