@pixel-point/toolcraft 0.0.9 → 0.0.12

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"
@@ -171,8 +243,6 @@ 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;
 
@@ -190,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 =
@@ -307,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));
 }
@@ -404,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);
@@ -425,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;
 }
 
@@ -1384,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;
 
@@ -1414,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,
@@ -1499,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;
       }
 
@@ -1528,6 +1924,107 @@ function getToolcraftControlOrderErrors(schema: ResolvedToolcraftAppSchema): str
   return errors;
 }
 
+function getToolcraftRuntimeSetupSectionErrors(
+  schema: ResolvedToolcraftAppSchema,
+): string[] {
+  const errors: string[] = [];
+  const controlsPanel = schema.panels.controls;
+
+  if (!controlsPanel) {
+    return [
+      "Generated Toolcraft apps must define a controls panel so the mandatory runtime Setup section is visible.",
+    ];
+  }
+
+  const sections = schema.panels.controls?.sections ?? [];
+
+  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;
 
@@ -1846,13 +2343,14 @@ function isToolcraftProductSectionControl(control: ToolcraftControlSchema): bool
   return (
     control.type !== "panelActions" &&
     control.type !== "settingsTransfer" &&
-    control.target !== "canvas.aspectRatio" &&
-    control.target !== "canvas.renderScale" &&
-    control.target !== "canvas.size.width" &&
-    control.target !== "canvas.size.height"
+    !isRuntimeSetupControlTarget(control.target)
   );
 }
 
+function isToolcraftVisibleAcceptanceControl(control: ToolcraftControlSchema): boolean {
+  return control.type === "panelActions" || isToolcraftProductSectionControl(control);
+}
+
 function getToolcraftGenericControlLabelError({
   control,
   controlId,
@@ -2266,8 +2764,8 @@ function getToolcraftControlSectionGroupingErrors(
   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) {
@@ -2445,7 +2943,7 @@ function getToolcraftControlSectionGroupingErrors(
       }
 
       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/disabledWhen inside that section instead of splitting branch controls into their own section.`,
+        `${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.`,
       );
     }
   }
@@ -2509,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,
+      })),
   );
 }
 
@@ -2530,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);
 
@@ -2569,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" &&
@@ -2586,11 +3087,32 @@ export function validateToolcraftAcceptanceCoverage(
     "history.undo",
   ]);
 
+  errors.push(...getToolcraftRuntimeSetupSectionErrors(schema));
   errors.push(...getToolcraftControlOrderErrors(schema));
   errors.push(...getToolcraftControlSectionGroupingErrors(schema, sectionInventory));
   errors.push(...getToolcraftControlSectionInventoryErrors(schema, sectionInventory));
 
-  for (const [sectionIndex, section] of (schema.panels.controls?.sections ?? []).entries()) {
+  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);
 
     for (const layoutGroup of section.layoutGroups ?? []) {
@@ -2672,8 +3194,8 @@ export function validateToolcraftAcceptanceCoverage(
       }
     }
 
-    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) {
@@ -2709,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
@@ -2901,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(
       [
@@ -2922,6 +3449,12 @@ export function validateToolcraftAcceptanceCoverage(
       );
     }
 
+    if (hasVideoExportAction) {
+      errors.push(
+        '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.',
@@ -2947,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(
@@ -2969,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(
@@ -3008,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".',
@@ -3021,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.',
@@ -3058,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")
@@ -3141,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) {
@@ -3213,19 +4081,32 @@ 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.`,
+        );
+      }
     }
   }
 
@@ -3275,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 (!settingsTransferOptOutEntry.automated || !settingsTransferOptOutEntry.automatedTestName.trim()) {
+      if (!persistenceEntry.automated || !persistenceEntry.automatedTestName.trim()) {
         errors.push(
-          `${settingsTransferOptOutEntry.id} settingsTransferCoverage "opt-out" must have automated coverage proving the app intentionally omits portable settings.`,
+          `${persistenceEntry.id} must have automated coverage proving persistence reload behavior.`,
         );
       }
 
-      if (!settingsTransferOptOutEntry.browser || !settingsTransferOptOutEntry.browserTestName.trim()) {
+      if (!persistenceEntry.browser || !persistenceEntry.browserTestName.trim()) {
         errors.push(
-          `${settingsTransferOptOutEntry.id} settingsTransferCoverage "opt-out" must have browser coverage proving the app intentionally omits portable settings.`,
+          `${persistenceEntry.id} must have browser coverage proving persistence reload behavior.`,
         );
       }
 
-      if (!settingsTransferOptOutReasonPattern.test(evidenceText)) {
+      if (!persistenceEntry.expectedObservable.trim()) {
+        errors.push(
+          `${persistenceEntry.id} must describe the persisted state observable after reload.`,
+        );
+      }
+
+      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.`,
         );
       }
     }
@@ -3467,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;
@@ -3499,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 (
@@ -3518,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(
@@ -3663,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}.`);
     }