@pixel-point/toolcraft 0.0.7 → 0.0.9

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

@@ -147,9 +147,11 @@ export type ToolcraftCustomControlCoverage =
 const builtInToolcraftControlTypeValues = [
   "actions",
   "anchorGrid",
+  "aspectRatio",
   "channelMixer",
   "checkbox",
   "code",
+  "collectionActions",
   "color",
   "colorOpacity",
   "curves",
@@ -171,6 +173,8 @@ const builtInToolcraftControlTypeValues = [
 ] 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];
@@ -263,6 +267,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",
@@ -276,10 +289,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 ?? ""}`;
 }
@@ -385,6 +404,34 @@ function getAcceptanceEvidenceText(entry: ToolcraftComponentAcceptance): string
   ].join(" ");
 }
 
+function getFileDropLifecycleCoverageErrors(
+  label: string,
+  entry: ToolcraftComponentAcceptance,
+): string[] {
+  const errors: string[] = [];
+  const evidenceText = getAcceptanceEvidenceText(entry);
+
+  if (entry.evidence !== "media-lifecycle") {
+    errors.push(
+      `${label} fileDrop acceptance evidence must be "media-lifecycle" so upload, clear, and reset behavior cannot be replaced by generic product-output coverage.`,
+    );
+  }
+
+  if (
+    !/\b(upload|import|drop|drag|browse|choose|select file|source image)\b/i.test(
+      evidenceText,
+    ) ||
+    !/\b(clear|remove|delete|trash)\b/i.test(evidenceText) ||
+    !/\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.`,
+    );
+  }
+
+  return errors;
+}
+
 const conditionOperatorLabels = [
   "equals",
   "notEquals",
@@ -520,9 +567,109 @@ function isCustomToolcraftControl(control: ToolcraftControlSchema): boolean {
   return !builtInToolcraftControlTypes.has(control.type);
 }
 
+const collectionEntityCustomControlRe =
+  /\b(collection|repeatable|list|lists|item|items|entry|entries|row|rows|asset|assets|object|objects|color|colors|swatch|swatches|glyph|glyphs|symbol|symbols|point|points|stop|stops|variant|variants|rule|rules|mask|masks|shape|shapes|layer|layers|media|image|images|file|files)\b/i;
+const collectionOperationCustomControlRe =
+  /\b(add|adding|delete|deleting|remove|removing|reorder|reordering|order|ordering|sort|sorting|select|selecting|selected|selection|duplicate|duplicating|upload|import|clear|clearing)\b/i;
+
+const actionLikeCustomControlRe =
+  /\b(add|adding|delete|deleting|remove|removing|duplicate|duplicating|sort|sorting|normalize|normalizing|clear|clearing|reset|shuffle|randomize|randomizing)\b/i;
+
+const chromeOnlyCustomControlReasonRe =
+  /\b(icon|icons|visual|style|styling|layout|spacing|chrome|button|buttons|compact|custom look|custom ui)\b/i;
+const productInteractionCustomControlReasonRe =
+  /\b(runtime|state|canvas|output|export|upload|import|preview|reorder|ordering|sort|drag|resize|handle|threshold|density|mapping|geometry|nested|multi|multiple|per-item|metadata|hit target|validation|selection)\b/i;
+const collectionValueKeyRe =
+  /^(items?|entries|rows|assets|objects|colors?|glyphs?|symbols?|points?|stops?|variants?|rules?|masks?|shapes?|layers?|media|images?|files?)$/i;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringifyUnknownForFitCheck(value: unknown): string {
+  if (value == null) {
+    return "";
+  }
+
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(stringifyUnknownForFitCheck).join(" ");
+  }
+
+  if (isRecord(value)) {
+    return Object.entries(value)
+      .flatMap(([key, entryValue]) => [key, stringifyUnknownForFitCheck(entryValue)])
+      .join(" ");
+  }
+
+  return "";
+}
+
+function arrayLooksLikeCollectionValue(value: readonly unknown[]): boolean {
+  return (
+    value.length === 0 ||
+    value.some((item) => isRecord(item) || Array.isArray(item) || typeof item === "string")
+  );
+}
+
+function hasCollectionValueShape(value: unknown): boolean {
+  if (!isRecord(value)) {
+    return Array.isArray(value) && arrayLooksLikeCollectionValue(value);
+  }
+
+  return Object.entries(value).some(([key, entryValue]) => {
+    if (Array.isArray(entryValue)) {
+      return collectionValueKeyRe.test(key) || arrayLooksLikeCollectionValue(entryValue);
+    }
+
+    return collectionValueKeyRe.test(key) && isRecord(entryValue);
+  });
+}
+
+function getCustomFitCheckSearchText(
+  entry: ToolcraftComponentAcceptance,
+  control?: ToolcraftControlSchema,
+): string {
+  return [
+    control?.type,
+    control?.target,
+    typeof control?.label === "string" ? control.label : undefined,
+    stringifyUnknownForFitCheck(control?.defaultValue),
+    entry.id,
+    entry.target,
+    entry.componentType,
+    entry.expectedObservable,
+    entry.userAction,
+    entry.builtInFitCheck?.whyInsufficient,
+    entry.builtInFitCheck?.productObservable,
+  ]
+    .filter(Boolean)
+    .join(" ");
+}
+
+function isCollectionLikeCustomControl(
+  entry: ToolcraftComponentAcceptance,
+  control: ToolcraftControlSchema,
+): boolean {
+  if (hasCollectionValueShape(control.defaultValue)) {
+    return true;
+  }
+
+  const searchText = getCustomFitCheckSearchText(entry, control);
+
+  return (
+    collectionEntityCustomControlRe.test(searchText) &&
+    collectionOperationCustomControlRe.test(searchText)
+  );
+}
+
 function getBuiltInFitCheckErrors(
   label: string,
   entry: ToolcraftComponentAcceptance,
+  control: ToolcraftControlSchema,
 ): string[] {
   const fitCheck = entry.builtInFitCheck;
 
@@ -574,6 +721,32 @@ function getBuiltInFitCheckErrors(
     );
   }
 
+  const searchText = getCustomFitCheckSearchText(entry, control);
+
+  if (
+    isCollectionLikeCustomControl(entry, control) &&
+    !checkedBuiltIns.includes("collectionActions")
+  ) {
+    errors.push(
+      `${label} builtInFitCheck.checkedBuiltIns must include collectionActions when the custom control owns a growable, removable, selectable, or reorderable runtime item set.`,
+    );
+  }
+
+  if (actionLikeCustomControlRe.test(searchText) && !checkedBuiltIns.includes("actions")) {
+    errors.push(
+      `${label} builtInFitCheck.checkedBuiltIns must include actions when the custom control exposes local command buttons such as add, remove, delete, duplicate, sort, normalize, or clear.`,
+    );
+  }
+
+  if (
+    chromeOnlyCustomControlReasonRe.test(fitCheck.whyInsufficient) &&
+    !productInteractionCustomControlReasonRe.test(fitCheck.whyInsufficient)
+  ) {
+    errors.push(
+      `${label} builtInFitCheck.whyInsufficient cannot justify a custom control only with icons, layout, styling, or custom buttons; name the product interaction or value model that built-ins cannot express.`,
+    );
+  }
+
   return errors;
 }
 
@@ -714,6 +887,68 @@ function getControlLabelText(control: ToolcraftControlSchema): string {
   return typeof control.label === "string" ? control.label : "";
 }
 
+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 =
@@ -772,6 +1007,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;
 
@@ -1160,7 +1422,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)}`,
   );
 }
@@ -1286,7 +1548,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],
@@ -1524,6 +1786,73 @@ 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" &&
+    control.target !== "canvas.aspectRatio" &&
+    control.target !== "canvas.renderScale" &&
+    control.target !== "canvas.size.width" &&
+    control.target !== "canvas.size.height"
+  );
+}
+
 function getToolcraftGenericControlLabelError({
   control,
   controlId,
@@ -1603,13 +1932,23 @@ function getToolcraftControlDescriptionError({
 }
 
 function isToolcraftColorSectionTitle(sectionTitle: string | undefined): boolean {
-  return /\b(colou?rs?|palette|palettes)\b/i.test(sectionTitle ?? "");
+  return /\b(colou?rs?|palette|palettes|shades?|accents?)\b/i.test(
+    sectionTitle ?? "",
+  );
 }
 
 function isToolcraftSequentialColorLabel(label: string): boolean {
   return /^colou?r\s+\d+$/i.test(label.trim());
 }
 
+function isToolcraftPaletteVariationTarget(target: string): boolean {
+  return (
+    /(?:^|\.)(?:palette|palettes|colou?rs?|shades?|accents?)\b/i.test(
+      target,
+    ) || /(?:^|\.)(?:accent|shade|colou?r)\d+\b/i.test(target)
+  );
+}
+
 function isToolcraftSimplePaletteDistributionLabel(label: string): boolean {
   return /^(spread|mix|distribution)$/i.test(label.trim());
 }
@@ -1648,8 +1987,257 @@ function isToolcraftObviousColorSectionControlDescription({
   );
 }
 
+function getToolcraftColorBankLabelErrors({
+  controls,
+  sectionLabel,
+  sectionTitle,
+}: {
+  controls: readonly [string, ToolcraftControlSchema][];
+  sectionLabel: string;
+  sectionTitle: string | undefined;
+}): string[] {
+  const colorControls = controls.filter(([, control]) => {
+    if (control.type !== "color" && control.type !== "colorOpacity") {
+      return false;
+    }
+
+    return true;
+  });
+
+  if (colorControls.length < 2) {
+    return [];
+  }
+
+  const loosePrefixes = new Set(
+    colorControls
+      .map(([, control]) => getToolcraftLooseTargetPrefix(control.target))
+      .filter((prefix): prefix is string => Boolean(prefix)),
+  );
+
+  if (loosePrefixes.size !== 1) {
+    return [];
+  }
+
+  const sequentialColorControls = colorControls.filter(([, control]) =>
+    isToolcraftSequentialColorLabel(getControlLabelText(control)),
+  );
+  const isPaletteVariationBank =
+    colorControls.every(([, control]) =>
+      isToolcraftPaletteVariationTarget(control.target),
+    ) ||
+    (isToolcraftColorSectionTitle(sectionTitle) &&
+      sequentialColorControls.length > 0);
+
+  if (!isPaletteVariationBank) {
+    return [];
+  }
+
+  const visibleColorControls = colorControls.filter(([, control]) =>
+    hasVisibleControlLabel(control),
+  );
+  const errors: string[] = [];
+
+  if (
+    visibleColorControls.length > 0 &&
+    visibleColorControls.length < colorControls.length
+  ) {
+    errors.push(
+      `${sectionLabel} mixes labeled and unlabeled color items in one palette variation group. Decide label visibility for the whole group: omit all per-item labels when colors only add variety, or label every item only when each color has a distinct user-facing role.`,
+    );
+  }
+
+  for (const [controlId, control] of sequentialColorControls) {
+    const label = getControlLabelText(control).trim();
+
+    errors.push(
+      `${sectionLabel} / ${controlId} uses visible label "${label}" for a palette variation color. When colors only add variety to one shared palette, set label: false or use collectionActions with unlabeled items. Keep visible labels only when each color edits a distinct user-facing entity such as Fill, Stroke, Background, Connector, or Object color.`,
+    );
+  }
+
+  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<{
@@ -1657,11 +2245,23 @@ 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();
@@ -1706,11 +2306,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]) =>
@@ -1737,6 +2334,14 @@ function getToolcraftControlSectionGroupingErrors(
       );
     }
 
+    errors.push(
+      ...getToolcraftColorBankLabelErrors({
+        controls,
+        sectionLabel,
+        sectionTitle,
+      }),
+    );
+
     for (const [controlId, control] of controls) {
       const strictPrefix = getToolcraftStrictTargetPrefix(control.target);
       const loosePrefix = getToolcraftLooseTargetPrefix(control.target);
@@ -1768,6 +2373,14 @@ function getToolcraftControlSectionGroupingErrors(
         controlId,
         loosePrefix,
         sectionLabel,
+        sectionTitle,
+      });
+      controlsByTarget.set(control.target, {
+        control,
+        controlId,
+        loosePrefix,
+        sectionLabel,
+        sectionTitle,
       });
 
       if (strictPrefix) {
@@ -1801,6 +2414,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/disabledWhen inside that section instead of splitting branch controls into their own section.`,
+      );
+    }
+  }
+
   const fontPickerControls = visibleControls.filter(
     (item) => item.control.type === "fontPicker" && item.loosePrefix,
   );
@@ -1833,9 +2482,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.`,
       );
     }
   }
@@ -1904,6 +2556,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);
@@ -1934,7 +2587,8 @@ export function validateToolcraftAcceptanceCoverage(
   ]);
 
   errors.push(...getToolcraftControlOrderErrors(schema));
-  errors.push(...getToolcraftControlSectionGroupingErrors(schema));
+  errors.push(...getToolcraftControlSectionGroupingErrors(schema, sectionInventory));
+  errors.push(...getToolcraftControlSectionInventoryErrors(schema, sectionInventory));
 
   for (const [sectionIndex, section] of (schema.panels.controls?.sections ?? []).entries()) {
     const sectionLabel = getToolcraftSectionLabel(section.title, sectionIndex);
@@ -1954,6 +2608,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(
@@ -1995,6 +2659,16 @@ 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.`,
+          );
+        }
       }
     }
 
@@ -2121,7 +2795,7 @@ export function validateToolcraftAcceptanceCoverage(
 
     if (!schemaHasOutputBackgroundToggleControl(controls)) {
       errors.push(
-        'Product apps with Export PNG must expose export.includeBackground inside the required "Background" section as a Switch labeled "Include". PNG export must pass that runtime value to createToolcraftPngExportCanvas includeBackground; video export keeps the background.',
+        'Product apps with Export PNG must expose export.includeBackground inside the required "Background" section as a Switch labeled "Include". PNG export must pass that runtime value to createToolcraftPngExportCanvas includeBackground; live preview must use shouldIncludeToolcraftPreviewBackground(state); video export keeps the background.',
       );
     }
 
@@ -2556,6 +3230,12 @@ export function validateToolcraftAcceptanceCoverage(
   }
 
   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" &&
@@ -2564,14 +3244,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.`,
         );
       }
 
@@ -2691,11 +3377,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) &&
@@ -2798,6 +3498,10 @@ export function validateToolcraftAcceptanceCoverage(
       );
     }
 
+    if (control.type === "fileDrop") {
+      errors.push(...getFileDropLifecycleCoverageErrors(label, entry));
+    }
+
     if (
       isCustomControl &&
       !hasCustomControlCoverage(
@@ -2811,7 +3515,7 @@ export function validateToolcraftAcceptanceCoverage(
     }
 
     if (isCustomControl) {
-      errors.push(...getBuiltInFitCheckErrors(label, entry));
+      errors.push(...getBuiltInFitCheckErrors(label, entry, control));
     }
 
     if (
@@ -2841,17 +3545,23 @@ export function validateToolcraftAcceptanceCoverage(
       isOutputBackgroundToggleControl({ control, controlId, sectionTitle })
     ) {
       const evidenceText = getAcceptanceEvidenceText(entry);
-
-      if (
-        !/\b(png|image)\b/i.test(evidenceText) ||
-        !/\b(transparent|transparency|alpha)\b/i.test(evidenceText) ||
-        !/\b(preview|canvas|workspace|backing|video)\b/i.test(evidenceText) ||
-        !/\b(keep|keeps|preserve|preserves|stay|stays|remain|remains|still|not transparent|non-transparent)\b/i.test(
+      const provesPngTransparency =
+        /\b(png|image)\b/i.test(evidenceText) &&
+        /\b(transparent|transparency|alpha)\b/i.test(evidenceText);
+      const provesPreviewTransparency =
+        /\b(preview|canvas)\b/i.test(evidenceText) &&
+        /\b(transparent|transparency|alpha|hide|hides|hidden|without background|no background|background off)\b/i.test(
           evidenceText,
-        )
-      ) {
+        );
+      const provesVideoBackground =
+        /\bvideo\b/i.test(evidenceText) &&
+        /\b(keep|keeps|preserve|preserves|stay|stays|remain|remains|still|background)\b/i.test(
+          evidenceText,
+        );
+
+      if (!provesPngTransparency || !provesPreviewTransparency || !provesVideoBackground) {
         errors.push(
-          `${label} controls PNG background inclusion and acceptance must prove disabling it makes PNG output transparent while live preview, workspace canvas backing, and video output keep the product background.`,
+          `${label} controls background inclusion and acceptance must prove disabling it makes PNG output transparent, hides the live preview product background, and keeps video output with the product background.`,
         );
       }
     }
@@ -2886,6 +3596,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 &&