@pixel-point/toolcraft 0.0.8 → 0.0.11

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

@@ -1,7 +1,4 @@
-import {
-  getToolcraftControlKeyframeCapability,
-  getToolcraftSettingsTransferEligibility,
-} from "@repo/toolcraft-runtime";
+import { getToolcraftControlKeyframeCapability } from "@repo/toolcraft-runtime";
 import type {
   ToolcraftActionSchema,
   ToolcraftControlConditionSchema,
@@ -58,7 +55,7 @@ export type ToolcraftTimelinePlaybackCoverage =
   | "rendered-frame"
   | "scrub";
 
-export type ToolcraftCanvasSizingCoverage = "fixed-output-size";
+export type ToolcraftCanvasSizingCoverage = "fixed-output-size" | "intrinsic-media-size";
 
 export type ToolcraftPersistenceCoverage = "reload";
 
@@ -72,6 +69,17 @@ export type ToolcraftAutonomousAnimationCoverage =
   | "no-scrub"
   | "no-user-facing-transport";
 
+export type ToolcraftTimelineLoopDurationSource =
+  | "product-derived"
+  | "reference"
+  | "user-request";
+
+export type ToolcraftTimelineLoopDurationIntent = {
+  evidence: string;
+  seconds: number;
+  source: ToolcraftTimelineLoopDurationSource;
+};
+
 export type ToolcraftAnimationIntent =
   | {
       mode: "none";
@@ -82,9 +90,11 @@ export type ToolcraftAnimationIntent =
       reason: string;
     }
   | {
+      loopDuration: ToolcraftTimelineLoopDurationIntent;
       mode: "timeline-keyframes";
     }
   | {
+      loopDuration: ToolcraftTimelineLoopDurationIntent;
       mode: "timeline-playback";
     };
 
@@ -96,9 +106,71 @@ export type ToolcraftReferenceTimelineMode =
 
 export type ToolcraftReferenceTimelineContract = {
   behaviorCoverage: readonly ToolcraftReferenceTimelineCoverage[];
+  loopDuration?: ToolcraftTimelineLoopDurationIntent;
   mode: ToolcraftReferenceTimelineMode;
 };
 
+export type ToolcraftReferenceStudyStatus =
+  | "ran-original"
+  | "restored-local"
+  | "source-inspection-only";
+
+export type ToolcraftReferenceStudyEvidence = {
+  behaviorEvidence: string;
+  referenceLocation: string;
+  reproductionSteps: string;
+  sourceEvidence: string;
+  sourceOnlyReason?: string;
+  status: ToolcraftReferenceStudyStatus;
+};
+
+export type ToolcraftVideoReferenceStoryboardFrame = {
+  behaviorObservation: string;
+  frameId: string;
+  frameSource: string;
+  timeSeconds: number;
+  visualObservation: string;
+};
+
+export type ToolcraftVideoReferenceTransition = {
+  behaviorDelta: string;
+  fromFrameId: string;
+  id: string;
+  toFrameId: string;
+};
+
+export type ToolcraftVideoReferenceAcceptanceMapping = {
+  acceptanceId: string;
+  behavior: string;
+  frameIds: readonly string[];
+};
+
+export type ToolcraftVideoReferenceStudyEvidence = {
+  acceptanceMapping: readonly ToolcraftVideoReferenceAcceptanceMapping[];
+  behaviorDecomposition: string;
+  extractionEvidence: string;
+  referenceLocation: string;
+  storyboard: readonly ToolcraftVideoReferenceStoryboardFrame[];
+  transitionAnalysis: readonly ToolcraftVideoReferenceTransition[];
+};
+
+export type ToolcraftReferenceFeatureStatus =
+  | "intentionally-changed"
+  | "ported"
+  | "toolcraft-native";
+
+export type ToolcraftReferenceFeatureInventoryItem = {
+  acceptanceId: string;
+  behaviorEvidence: string;
+  featureName: string;
+  id: string;
+  referenceBehavior: string;
+  sourceEvidence: string;
+  status: ToolcraftReferenceFeatureStatus;
+  toolcraftMapping: string;
+  userApprovedChangeReason?: string;
+};
+
 export type ToolcraftLayerCoverage =
   | "grouping"
   | "media-lifecycle"
@@ -147,6 +219,7 @@ export type ToolcraftCustomControlCoverage =
 const builtInToolcraftControlTypeValues = [
   "actions",
   "anchorGrid",
+  "aspectRatio",
   "channelMixer",
   "checkbox",
   "code",
@@ -170,8 +243,8 @@ const builtInToolcraftControlTypeValues = [
   "text",
   "vector",
 ] as const;
-const settingsTransferOptOutReasonPattern =
-  /\b(ephemeral|temporary|one-off|not portable|session-only)\b/i;
+const insufficientFixedCanvasSizingReasonPattern =
+  /\b(no|without|missing|lacks?|does\s+not\s+(?:have|expose)|did\s+not\s+(?:have|expose)|has\s+no|had\s+no)\b[^.]{0,80}\b(?:size|dimension|canvas|output)\b[^.]{0,80}\b(?:editor|controls?|settings?|picker|input|ui)\b|\breference\s+app\b[^.]{0,120}\b(?:no|without|missing|lacks?|does\s+not\s+(?:have|expose)|did\s+not\s+(?:have|expose)|has\s+no|had\s+no)\b[^.]{0,80}\b(?:size|dimension|canvas|output)\b/i;
 
 export type ToolcraftBuiltInControlType =
   (typeof builtInToolcraftControlTypeValues)[number];
@@ -187,14 +260,18 @@ export type ToolcraftTransferMode =
   | {
       animationIntent?: ToolcraftAnimationIntent;
       mode: "new-toolcraft-app";
+      videoReferenceStudy?: ToolcraftVideoReferenceStudyEvidence;
     }
   | {
       animationIntent?: ToolcraftAnimationIntent;
       behaviorCoverage: readonly ToolcraftReferenceCoverage[];
       mode: "reference-runtime-clone";
+      referenceFeatureInventory?: readonly ToolcraftReferenceFeatureInventoryItem[];
       referenceName: string;
+      referenceStudy?: ToolcraftReferenceStudyEvidence;
       referenceTimeline: ToolcraftReferenceTimelineContract;
       sourceOfTruth: "reference-runtime";
+      videoReferenceStudy?: ToolcraftVideoReferenceStudyEvidence;
     };
 
 export type ToolcraftProductReadiness =
@@ -264,6 +341,15 @@ export type ToolcraftControlOrderItem = {
   type: string;
 };
 
+export type ToolcraftControlSectionInventoryEntry = {
+  entity?: string;
+  groupingReason: string;
+  splitReason?: string;
+  targets: readonly string[];
+  title: string;
+  workflowStage?: string;
+};
+
 export const starterTransferMode: ToolcraftTransferMode = {
   animationIntent: { mode: "none" },
   mode: "new-toolcraft-app",
@@ -277,10 +363,16 @@ export const starterProductReadiness: ToolcraftProductReadiness = {
 
 export const starterAcceptance: readonly ToolcraftComponentAcceptance[] = [];
 
+export const starterControlSectionInventory: readonly ToolcraftControlSectionInventoryEntry[] = [];
+
 function getActionValue(action: ToolcraftActionSchema | string): string {
   return typeof action === "string" ? action : action.value;
 }
 
+function getActionLabelText(action: ToolcraftActionSchema | string): string {
+  return typeof action === "string" ? action : (action.label ?? action.value);
+}
+
 function getActionSearchText(action: ToolcraftActionSchema | string): string {
   return typeof action === "string" ? action : `${action.label} ${action.value} ${action.command ?? ""}`;
 }
@@ -289,6 +381,19 @@ function isCanvasSizeTarget(target: string): boolean {
   return target === "canvas.size.width" || target === "canvas.size.height";
 }
 
+const runtimeSetupControlTargets = new Set([
+  "runtime.settingsTransfer",
+  "canvas.aspectRatio",
+  "canvas.renderScale",
+  "canvas.size.width",
+  "canvas.size.height",
+  "panels.timeline.extended",
+]);
+
+function isRuntimeSetupControlTarget(target: string): boolean {
+  return runtimeSetupControlTargets.has(target);
+}
+
 function isResetPanelAction(action: ToolcraftActionSchema | string): boolean {
   return /\breset\b/i.test(getActionSearchText(action));
 }
@@ -386,9 +491,70 @@ function getAcceptanceEvidenceText(entry: ToolcraftComponentAcceptance): string
   ].join(" ");
 }
 
+function getTimelineLoopDurationIntent(
+  animationIntent: ToolcraftAnimationIntent | undefined,
+): ToolcraftTimelineLoopDurationIntent | undefined {
+  if (
+    animationIntent?.mode !== "timeline-playback" &&
+    animationIntent?.mode !== "timeline-keyframes"
+  ) {
+    return undefined;
+  }
+
+  return animationIntent.loopDuration;
+}
+
+function isValidTimelineLoopDurationSource(source: string): boolean {
+  return source === "reference" || source === "user-request" || source === "product-derived";
+}
+
+const runtimeDefaultLoopDurationEvidencePattern =
+  /\b(?:runtime|template|generic|fallback|default)\b.{0,40}\b(?:8\s*s|8\s*sec(?:ond)?s?|eight\s*sec(?:ond)?s?)\b|\b(?:8\s*s|8\s*sec(?:ond)?s?|eight\s*sec(?:ond)?s?)\b.{0,40}\b(?:runtime|template|generic|fallback|default)\b/i;
+
+function hasSeamlessForwardLoopEvidence(text: string): boolean {
+  const hasDurationChange =
+    /\b(duration|range|state\.timeline\.durationSeconds|timeline)\b/i.test(text) &&
+    /\b(edit|change|changed|changing|commit|set|after)\w*\b/i.test(text);
+  const hasFirstLastFrameEvidence =
+    /\b(first[-\s/]*(?:and\s+)?last|last[-\s/]*(?:and\s+)?first|wrapped\s+first\s+frame)\b/i.test(
+      text,
+    ) ||
+    (/\bfirst\s+frame\b/i.test(text) && /\blast\s+frame\b/i.test(text)) ||
+    (/\bstart\s+frame\b/i.test(text) && /\bend\s+frame\b/i.test(text));
+  const hasNoVisibleJumpEvidence =
+    /\b(no|not|without|avoid(?:s|ing)?|absent|rejects?|disallow(?:s|ed)?|forbid(?:s|den)?)\b.{0,40}\bvisible\s+jump\b/i.test(
+      text,
+    );
+  const hasSeamEvidence =
+    hasFirstLastFrameEvidence &&
+    (/\b(stitch(?:es|ed|ing)?|seam(?:less)?)\b/i.test(text) || hasNoVisibleJumpEvidence);
+  const hasForwardDirectionEvidence =
+    /\b(forward[-\s]*only|one\s+direction|same\s+direction|advances?\s+in\s+one\s+direction|motion\s+advances?\s+forward|direction\s+does\s+not\s+reverse)\b/i.test(text);
+  const hasNoMirrorEvidence =
+    /\b(no|not|without|avoid(?:s|ing)?|absent|rejects?|disallow(?:s|ed)?|forbid(?:s|den)?)\b.{0,40}\bmirror(?:ed|ing)?\b/i.test(text);
+  const hasNoYoyoEvidence =
+    /\b(no|not|without|avoid(?:s|ing)?|absent|rejects?|disallow(?:s|ed)?|forbid(?:s|den)?)\b.{0,40}\byo-?yo\b/i.test(text);
+  const hasNoPingPongEvidence =
+    /\b(no|not|without|avoid(?:s|ing)?|absent|rejects?|disallow(?:s|ed)?|forbid(?:s|den)?)\b.{0,40}\bping[-\s]*pong\b/i.test(text);
+  const hasNoReverseEvidence =
+    /\b(no|not|without|avoid(?:s|ing)?|absent|rejects?|disallow(?:s|ed)?|forbid(?:s|den)?)\b.{0,40}\breverse\b/i.test(text);
+
+  return (
+    hasDurationChange &&
+    hasSeamEvidence &&
+    hasForwardDirectionEvidence &&
+    hasNoMirrorEvidence &&
+    hasNoYoyoEvidence &&
+    hasNoPingPongEvidence &&
+    hasNoReverseEvidence
+  );
+}
+
 function getFileDropLifecycleCoverageErrors(
   label: string,
+  control: ToolcraftControlSchema,
   entry: ToolcraftComponentAcceptance,
+  hasDefaultMediaAssets: boolean,
 ): string[] {
   const errors: string[] = [];
   const evidenceText = getAcceptanceEvidenceText(entry);
@@ -407,10 +573,59 @@ function getFileDropLifecycleCoverageErrors(
     !/\b(reset|reset controls|section reset|global reset)\b/i.test(evidenceText)
   ) {
     errors.push(
-      `${label} fileDrop acceptance must prove upload/import, clear/remove, and section or global reset remove source media.`,
+      `${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) {
+    const provesDefaultRemoval =
+      /\b(default|predefined|preset|attached)\b.{0,60}\b(clear|remove|delete|trash)\b/i.test(
+        evidenceText,
+      ) ||
+      /\b(clear|remove|delete|trash)\b.{0,60}\b(default|predefined|preset|attached)\b/i.test(
+        evidenceText,
+      );
+    const provesDefaultReset =
+      /\b(reset|section reset|global reset)\b.{0,80}\b(restore|restores|return|returns|recreate|recreates)\b.{0,80}\b(default|predefined|preset|attached)\b/i.test(
+        evidenceText,
+      );
+
+    if (!provesDefaultRemoval || !provesDefaultReset) {
+      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") {
+    const provesRotate = /\b(rotate|rotation|90°|90\s*degrees?)\b/i.test(evidenceText);
+    const provesFlip = /\b(flip|flipped)\b/i.test(evidenceText);
+    const provesTransformConsumption =
+      /\b(mediaAssets\[\]\.transform|runtime media transform|transform metadata|preview|renderer|rendered output|export)\b/i.test(
+        evidenceText,
+      );
+
+    if (!provesRotate || !provesFlip || !provesTransformConsumption) {
+      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) {
+    const provesReorder = /\b(reorder|sort|sorting|drag|order)\b/i.test(evidenceText);
+    const provesOrderConsumption =
+      /\b(runtime media order|mediaAssets order|ordered media|preview|renderer|rendered output|export)\b/i.test(
+        evidenceText,
+      );
+
+    if (!provesReorder || !provesOrderConsumption) {
+      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;
 }
 
@@ -873,6 +1088,64 @@ function hasVisibleControlLabel(control: ToolcraftControlSchema): boolean {
   return typeof control.label === "string" && control.label.trim().length > 0;
 }
 
+const shortSingleLineTextMaxLength = 80;
+const longTextControlEvidencePattern =
+  /\b(multiline|multi-line|multi\s+line|long\s+(?:text|content|prompt|instructions?)|paragraph|body\s+(?:copy|text)|rich\s+text|textarea|instructions?|script|code|json|css|shader|template|markdown|csv|xml|yaml|html|svg|list|lines|dataset|structured|source\s+text)\b/i;
+const shortSingleLineTextIntentPattern =
+  /\b(button|label|title|name|caption|headline|cta|badge|token|word|phrase|single-line|one-line|short\s+text)\b/i;
+
+function getControlDefaultString(control: ToolcraftControlSchema): string | undefined {
+  return typeof control.defaultValue === "string" ? control.defaultValue : undefined;
+}
+
+function getTextValueControlIntentText(
+  controlId: string,
+  control: ToolcraftControlSchema,
+): string {
+  return [
+    controlId,
+    control.target,
+    getControlLabelText(control),
+    control.description ?? "",
+  ]
+    .join(" ")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+}
+
+function getCodeTextareaControlError({
+  control,
+  controlId,
+  label,
+}: {
+  control: ToolcraftControlSchema;
+  controlId: string;
+  label: string;
+}): string | undefined {
+  if (control.type !== "code") {
+    return undefined;
+  }
+
+  const defaultValue = getControlDefaultString(control);
+  const intentText = getTextValueControlIntentText(controlId, control);
+  const hasLongTextEvidence =
+    longTextControlEvidencePattern.test(intentText) ||
+    (defaultValue !== undefined &&
+      (defaultValue.length > shortSingleLineTextMaxLength ||
+        /[\r\n]/.test(defaultValue)));
+  const looksLikeShortSingleLineText =
+    shortSingleLineTextIntentPattern.test(intentText) ||
+    (defaultValue !== undefined &&
+      defaultValue.trim().length > 0 &&
+      defaultValue.trim().length <= shortSingleLineTextMaxLength &&
+      !/[\r\n]/.test(defaultValue));
+
+  if (!looksLikeShortSingleLineText || hasLongTextEvidence) {
+    return undefined;
+  }
+
+  return `${label} uses CodeTextarea for short single-line text. Use type "text" for button labels, canvas labels, titles, captions, names, badges, tokens, and other short one-line content. Reserve type "code" for long, multiline, or structured values, and document that reason in description when the default is short.`;
+}
+
 const singleCurveSemanticPattern =
   /\b(acceleration|accel|bend|easing|ease|response|depth|mask|opacity|alpha|motion|velocity|threshold|falloff|remap|remapping)\b|speed\s+profile|mapping\s+curve|curve\s+mapping/i;
 const rgbCurveSemanticPattern =
@@ -931,6 +1204,33 @@ function getToggleControlLabelError(
   return undefined;
 }
 
+function getSingleActionsControlLabelError(
+  control: ToolcraftControlSchema,
+): string | undefined {
+  if (control.type !== "actions") {
+    return undefined;
+  }
+
+  const actions = getControlActions(control);
+
+  if (actions.length !== 1) {
+    return undefined;
+  }
+
+  const label = getControlLabelText(control).trim();
+  const actionLabel = getActionLabelText(actions[0] as ToolcraftActionSchema | string).trim();
+
+  if (
+    label &&
+    actionLabel &&
+    normalizeToolcraftSemanticText(label) === normalizeToolcraftSemanticText(actionLabel)
+  ) {
+    return `single Actions control label "${label}" duplicates its only button label "${actionLabel}". Keep the button as the command and use a short context label such as "Ink wash", "Palette action", or "Current layer".`;
+  }
+
+  return undefined;
+}
+
 const maxInlineSwitchLabelLength = 16;
 const maxInlineSwitchLabelWordCount = 2;
 
@@ -1281,6 +1581,27 @@ const customReferenceTimelineCoverage = new Set<ToolcraftReferenceTimelineCovera
   "trim-range",
 ]);
 
+const referenceFeatureStatusValues = new Set<ToolcraftReferenceFeatureStatus>([
+  "intentionally-changed",
+  "ported",
+  "toolcraft-native",
+]);
+
+const referenceStudyStatusValues = new Set<ToolcraftReferenceStudyStatus>([
+  "ran-original",
+  "restored-local",
+  "source-inspection-only",
+]);
+
+const explicitReferenceChangeReasonPattern =
+  /\b(user|requested|explicit|approved|redesign|change request)\b/i;
+
+const referenceStudySourceOnlyReasonPattern =
+  /\b(cannot|can't|unable|unavailable|missing|broken|fails?|blocked|no\s+(?:server|deps?|dependency|access)|not\s+(?:runnable|available))\b/i;
+
+const videoReferenceEvidencePattern =
+  /\b(?:reference\s+(?:video|gif)|screen\s*recording|contact[-\s]*sheet|storyboard|frame[-\s]*by[-\s]*frame|extracted[-\s]*frames?|ffprobe)\b|(?:^|[\\/"'\s])[^\\/"'\s]+\.(?:mp4|mov|webm|gif)\b/i;
+
 const timelineTransportControlPattern =
   /\b(play|pause|paused|resume|animate|restart)\b/i;
 
@@ -1311,6 +1632,184 @@ const requiredTimelinePlaybackCoverage = [
   "rendered-frame",
 ] satisfies readonly ToolcraftTimelinePlaybackCoverage[];
 
+function getToolcraftTransferModeEvidenceText(
+  transferMode: ToolcraftTransferMode,
+): string {
+  return JSON.stringify(transferMode);
+}
+
+function validateToolcraftVideoReferenceStudy(
+  study: ToolcraftVideoReferenceStudyEvidence,
+  acceptance: readonly ToolcraftComponentAcceptance[],
+): string[] {
+  const errors: string[] = [];
+  const acceptanceById = new Map(acceptance.map((entry) => [entry.id, entry]));
+  const frameIds = new Set<string>();
+
+  if (!study.referenceLocation.trim()) {
+    errors.push(
+      "videoReferenceStudy.referenceLocation must name the inspected video, GIF, screen recording, contact sheet, or extracted-frame folder.",
+    );
+  }
+
+  if (!study.extractionEvidence.trim()) {
+    errors.push(
+      "videoReferenceStudy.extractionEvidence must explain how frames were inspected or extracted before implementation.",
+    );
+  }
+
+  if (!study.behaviorDecomposition.trim()) {
+    errors.push(
+      "videoReferenceStudy.behaviorDecomposition must decompose the observed frame-to-frame changes into product behavior to preserve.",
+    );
+  }
+
+  if (study.storyboard.length < 4) {
+    errors.push(
+      "videoReferenceStudy.storyboard must include at least four timecoded frames so the reference is studied as motion, not a single screenshot.",
+    );
+  }
+
+  for (const [index, frame] of study.storyboard.entries()) {
+    const frameLabel = frame.frameId.trim() || `#${index + 1}`;
+
+    if (!frame.frameId.trim()) {
+      errors.push(`videoReferenceStudy.storyboard frame ${index + 1} must include a stable frameId.`);
+    } else if (frameIds.has(frame.frameId)) {
+      errors.push(
+        `videoReferenceStudy.storyboard frameId "${frame.frameId}" is duplicated; each sampled frame needs a stable id.`,
+      );
+    } else {
+      frameIds.add(frame.frameId);
+    }
+
+    if (!Number.isFinite(frame.timeSeconds) || frame.timeSeconds < 0) {
+      errors.push(
+        `videoReferenceStudy.storyboard "${frameLabel}" must include a non-negative finite timeSeconds value.`,
+      );
+    }
+
+    if (!frame.frameSource.trim()) {
+      errors.push(
+        `videoReferenceStudy.storyboard "${frameLabel}" must cite the frame image, contact sheet cell, or source timecode inspected.`,
+      );
+    }
+
+    if (!frame.visualObservation.trim()) {
+      errors.push(
+        `videoReferenceStudy.storyboard "${frameLabel}" must describe the visible frame state.`,
+      );
+    }
+
+    if (!frame.behaviorObservation.trim()) {
+      errors.push(
+        `videoReferenceStudy.storyboard "${frameLabel}" must describe the behavior inferred from that frame.`,
+      );
+    }
+  }
+
+  if (study.transitionAnalysis.length < 3) {
+    errors.push(
+      "videoReferenceStudy.transitionAnalysis must include at least three frame-to-frame deltas proving how behavior changes between sampled frames.",
+    );
+  }
+
+  for (const [index, transition] of study.transitionAnalysis.entries()) {
+    const transitionLabel = transition.id.trim() || `#${index + 1}`;
+
+    if (!transition.id.trim()) {
+      errors.push(
+        `videoReferenceStudy.transitionAnalysis item ${index + 1} must include a stable id.`,
+      );
+    }
+
+    if (!frameIds.has(transition.fromFrameId)) {
+      errors.push(
+        `videoReferenceStudy.transitionAnalysis "${transitionLabel}" fromFrameId "${transition.fromFrameId}" must point to a storyboard frameId.`,
+      );
+    }
+
+    if (!frameIds.has(transition.toFrameId)) {
+      errors.push(
+        `videoReferenceStudy.transitionAnalysis "${transitionLabel}" toFrameId "${transition.toFrameId}" must point to a storyboard frameId.`,
+      );
+    }
+
+    if (!transition.behaviorDelta.trim()) {
+      errors.push(
+        `videoReferenceStudy.transitionAnalysis "${transitionLabel}" must describe the behavior delta between frames.`,
+      );
+    }
+  }
+
+  if (study.acceptanceMapping.length === 0) {
+    errors.push(
+      "videoReferenceStudy.acceptanceMapping must map observed video behaviors to acceptance rows.",
+    );
+  }
+
+  for (const [index, mapping] of study.acceptanceMapping.entries()) {
+    const mappingLabel = mapping.behavior.trim() || `#${index + 1}`;
+
+    if (!mapping.behavior.trim()) {
+      errors.push(
+        `videoReferenceStudy.acceptanceMapping item ${index + 1} must name the observed behavior.`,
+      );
+    }
+
+    if (mapping.frameIds.length === 0) {
+      errors.push(
+        `videoReferenceStudy.acceptanceMapping "${mappingLabel}" must cite storyboard frameIds that prove the behavior.`,
+      );
+    }
+
+    for (const frameId of mapping.frameIds) {
+      if (!frameIds.has(frameId)) {
+        errors.push(
+          `videoReferenceStudy.acceptanceMapping "${mappingLabel}" frameId "${frameId}" must point to a storyboard frameId.`,
+        );
+      }
+    }
+
+    const acceptanceId = mapping.acceptanceId.trim();
+    const entry = acceptanceById.get(acceptanceId);
+
+    if (!acceptanceId) {
+      errors.push(
+        `videoReferenceStudy.acceptanceMapping "${mappingLabel}" must include acceptanceId for the test proving the copied behavior.`,
+      );
+      continue;
+    }
+
+    if (!entry) {
+      errors.push(
+        `videoReferenceStudy.acceptanceMapping "${mappingLabel}" points to missing acceptanceId "${acceptanceId}".`,
+      );
+      continue;
+    }
+
+    if (!entry.automated || !entry.automatedTestName.trim()) {
+      errors.push(
+        `${acceptanceId} must have automated coverage proving video reference behavior "${mappingLabel}".`,
+      );
+    }
+
+    if (!entry.browser || !entry.browserTestName.trim()) {
+      errors.push(
+        `${acceptanceId} must have browser coverage proving video reference behavior "${mappingLabel}".`,
+      );
+    }
+
+    if (!entry.expectedObservable.trim()) {
+      errors.push(
+        `${acceptanceId} must describe the observable result for video reference behavior "${mappingLabel}".`,
+      );
+    }
+  }
+
+  return errors;
+}
+
 function isModeSelectorControl(
   controlId: string,
   control: ToolcraftControlSchema,
@@ -1319,7 +1818,7 @@ function isModeSelectorControl(
     return false;
   }
 
-  return /mode|type|filter|blend|style|preset|variant/i.test(
+  return /mode|type|filter|style|preset|variant/i.test(
     `${controlId} ${control.target} ${getControlLabelText(control)}`,
   );
 }
@@ -1396,7 +1895,7 @@ function getToolcraftControlOrderErrors(schema: ResolvedToolcraftAppSchema): str
     let previousItem: ToolcraftControlOrderItem | undefined;
 
     for (const [controlId, control] of Object.entries(section.controls)) {
-      if (control.type === "panelActions") {
+      if (control.type === "panelActions" || isRuntimeSetupControlTarget(control.target)) {
         continue;
       }
 
@@ -1425,17 +1924,118 @@ function getToolcraftControlOrderErrors(schema: ResolvedToolcraftAppSchema): str
   return errors;
 }
 
-const genericControlSectionTitlePattern =
-  /^(controls?|settings?|parameters?|options?|configuration|config|adjustments?)$/i;
+function getToolcraftRuntimeSetupSectionErrors(
+  schema: ResolvedToolcraftAppSchema,
+): string[] {
+  const errors: string[] = [];
+  const controlsPanel = schema.panels.controls;
 
-const controlTypeSectionTitlePattern =
-  /^(sliders?|colors?|colours?|inputs?|selects?|switches?|checkboxes?|toggles?|buttons?|actions?)$/i;
+  if (!controlsPanel) {
+    return [
+      "Generated Toolcraft apps must define a controls panel so the mandatory runtime Setup section is visible.",
+    ];
+  }
 
-const weakControlLabelContextSectionTitlePattern =
-  /^(appearance|look|looks|properties?|style|styles|values?|visuals?)$/i;
+  const sections = schema.panels.controls?.sections ?? [];
 
-const broadControlSectionTitlePattern =
-  /^(animation|export|flow|icon|logo|motion|output|scene|shape|shapes|text|typography|visual|visuals)$/i;
+  if (sections.length === 0) {
+    return [
+      'Runtime Setup must be the first visible controls-panel section titled "Setup". Do not ship an empty controls panel.',
+    ];
+  }
+
+  const setupSection = sections[0];
+  const setupTitle = setupSection?.title?.trim();
+  const setupControls = Object.values(setupSection?.controls ?? {});
+  const setupTargets = new Set(setupControls.map((control) => control.target));
+  const hasSetupTarget = (target: string) => setupTargets.has(target);
+
+  if (setupTitle !== "Setup") {
+    errors.push(
+      'Runtime Setup must be the first visible controls-panel section titled "Setup". Do not move Export Settings, Import Settings, canvas sizing, Resolution scale, or Timeline into app-authored sections.',
+    );
+  }
+
+  if (
+    !setupControls.some(
+      (control) =>
+        control.type === "settingsTransfer" &&
+        control.target === "runtime.settingsTransfer",
+    )
+  ) {
+    errors.push(
+      'Runtime Setup must include settingsTransfer at target "runtime.settingsTransfer" so Export Settings and Import Settings are always visible.',
+    );
+  }
+
+  if (schema.canvas.enabled && schema.canvas.sizing.mode === "editable-output") {
+    const missingCanvasTargets = [
+      "canvas.aspectRatio",
+      "canvas.size.width",
+      "canvas.size.height",
+    ].filter((target) => !hasSetupTarget(target));
+
+    if (missingCanvasTargets.length > 0) {
+      errors.push(
+        `Runtime Setup for editable-output canvas must include Aspect ratio, Canvas width, and Canvas height. Missing targets: ${missingCanvasTargets.join(", ")}.`,
+      );
+    }
+  }
+
+  if (schema.canvas.renderScale.enabled && !hasSetupTarget("canvas.renderScale")) {
+    errors.push(
+      'Runtime Setup must include Resolution scale at target "canvas.renderScale" whenever canvas.renderScale is enabled.',
+    );
+  }
+
+  if (schema.panels.timeline?.enabled) {
+    if (!hasSetupTarget("panels.timeline.extended")) {
+      errors.push(
+        'Runtime Setup must include the Timeline switch at target "panels.timeline.extended" whenever panels.timeline is enabled.',
+      );
+    }
+  } else if (
+    sections.some((section) =>
+      Object.values(section.controls).some(
+        (control) => control.target === "panels.timeline.extended",
+      ),
+    )
+  ) {
+    errors.push(
+      'Runtime Setup must not include the Timeline switch unless panels.timeline is enabled.',
+    );
+  }
+
+  for (const [sectionIndex, section] of sections.entries()) {
+    const isRuntimeSetupSection = sectionIndex === 0 && section.title?.trim() === "Setup";
+
+    for (const [controlId, control] of Object.entries(section.controls)) {
+      if (!isRuntimeSetupControlTarget(control.target) || isRuntimeSetupSection) {
+        continue;
+      }
+
+      const sectionLabel = getToolcraftSectionLabel(section.title, sectionIndex);
+
+      errors.push(
+        `${sectionLabel} / ${controlId} uses runtime Setup target "${control.target}". Runtime Setup owns Export Settings, Import Settings, Aspect ratio, Canvas width, Canvas height, Resolution scale, and Timeline; do not declare these controls in app-authored sections.`,
+      );
+    }
+  }
+
+  return errors;
+}
+
+const genericControlSectionTitlePattern =
+  /^(controls?|settings?|parameters?|options?|configuration|config|adjustments?)$/i;
+
+const controlTypeSectionTitlePattern =
+  /^(sliders?|colors?|colours?|inputs?|selects?|switches?|checkboxes?|toggles?|buttons?|actions?)$/i;
+
+const weakControlLabelContextSectionTitlePattern =
+  /^(appearance|look|looks|properties?|style|styles|values?|visuals?)$/i;
+
+const broadControlSectionTitlePattern =
+  /^(animation|export|flow|icon|logo|motion|output|scene|shape|shapes|text|typography|visual|visuals)$/i;
 
 const genericControlLabelPattern =
   /^(angle|amount|blur|brightness|color|contrast|count|density|depth|frequency|height|hue|intensity|offset|opacity|phase|position|quality|radius|rotation|saturation|scale|size|spacing|speed|strength|threshold|tint|width)$/i;
@@ -1445,7 +2045,7 @@ const maxHardControlsPerSection = 10;
 
 const controlSemanticClusterPatterns: ReadonlyArray<readonly [string, RegExp]> = [
   ["input", /\b(upload|source|prompt|content|text|phrase|copy|message|file|media|image)\b/i],
-  ["mode", /\b(mode|type|preset|style|variant|blend|filter|layout|format|quality)\b/i],
+  ["mode", /\b(mode|type|preset|style|variant|filter|layout|format|quality)\b/i],
   ["motion", /\b(animation|speed|velocity|accel|acceleration|correlation|duration|timing|loop|phase|fps|rate)\b/i],
   ["geometry", /\b(width|height|size|scale|position|offset|anchor|origin|target|radius|distance|spread|bend|curve|curves|path|shape|grid|gap)\b/i],
   ["density", /\b(fill|density|amount|count|ratio|word|words|letter|letters|particle|particles|layer|layers|island|islands)\b/i],
@@ -1683,6 +2283,74 @@ function getToolcraftControlSemanticCluster(
   return inferToolcraftControlOrderRole(controlId, control);
 }
 
+function normalizeToolcraftConditionValue(value: unknown): string | null {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    const normalized = normalizeToolcraftSemanticText(String(value));
+    return normalized || null;
+  }
+
+  return null;
+}
+
+function getToolcraftConditionBranchTexts(
+  condition: ToolcraftControlConditionSchema,
+  gateControl: ToolcraftControlSchema,
+): string[] {
+  const rawValues =
+    "equals" in condition
+      ? [condition.equals]
+      : Array.isArray(condition.oneOf)
+        ? [...condition.oneOf]
+        : [];
+  const normalizedValues = rawValues
+    .map(normalizeToolcraftConditionValue)
+    .filter((value): value is string => Boolean(value));
+  const optionLabels = (gateControl.options ?? [])
+    .filter((option) =>
+      normalizedValues.includes(normalizeToolcraftSemanticText(option.value)),
+    )
+    .map((option) => normalizeToolcraftSemanticText(option.label))
+    .filter(Boolean);
+
+  return [...new Set([...normalizedValues, ...optionLabels])];
+}
+
+function sectionTitleLooksLikeDependencyBranch({
+  condition,
+  gateControl,
+  sectionTitle,
+}: {
+  condition: ToolcraftControlConditionSchema;
+  gateControl: ToolcraftControlSchema;
+  sectionTitle: string | undefined;
+}): boolean {
+  const sectionText = normalizeToolcraftSemanticText(sectionTitle);
+
+  if (!sectionText) {
+    return false;
+  }
+
+  return getToolcraftConditionBranchTexts(condition, gateControl).some(
+    (branchText) =>
+      branchText.length > 2 &&
+      (sectionText === branchText ||
+        sectionText.includes(branchText) ||
+        branchText.includes(sectionText)),
+  );
+}
+
+function isToolcraftProductSectionControl(control: ToolcraftControlSchema): boolean {
+  return (
+    control.type !== "panelActions" &&
+    control.type !== "settingsTransfer" &&
+    !isRuntimeSetupControlTarget(control.target)
+  );
+}
+
+function isToolcraftVisibleAcceptanceControl(control: ToolcraftControlSchema): boolean {
+  return control.type === "panelActions" || isToolcraftProductSectionControl(control);
+}
+
 function getToolcraftGenericControlLabelError({
   control,
   controlId,
@@ -1887,8 +2555,187 @@ function getToolcraftColorBankLabelErrors({
   return errors;
 }
 
+function getToolcraftSectionInventoryByTitle(
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[],
+): Map<string, ToolcraftControlSectionInventoryEntry> {
+  return new Map(
+    sectionInventory.map((entry) => [entry.title.trim(), entry]),
+  );
+}
+
+function hasToolcraftInventorySplitEvidence({
+  sectionInventoryByTitle,
+  sections,
+}: {
+  sectionInventoryByTitle: ReadonlyMap<string, ToolcraftControlSectionInventoryEntry>;
+  sections: ReadonlySet<string>;
+}): boolean {
+  const entries = [...sections].map((sectionLabel) =>
+    sectionInventoryByTitle.get(sectionLabel),
+  );
+
+  return (
+    entries.length === sections.size &&
+    entries.every(
+      (entry) =>
+        entry &&
+        (entry.workflowStage?.trim().length ?? 0) > 0 &&
+        (entry.splitReason?.trim().length ?? 0) >= 12,
+    )
+  );
+}
+
+function getToolcraftControlSectionInventoryErrors(
+  schema: ResolvedToolcraftAppSchema,
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[],
+): string[] {
+  const errors: string[] = [];
+
+  if (sectionInventory.length === 0) {
+    return errors;
+  }
+
+  const schemaSections = (schema.panels.controls?.sections ?? []).flatMap(
+    (section, sectionIndex) => {
+      const targets = Object.values(section.controls)
+        .filter(isToolcraftProductSectionControl)
+        .map((control) => control.target);
+
+      if (targets.length === 0) {
+        return [];
+      }
+
+      return [
+        {
+          label: getToolcraftSectionLabel(section.title, sectionIndex),
+          targets,
+        },
+      ];
+    },
+  );
+  const schemaSectionTitles = new Set(schemaSections.map((section) => section.label));
+  const schemaTargetToSection = new Map<string, string>();
+
+  for (const section of schemaSections) {
+    for (const target of section.targets) {
+      schemaTargetToSection.set(target, section.label);
+    }
+  }
+
+  const inventoryTitleCounts = new Map<string, number>();
+  const inventoryTargetToSection = new Map<string, string>();
+
+  for (const entry of sectionInventory) {
+    const title = entry.title.trim();
+    const entity = entry.entity?.trim() ?? "";
+    const workflowStage = entry.workflowStage?.trim() ?? "";
+    const groupingReason = entry.groupingReason.trim();
+    const splitReason = entry.splitReason?.trim() ?? "";
+
+    if (!title) {
+      errors.push(
+        "Control Section Inventory contains an entry without a section title.",
+      );
+      continue;
+    }
+
+    inventoryTitleCounts.set(title, (inventoryTitleCounts.get(title) ?? 0) + 1);
+
+    if (!schemaSectionTitles.has(title)) {
+      errors.push(
+        `Control Section Inventory references "${title}", but no rendered product controls section uses that title.`,
+      );
+    }
+
+    if (!entity && !workflowStage) {
+      errors.push(
+        `Control Section Inventory entry "${title}" must declare entity or workflowStage so grouping is based on product meaning, not UI layout.`,
+      );
+    }
+
+    if (groupingReason.length < 12) {
+      errors.push(
+        `Control Section Inventory entry "${title}" must include a concrete groupingReason explaining why these controls belong together.`,
+      );
+    }
+
+    if (splitReason && splitReason.length < 12) {
+      errors.push(
+        `Control Section Inventory entry "${title}" splitReason is too vague. Explain the product workflow split or omit splitReason.`,
+      );
+    }
+
+    if (entry.targets.length === 0) {
+      errors.push(
+        `Control Section Inventory entry "${title}" must list the product control targets rendered in that section.`,
+      );
+    }
+
+    for (const target of entry.targets) {
+      const schemaSection = schemaTargetToSection.get(target);
+
+      if (!schemaSection) {
+        errors.push(
+          `Control Section Inventory entry "${title}" lists target "${target}", but that target is not rendered by any product controls section.`,
+        );
+        continue;
+      }
+
+      if (schemaSection !== title) {
+        errors.push(
+          `Control Section Inventory entry "${title}" lists target "${target}", but the schema renders it in "${schemaSection}". Update the schema grouping or the inventory.`,
+        );
+      }
+
+      const existingSection = inventoryTargetToSection.get(target);
+
+      if (existingSection && existingSection !== title) {
+        errors.push(
+          `Control Section Inventory lists target "${target}" in both "${existingSection}" and "${title}". Each product control target belongs to exactly one section inventory entry.`,
+        );
+      }
+
+      inventoryTargetToSection.set(target, title);
+    }
+  }
+
+  for (const [title, count] of inventoryTitleCounts) {
+    if (count > 1) {
+      errors.push(
+        `Control Section Inventory repeats section "${title}" ${count} times. Section inventory entries must be unique.`,
+      );
+    }
+  }
+
+  for (const section of schemaSections) {
+    const entry = sectionInventory.find(
+      (inventoryEntry) => inventoryEntry.title.trim() === section.label,
+    );
+
+    if (!entry) {
+      errors.push(
+        `Control Section Inventory is missing product section "${section.label}". Add its entity/workflow stage, targets, and groupingReason.`,
+      );
+      continue;
+    }
+
+    const inventoryTargets = new Set(entry.targets);
+
+    for (const target of section.targets) {
+      if (!inventoryTargets.has(target)) {
+        errors.push(
+          `Control Section Inventory entry "${section.label}" is missing rendered target "${target}". The inventory must cover every product control in the section.`,
+        );
+      }
+    }
+  }
+
+  return errors;
+}
+
 function getToolcraftControlSectionGroupingErrors(
   schema: ResolvedToolcraftAppSchema,
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[] = [],
 ): string[] {
   const errors: string[] = [];
   const visibleControls: Array<{
@@ -1896,17 +2743,29 @@ function getToolcraftControlSectionGroupingErrors(
     controlId: string;
     loosePrefix: string | null;
     sectionLabel: string;
+    sectionTitle: string | undefined;
   }> = [];
   const strictPrefixSections = new Map<string, Set<string>>();
   const loosePrefixSections = new Map<string, Set<string>>();
   const colorSectionLoosePrefixes = new Map<string, string>();
+  const sectionInventoryByTitle = getToolcraftSectionInventoryByTitle(sectionInventory);
   const sectionTitleCounts = new Map<string, { count: number; label: string }>();
+  const controlsByTarget = new Map<
+    string,
+    {
+      control: ToolcraftControlSchema;
+      controlId: string;
+      loosePrefix: string | null;
+      sectionLabel: string;
+      sectionTitle: string | undefined;
+    }
+  >();
 
   for (const [sectionIndex, section] of (schema.panels.controls?.sections ?? []).entries()) {
     const sectionTitle = section.title?.trim();
     const sectionLabel = getToolcraftSectionLabel(sectionTitle, sectionIndex);
-    const controls = Object.entries(section.controls).filter(
-      ([, control]) => control.type !== "panelActions",
+    const controls = Object.entries(section.controls).filter(([, control]) =>
+      isToolcraftProductSectionControl(control),
     );
 
     if (controls.length === 0) {
@@ -1945,11 +2804,8 @@ function getToolcraftControlSectionGroupingErrors(
         .map(([, control]) => getToolcraftLooseTargetPrefix(control.target))
         .filter((prefix): prefix is string => Boolean(prefix)),
     );
-    const productControls = controls.filter(
-      ([, control]) =>
-        control.type !== "settingsTransfer" &&
-        control.target !== "canvas.size.width" &&
-        control.target !== "canvas.size.height",
+    const productControls = controls.filter(([, control]) =>
+      isToolcraftProductSectionControl(control),
     );
     const semanticClusters = new Set(
       productControls.map(([controlId, control]) =>
@@ -2015,6 +2871,14 @@ function getToolcraftControlSectionGroupingErrors(
         controlId,
         loosePrefix,
         sectionLabel,
+        sectionTitle,
+      });
+      controlsByTarget.set(control.target, {
+        control,
+        controlId,
+        loosePrefix,
+        sectionLabel,
+        sectionTitle,
       });
 
       if (strictPrefix) {
@@ -2048,6 +2912,42 @@ function getToolcraftControlSectionGroupingErrors(
     }
   }
 
+  for (const item of visibleControls) {
+    for (const [conditionName, condition] of [
+      ["visibleWhen", item.control.visibleWhen],
+      ["disabledWhen", item.control.disabledWhen],
+    ] as const) {
+      if (!condition || !item.loosePrefix) {
+        continue;
+      }
+
+      const gateControl = controlsByTarget.get(condition.target);
+
+      if (!gateControl || gateControl.sectionLabel === item.sectionLabel) {
+        continue;
+      }
+
+      const sharesTargetEntity =
+        gateControl.loosePrefix !== null &&
+        gateControl.loosePrefix === item.loosePrefix;
+      const looksLikeBranchSection =
+        conditionName === "visibleWhen" &&
+        sectionTitleLooksLikeDependencyBranch({
+          condition,
+          gateControl: gateControl.control,
+          sectionTitle: item.sectionTitle,
+        });
+
+      if (!sharesTargetEntity && !looksLikeBranchSection) {
+        continue;
+      }
+
+      errors.push(
+        `${item.sectionLabel} / ${item.controlId} is gated by ${conditionName} target "${condition.target}" in ${gateControl.sectionLabel}, but it belongs to the same dependency group. Keep selectors and their dependent controls in one semantic section when they describe one product entity or branch; use visibleWhen for branch-specific controls inside that section instead of splitting branch controls into their own section. Do not use disabledWhen for product controls.`,
+      );
+    }
+  }
+
   const fontPickerControls = visibleControls.filter(
     (item) => item.control.type === "fontPicker" && item.loosePrefix,
   );
@@ -2080,9 +2980,12 @@ function getToolcraftControlSectionGroupingErrors(
   }
 
   for (const [prefix, sections] of strictPrefixSections) {
-    if (sections.size > 1) {
+    if (
+      sections.size > 1 &&
+      !hasToolcraftInventorySplitEvidence({ sectionInventoryByTitle, sections })
+    ) {
       errors.push(
-        `Controls for product entity "${prefix}" are split across sections: ${[...sections].join(", ")}. Keep controls for the same product entity in one semantic section unless the spec names a real workflow split.`,
+        `Controls for product entity "${prefix}" are split across sections: ${[...sections].join(", ")}. Keep controls for the same product entity in one semantic section unless the Control Section Inventory declares workflowStage and splitReason for every split section.`,
       );
     }
   }
@@ -2104,11 +3007,13 @@ export function collectToolcraftVisibleControls(
   schema: ResolvedToolcraftAppSchema = starterSchema,
 ): ToolcraftVisibleControl[] {
   return (schema.panels.controls?.sections ?? []).flatMap((section) =>
-    Object.entries(section.controls).map(([controlId, control]) => ({
-      control,
-      controlId,
-      sectionTitle: section.title,
-    })),
+    Object.entries(section.controls)
+      .filter(([, control]) => isToolcraftVisibleAcceptanceControl(control))
+      .map(([controlId, control]) => ({
+        control,
+        controlId,
+        sectionTitle: section.title,
+      })),
   );
 }
 
@@ -2125,7 +3030,7 @@ export function getToolcraftControlOrder(
 ): ToolcraftControlOrderItem[] {
   return (schema.panels.controls?.sections ?? []).flatMap((section) =>
     Object.entries(section.controls)
-      .filter(([, control]) => control.type !== "panelActions")
+      .filter(([, control]) => isToolcraftProductSectionControl(control))
       .map(([controlId, control]) => {
         const role = inferToolcraftControlOrderRole(controlId, control);
 
@@ -2151,6 +3056,7 @@ export function validateToolcraftAcceptanceCoverage(
   schema: ResolvedToolcraftAppSchema = starterSchema,
   acceptance: readonly ToolcraftComponentAcceptance[] = starterAcceptance,
   transferMode: ToolcraftTransferMode = starterTransferMode,
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[] = starterControlSectionInventory,
 ): string[] {
   const errors: string[] = [];
   const controls = collectToolcraftVisibleControls(schema);
@@ -2163,6 +3069,7 @@ export function validateToolcraftAcceptanceCoverage(
   const layersEnabled = Boolean(schema.panels.layers);
   const controlTargets = new Set(controls.map(({ control }) => control.target));
   const animationIntent = transferMode.animationIntent;
+  const hasVideoExportAction = schemaHasVideoExportPanelAction(schema);
   const animationControls = controls.filter(
     (visibleControl) =>
       visibleControl.control.type !== "panelActions" &&
@@ -2180,8 +3087,30 @@ export function validateToolcraftAcceptanceCoverage(
     "history.undo",
   ]);
 
+  errors.push(...getToolcraftRuntimeSetupSectionErrors(schema));
   errors.push(...getToolcraftControlOrderErrors(schema));
-  errors.push(...getToolcraftControlSectionGroupingErrors(schema));
+  errors.push(...getToolcraftControlSectionGroupingErrors(schema, sectionInventory));
+  errors.push(...getToolcraftControlSectionInventoryErrors(schema, sectionInventory));
+
+  const transferModeEvidenceText = getToolcraftTransferModeEvidenceText(transferMode);
+
+  if (
+    videoReferenceEvidencePattern.test(transferModeEvidenceText) &&
+    !transferMode.videoReferenceStudy
+  ) {
+    errors.push(
+      "starterTransferMode cites a video reference, screen recording, GIF, extracted frames, or contact sheet; declare videoReferenceStudy with storyboard frames, frame-to-frame transition analysis, behavior decomposition, and acceptance mapping before implementation.",
+    );
+  }
+
+  if (transferMode.videoReferenceStudy) {
+    errors.push(
+      ...validateToolcraftVideoReferenceStudy(
+        transferMode.videoReferenceStudy,
+        acceptance,
+      ),
+    );
+  }
 
   for (const [sectionIndex, section] of (schema.panels.controls?.sections ?? []).entries()) {
     const sectionLabel = getToolcraftSectionLabel(section.title, sectionIndex);
@@ -2201,6 +3130,16 @@ export function validateToolcraftAcceptanceCoverage(
         );
       }
 
+      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(
@@ -2242,11 +3181,21 @@ export function validateToolcraftAcceptanceCoverage(
             `${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]) => control.type !== "panelActions",
+    const sectionControls = Object.entries(section.controls).filter(([, control]) =>
+      isToolcraftProductSectionControl(control),
     );
 
     for (let index = 0; index < sectionControls.length - 1; index += 1) {
@@ -2282,7 +3231,6 @@ export function validateToolcraftAcceptanceCoverage(
     const panelActionsSectionIndex = getFirstPanelActionsSectionIndex(schema);
     const imageExportSectionIndex = getSchemaControlsSectionIndexByTitle(schema, "Image Export");
     const videoExportSectionIndex = getSchemaControlsSectionIndexByTitle(schema, "Video Export");
-    const hasVideoExportAction = schemaHasVideoExportPanelAction(schema);
     const expectedOutputSettingsIndex =
       imageExportSectionIndex >= 0 ? imageExportSectionIndex : videoExportSectionIndex;
     const finalExportSettingsIndex = hasVideoExportAction
@@ -2474,6 +3422,12 @@ export function validateToolcraftAcceptanceCoverage(
     }
   }
 
+  if (hasVideoExportAction && !timelineMode) {
+    errors.push(
+      'Apps with Export Video must enable the top Toolcraft timeline. Use panels.timeline mode "playback" for product animation transport, or mode "keyframes" when exported animation is driven by keyframes; autonomous no-timeline animation is only allowed when there is no video export.',
+    );
+  }
+
   if (animationControls.length > 0 && !timelineMode && animationIntent?.mode !== "autonomous") {
     errors.push(
       [
@@ -2495,9 +3449,15 @@ export function validateToolcraftAcceptanceCoverage(
       );
     }
 
-    if (!animationIntent.reason.trim()) {
+    if (hasVideoExportAction) {
       errors.push(
-        'starterTransferMode.animationIntent mode "autonomous" must include a reason explaining why the animation is decorative/self-running and does not need top timeline transport.',
+        'starterTransferMode.animationIntent mode "autonomous" conflicts with Export Video. Video export creates product-time behavior, so the renderer and export must use the top Toolcraft timeline duration, loop, and deterministic timestamps.',
+      );
+    }
+
+    if (!animationIntent.reason.trim()) {
+      errors.push(
+        'starterTransferMode.animationIntent mode "autonomous" must include a reason explaining why the animation is decorative/self-running and does not need top timeline transport.',
       );
     }
 
@@ -2520,9 +3480,92 @@ export function validateToolcraftAcceptanceCoverage(
     );
   }
 
+  if (
+    transferMode.mode === "new-toolcraft-app" &&
+    timelineMode === "playback" &&
+    animationIntent?.mode !== "timeline-playback"
+  ) {
+    errors.push(
+      'panels.timeline mode "playback" requires starterTransferMode.animationIntent mode "timeline-playback" with loopDuration provenance.',
+    );
+  }
+
+  if (
+    transferMode.mode === "new-toolcraft-app" &&
+    timelineMode === "keyframes" &&
+    animationIntent?.mode !== "timeline-keyframes"
+  ) {
+    errors.push(
+      'panels.timeline mode "keyframes" requires starterTransferMode.animationIntent mode "timeline-keyframes" with loopDuration provenance.',
+    );
+  }
+
+  if (
+    timelineMode &&
+    (animationIntent?.mode === "timeline-playback" ||
+      animationIntent?.mode === "timeline-keyframes")
+  ) {
+    const timelineDefaultDurationSeconds = schema.panels.timeline?.defaultDurationSeconds;
+    const loopDuration = getTimelineLoopDurationIntent(animationIntent);
+
+    if (!loopDuration) {
+      errors.push(
+        `starterTransferMode.animationIntent mode "${animationIntent.mode}" must declare loopDuration with source, seconds, and evidence. Do not let runtime/template fallback duration such as 8s stand in for product loop intent.`,
+      );
+    } else {
+      if (
+        !Number.isFinite(loopDuration.seconds) ||
+        loopDuration.seconds <= 0
+      ) {
+        errors.push(
+          `starterTransferMode.animationIntent.loopDuration.seconds must be a positive finite duration; received ${String(loopDuration.seconds)}.`,
+        );
+      }
+
+      if (!isValidTimelineLoopDurationSource(loopDuration.source)) {
+        errors.push(
+          `starterTransferMode.animationIntent.loopDuration.source must be "reference", "user-request", or "product-derived"; received "${String(loopDuration.source)}". Runtime/template fallback is not a valid loop-duration source.`,
+        );
+      }
+
+      if (!loopDuration.evidence.trim()) {
+        errors.push(
+          "starterTransferMode.animationIntent.loopDuration.evidence must explain where the initial loop duration came from, such as reference timing, an explicit user request, or a product-derived timing rule.",
+        );
+      }
+
+      if (runtimeDefaultLoopDurationEvidencePattern.test(loopDuration.evidence)) {
+        errors.push(
+          "starterTransferMode.animationIntent.loopDuration.evidence must not cite the runtime/template fallback 8s default as the product loop source. Use reference timing, an explicit user request, or a product-derived timing rule.",
+        );
+      }
+
+      if (typeof timelineDefaultDurationSeconds !== "number") {
+        errors.push(
+          "Timeline playback/keyframe apps must set panels.timeline.defaultDurationSeconds to the declared loopDuration.seconds so the initial UI duration is not the runtime fallback.",
+        );
+      } else if (
+        Number.isFinite(loopDuration.seconds) &&
+        Math.abs(timelineDefaultDurationSeconds - loopDuration.seconds) > 0.001
+      ) {
+        errors.push(
+          `panels.timeline.defaultDurationSeconds (${timelineDefaultDurationSeconds}) must match starterTransferMode.animationIntent.loopDuration.seconds (${loopDuration.seconds}).`,
+        );
+      }
+    }
+  }
+
   if (transferMode.mode === "reference-runtime-clone") {
     const declaredReferenceCoverage = new Set(transferMode.behaviorCoverage);
     const referenceTimeline = transferMode.referenceTimeline;
+    const referenceStudy = transferMode.referenceStudy;
+    const referenceFeatureInventory = transferMode.referenceFeatureInventory ?? [];
+    const acceptanceById = new Map(acceptance.map((entry) => [entry.id, entry]));
+    const referenceFeatureIds = new Set<string>();
+    const referenceFeatureAcceptanceIds = new Set<string>();
+    const referenceCoverageFromInventory = new Set<ToolcraftReferenceCoverage>();
+    const referenceTimelineCoverageFromInventory =
+      new Set<ToolcraftReferenceTimelineCoverage>();
 
     if (!schema.assembly.surfaces.canvas.enabled) {
       errors.push(
@@ -2542,6 +3585,180 @@ export function validateToolcraftAcceptanceCoverage(
       );
     }
 
+    if (!referenceStudy) {
+      errors.push(
+        "reference-runtime-clone transferMode must declare referenceStudy proving the reference was inspected and, when runnable or reconstructable, run or restored locally before implementation.",
+      );
+    } else {
+      if (!referenceStudyStatusValues.has(referenceStudy.status)) {
+        errors.push(
+          'referenceStudy.status must be "ran-original", "restored-local", or "source-inspection-only".',
+        );
+      }
+
+      if (!referenceStudy.referenceLocation.trim()) {
+        errors.push(
+          "referenceStudy.referenceLocation must name the inspected reference folder, URL, artifact, or source location.",
+        );
+      }
+
+      if (!referenceStudy.sourceEvidence.trim()) {
+        errors.push(
+          "referenceStudy.sourceEvidence must summarize the source/runtime files, routes, schemas, or assets inspected.",
+        );
+      }
+
+      if (!referenceStudy.behaviorEvidence.trim()) {
+        errors.push(
+          "referenceStudy.behaviorEvidence must summarize the runtime/browser behavior checked from the original or restored reference.",
+        );
+      }
+
+      if (!referenceStudy.reproductionSteps.trim()) {
+        errors.push(
+          "referenceStudy.reproductionSteps must record how the reference was run, restored in the Toolcraft environment, or why source-only inspection was used.",
+        );
+      }
+
+      if (referenceStudy.status === "source-inspection-only") {
+        if (!referenceStudy.sourceOnlyReason?.trim()) {
+          errors.push(
+            'referenceStudy.status "source-inspection-only" requires sourceOnlyReason explaining why the reference could not be run or restored locally.',
+          );
+        } else if (
+          !referenceStudySourceOnlyReasonPattern.test(referenceStudy.sourceOnlyReason)
+        ) {
+          errors.push(
+            'referenceStudy.sourceOnlyReason must state the concrete blocker that made running or restoring the reference unavailable.',
+          );
+        }
+      }
+    }
+
+    if (referenceFeatureInventory.length === 0) {
+      errors.push(
+        "reference-runtime-clone transferMode must declare referenceFeatureInventory with every user-visible and output-affecting behavior from the inspected reference, mapped to Toolcraft implementation and acceptance coverage.",
+      );
+    }
+
+    for (const [index, feature] of referenceFeatureInventory.entries()) {
+      const featureLabel = feature.id.trim() || `#${index + 1}`;
+
+      if (!feature.id.trim()) {
+        errors.push(
+          `referenceFeatureInventory item ${index + 1} must include a stable id.`,
+        );
+      } else if (referenceFeatureIds.has(feature.id)) {
+        errors.push(
+          `referenceFeatureInventory id "${feature.id}" is duplicated; each reference feature must be inventoried once.`,
+        );
+      } else {
+        referenceFeatureIds.add(feature.id);
+      }
+
+      if (!feature.featureName.trim()) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" must include a short featureName.`,
+        );
+      }
+
+      if (!feature.sourceEvidence.trim()) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" must include sourceEvidence from the inspected reference source, runtime, UI, or browser behavior.`,
+        );
+      }
+
+      if (!feature.behaviorEvidence.trim()) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" must include behaviorEvidence from the original, restored, or source-only reference study proving this feature was observed before Toolcraft mapping.`,
+        );
+      }
+
+      if (!feature.referenceBehavior.trim()) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" must describe the referenceBehavior to preserve.`,
+        );
+      }
+
+      if (!feature.toolcraftMapping.trim()) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" must describe the Toolcraft mapping for the preserved behavior.`,
+        );
+      }
+
+      if (!referenceFeatureStatusValues.has(feature.status)) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" status must be "ported", "toolcraft-native", or "intentionally-changed".`,
+        );
+      }
+
+      if (feature.status === "intentionally-changed") {
+        if (!feature.userApprovedChangeReason?.trim()) {
+          errors.push(
+            `referenceFeatureInventory "${featureLabel}" status "intentionally-changed" requires userApprovedChangeReason.`,
+          );
+        } else if (
+          !explicitReferenceChangeReasonPattern.test(feature.userApprovedChangeReason)
+        ) {
+          errors.push(
+            `referenceFeatureInventory "${featureLabel}" userApprovedChangeReason must cite explicit user approval or redesign/change-request evidence.`,
+          );
+        }
+      }
+
+      const acceptanceId = feature.acceptanceId.trim();
+
+      if (!acceptanceId) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" must include acceptanceId for the test proving the mapped reference behavior.`,
+        );
+        continue;
+      }
+
+      referenceFeatureAcceptanceIds.add(acceptanceId);
+
+      const entry = acceptanceById.get(acceptanceId);
+
+      if (!entry) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" points to missing acceptanceId "${acceptanceId}".`,
+        );
+        continue;
+      }
+
+      if (!entry.referenceCoverage && !entry.referenceTimelineCoverage) {
+        errors.push(
+          `referenceFeatureInventory "${featureLabel}" acceptanceId "${acceptanceId}" must point to an acceptance entry with referenceCoverage or referenceTimelineCoverage.`,
+        );
+      }
+
+      if (entry.referenceCoverage) {
+        referenceCoverageFromInventory.add(entry.referenceCoverage);
+      }
+
+      if (entry.referenceTimelineCoverage) {
+        referenceTimelineCoverageFromInventory.add(entry.referenceTimelineCoverage);
+      }
+
+      if (!entry.automated || !entry.automatedTestName.trim()) {
+        errors.push(
+          `${acceptanceId} must have automated coverage proving inventoried reference feature "${featureLabel}".`,
+        );
+      }
+
+      if (!entry.browser || !entry.browserTestName.trim()) {
+        errors.push(
+          `${acceptanceId} must have browser coverage proving inventoried reference feature "${featureLabel}".`,
+        );
+      }
+
+      if (!entry.expectedObservable.trim()) {
+        errors.push(
+          `${acceptanceId} must describe the observable result for inventoried reference feature "${featureLabel}".`,
+        );
+      }
+    }
+
     for (const coverage of requiredReferenceCloneCoverage) {
       if (!declaredReferenceCoverage.has(coverage)) {
         errors.push(
@@ -2581,6 +3798,14 @@ export function validateToolcraftAcceptanceCoverage(
       }
     }
 
+    for (const coverage of declaredReferenceCoverage) {
+      if (!referenceCoverageFromInventory.has(coverage)) {
+        errors.push(
+          `reference-runtime-clone behaviorCoverage "${coverage}" must be represented in referenceFeatureInventory by an item whose acceptanceId points to that referenceCoverage.`,
+        );
+      }
+    }
+
     if (!referenceTimeline) {
       errors.push(
         'reference-runtime-clone transferMode must declare referenceTimeline with mode "none", "toolcraft-playback", "toolcraft-keyframes", or "custom-reference-timeline".',
@@ -2594,6 +3819,14 @@ export function validateToolcraftAcceptanceCoverage(
         (coverage) => toolcraftReferenceTimelineCoverage.has(coverage),
       );
 
+      for (const coverage of declaredReferenceTimelineCoverage) {
+        if (!referenceTimelineCoverageFromInventory.has(coverage)) {
+          errors.push(
+            `referenceTimeline behaviorCoverage "${coverage}" must be represented in referenceFeatureInventory by an item whose acceptanceId points to that referenceTimelineCoverage.`,
+          );
+        }
+      }
+
       if (referenceTimeline.mode === "none" && declaredReferenceTimelineCoverage.size > 0) {
         errors.push(
           'referenceTimeline mode "none" must not declare reference timeline behaviorCoverage.',
@@ -2631,6 +3864,57 @@ export function validateToolcraftAcceptanceCoverage(
         );
       }
 
+      if (
+        referenceTimeline.mode === "toolcraft-playback" ||
+        referenceTimeline.mode === "toolcraft-keyframes"
+      ) {
+        const timelineDefaultDurationSeconds = schema.panels.timeline?.defaultDurationSeconds;
+        const loopDuration = referenceTimeline.loopDuration;
+
+        if (!loopDuration) {
+          errors.push(
+            `referenceTimeline mode "${referenceTimeline.mode}" must declare loopDuration with source, seconds, and evidence. Do not let runtime/template fallback duration such as 8s stand in for reference loop intent.`,
+          );
+        } else {
+          if (!Number.isFinite(loopDuration.seconds) || loopDuration.seconds <= 0) {
+            errors.push(
+              `referenceTimeline.loopDuration.seconds must be a positive finite duration; received ${String(loopDuration.seconds)}.`,
+            );
+          }
+
+          if (!isValidTimelineLoopDurationSource(loopDuration.source)) {
+            errors.push(
+              `referenceTimeline.loopDuration.source must be "reference", "user-request", or "product-derived"; received "${String(loopDuration.source)}". Runtime/template fallback is not a valid loop-duration source.`,
+            );
+          }
+
+          if (!loopDuration.evidence.trim()) {
+            errors.push(
+              "referenceTimeline.loopDuration.evidence must explain where the reference loop duration came from, such as measured reference timing, an explicit user request, or a product-derived timing rule.",
+            );
+          }
+
+          if (runtimeDefaultLoopDurationEvidencePattern.test(loopDuration.evidence)) {
+            errors.push(
+              "referenceTimeline.loopDuration.evidence must not cite the runtime/template fallback 8s default as the reference loop source. Use measured reference timing, an explicit user request, or a product-derived timing rule.",
+            );
+          }
+
+          if (typeof timelineDefaultDurationSeconds !== "number") {
+            errors.push(
+              "Toolcraft reference playback/keyframe timelines must set panels.timeline.defaultDurationSeconds to referenceTimeline.loopDuration.seconds so the initial UI duration is not the runtime fallback.",
+            );
+          } else if (
+            Number.isFinite(loopDuration.seconds) &&
+            Math.abs(timelineDefaultDurationSeconds - loopDuration.seconds) > 0.001
+          ) {
+            errors.push(
+              `panels.timeline.defaultDurationSeconds (${timelineDefaultDurationSeconds}) must match referenceTimeline.loopDuration.seconds (${loopDuration.seconds}).`,
+            );
+          }
+        }
+      }
+
       if (
         referenceTimeline.mode === "toolcraft-playback" &&
         declaredReferenceTimelineCoverage.has("keyframes")
@@ -2714,6 +3998,17 @@ export function validateToolcraftAcceptanceCoverage(
         }
       }
     }
+
+    for (const entry of acceptance) {
+      if (
+        (entry.referenceCoverage || entry.referenceTimelineCoverage) &&
+        !referenceFeatureAcceptanceIds.has(entry.id)
+      ) {
+        errors.push(
+          `${entry.id} declares reference coverage but is not mapped from referenceFeatureInventory. Every reference acceptance row must correspond to an inventoried reference feature.`,
+        );
+      }
+    }
   } else {
     for (const entry of acceptance) {
       if (entry.referenceCoverage) {
@@ -2786,23 +4081,42 @@ export function validateToolcraftAcceptanceCoverage(
       errors.push(
         `${playbackEntry.id} timelineCoverage "playback" must declare timelinePlaybackCoverage for pause-resume, scrub, duration, loop, and rendered-frame. Duration coverage must prove renderer progress maps 0..state.timeline.durationSeconds, not a local fixed animation duration.`,
       );
-    } else if (hasTimelinePlaybackCoveragePart(playbackEntry.timelinePlaybackCoverage, "duration")) {
-      const durationEvidenceText = [
+    } else {
+      const playbackEvidenceText = [
         playbackEntry.automatedTestName,
         playbackEntry.browserTestName,
         playbackEntry.expectedObservable,
         playbackEntry.userAction,
       ].join(" ");
 
-      if (!/\bduration\b/i.test(durationEvidenceText) || !/\b(edit|change|commit|enter|set)\w*\b/i.test(durationEvidenceText)) {
+      if (
+        hasTimelinePlaybackCoveragePart(playbackEntry.timelinePlaybackCoverage, "duration") &&
+        (!/\bduration\b/i.test(playbackEvidenceText) ||
+          !/\b(edit|change|commit|enter|set)\w*\b/i.test(playbackEvidenceText))
+      ) {
         errors.push(
           `${playbackEntry.id} timelinePlaybackCoverage "duration" must describe editing/changing the timeline duration through the UI and proving the renderer follows state.timeline.durationSeconds.`,
         );
       }
+
+      if (
+        hasTimelinePlaybackCoveragePart(playbackEntry.timelinePlaybackCoverage, "loop") &&
+        !hasSeamlessForwardLoopEvidence(playbackEvidenceText)
+      ) {
+        errors.push(
+          `${playbackEntry.id} timelinePlaybackCoverage "loop" must prove a seamless forward-only product loop: motion advances in one direction, avoids mirror/yoyo/ping-pong/reverse fallbacks, first and last frames stitch without a visible jump, and the same seam holds after changing timeline duration.`,
+        );
+      }
     }
   }
 
   if (schema.canvas.sizing.mode === "fixed-output") {
+    if (schemaHasPngExportPanelAction(schema) || schemaHasVideoExportPanelAction(schema)) {
+      errors.push(
+        'Product/output apps with export actions must use canvas.sizing mode "editable-output" so Aspect ratio, Canvas width, and Canvas height are always available. Put reference, fixed-format, or user-requested dimensions in canvas.size as the initial value instead of hiding size controls with "fixed-output".',
+      );
+    }
+
     const fixedCanvasSizingEntry = acceptance.find(
       (entry) =>
         entry.kind === "runtime" &&
@@ -2811,14 +4125,20 @@ export function validateToolcraftAcceptanceCoverage(
 
     if (!fixedCanvasSizingEntry) {
       errors.push(
-        'canvas.sizing mode "fixed-output" requires a runtime acceptance entry with canvasSizingCoverage "fixed-output-size" explaining why width and height are intentionally non-editable. A user-provided base/default size should normally use "editable-output".',
+        'canvas.sizing mode "fixed-output" requires a runtime acceptance entry with canvasSizingCoverage "fixed-output-size" explaining why width and height are intentionally non-editable. Product/output apps must use "editable-output"; user-provided, reference, fixed-format, or base/default sizes belong in canvas.size as editable initial values.',
       );
     } else {
       const evidenceText = getAcceptanceEvidenceText(fixedCanvasSizingEntry);
 
       if (!/(fixed|locked|non-editable|not user-editable|must not edit|reference-defined|product-defined)/i.test(evidenceText)) {
         errors.push(
-          `${fixedCanvasSizingEntry.id} canvasSizingCoverage "fixed-output-size" must explain why the product output dimensions are intentionally fixed, not merely initialized from a default size.`,
+          `${fixedCanvasSizingEntry.id} canvasSizingCoverage "fixed-output-size" must explain why the output dimensions are intentionally fixed for a non-product/internal fixture, not merely initialized from a default size.`,
+        );
+      }
+
+      if (insufficientFixedCanvasSizingReasonPattern.test(evidenceText)) {
+        errors.push(
+          `${fixedCanvasSizingEntry.id} canvasSizingCoverage "fixed-output-size" cannot be justified by the reference or previous app lacking a size editor. Exportable product apps must use editable-output; put reference, product-defined, or fixed-format dimensions in canvas.size as initial values instead of hiding size controls.`,
         );
       }
 
@@ -2836,84 +4156,83 @@ export function validateToolcraftAcceptanceCoverage(
     }
   }
 
-  if (schema.persistence.storage === "localStorage") {
-    const persistenceEntry = acceptance.find(
+  if (
+    schema.canvas.enabled &&
+    schema.canvas.upload &&
+    schema.canvas.sizing.mode === "intrinsic-media"
+  ) {
+    const intrinsicCanvasSizingEntry = acceptance.find(
       (entry) =>
         entry.kind === "runtime" &&
-        entry.persistenceCoverage === "reload",
+        entry.canvasSizingCoverage === "intrinsic-media-size",
     );
 
-    if (!persistenceEntry) {
+    if (!intrinsicCanvasSizingEntry) {
       errors.push(
-        'persistence.storage "localStorage" requires a runtime acceptance entry with persistenceCoverage "reload" proving user-edited persisted state restores after a real browser reload. Settings import/export is not a substitute for persistence.',
+        'canvas.sizing mode "intrinsic-media" with upload requires a runtime acceptance entry with canvasSizingCoverage "intrinsic-media-size" proving the app is a true media-viewer/source-native product where imported media natural dimensions intentionally own canvas.size. Uploaded background/source images inside product canvases must use "editable-output" and keep the current canvas size.',
       );
     } else {
-      const evidenceText = getAcceptanceEvidenceText(persistenceEntry);
+      const evidenceText = getAcceptanceEvidenceText(intrinsicCanvasSizingEntry);
 
-      if (!persistenceEntry.automated || !persistenceEntry.automatedTestName.trim()) {
-        errors.push(
-          `${persistenceEntry.id} must have automated coverage proving persistence reload behavior.`,
-        );
-      }
-
-      if (!persistenceEntry.browser || !persistenceEntry.browserTestName.trim()) {
+      if (
+        !/(media[- ]viewer|source[- ]native|natural dimension|natural size|intrinsic media|intrinsic size|media owns canvas|canvas\.size)/i.test(
+          evidenceText,
+        )
+      ) {
         errors.push(
-          `${persistenceEntry.id} must have browser coverage proving persistence reload behavior.`,
+          `${intrinsicCanvasSizingEntry.id} canvasSizingCoverage "intrinsic-media-size" must explain why uploaded media natural dimensions intentionally own canvas.size instead of behaving as background/source material inside the current editable output canvas.`,
         );
       }
 
-      if (!persistenceEntry.expectedObservable.trim()) {
+      if (!intrinsicCanvasSizingEntry.automated || !intrinsicCanvasSizingEntry.automatedTestName.trim()) {
         errors.push(
-          `${persistenceEntry.id} must describe the persisted state observable after reload.`,
+          `${intrinsicCanvasSizingEntry.id} must have automated coverage proving intrinsic media sizing.`,
         );
       }
 
-      if (!/\b(reload|refresh|reopen|page\.reload)\b/i.test(evidenceText)) {
+      if (!intrinsicCanvasSizingEntry.browser || !intrinsicCanvasSizingEntry.browserTestName.trim()) {
         errors.push(
-          `${persistenceEntry.id} persistenceCoverage "reload" must describe changing a user-facing setting, reloading the browser page, and observing the restored value/output.`,
+          `${intrinsicCanvasSizingEntry.id} must have browser coverage proving intrinsic media sizing.`,
         );
       }
     }
   }
 
-  const settingsTransferEligibility = getToolcraftSettingsTransferEligibility({
-    panels: schema.panels,
-  });
-
-  if (settingsTransferEligibility.eligible && !schema.settingsTransfer.enabled) {
-    const settingsTransferOptOutEntry = acceptance.find(
+  if (schema.persistence.storage === "localStorage") {
+    const persistenceEntry = acceptance.find(
       (entry) =>
         entry.kind === "runtime" &&
-        entry.target === "runtime.settingsTransfer" &&
-        entry.settingsTransferCoverage === "opt-out",
+        entry.persistenceCoverage === "reload",
     );
 
-    if (!settingsTransferOptOutEntry) {
+    if (!persistenceEntry) {
       errors.push(
-        [
-          "settingsTransfer is required for this complex product app because settings-transfer eligibility was reached.",
-          `Eligibility: ${settingsTransferEligibility.controlCount} product controls, ${settingsTransferEligibility.sectionCount} product sections, weighted score ${settingsTransferEligibility.score}, reasons ${settingsTransferEligibility.reasons.join(", ")}.`,
-          'Use schema settingsTransfer: "auto" or true, or add a runtime acceptance entry with settingsTransferCoverage "opt-out" explaining why the app is ephemeral, temporary, one-off, not portable, or session-only.',
-        ].join(" "),
+        'persistence.storage "localStorage" requires a runtime acceptance entry with persistenceCoverage "reload" proving user-edited persisted state restores after a real browser reload. Settings import/export is not a substitute for persistence.',
       );
     } else {
-      const evidenceText = getAcceptanceEvidenceText(settingsTransferOptOutEntry);
+      const evidenceText = getAcceptanceEvidenceText(persistenceEntry);
+
+      if (!persistenceEntry.automated || !persistenceEntry.automatedTestName.trim()) {
+        errors.push(
+          `${persistenceEntry.id} must have automated coverage proving persistence reload behavior.`,
+        );
+      }
 
-      if (!settingsTransferOptOutEntry.automated || !settingsTransferOptOutEntry.automatedTestName.trim()) {
+      if (!persistenceEntry.browser || !persistenceEntry.browserTestName.trim()) {
         errors.push(
-          `${settingsTransferOptOutEntry.id} settingsTransferCoverage "opt-out" must have automated coverage proving the app intentionally omits portable settings.`,
+          `${persistenceEntry.id} must have browser coverage proving persistence reload behavior.`,
         );
       }
 
-      if (!settingsTransferOptOutEntry.browser || !settingsTransferOptOutEntry.browserTestName.trim()) {
+      if (!persistenceEntry.expectedObservable.trim()) {
         errors.push(
-          `${settingsTransferOptOutEntry.id} settingsTransferCoverage "opt-out" must have browser coverage proving the app intentionally omits portable settings.`,
+          `${persistenceEntry.id} must describe the persisted state observable after reload.`,
         );
       }
 
-      if (!settingsTransferOptOutReasonPattern.test(evidenceText)) {
+      if (!/\b(reload|refresh|reopen|page\.reload)\b/i.test(evidenceText)) {
         errors.push(
-          `${settingsTransferOptOutEntry.id} settingsTransferCoverage "opt-out" must explain why the complex app does not need portable settings using a concrete reason such as ephemeral, temporary, one-off, not portable, or session-only.`,
+          `${persistenceEntry.id} persistenceCoverage "reload" must describe changing a user-facing setting, reloading the browser page, and observing the restored value/output.`,
         );
       }
     }
@@ -2938,11 +4257,25 @@ export function validateToolcraftAcceptanceCoverage(
     const isCustomControl = isCustomToolcraftControl(control);
     const isSelectedLayerTarget = control.target.startsWith("selectedLayer.");
     const toggleLabelError = getToggleControlLabelError(control, sectionTitle);
+    const singleActionsLabelError = getSingleActionsControlLabelError(control);
+    const codeTextareaError = getCodeTextareaControlError({
+      control,
+      controlId,
+      label,
+    });
 
     if (toggleLabelError) {
       errors.push(`${label} ${toggleLabelError}`);
     }
 
+    if (singleActionsLabelError) {
+      errors.push(`${label} ${singleActionsLabelError}`);
+    }
+
+    if (codeTextareaError) {
+      errors.push(codeTextareaError);
+    }
+
     if (
       control.type === "rangeSlider" &&
       Array.isArray(control.defaultValue) &&
@@ -3014,6 +4347,18 @@ export function validateToolcraftAcceptanceCoverage(
       );
     }
 
+    if (control.disabled === true) {
+      errors.push(
+        `${label} sets disabled: true. Generated product panels should show only controls usable in the current state; hide unavailable product controls with visibleWhen instead of rendering disabled controls.`,
+      );
+    }
+
+    if (control.disabledWhen) {
+      errors.push(
+        `${label} uses disabledWhen. Generated product panels should show only controls usable in the current state; hide unavailable product controls with visibleWhen instead of rendering disabled controls.`,
+      );
+    }
+
     if (!entry) {
       errors.push(`${label} is missing an acceptance entry.`);
       continue;
@@ -3046,7 +4391,18 @@ export function validateToolcraftAcceptanceCoverage(
     }
 
     if (control.type === "fileDrop") {
-      errors.push(...getFileDropLifecycleCoverageErrors(label, entry));
+      const hasDefaultMediaAssets = schema.media.defaultAssets.some(
+        (asset) => asset.sourceTarget === control.target,
+      );
+
+      errors.push(
+        ...getFileDropLifecycleCoverageErrors(
+          label,
+          control,
+          entry,
+          hasDefaultMediaAssets,
+        ),
+      );
     }
 
     if (
@@ -3065,17 +4421,6 @@ export function validateToolcraftAcceptanceCoverage(
       errors.push(...getBuiltInFitCheckErrors(label, entry, control));
     }
 
-    if (
-      control.disabledWhen &&
-      !/\b(disabled|unavailable|inactive|not editable|not meaningful|no effect|without effect)\b/i.test(
-        getAcceptanceEvidenceText(entry),
-      )
-    ) {
-      errors.push(
-        `${label} uses disabledWhen and acceptance must prove the control becomes disabled/unavailable when ${control.disabledWhen.target} reaches the disabling value.`,
-      );
-    }
-
     if (
       control.visibleWhen &&
       !/\b(visible|shown|show|appears|hidden|hide|hides|not visible|disappear|unavailable)\b/i.test(
@@ -3143,6 +4488,12 @@ export function validateToolcraftAcceptanceCoverage(
     if (isSliderLikeControl(control)) {
       const expectedMarkerCount = getStepMarkerCount(control);
 
+      if (control.unit === "x") {
+        errors.push(
+          `${label} uses unit "x", but Toolcraft slider values do not use x suffixes. Omit unit for scale, multiplier, intensity, opacity, strength, depth, and shader amount values unless a real measurement unit applies.`,
+        );
+      }
+
       if (
         control.variant === "discrete" &&
         expectedMarkerCount &&
@@ -3204,7 +4555,12 @@ export function validateToolcraftAcceptanceCoverage(
   }
 
   for (const entry of acceptance) {
-    if (entry.kind === "control" && entry.target && !controlTargets.has(entry.target)) {
+    if (
+      entry.kind === "control" &&
+      entry.target &&
+      !controlTargets.has(entry.target) &&
+      !isRuntimeSetupControlTarget(entry.target)
+    ) {
       errors.push(`${entry.id} points to missing control target ${entry.target}.`);
     }