@pixel-point/toolcraft 0.0.14 → 0.0.15

package/templates/starter/src/app/acceptance/custom-controls.ts

@@ -0,0 +1,140 @@
+import type { ToolcraftControlSchema } from "@repo/toolcraft-runtime";
+
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftCustomControlCapability,
+  ToolcraftCustomControlCoverage,
+} from "./types";
+import { builtInToolcraftControlTypeValues } from "./types";
+
+const builtInToolcraftControlTypes = new Set<string>(
+  builtInToolcraftControlTypeValues,
+);
+
+export const requiredCustomControlCoverage: readonly ToolcraftCustomControlCoverage[] = [
+  "built-in-gap",
+  "kit-primitives",
+  "minimal-ui",
+  "product-output",
+  "runtime-state",
+];
+
+export function isCustomToolcraftControl(control: ToolcraftControlSchema): boolean {
+  return !builtInToolcraftControlTypes.has(control.type);
+}
+
+const customControlCapabilities = new Set<ToolcraftCustomControlCapability>([
+  "collection",
+  "commands",
+  "custom-interaction",
+  "custom-value-model",
+  "custom-visualization",
+  "reorder",
+  "selection",
+]);
+
+export function getBuiltInFitCheckErrors(
+  label: string,
+  entry: ToolcraftComponentAcceptance,
+  control: ToolcraftControlSchema,
+): string[] {
+  const fitCheck = entry.builtInFitCheck;
+
+  if (!fitCheck) {
+    return [
+      `${label} is a custom control and must declare builtInFitCheck with checkedBuiltIns, closestBuiltIn, whyInsufficient, and productObservable.`,
+    ];
+  }
+
+  const errors: string[] = [];
+  const checkedBuiltIns = Array.isArray(fitCheck.checkedBuiltIns)
+    ? fitCheck.checkedBuiltIns
+    : [];
+  const capabilities = Array.isArray(fitCheck.capabilities)
+    ? fitCheck.capabilities
+    : [];
+
+  if (capabilities.length === 0) {
+    errors.push(
+      `${label} builtInFitCheck.capabilities must declare the product capabilities that require custom UI; prose labels are not capability evidence.`,
+    );
+  }
+
+  const unknownCapabilities = capabilities.filter(
+    (capability) => !customControlCapabilities.has(capability),
+  );
+  if (unknownCapabilities.length > 0) {
+    errors.push(
+      `${label} builtInFitCheck.capabilities contains unknown capabilities: ${unknownCapabilities.join(", ")}.`,
+    );
+  }
+  if (new Set(capabilities).size !== capabilities.length) {
+    errors.push(`${label} builtInFitCheck.capabilities must not contain duplicates.`);
+  }
+
+  if (checkedBuiltIns.length === 0) {
+    errors.push(
+      `${label} builtInFitCheck.checkedBuiltIns must name at least one checked built-in control.`,
+    );
+  }
+
+  const unknownCheckedBuiltIns = checkedBuiltIns.filter(
+    (builtIn) => !builtInToolcraftControlTypes.has(builtIn),
+  );
+
+  if (unknownCheckedBuiltIns.length > 0) {
+    errors.push(
+      `${label} builtInFitCheck.checkedBuiltIns contains unknown built-in controls: ${unknownCheckedBuiltIns.join(", ")}.`,
+    );
+  }
+
+  if (
+    fitCheck.closestBuiltIn !== "none" &&
+    !checkedBuiltIns.includes(fitCheck.closestBuiltIn)
+  ) {
+    errors.push(
+      `${label} builtInFitCheck.closestBuiltIn must be one of the checked built-ins or "none".`,
+    );
+  }
+
+  if (fitCheck.whyInsufficient.trim().length < 24) {
+    errors.push(
+      `${label} builtInFitCheck.whyInsufficient must explain why the closest built-in cannot express the product interaction.`,
+    );
+  }
+
+  if (fitCheck.productObservable.trim().length < 24) {
+    errors.push(
+      `${label} builtInFitCheck.productObservable must name the product output or side effect that proves the custom control is necessary.`,
+    );
+  }
+
+  if (
+    capabilities.some((capability) =>
+      ["collection", "reorder", "selection"].includes(capability),
+    ) &&
+    !checkedBuiltIns.includes("collectionActions")
+  ) {
+    errors.push(
+      `${label} builtInFitCheck.checkedBuiltIns must include collectionActions when the custom control owns a growable, removable, selectable, or reorderable runtime item set.`,
+    );
+  }
+
+  if (capabilities.includes("commands") && !checkedBuiltIns.includes("actions")) {
+    errors.push(
+      `${label} builtInFitCheck.checkedBuiltIns must include actions when the custom control exposes local command buttons such as add, remove, delete, duplicate, sort, normalize, or clear.`,
+    );
+  }
+
+  if (!capabilities.some((capability) =>
+    ["custom-interaction", "custom-value-model", "custom-visualization"].includes(
+      capability,
+    ),
+  )) {
+    errors.push(
+      `${label} builtInFitCheck.capabilities must include custom-interaction, custom-value-model, or custom-visualization; collection or command chrome alone is not enough to justify custom UI.`,
+    );
+  }
+
+  return errors;
+}

package/templates/starter/src/app/acceptance/inline-layout.ts

@@ -0,0 +1,192 @@
+import type {
+  ResolvedToolcraftAppSchema,
+  ToolcraftControlSchema,
+} from "@repo/toolcraft-runtime";
+
+import {
+  getControlLabelText,
+  isToolcraftProductSectionControl,
+} from "./controls";
+import { getToolcraftSectionLabel } from "./sections";
+import { getToolcraftLooseTargetPrefix } from "./semantic";
+
+const maxInlineSwitchLabelLength = 16;
+const maxInlineSwitchLabelWordCount = 2;
+
+function getInlineSwitchLabelText(
+  controlId: string,
+  control: ToolcraftControlSchema,
+): string {
+  if (control.label === false) {
+    return "";
+  }
+
+  const label = getControlLabelText(control).trim();
+
+  return label || controlId;
+}
+
+function isInlineSwitchLabelSafe(
+  controlId: string,
+  control: ToolcraftControlSchema,
+): boolean {
+  const label = getInlineSwitchLabelText(controlId, control);
+
+  if (!label) {
+    return true;
+  }
+
+  const wordCount = label.split(/\s+/u).filter(Boolean).length;
+
+  return label.length <= maxInlineSwitchLabelLength && wordCount <= maxInlineSwitchLabelWordCount;
+}
+
+function isBooleanControl(control: ToolcraftControlSchema | undefined): boolean {
+  return control?.type === "checkbox" || control?.type === "switch";
+}
+
+function controlsShareToolcraftTargetEntity(
+  firstControl: ToolcraftControlSchema,
+  secondControl: ToolcraftControlSchema,
+): boolean {
+  const firstPrefix = getToolcraftLooseTargetPrefix(firstControl.target);
+  const secondPrefix = getToolcraftLooseTargetPrefix(secondControl.target);
+
+  return Boolean(firstPrefix && firstPrefix === secondPrefix);
+}
+
+export function sectionHasInlineLayoutGroupForPair(
+  section: NonNullable<ResolvedToolcraftAppSchema["panels"]["controls"]>["sections"][number],
+  firstControlId: string,
+  secondControlId: string,
+): boolean {
+  return (section.layoutGroups ?? []).some(
+    (layoutGroup) =>
+      layoutGroup.layout === "inline" &&
+      layoutGroup.columns === 2 &&
+      layoutGroup.controls.length === 2 &&
+      layoutGroup.controls.includes(firstControlId) &&
+      layoutGroup.controls.includes(secondControlId),
+  );
+}
+
+export function getToolcraftInlineLayoutErrors(
+  schema: ResolvedToolcraftAppSchema,
+): string[] {
+  const errors: string[] = [];
+
+  for (const [sectionIndex, section] of (schema.panels.controls?.sections ?? []).entries()) {
+    const sectionLabel = getToolcraftSectionLabel(section.title, sectionIndex);
+
+    for (const layoutGroup of section.layoutGroups ?? []) {
+      if (layoutGroup.layout !== "inline") {
+        continue;
+      }
+
+      const rangeSliderIds = layoutGroup.controls.filter(
+        (controlId) => section.controls[controlId]?.type === "rangeSlider",
+      );
+
+      if (rangeSliderIds.length > 0) {
+        errors.push(
+          `${sectionLabel} layoutGroups inline row "${layoutGroup.controls.join(", ")}" includes rangeSlider ${rangeSliderIds.join(", ")}. RangeSlider is a full-width two-thumb control and must not share a row with another slider or range slider.`,
+        );
+      }
+
+      const segmentedIds = layoutGroup.controls.filter(
+        (controlId) => section.controls[controlId]?.type === "segmented",
+      );
+
+      if (segmentedIds.length > 0) {
+        errors.push(
+          `${sectionLabel} layoutGroups inline row "${layoutGroup.controls.join(", ")}" includes segmented control ${segmentedIds.join(", ")}. Segmented is full-width and must not share a two-column or half-width row; use Select when a finite choice must fit beside another control.`,
+        );
+      }
+
+      const switchEntries = layoutGroup.controls
+        .map((controlId) => [controlId, section.controls[controlId]] as const)
+        .filter(
+          (entry): entry is readonly [string, ToolcraftControlSchema] =>
+            Boolean(entry[1]) && entry[1].type === "switch",
+        );
+      const booleanEntries = layoutGroup.controls
+        .map((controlId) => [controlId, section.controls[controlId]] as const)
+        .filter(
+          (entry): entry is readonly [string, ToolcraftControlSchema] =>
+            Boolean(entry[1]) && isBooleanControl(entry[1]),
+        );
+      const parameterEntries = layoutGroup.controls
+        .map((controlId) => [controlId, section.controls[controlId]] as const)
+        .filter(
+          (entry): entry is readonly [string, ToolcraftControlSchema] =>
+            Boolean(entry[1]) && !isBooleanControl(entry[1]),
+        );
+
+      if (switchEntries.length > 1) {
+        const unsafeSwitchLabels = switchEntries.filter(
+          ([controlId, control]) => !isInlineSwitchLabelSafe(controlId, control),
+        );
+
+        if (unsafeSwitchLabels.length > 0) {
+          errors.push(
+            `${sectionLabel} layoutGroups inline row "${layoutGroup.controls.join(", ")}" includes switch labels ${unsafeSwitchLabels.map(([controlId, control]) => `${controlId} "${getInlineSwitchLabelText(controlId, control)}"`).join(", ")} that are too long for a two-column toggle row. Switches share a row only when every visible label fits without truncation; shorten labels or stack them.`,
+          );
+        }
+      }
+
+      if (booleanEntries.length === 1 && parameterEntries.length === 1) {
+        const unsafeBooleanLabels = booleanEntries.filter(
+          ([controlId, control]) => !isInlineSwitchLabelSafe(controlId, control),
+        );
+
+        if (unsafeBooleanLabels.length > 0) {
+          errors.push(
+            `${sectionLabel} layoutGroups inline row "${layoutGroup.controls.join(", ")}" includes toggle label ${unsafeBooleanLabels.map(([controlId, control]) => `${controlId} "${getInlineSwitchLabelText(controlId, control)}"`).join(", ")} that is too long for a compact toggle-plus-parameter row. Keep the toggle label short, such as "Include" inside Background, or stack the controls.`,
+          );
+        }
+
+        const visibleParameterLabels = parameterEntries.filter(
+          ([, control]) => control.label !== false,
+        );
+
+        if (visibleParameterLabels.length > 0) {
+          errors.push(
+            `${sectionLabel} layoutGroups inline row "${layoutGroup.controls.join(", ")}" pairs a toggle with parameter labels ${visibleParameterLabels.map(([controlId, control]) => `${controlId} "${getControlLabelText(control)}"`).join(", ")}. In toggle-plus-parameter rows, the non-toggle parameter must use label false; if that label is needed, stack the controls instead.`,
+          );
+        }
+      }
+    }
+
+    const sectionControls = Object.entries(section.controls).filter(([, control]) =>
+      isToolcraftProductSectionControl(control),
+    );
+
+    for (let index = 0; index < sectionControls.length - 1; index += 1) {
+      const [firstControlId, firstControl] = sectionControls[index] ?? [];
+      const [secondControlId, secondControl] = sectionControls[index + 1] ?? [];
+
+      if (
+        !firstControlId ||
+        !secondControlId ||
+        !firstControl ||
+        !secondControl ||
+        firstControl.visibleWhen ||
+        secondControl.visibleWhen ||
+        !isBooleanControl(firstControl) ||
+        !isBooleanControl(secondControl) ||
+        !isInlineSwitchLabelSafe(firstControlId, firstControl) ||
+        !isInlineSwitchLabelSafe(secondControlId, secondControl) ||
+        !controlsShareToolcraftTargetEntity(firstControl, secondControl) ||
+        sectionHasInlineLayoutGroupForPair(section, firstControlId, secondControlId)
+      ) {
+        continue;
+      }
+
+      errors.push(
+        `${sectionLabel} has adjacent short toggle controls "${firstControlId}" and "${secondControlId}" for the same product entity "${getToolcraftLooseTargetPrefix(firstControl.target)}". Put them in a two-column inline layoutGroup so compact paired toggles share one row.`,
+      );
+    }
+  }
+
+  return errors;
+}

package/templates/starter/src/app/acceptance/media-upload.ts

@@ -0,0 +1,55 @@
+import type { ToolcraftControlSchema } from "@repo/toolcraft-runtime";
+
+import type { ToolcraftComponentAcceptance } from "./types";
+
+export function getFileDropLifecycleCoverageErrors(
+  label: string,
+  control: ToolcraftControlSchema,
+  entry: ToolcraftComponentAcceptance,
+  hasDefaultMediaAssets: boolean,
+): string[] {
+  const errors: string[] = [];
+  const coverage = new Set(entry.mediaLifecycleCoverage ?? []);
+
+  if (entry.evidence !== "media-lifecycle") {
+    errors.push(
+      `${label} fileDrop acceptance evidence must be "media-lifecycle" so upload, clear, and reset behavior cannot be replaced by generic product-output coverage.`,
+    );
+  }
+
+  if (!coverage.has("upload") || !coverage.has("remove") || !coverage.has("reset")) {
+    errors.push(
+      `${label} fileDrop acceptance must prove upload/import, clear/remove, and section or global reset restore default source media or remove uploaded source media when no default exists.`,
+    );
+  }
+
+  if (hasDefaultMediaAssets) {
+    if (!coverage.has("default-remove") || !coverage.has("default-reset")) {
+      errors.push(
+        `${label} fileDrop acceptance must prove predefined media.defaultAssets render as attached files, can be removed to an empty source/canvas state, and are restored by section or global Reset.`,
+      );
+    }
+  }
+
+  if (control.assetKind !== "file") {
+    if (
+      !coverage.has("rotate") ||
+      !coverage.has("flip") ||
+      !coverage.has("transform-output")
+    ) {
+      errors.push(
+        `${label} image fileDrop acceptance must prove rotate and flip actions update runtime media transform metadata and that preview, renderer, or export consumes the transform.`,
+      );
+    }
+  }
+
+  if (control.multiple === true) {
+    if (!coverage.has("reorder") || !coverage.has("order-output")) {
+      errors.push(
+        `${label} multiple fileDrop acceptance must prove thumbnail/file reorder updates runtime media order and that preview, renderer, or export consumes that order.`,
+      );
+    }
+  }
+
+  return errors;
+}

package/templates/starter/src/app/acceptance/output-background-rules.ts

@@ -0,0 +1,135 @@
+import { getControlLabelText } from "./controls";
+import {
+  getSearchableControlText,
+  type ToolcraftControlsSection,
+  type ToolcraftOutputExportFacts,
+} from "./output-export-model";
+import type { ToolcraftVisibleControl } from "./types";
+
+function schemaHasOutputBackgroundColorControl(
+  controls: readonly ToolcraftVisibleControl[],
+): boolean {
+  return controls.some((visibleControl) => {
+    const { control } = visibleControl;
+
+    if (control.type !== "color") {
+      return false;
+    }
+
+    return /\b(background|backdrop|scene|canvas)\b/i.test(
+      getSearchableControlText(visibleControl),
+    );
+  });
+}
+
+function schemaHasOutputBackgroundToggleControl(
+  controls: readonly ToolcraftVisibleControl[],
+): boolean {
+  return controls.some(isOutputBackgroundToggleControl);
+}
+
+export function isOutputBackgroundToggleControl(
+  visibleControl: ToolcraftVisibleControl,
+): boolean {
+  const { control } = visibleControl;
+
+  if (
+    control.type !== "switch" &&
+    control.type !== "checkbox" &&
+    control.type !== "select" &&
+    control.type !== "segmented"
+  ) {
+    return false;
+  }
+
+  return /\b(background|backdrop|transparent|transparency|alpha)\b/i.test(
+    getSearchableControlText(visibleControl),
+  );
+}
+
+function sectionHasEqualWidthOutputBackgroundRow(
+  section: ToolcraftControlsSection | undefined,
+  toggleControlId: string | undefined,
+  colorControlId: string | undefined,
+): boolean {
+  if (!section || !toggleControlId || !colorControlId) {
+    return false;
+  }
+
+  return (section.layoutGroups ?? []).some(
+    (layoutGroup) =>
+      layoutGroup.layout === "inline" &&
+      layoutGroup.columns === 2 &&
+      layoutGroup.controls.length === 2 &&
+      layoutGroup.controls[0] === toggleControlId &&
+      layoutGroup.controls[1] === colorControlId,
+  );
+}
+
+export function getToolcraftOutputBackgroundErrors({
+  controls,
+  facts,
+}: {
+  controls: readonly ToolcraftVisibleControl[];
+  facts: ToolcraftOutputExportFacts;
+}): string[] {
+  const errors: string[] = [];
+
+  if (!schemaHasOutputBackgroundColorControl(controls)) {
+    errors.push(
+      "Product apps with Export PNG must expose a user-facing background color control such as appearance.background or scene.background. Preview, PNG export, and video export must read that runtime value instead of hardcoding the product background.",
+    );
+  }
+
+  if (!facts.backgroundColorEntry) {
+    errors.push(
+      'The "Background" section must contain the renderer-owned background color control, such as appearance.background or scene.background.',
+    );
+  } else {
+    const [, backgroundColorControl] = facts.backgroundColorEntry;
+
+    if (backgroundColorControl.label !== false) {
+      errors.push(
+        'The background color control inside the required "Background" section must use label false; the section title already supplies the visible context.',
+      );
+    }
+  }
+
+  if (!schemaHasOutputBackgroundToggleControl(controls)) {
+    errors.push(
+      'Product apps with Export PNG must expose export.includeBackground inside the required "Background" section as a Switch labeled "Include". PNG export must pass that runtime value to createToolcraftPngExportCanvas includeBackground; live preview must use shouldIncludeToolcraftPreviewBackground(state); video export keeps the background.',
+    );
+  }
+
+  if (!facts.includeBackgroundEntry) {
+    errors.push(
+      'The "Background" section must contain export.includeBackground as the Include switch.',
+    );
+  } else {
+    const [, includeBackgroundControl] = facts.includeBackgroundEntry;
+
+    if (includeBackgroundControl.type !== "switch") {
+      errors.push('export.includeBackground must be a Switch control labeled "Include".');
+    }
+
+    if (getControlLabelText(includeBackgroundControl) !== "Include") {
+      errors.push(
+        'export.includeBackground must use the short visible label "Include"; the Background section title already supplies the rest of the context.',
+      );
+    }
+  }
+
+  if (
+    !sectionHasEqualWidthOutputBackgroundRow(
+      facts.backgroundSection,
+      facts.includeBackgroundEntry?.[0],
+      facts.backgroundColorEntry?.[0],
+    )
+  ) {
+    errors.push(
+      'The "Background" section must render export.includeBackground and the background color in one two-column inline layoutGroup, with Include on the left and the unlabeled background color on the right.',
+    );
+  }
+
+  return errors;
+}

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

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { defineToolcraft } from "@repo/toolcraft-runtime";
+
+import {
+  schemaHasPngExportPanelAction,
+  schemaHasVideoExportPanelAction,
+} from "./output-export-actions";
+
+function createOutputSchema() {
+  return defineToolcraft({
+    canvas: { enabled: true },
+    panels: {
+      controls: {
+        sections: [
+          {
+            controls: {
+              output: {
+                actions: [
+                  {
+                    label: "Guardar imagen",
+                    role: "export-image",
+                    value: "salida.imagen",
+                  },
+                  {
+                    label: "Guardar movimiento",
+                    role: "export-video",
+                    value: "salida.movimiento",
+                  },
+                ],
+                target: "salida.acciones",
+                type: "panelActions",
+              },
+            },
+            title: "Salida",
+          },
+        ],
+        title: "Controles",
+      },
+    },
+  });
+}
+
+describe("Toolcraft typed output action roles", () => {
+  it("detects image and video export without parsing labels or values", () => {
+    const schema = createOutputSchema();
+
+    expect(schemaHasPngExportPanelAction(schema)).toBe(true);
+    expect(schemaHasVideoExportPanelAction(schema)).toBe(true);
+  });
+
+  it("does not treat export-like prose as semantic output evidence", () => {
+    const schema = defineToolcraft({
+      canvas: { enabled: true },
+      panels: {
+        controls: {
+          sections: [
+            {
+              controls: {
+                output: {
+                  actions: [{ label: "Export PNG", value: "export.png" }],
+                  target: "actions.output",
+                  type: "panelActions",
+                },
+              },
+              title: "Output",
+            },
+          ],
+          title: "Controls",
+        },
+      },
+    });
+
+    expect(schemaHasPngExportPanelAction(schema)).toBe(false);
+    expect(schemaHasVideoExportPanelAction(schema)).toBe(false);
+  });
+});

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

@@ -0,0 +1,34 @@
+import type {
+  ResolvedToolcraftAppSchema,
+  ToolcraftActionSchema,
+} from "@repo/toolcraft-runtime";
+
+import { getControlActions } from "./actions";
+
+function actionLooksLikePngExport(action: ToolcraftActionSchema | string): boolean {
+  return typeof action !== "string" && action.role === "export-image";
+}
+
+function actionLooksLikeVideoExport(action: ToolcraftActionSchema | string): boolean {
+  return typeof action !== "string" && action.role === "export-video";
+}
+
+export function schemaHasPngExportPanelAction(schema: ResolvedToolcraftAppSchema): boolean {
+  return (schema.panels.controls?.sections ?? []).some((section) =>
+    Object.values(section.controls).some(
+      (control) =>
+        control.type === "panelActions" &&
+        getControlActions(control).some(actionLooksLikePngExport),
+    ),
+  );
+}
+
+export function schemaHasVideoExportPanelAction(schema: ResolvedToolcraftAppSchema): boolean {
+  return (schema.panels.controls?.sections ?? []).some((section) =>
+    Object.values(section.controls).some(
+      (control) =>
+        control.type === "panelActions" &&
+        getControlActions(control).some(actionLooksLikeVideoExport),
+    ),
+  );
+}

package/templates/starter/src/app/acceptance/output-export-layout-rules.ts

@@ -0,0 +1,46 @@
+import type { ToolcraftOutputExportFacts } from "./output-export-model";
+
+export function getToolcraftOutputExportLayoutErrors(
+  facts: ToolcraftOutputExportFacts,
+): string[] {
+  const errors: string[] = [];
+
+  if (!facts.backgroundSection) {
+    errors.push(
+      'Product apps with Export PNG must expose a separate controls section titled "Background" directly before the first export settings section.',
+    );
+  }
+
+  if (
+    facts.backgroundSectionIndex >= 0 &&
+    facts.expectedOutputSettingsIndex >= 0 &&
+    facts.backgroundSectionIndex !== facts.expectedOutputSettingsIndex - 1
+  ) {
+    errors.push(
+      'The "Background" controls section must sit directly before the first export settings section: Image Export when PNG export exists, otherwise Video Export.',
+    );
+  }
+
+  if (
+    facts.finalExportSettingsIndex >= 0 &&
+    facts.panelActionsSectionIndex >= 0 &&
+    facts.finalExportSettingsIndex !== facts.panelActionsSectionIndex - 1
+  ) {
+    errors.push(
+      'Export settings must sit directly above sticky footer actions: Image Export for still apps, or Video Export after Image Export for animated apps.',
+    );
+  }
+
+  if (
+    facts.hasVideoExportAction &&
+    facts.imageExportSectionIndex >= 0 &&
+    facts.videoExportSectionIndex >= 0 &&
+    facts.imageExportSectionIndex !== facts.videoExportSectionIndex - 1
+  ) {
+    errors.push(
+      'Animated apps with both Export PNG and Export Video must place Image Export immediately before Video Export.',
+    );
+  }
+
+  return errors;
+}