@pixel-point/toolcraft 0.0.8 → 0.0.9

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

@@ -147,6 +147,7 @@ export type ToolcraftCustomControlCoverage =
 const builtInToolcraftControlTypeValues = [
   "actions",
   "anchorGrid",
+  "aspectRatio",
   "channelMixer",
   "checkbox",
   "code",
@@ -172,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];
@@ -264,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",
@@ -277,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 ?? ""}`;
 }
@@ -873,6 +891,64 @@ function hasVisibleControlLabel(control: ToolcraftControlSchema): boolean {
   return typeof control.label === "string" && control.label.trim().length > 0;
 }
 
+const shortSingleLineTextMaxLength = 80;
+const longTextControlEvidencePattern =
+  /\b(multiline|multi-line|multi\s+line|long\s+(?:text|content|prompt|instructions?)|paragraph|body\s+(?:copy|text)|rich\s+text|textarea|instructions?|script|code|json|css|shader|template|markdown|csv|xml|yaml|html|svg|list|lines|dataset|structured|source\s+text)\b/i;
+const shortSingleLineTextIntentPattern =
+  /\b(button|label|title|name|caption|headline|cta|badge|token|word|phrase|single-line|one-line|short\s+text)\b/i;
+
+function getControlDefaultString(control: ToolcraftControlSchema): string | undefined {
+  return typeof control.defaultValue === "string" ? control.defaultValue : undefined;
+}
+
+function getTextValueControlIntentText(
+  controlId: string,
+  control: ToolcraftControlSchema,
+): string {
+  return [
+    controlId,
+    control.target,
+    getControlLabelText(control),
+    control.description ?? "",
+  ]
+    .join(" ")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+}
+
+function getCodeTextareaControlError({
+  control,
+  controlId,
+  label,
+}: {
+  control: ToolcraftControlSchema;
+  controlId: string;
+  label: string;
+}): string | undefined {
+  if (control.type !== "code") {
+    return undefined;
+  }
+
+  const defaultValue = getControlDefaultString(control);
+  const intentText = getTextValueControlIntentText(controlId, control);
+  const hasLongTextEvidence =
+    longTextControlEvidencePattern.test(intentText) ||
+    (defaultValue !== undefined &&
+      (defaultValue.length > shortSingleLineTextMaxLength ||
+        /[\r\n]/.test(defaultValue)));
+  const looksLikeShortSingleLineText =
+    shortSingleLineTextIntentPattern.test(intentText) ||
+    (defaultValue !== undefined &&
+      defaultValue.trim().length > 0 &&
+      defaultValue.trim().length <= shortSingleLineTextMaxLength &&
+      !/[\r\n]/.test(defaultValue));
+
+  if (!looksLikeShortSingleLineText || hasLongTextEvidence) {
+    return undefined;
+  }
+
+  return `${label} uses CodeTextarea for short single-line text. Use type "text" for button labels, canvas labels, titles, captions, names, badges, tokens, and other short one-line content. Reserve type "code" for long, multiline, or structured values, and document that reason in description when the default is short.`;
+}
+
 const singleCurveSemanticPattern =
   /\b(acceleration|accel|bend|easing|ease|response|depth|mask|opacity|alpha|motion|velocity|threshold|falloff|remap|remapping)\b|speed\s+profile|mapping\s+curve|curve\s+mapping/i;
 const rgbCurveSemanticPattern =
@@ -931,6 +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;
 
@@ -1319,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)}`,
   );
 }
@@ -1445,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],
@@ -1683,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,
@@ -1887,8 +2057,187 @@ function getToolcraftColorBankLabelErrors({
   return errors;
 }
 
+function getToolcraftSectionInventoryByTitle(
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[],
+): Map<string, ToolcraftControlSectionInventoryEntry> {
+  return new Map(
+    sectionInventory.map((entry) => [entry.title.trim(), entry]),
+  );
+}
+
+function hasToolcraftInventorySplitEvidence({
+  sectionInventoryByTitle,
+  sections,
+}: {
+  sectionInventoryByTitle: ReadonlyMap<string, ToolcraftControlSectionInventoryEntry>;
+  sections: ReadonlySet<string>;
+}): boolean {
+  const entries = [...sections].map((sectionLabel) =>
+    sectionInventoryByTitle.get(sectionLabel),
+  );
+
+  return (
+    entries.length === sections.size &&
+    entries.every(
+      (entry) =>
+        entry &&
+        (entry.workflowStage?.trim().length ?? 0) > 0 &&
+        (entry.splitReason?.trim().length ?? 0) >= 12,
+    )
+  );
+}
+
+function getToolcraftControlSectionInventoryErrors(
+  schema: ResolvedToolcraftAppSchema,
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[],
+): string[] {
+  const errors: string[] = [];
+
+  if (sectionInventory.length === 0) {
+    return errors;
+  }
+
+  const schemaSections = (schema.panels.controls?.sections ?? []).flatMap(
+    (section, sectionIndex) => {
+      const targets = Object.values(section.controls)
+        .filter(isToolcraftProductSectionControl)
+        .map((control) => control.target);
+
+      if (targets.length === 0) {
+        return [];
+      }
+
+      return [
+        {
+          label: getToolcraftSectionLabel(section.title, sectionIndex),
+          targets,
+        },
+      ];
+    },
+  );
+  const schemaSectionTitles = new Set(schemaSections.map((section) => section.label));
+  const schemaTargetToSection = new Map<string, string>();
+
+  for (const section of schemaSections) {
+    for (const target of section.targets) {
+      schemaTargetToSection.set(target, section.label);
+    }
+  }
+
+  const inventoryTitleCounts = new Map<string, number>();
+  const inventoryTargetToSection = new Map<string, string>();
+
+  for (const entry of sectionInventory) {
+    const title = entry.title.trim();
+    const entity = entry.entity?.trim() ?? "";
+    const workflowStage = entry.workflowStage?.trim() ?? "";
+    const groupingReason = entry.groupingReason.trim();
+    const splitReason = entry.splitReason?.trim() ?? "";
+
+    if (!title) {
+      errors.push(
+        "Control Section Inventory contains an entry without a section title.",
+      );
+      continue;
+    }
+
+    inventoryTitleCounts.set(title, (inventoryTitleCounts.get(title) ?? 0) + 1);
+
+    if (!schemaSectionTitles.has(title)) {
+      errors.push(
+        `Control Section Inventory references "${title}", but no rendered product controls section uses that title.`,
+      );
+    }
+
+    if (!entity && !workflowStage) {
+      errors.push(
+        `Control Section Inventory entry "${title}" must declare entity or workflowStage so grouping is based on product meaning, not UI layout.`,
+      );
+    }
+
+    if (groupingReason.length < 12) {
+      errors.push(
+        `Control Section Inventory entry "${title}" must include a concrete groupingReason explaining why these controls belong together.`,
+      );
+    }
+
+    if (splitReason && splitReason.length < 12) {
+      errors.push(
+        `Control Section Inventory entry "${title}" splitReason is too vague. Explain the product workflow split or omit splitReason.`,
+      );
+    }
+
+    if (entry.targets.length === 0) {
+      errors.push(
+        `Control Section Inventory entry "${title}" must list the product control targets rendered in that section.`,
+      );
+    }
+
+    for (const target of entry.targets) {
+      const schemaSection = schemaTargetToSection.get(target);
+
+      if (!schemaSection) {
+        errors.push(
+          `Control Section Inventory entry "${title}" lists target "${target}", but that target is not rendered by any product controls section.`,
+        );
+        continue;
+      }
+
+      if (schemaSection !== title) {
+        errors.push(
+          `Control Section Inventory entry "${title}" lists target "${target}", but the schema renders it in "${schemaSection}". Update the schema grouping or the inventory.`,
+        );
+      }
+
+      const existingSection = inventoryTargetToSection.get(target);
+
+      if (existingSection && existingSection !== title) {
+        errors.push(
+          `Control Section Inventory lists target "${target}" in both "${existingSection}" and "${title}". Each product control target belongs to exactly one section inventory entry.`,
+        );
+      }
+
+      inventoryTargetToSection.set(target, title);
+    }
+  }
+
+  for (const [title, count] of inventoryTitleCounts) {
+    if (count > 1) {
+      errors.push(
+        `Control Section Inventory repeats section "${title}" ${count} times. Section inventory entries must be unique.`,
+      );
+    }
+  }
+
+  for (const section of schemaSections) {
+    const entry = sectionInventory.find(
+      (inventoryEntry) => inventoryEntry.title.trim() === section.label,
+    );
+
+    if (!entry) {
+      errors.push(
+        `Control Section Inventory is missing product section "${section.label}". Add its entity/workflow stage, targets, and groupingReason.`,
+      );
+      continue;
+    }
+
+    const inventoryTargets = new Set(entry.targets);
+
+    for (const target of section.targets) {
+      if (!inventoryTargets.has(target)) {
+        errors.push(
+          `Control Section Inventory entry "${section.label}" is missing rendered target "${target}". The inventory must cover every product control in the section.`,
+        );
+      }
+    }
+  }
+
+  return errors;
+}
+
 function getToolcraftControlSectionGroupingErrors(
   schema: ResolvedToolcraftAppSchema,
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[] = [],
 ): string[] {
   const errors: string[] = [];
   const visibleControls: Array<{
@@ -1896,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();
@@ -1945,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]) =>
@@ -2015,6 +2373,14 @@ function getToolcraftControlSectionGroupingErrors(
         controlId,
         loosePrefix,
         sectionLabel,
+        sectionTitle,
+      });
+      controlsByTarget.set(control.target, {
+        control,
+        controlId,
+        loosePrefix,
+        sectionLabel,
+        sectionTitle,
       });
 
       if (strictPrefix) {
@@ -2048,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,
   );
@@ -2080,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.`,
       );
     }
   }
@@ -2151,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);
@@ -2181,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);
@@ -2201,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(
@@ -2242,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.`,
+          );
+        }
       }
     }
 
@@ -2803,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" &&
@@ -2811,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.`,
         );
       }
 
@@ -2938,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) &&
@@ -3143,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 &&