@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/starter/src/app/acceptance/export-artifact-coverage.ts

@@ -0,0 +1,113 @@
+import type {
+  ResolvedToolcraftAppSchema,
+  ToolcraftActionSchema,
+} from "@repo/toolcraft-runtime";
+
+import { getControlActions } from "./actions";
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftExportArtifactCoverage,
+} from "./types";
+
+const requiredCoverageByRole = {
+  "export-image": "all-required-image-export-behavior",
+  "export-video": "all-required-video-export-behavior",
+} as const satisfies Record<
+  "export-image" | "export-video",
+  ToolcraftExportArtifactCoverage
+>;
+
+function getCoverageValues(
+  entry: ToolcraftComponentAcceptance,
+): readonly ToolcraftExportArtifactCoverage[] {
+  if (!entry.exportArtifactCoverage) return [];
+  return typeof entry.exportArtifactCoverage === "string"
+    ? [entry.exportArtifactCoverage]
+    : entry.exportArtifactCoverage;
+}
+
+function isMediaExportAction(
+  action: ToolcraftActionSchema | string,
+): action is ToolcraftActionSchema & {
+  role: "export-image" | "export-video";
+} {
+  return (
+    typeof action !== "string" &&
+    (action.role === "export-image" || action.role === "export-video")
+  );
+}
+
+function collectMediaExportActions(schema: ResolvedToolcraftAppSchema) {
+  return (schema.panels.controls?.sections ?? []).flatMap((section) =>
+    Object.values(section.controls).flatMap((control) =>
+      control.type !== "panelActions" || !control.target
+        ? []
+        : getControlActions(control)
+            .filter(isMediaExportAction)
+            .map((action) => ({
+              requiredCoverage: requiredCoverageByRole[action.role],
+              role: action.role,
+              target: control.target,
+              value: action.value,
+            })),
+    ),
+  );
+}
+
+export function getToolcraftExportArtifactCoverageErrors({
+  acceptance,
+  schema,
+}: Readonly<{
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  schema: ResolvedToolcraftAppSchema;
+}>): string[] {
+  const errors: string[] = [];
+  const exportActions = collectMediaExportActions(schema);
+
+  for (const entry of acceptance) {
+    const coverage = getCoverageValues(entry);
+    if (coverage.length === 0) continue;
+    if (entry.evidence !== "exported-bytes") {
+      errors.push(
+        `Acceptance "${entry.id}" declares exportArtifactCoverage but evidence is not "exported-bytes".`,
+      );
+    }
+    if (!entry.automated || !entry.browser) {
+      errors.push(
+        `Acceptance "${entry.id}" exportArtifactCoverage requires automated and browser proof.`,
+      );
+    }
+    for (const value of coverage) {
+      const hasMatchingAction = exportActions.some(
+        (action) =>
+          action.target === entry.target &&
+          action.requiredCoverage === value &&
+          (entry.actionCoverage ?? []).includes(action.value),
+      );
+      if (!hasMatchingAction) {
+        errors.push(
+          `Acceptance "${entry.id}" declares ${value} without a matching typed export action in target/actionCoverage.`,
+        );
+      }
+    }
+  }
+
+  for (const action of exportActions) {
+    const hasCoverage = acceptance.some(
+      (entry) =>
+        entry.target === action.target &&
+        entry.evidence === "exported-bytes" &&
+        entry.automated &&
+        entry.browser &&
+        (entry.actionCoverage ?? []).includes(action.value) &&
+        getCoverageValues(entry).includes(action.requiredCoverage),
+    );
+    if (!hasCoverage) {
+      errors.push(
+        `Typed ${action.role} action "${action.value}" on "${action.target}" requires ${action.requiredCoverage} acceptance coverage.`,
+      );
+    }
+  }
+
+  return errors;
+}

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

@@ -1,7 +1,7 @@
-import type {
-  ResolvedToolcraftAppSchema,
-  ResolvedToolcraftControlSchema,
-  ToolcraftControlSchema,
+import {
+  type ResolvedToolcraftAppSchema,
+  type ResolvedToolcraftControlSchema,
+  type ToolcraftControlSchema,
 } from "@repo/toolcraft-runtime";
 
 import {
@@ -9,10 +9,23 @@ import {
   isToolcraftProductSectionControl,
 } from "./controls";
 import { getToolcraftSectionLabel } from "./sections";
-import { getToolcraftLooseTargetPrefix } from "./semantic";
+import {
+  getToolcraftLooseTargetPrefix,
+  normalizeToolcraftSemanticText,
+} from "./semantic";
 
 const maxInlineSwitchLabelLength = 16;
 const maxInlineSwitchLabelWordCount = 2;
+const normalizedVideoExportSectionTitle =
+  normalizeToolcraftSemanticText("Video Export");
+
+type ToolcraftControlsSection = NonNullable<
+  ResolvedToolcraftAppSchema["panels"]["controls"]
+>["sections"][number];
+
+type ToolcraftControlLayoutGroup = NonNullable<
+  ToolcraftControlsSection["layoutGroups"]
+>[number];
 
 function getInlineSwitchLabelText(
   controlId: string,
@@ -56,8 +69,42 @@ function controlsShareToolcraftTargetEntity(
   return Boolean(firstPrefix && firstPrefix === secondPrefix);
 }
 
+function isToolcraftVideoExportSegmentedInlinePair({
+  layoutGroup,
+  section,
+  segmentedControlId,
+}: {
+  layoutGroup: ToolcraftControlLayoutGroup;
+  section: ToolcraftControlsSection;
+  segmentedControlId: string;
+}): boolean {
+  if (
+    normalizeToolcraftSemanticText(section.title) !==
+      normalizedVideoExportSectionTitle ||
+    layoutGroup.columns !== 2 ||
+    layoutGroup.controls.length !== 2
+  ) {
+    return false;
+  }
+
+  const formatControl = section.controls[segmentedControlId];
+  const resolutionControlId = layoutGroup.controls.find(
+    (controlId) => controlId !== segmentedControlId,
+  );
+  const resolutionControl = resolutionControlId
+    ? section.controls[resolutionControlId]
+    : undefined;
+
+  return (
+    formatControl?.type === "segmented" &&
+    formatControl.target === "export.video.format" &&
+    resolutionControl?.type === "select" &&
+    resolutionControl.target === "export.video.resolution"
+  );
+}
+
 export function sectionHasInlineLayoutGroupForPair(
-  section: NonNullable<ResolvedToolcraftAppSchema["panels"]["controls"]>["sections"][number],
+  section: ToolcraftControlsSection,
   firstControlId: string,
   secondControlId: string,
 ): boolean {
@@ -95,7 +142,13 @@ export function getToolcraftInlineLayoutErrors(
       }
 
       const segmentedIds = layoutGroup.controls.filter(
-        (controlId) => section.controls[controlId]?.type === "segmented",
+        (controlId) =>
+          section.controls[controlId]?.type === "segmented" &&
+          !isToolcraftVideoExportSegmentedInlinePair({
+            layoutGroup,
+            section,
+            segmentedControlId: controlId,
+          }),
       );
 
       if (segmentedIds.length > 0) {
@@ -181,8 +234,10 @@ export function getToolcraftInlineLayoutErrors(
         !secondControlId ||
         !firstControl ||
         !secondControl ||
-        firstControl.visibleWhen ||
-        secondControl.visibleWhen ||
+        firstControl.applicability.mode ===
+          "conditional" ||
+        secondControl.applicability.mode ===
+          "conditional" ||
         !isBooleanControl(firstControl) ||
         !isBooleanControl(secondControl) ||
         !isInlineSwitchLabelSafe(firstControlId, firstControl) ||

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

@@ -148,7 +148,11 @@ export function getFileDropLifecycleCoverageErrors({
     );
   }
 
-  if (control.multiple === true && !layersOwnMediaManagement) {
+  if (
+    control.multiple === true &&
+    control.variant !== "collection-actions" &&
+    !layersOwnMediaManagement
+  ) {
     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.`,

package/templates/starter/src/app/acceptance/orientation-gizmo.ts

@@ -1,10 +1,13 @@
 import type {
   ResolvedToolcraftAppSchema,
-  ToolcraftControlSchema,
+  ResolvedToolcraftControlSchema,
+} from "@repo/toolcraft-runtime";
+import {
+  areToolcraftPredicateSetsProvablyExclusive,
+  getToolcraftApplicabilityPredicates,
 } from "@repo/toolcraft-runtime";
 
 import { isToolcraftProductSectionControl } from "./controls";
-import { areToolcraftConditionSetsProvablyExclusive } from "./condition-exclusivity";
 
 const vectorOrbitIntentPattern =
   /\b(camera\s+orbit|object\s+orbit|model\s+orbit|3d\s+(?:orientation|rotation)|view\s+orientation|model\s+rotation|object\s+rotation)\b/i;
@@ -34,7 +37,7 @@ function getCrossLength(
   );
 }
 
-function hasValidOrientationDefault(control: ToolcraftControlSchema): boolean {
+function hasValidOrientationDefault(control: ResolvedToolcraftControlSchema): boolean {
   if (!control.defaultValue || typeof control.defaultValue !== "object") {
     return false;
   }
@@ -55,7 +58,7 @@ function getOrientationControlErrors({
   controlId,
   sectionTitle,
 }: {
-  control: ToolcraftControlSchema;
+  control: ResolvedToolcraftControlSchema;
   controlId: string;
   sectionTitle: string;
 }): string[] {
@@ -112,16 +115,20 @@ export function getToolcraftOrientationGizmoErrors(
       }
 
       const leftConditions = [
-        left.section.visibleWhen,
-        left.control.visibleWhen,
-      ].filter((condition) => condition !== undefined);
+        ...(left.section.visibleWhen ? [left.section.visibleWhen] : []),
+        ...getToolcraftApplicabilityPredicates(
+          left.control.applicability,
+        ),
+      ];
       const rightConditions = [
-        right.section.visibleWhen,
-        right.control.visibleWhen,
-      ].filter((condition) => condition !== undefined);
+        ...(right.section.visibleWhen ? [right.section.visibleWhen] : []),
+        ...getToolcraftApplicabilityPredicates(
+          right.control.applicability,
+        ),
+      ];
 
       if (
-        !areToolcraftConditionSetsProvablyExclusive(
+        !areToolcraftPredicateSetsProvablyExclusive(
           leftConditions,
           rightConditions,
         )

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

@@ -83,7 +83,7 @@ export function getToolcraftOutputBackgroundErrors({
 
   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.",
+      "Product apps with artifact export must expose a user-facing background color control such as appearance.background or scene.background. Preview, image export, and video export must read that runtime value instead of hardcoding the product background.",
     );
   }
 
@@ -103,7 +103,7 @@ export function getToolcraftOutputBackgroundErrors({
 
   if (!schemaHasOutputBackgroundToggleControl(controls)) {
     errors.push(
-      'Product apps with Export PNG must expose export.includeBackground in runtime Setup as a Switch labeled "Background". PNG export must pass that runtime value to createToolcraftPngExportCanvas includeBackground; live preview must use shouldIncludeToolcraftPreviewBackground(state); video export keeps the background.',
+      'Product apps with artifact export must expose export.includeBackground in runtime Setup as a Switch labeled "Background". Runtime artifact export owns image alpha and preserves the background for opaque image formats and video; bounded live preview must use shouldIncludeToolcraftPreviewBackground(state).',
     );
   }
 

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

@@ -1,20 +1,27 @@
+import type { ToolcraftArtifactExportDelivery } from "./artifact-export-intent";
 import type { ToolcraftOutputExportFacts } from "./output-export-model";
 
-export function getToolcraftOutputExportLayoutErrors(
-  facts: ToolcraftOutputExportFacts,
-): string[] {
+export function getToolcraftOutputExportLayoutErrors({
+  delivery,
+  facts,
+}: {
+  delivery: ToolcraftArtifactExportDelivery;
+  facts: ToolcraftOutputExportFacts;
+}): string[] {
+  if (!delivery.imageEnabled && !delivery.videoEnabled) {
+    return [];
+  }
+
   const errors: string[] = [];
 
   if (facts.backgroundSection) {
     errors.push(
-      'Product apps with Export PNG must not render a separate "Background" section; runtime Setup owns Background, Infinity canvas, and Color.',
+      'Product apps with artifact export must not render a separate "Background" section; runtime Setup owns Background, Infinity canvas, and Color.',
     );
   }
 
   if (!facts.setupSection || facts.setupSectionIndex !== 0) {
-    errors.push(
-      "Runtime Setup must remain the first controls block.",
-    );
+    errors.push("Runtime Setup must remain the first controls block.");
   }
 
   if (
@@ -23,18 +30,19 @@ export function getToolcraftOutputExportLayoutErrors(
     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.',
+      "The final enabled artifact export settings section must sit directly above sticky footer actions.",
     );
   }
 
   if (
-    facts.hasVideoExportAction &&
+    delivery.imageEnabled &&
+    delivery.videoEnabled &&
     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.',
+      'Products with image and video delivery must place "Image Export" immediately before "Video Export".',
     );
   }
 

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

@@ -4,6 +4,10 @@ import type {
 } from "@repo/toolcraft-runtime";
 
 import { getControlLabelText } from "./controls";
+import {
+  schemaHasPngExportPanelAction,
+  schemaHasVideoExportPanelAction,
+} from "./output-export-actions";
 import { normalizeToolcraftSemanticText } from "./semantic";
 
 export type ToolcraftControlsSection = NonNullable<
@@ -14,6 +18,7 @@ export type ToolcraftOutputExportFacts = {
   backgroundColorEntry: readonly [string, ToolcraftControlSchema] | undefined;
   backgroundSection: ToolcraftControlsSection | undefined;
   finalExportSettingsIndex: number;
+  hasImageExportAction: boolean;
   hasVideoExportAction: boolean;
   imageExportSection: ToolcraftControlsSection | undefined;
   imageExportSectionIndex: number;
@@ -25,7 +30,10 @@ export type ToolcraftOutputExportFacts = {
   setupSection: ToolcraftControlsSection | undefined;
   setupSectionIndex: number;
   timelineEntry: readonly [string, ToolcraftControlSchema] | undefined;
+  videoExportSection: ToolcraftControlsSection | undefined;
   videoExportSectionIndex: number;
+  videoFormatEntry: readonly [string, ToolcraftControlSchema] | undefined;
+  videoResolutionEntry: readonly [string, ToolcraftControlSchema] | undefined;
 };
 
 export function getSearchableControlText({
@@ -47,9 +55,13 @@ export function getSearchableControlText({
     .replace(/([a-z])([A-Z])/g, "$1 $2");
 }
 
-function getFirstPanelActionsSectionIndex(schema: ResolvedToolcraftAppSchema): number {
+function getFirstPanelActionsSectionIndex(
+  schema: ResolvedToolcraftAppSchema,
+): number {
   return (schema.panels.controls?.sections ?? []).findIndex((section) =>
-    Object.values(section.controls).some((control) => control.type === "panelActions"),
+    Object.values(section.controls).some(
+      (control) => control.type === "panelActions",
+    ),
   );
 }
 
@@ -60,7 +72,8 @@ function getSchemaControlsSectionByTitle(
   const normalizedTitle = normalizeToolcraftSemanticText(title);
 
   return (schema.panels.controls?.sections ?? []).find(
-    (section) => normalizeToolcraftSemanticText(section.title) === normalizedTitle,
+    (section) =>
+      normalizeToolcraftSemanticText(section.title) === normalizedTitle,
   );
 }
 
@@ -83,7 +96,9 @@ function getSectionControlEntryByTarget(
     return undefined;
   }
 
-  return Object.entries(section.controls).find(([, control]) => control.target === target);
+  return Object.entries(section.controls).find(
+    ([, control]) => control.target === target,
+  );
 }
 
 function getOutputBackgroundColorEntry(
@@ -107,24 +122,43 @@ function getOutputBackgroundColorEntry(
 }
 
 export function buildToolcraftOutputExportFacts({
-  hasVideoExportAction,
   schema,
 }: {
-  hasVideoExportAction: boolean;
   schema: ResolvedToolcraftAppSchema;
 }): ToolcraftOutputExportFacts {
-  const backgroundSection = getSchemaControlsSectionByTitle(schema, "Background");
+  const backgroundSection = getSchemaControlsSectionByTitle(
+    schema,
+    "Background",
+  );
   const setupSection = getSchemaControlsSectionByTitle(schema, "Setup");
-  const imageExportSection = getSchemaControlsSectionByTitle(schema, "Image Export");
-  const imageExportSectionIndex = getSchemaControlsSectionIndexByTitle(schema, "Image Export");
-  const videoExportSectionIndex = getSchemaControlsSectionIndexByTitle(schema, "Video Export");
+  const imageExportSection = getSchemaControlsSectionByTitle(
+    schema,
+    "Image Export",
+  );
+  const videoExportSection = getSchemaControlsSectionByTitle(
+    schema,
+    "Video Export",
+  );
+  const imageExportSectionIndex = getSchemaControlsSectionIndexByTitle(
+    schema,
+    "Image Export",
+  );
+  const videoExportSectionIndex = getSchemaControlsSectionIndexByTitle(
+    schema,
+    "Video Export",
+  );
+  const hasImageExportAction = schemaHasPngExportPanelAction(schema);
+  const hasVideoExportAction = schemaHasVideoExportPanelAction(schema);
 
   return {
     backgroundColorEntry: getOutputBackgroundColorEntry(setupSection),
     backgroundSection,
     finalExportSettingsIndex: hasVideoExportAction
       ? videoExportSectionIndex
-      : imageExportSectionIndex,
+      : hasImageExportAction
+        ? imageExportSectionIndex
+        : -1,
+    hasImageExportAction,
     hasVideoExportAction,
     imageExportSection,
     imageExportSectionIndex,
@@ -151,6 +185,15 @@ export function buildToolcraftOutputExportFacts({
       setupSection,
       "panels.timeline.extended",
     ),
+    videoExportSection,
     videoExportSectionIndex,
+    videoFormatEntry: getSectionControlEntryByTarget(
+      videoExportSection,
+      "export.video.format",
+    ),
+    videoResolutionEntry: getSectionControlEntryByTarget(
+      videoExportSection,
+      "export.video.resolution",
+    ),
   };
 }

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

@@ -1,5 +1,6 @@
 import type { ResolvedToolcraftAppSchema } from "@repo/toolcraft-runtime";
 
+import { validateToolcraftArtifactExportIntentCorrespondence } from "./artifact-export-intent";
 import {
   getToolcraftOutputBackgroundErrors,
   isOutputBackgroundToggleControl,
@@ -11,7 +12,13 @@ import {
 import { getToolcraftOutputExportLayoutErrors } from "./output-export-layout-rules";
 import { buildToolcraftOutputExportFacts } from "./output-export-model";
 import { getToolcraftImageExportErrors } from "./output-image-export-rules";
-import type { ToolcraftVisibleControl } from "./types";
+import { getToolcraftVideoExportErrors } from "./output-video-export-rules";
+import { getToolcraftExportArtifactCoverageErrors } from "./export-artifact-coverage";
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftProductReadiness,
+  ToolcraftVisibleControl,
+} from "./types";
 
 export {
   isOutputBackgroundToggleControl,
@@ -20,26 +27,42 @@ export {
 };
 
 export function getToolcraftOutputExportErrors({
+  acceptance,
   controls,
+  productReadiness,
   schema,
-  hasVideoExportAction = schemaHasVideoExportPanelAction(schema),
 }: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
   controls: readonly ToolcraftVisibleControl[];
-  hasVideoExportAction?: boolean;
+  productReadiness: ToolcraftProductReadiness;
   schema: ResolvedToolcraftAppSchema;
 }): string[] {
-  if (!schemaHasPngExportPanelAction(schema)) {
-    return [];
-  }
-
-  const facts = buildToolcraftOutputExportFacts({
-    hasVideoExportAction,
+  const exportArtifactCoverageErrors = getToolcraftExportArtifactCoverageErrors({
+    acceptance,
     schema,
   });
+  if (productReadiness.mode === "starter") {
+    return exportArtifactCoverageErrors;
+  }
+
+  const facts = buildToolcraftOutputExportFacts({ schema });
+  const { delivery, errors: intentErrors } =
+    validateToolcraftArtifactExportIntentCorrespondence({
+      hasImageExportAction: facts.hasImageExportAction,
+      hasImageExportSection: facts.imageExportSection !== undefined,
+      hasVideoExportAction: facts.hasVideoExportAction,
+      hasVideoExportSection: facts.videoExportSection !== undefined,
+      intent: productReadiness.exportIntent,
+    });
 
   return [
-    ...getToolcraftOutputExportLayoutErrors(facts),
-    ...getToolcraftOutputBackgroundErrors({ controls, facts }),
-    ...getToolcraftImageExportErrors(facts),
+    ...intentErrors,
+    ...(delivery.imageEnabled ? getToolcraftImageExportErrors(facts) : []),
+    ...(delivery.videoEnabled ? getToolcraftVideoExportErrors(facts) : []),
+    ...(delivery.imageEnabled || delivery.videoEnabled
+      ? getToolcraftOutputBackgroundErrors({ controls, facts })
+      : []),
+    ...getToolcraftOutputExportLayoutErrors({ delivery, facts }),
+    ...exportArtifactCoverageErrors,
   ];
 }

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

@@ -0,0 +1,99 @@
+import { sectionHasInlineLayoutGroupForPair } from "./inline-layout";
+import type { ToolcraftOutputExportFacts } from "./output-export-model";
+
+function hasExactOptionValueSet(
+  actual: readonly string[],
+  expected: readonly string[],
+): boolean {
+  return (
+    actual.length === expected.length &&
+    new Set(actual).size === expected.length &&
+    expected.every((value) => actual.includes(value))
+  );
+}
+
+export function getToolcraftVideoExportErrors(
+  facts: ToolcraftOutputExportFacts,
+): string[] {
+  const errors: string[] = [];
+  const videoFormatControl = facts.videoFormatEntry?.[1];
+  const videoResolutionControl = facts.videoResolutionEntry?.[1];
+  const videoFormatOptionValues =
+    videoFormatControl?.options?.map((option) => option.value.toLowerCase()) ??
+    [];
+  const videoResolutionOptionValues =
+    videoResolutionControl?.options?.map((option) =>
+      option.value.toLowerCase(),
+    ) ?? [];
+
+  if (!facts.videoExportSection) {
+    errors.push(
+      'Apps with Export Video must expose video export settings in a separate controls section titled "Video Export" directly above sticky footer export actions.',
+    );
+  }
+
+  if (!videoFormatControl) {
+    errors.push(
+      'The separate "Video Export" section must include a format control with target "export.video.format".',
+    );
+  } else {
+    if (
+      videoFormatControl.type !== "select" &&
+      videoFormatControl.type !== "segmented"
+    ) {
+      errors.push("Video Export format must be a Select or Segmented control.");
+    }
+
+    if (!hasExactOptionValueSet(videoFormatOptionValues, ["mp4", "webm"])) {
+      errors.push(
+        'Video Export format options must be exactly "mp4" and "webm".',
+      );
+    }
+
+    if (videoFormatControl.defaultValue !== "mp4") {
+      errors.push('Video Export format must default to "mp4".');
+    }
+  }
+
+  if (!videoResolutionControl) {
+    errors.push(
+      'The separate "Video Export" section must include a resolution control with target "export.video.resolution".',
+    );
+  } else {
+    if (videoResolutionControl.type !== "select") {
+      errors.push("Video Export resolution must be a Select control.");
+    }
+
+    if (
+      !hasExactOptionValueSet(videoResolutionOptionValues, ["current", "4k"])
+    ) {
+      errors.push(
+        'Video Export resolution options must be exactly "current" and "4k".',
+      );
+    }
+
+    if (videoResolutionControl.defaultValue !== "current") {
+      errors.push('Video Export resolution must default to "current".');
+    }
+  }
+
+  const videoFormatControlId = facts.videoFormatEntry?.[0];
+  const videoResolutionControlId = facts.videoResolutionEntry?.[0];
+  const videoExportHasInlinePair =
+    facts.videoExportSection !== undefined &&
+    videoFormatControlId !== undefined &&
+    videoResolutionControlId !== undefined &&
+    sectionHasInlineLayoutGroupForPair(
+      facts.videoExportSection,
+      videoFormatControlId,
+      videoResolutionControlId,
+    );
+
+  if (!videoExportHasInlinePair) {
+    errors.push(
+      "Video Export format and resolution must render as one exact two-column inline row.",
+    );
+  }
+
+  return errors;
+}