@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/starter/src/app/acceptance/motion-reference-study-coverage.ts

@@ -0,0 +1,206 @@
+import type { ToolcraftMotionReferenceInput } from "./types";
+
+const validEventClassifications = new Set<string>([
+  "edit-boundary",
+  "encoding-artifact",
+  "irrelevant-change",
+  "product-behavior",
+]);
+
+export function validateStudyCoverage(
+  input: ToolcraftMotionReferenceInput,
+): string[] {
+  const errors: string[] = [];
+  const behaviorsById = new Map<string, typeof input.behaviors>();
+  for (const behavior of input.behaviors) {
+    behaviorsById.set(behavior.id, [
+      ...(behaviorsById.get(behavior.id) ?? []),
+      behavior,
+    ]);
+  }
+
+  function validateBehaviorId({
+    behaviorId,
+    owner,
+  }: {
+    behaviorId: string;
+    owner: string;
+  }): void {
+    const behaviors = behaviorsById.get(behaviorId) ?? [];
+    if (behaviors.length === 0) {
+      errors.push(`${owner} cites unknown behaviorId "${behaviorId}".`);
+    } else if (behaviors.length > 1) {
+      errors.push(
+        `${owner} cites ambiguous behaviorId "${behaviorId}" with ${behaviors.length} definitions.`,
+      );
+    }
+  }
+
+  for (const study of input.studies) {
+    const reviewedFrameIndex = new Map(
+      study.evidence.reviewedFrames.map((frame, index) => [frame.frameId, index]),
+    );
+    const overviewFrameIndex = new Map<string, number>();
+    let previousReviewedFrameIndex = -1;
+
+    for (const [overviewIndex, frameId] of study.evidence.overviewFrameIds.entries()) {
+      const reviewedIndex = reviewedFrameIndex.get(frameId);
+
+      if (reviewedIndex === undefined) {
+        errors.push(
+          `motion reference study "${study.studyId}" overview frameId "${frameId}" must resolve to reviewedFrames.`,
+        );
+        continue;
+      }
+
+      if (reviewedIndex <= previousReviewedFrameIndex) {
+        errors.push(
+          `motion reference study "${study.studyId}" overviewFrameIds must follow reviewedFrames order; "${frameId}" resolves to index ${reviewedIndex} after ${previousReviewedFrameIndex}.`,
+        );
+      }
+
+      previousReviewedFrameIndex = reviewedIndex;
+      overviewFrameIndex.set(frameId, overviewIndex);
+    }
+
+    if (study.evidence.overviewFrameIds.length > 0 && study.phases.length === 0) {
+      errors.push(
+        `motion reference study "${study.studyId}" phases must cover the complete overview range.`,
+      );
+    }
+
+    let previousPhaseEndIndex: number | undefined;
+    for (const [phaseIndex, phase] of study.phases.entries()) {
+      const fromIndex = overviewFrameIndex.get(phase.fromFrameId);
+      const toIndex = overviewFrameIndex.get(phase.toFrameId);
+
+      if (fromIndex === undefined || toIndex === undefined) {
+        errors.push(
+          `motion reference study "${study.studyId}" phase "${phase.id}" frame range must resolve to overviewFrameIds.`,
+        );
+        continue;
+      }
+
+      if (fromIndex > toIndex) {
+        errors.push(
+          `motion reference study "${study.studyId}" phase "${phase.id}" must not end before it starts.`,
+        );
+      }
+
+      if (phaseIndex === 0 && fromIndex !== 0) {
+        errors.push(
+          `motion reference study "${study.studyId}" phases must start at overview index 0; "${phase.id}" starts at ${fromIndex}.`,
+        );
+      }
+
+      if (
+        previousPhaseEndIndex !== undefined &&
+        fromIndex !== previousPhaseEndIndex + 1
+      ) {
+        errors.push(
+          `motion reference study "${study.studyId}" phases must be contiguous; "${phase.id}" starts at overview index ${fromIndex} after index ${previousPhaseEndIndex}.`,
+        );
+      }
+      previousPhaseEndIndex = toIndex;
+
+      if (!phase.visualState.trim()) {
+        errors.push(
+          `motion reference study "${study.studyId}" phase "${phase.id}" must describe its visualState.`,
+        );
+      }
+
+      for (const behaviorId of phase.behaviorIds) {
+        validateBehaviorId({
+          behaviorId,
+          owner: `motion reference study "${study.studyId}" phase "${phase.id}"`,
+        });
+      }
+    }
+
+    const lastOverviewIndex = study.evidence.overviewFrameIds.length - 1;
+    if (
+      study.phases.length > 0 &&
+      previousPhaseEndIndex !== undefined &&
+      previousPhaseEndIndex !== lastOverviewIndex
+    ) {
+      errors.push(
+        `motion reference study "${study.studyId}" phases must end at overview index ${lastOverviewIndex}; received ${previousPhaseEndIndex}.`,
+      );
+    }
+
+    const evidenceEventsById = new Map(
+      study.evidence.detectedEvents.map((event) => [event.eventId, event]),
+    );
+    const authoredEventsByEvidenceId = new Map<string, typeof study.events>();
+
+    for (const event of study.events) {
+      const existing = authoredEventsByEvidenceId.get(event.evidenceEventId) ?? [];
+      authoredEventsByEvidenceId.set(event.evidenceEventId, [...existing, event]);
+
+      if (!evidenceEventsById.has(event.evidenceEventId)) {
+        errors.push(
+          `motion reference study "${study.studyId}" event "${event.id}" must cite a detected evidenceEventId.`,
+        );
+      }
+
+      if (!validEventClassifications.has(event.classification)) {
+        errors.push(
+          `motion reference study "${study.studyId}" event "${event.id}" has unsupported classification "${String(event.classification)}".`,
+        );
+        continue;
+      }
+
+      if (event.classification === "product-behavior") {
+        if (event.behaviorIds.length === 0) {
+          errors.push(
+            `motion reference study "${study.studyId}" product event "${event.id}" must cite at least one behaviorId.`,
+          );
+        }
+
+        for (const behaviorId of event.behaviorIds) {
+          validateBehaviorId({
+            behaviorId,
+            owner: `motion reference study "${study.studyId}" event "${event.id}"`,
+          });
+        }
+      } else {
+        if (event.behaviorIds.length !== 0) {
+          errors.push(
+            `motion reference study "${study.studyId}" event "${event.id}" classification "${event.classification}" must not cite behaviorIds.`,
+          );
+        }
+
+        if (!event.reason.trim()) {
+          errors.push(
+            `motion reference study "${study.studyId}" event "${event.id}" classification "${event.classification}" requires a non-empty reason.`,
+          );
+        }
+      }
+    }
+
+    for (const evidenceEvent of study.evidence.detectedEvents) {
+      const matchingAuthoredEvents =
+        authoredEventsByEvidenceId.get(evidenceEvent.eventId) ?? [];
+      if (matchingAuthoredEvents.length !== 1) {
+        errors.push(
+          `motion reference study "${study.studyId}" evidence event "${evidenceEvent.eventId}" must have exactly one authored event; found ${matchingAuthoredEvents.length}.`,
+        );
+      }
+
+      for (const frameId of [
+        evidenceEvent.beforeFrameId,
+        evidenceEvent.peakFrameId,
+        evidenceEvent.afterFrameId,
+        ...evidenceEvent.windowFrameIds,
+      ]) {
+        if (!reviewedFrameIndex.has(frameId)) {
+          errors.push(
+            `motion reference study "${study.studyId}" evidence event "${evidenceEvent.eventId}" frameId "${frameId}" must resolve to reviewedFrames.`,
+          );
+        }
+      }
+    }
+  }
+
+  return errors;
+}

package/templates/starter/src/app/acceptance/motion-reference-study-identity.ts

@@ -0,0 +1,129 @@
+import type { ToolcraftMotionReferenceInput } from "./types";
+
+export function getMotionReferenceSourceSha256(
+  input: ToolcraftMotionReferenceInput,
+): string | undefined {
+  const sourceSha256Values = new Set(
+    input.studies.map((study) => study.evidence.sourceSha256),
+  );
+
+  return sourceSha256Values.size === 1
+    ? sourceSha256Values.values().next().value
+    : undefined;
+}
+
+export function validateStudyIdentity(
+  input: ToolcraftMotionReferenceInput,
+): string[] {
+  const errors: string[] = [];
+  const studyIds = new Set<string>();
+  const evidencePaths = new Set<string>();
+  const sourceSha256Values = new Set<string>();
+  const behaviorIds = new Set<string>();
+
+  if (input.studies.length === 0) {
+    errors.push(
+      `motion reference "${input.referenceId}" must declare at least one study.`,
+    );
+  }
+
+  for (const behavior of input.behaviors) {
+    if (!behavior.id.trim()) {
+      errors.push(
+        `motion reference "${input.referenceId}" behaviors must include non-empty ids.`,
+      );
+    } else if (behaviorIds.has(behavior.id)) {
+      errors.push(
+        `motion reference "${input.referenceId}" behavior id "${behavior.id}" is duplicated.`,
+      );
+    }
+    behaviorIds.add(behavior.id);
+  }
+
+  for (const study of input.studies) {
+    const studyLabel = study.studyId.trim() || "<missing-study-id>";
+
+    if (!study.studyId.trim()) {
+      errors.push(
+        `motion reference "${input.referenceId}" studies must include non-empty studyId values.`,
+      );
+    } else if (studyIds.has(study.studyId)) {
+      errors.push(
+        `motion reference "${input.referenceId}" studyId "${study.studyId}" is duplicated.`,
+      );
+    }
+    studyIds.add(study.studyId);
+
+    if (evidencePaths.has(study.evidencePath)) {
+      errors.push(
+        `motion reference "${input.referenceId}" evidencePath "${study.evidencePath}" is duplicated.`,
+      );
+    }
+    evidencePaths.add(study.evidencePath);
+
+    if (study.evidence.studyId !== study.studyId) {
+      errors.push(
+        `motion reference study "${studyLabel}" must match evidence.studyId "${study.evidence.studyId}".`,
+      );
+    }
+
+    sourceSha256Values.add(study.evidence.sourceSha256);
+
+    const frameIds = new Set<string>();
+    for (const frame of study.evidence.reviewedFrames) {
+      if (frameIds.has(frame.frameId)) {
+        errors.push(
+          `motion reference study "${studyLabel}" reviewed frameId "${frame.frameId}" is duplicated.`,
+        );
+      }
+      frameIds.add(frame.frameId);
+
+      if (frame.sourceSha256 !== study.evidence.sourceSha256) {
+        errors.push(
+          `motion reference study "${studyLabel}" frame "${frame.frameId}" sourceSha256 must match its evidence sourceSha256.`,
+        );
+      }
+    }
+
+    const evidenceEventIds = new Set<string>();
+    for (const event of study.evidence.detectedEvents) {
+      if (evidenceEventIds.has(event.eventId)) {
+        errors.push(
+          `motion reference study "${studyLabel}" evidence eventId "${event.eventId}" is duplicated.`,
+        );
+      }
+      evidenceEventIds.add(event.eventId);
+    }
+
+    const eventIds = new Set<string>();
+    for (const event of study.events) {
+      if (eventIds.has(event.id)) {
+        errors.push(
+          `motion reference study "${studyLabel}" event id "${event.id}" is duplicated.`,
+        );
+      }
+      eventIds.add(event.id);
+    }
+
+    const phaseIds = new Set<string>();
+    for (const phase of study.phases) {
+      if (phaseIds.has(phase.id)) {
+        errors.push(
+          `motion reference study "${studyLabel}" phase id "${phase.id}" is duplicated.`,
+        );
+      }
+      phaseIds.add(phase.id);
+    }
+  }
+
+  if (sourceSha256Values.size > 1) {
+    const sortedSourceSha256Values = [...sourceSha256Values].sort((left, right) =>
+      left.localeCompare(right, "en"),
+    );
+    errors.push(
+      `motion reference "${input.referenceId}" studies must share one sourceSha256; found ${sortedSourceSha256Values.join(", ")}.`,
+    );
+  }
+
+  return errors;
+}

package/templates/starter/src/app/acceptance/motion-reference-study-partitions.ts

@@ -0,0 +1,186 @@
+import type { ToolcraftMotionReferenceInput } from "./types";
+
+type TimedStudyEvidence = Extract<
+  ToolcraftMotionReferenceInput["studies"][number]["evidence"],
+  { timingMode: "seconds" }
+>;
+type ReviewPartition = NonNullable<TimedStudyEvidence["reviewPartition"]>;
+
+type PartitionStudy = {
+  evidence: TimedStudyEvidence;
+  partition: ReviewPartition;
+  studyId: string;
+};
+
+function formatNumber(value: number): string {
+  return String(value);
+}
+
+function compareNumbers(left: number, right: number): number {
+  if (Number.isFinite(left) && Number.isFinite(right)) {
+    return left - right;
+  }
+  return formatNumber(left).localeCompare(formatNumber(right), "en");
+}
+
+export function validatePartitionCoverage(
+  input: ToolcraftMotionReferenceInput,
+): string[] {
+  const errors: string[] = [];
+  const groups = new Map<string, PartitionStudy[]>();
+
+  for (const study of input.studies) {
+    if (study.evidence.timingMode !== "seconds") {
+      continue;
+    }
+    const partition = study.evidence.reviewPartition;
+    if (!partition) {
+      continue;
+    }
+
+    const group = groups.get(partition.groupId) ?? [];
+    group.push({ evidence: study.evidence, partition, studyId: study.studyId });
+    groups.set(partition.groupId, group);
+  }
+
+  for (const [groupId, group] of groups) {
+    const countValues = [...new Set(group.map(({ partition }) => partition.count))];
+    const invalidCounts = countValues
+      .filter((count) => !Number.isSafeInteger(count) || count <= 0)
+      .sort(compareNumbers);
+    for (const count of invalidCounts) {
+      errors.push(
+        `motion reference partition "${groupId}" count must be a finite safe positive integer; received ${formatNumber(count)}.`,
+      );
+    }
+
+    const countIsShared = countValues.length === 1;
+    if (!countIsShared) {
+      errors.push(
+        `motion reference partition "${groupId}" studies must declare one shared count.`,
+      );
+    }
+
+    const validCounts = countValues.filter(
+      (count) => Number.isSafeInteger(count) && count > 0,
+    );
+    const oversizedCounts = validCounts
+      .filter((count) => count > group.length)
+      .sort(compareNumbers);
+    for (const count of oversizedCounts) {
+      errors.push(
+        `motion reference partition "${groupId}" count ${count} cannot exceed group cardinality ${group.length}.`,
+      );
+    }
+
+    const planValues = new Set(
+      group.map(({ partition }) => partition.planSha256),
+    );
+    const planIsShared = planValues.size === 1;
+    if (!planIsShared) {
+      errors.push(
+        `motion reference partition "${groupId}" studies must declare one shared planSha256.`,
+      );
+    }
+
+    const scopeStarts = new Set(
+      group.map(({ partition }) => partition.scope.startSeconds),
+    );
+    const scopeEnds = new Set(
+      group.map(({ partition }) => partition.scope.endSeconds),
+    );
+    const scopeIsShared = scopeStarts.size === 1 && scopeEnds.size === 1;
+    if (!scopeIsShared) {
+      errors.push(
+        `motion reference partition "${groupId}" studies must declare one shared scope.`,
+      );
+    }
+
+    const metadataIsValid =
+      invalidCounts.length === 0 &&
+      oversizedCounts.length === 0 &&
+      countIsShared &&
+      planIsShared &&
+      scopeIsShared;
+    if (!metadataIsValid) {
+      continue;
+    }
+
+    const [expectedCount] = countValues;
+    const [scopeStart] = scopeStarts;
+    const [scopeEnd] = scopeEnds;
+    if (
+      expectedCount === undefined ||
+      scopeStart === undefined ||
+      scopeEnd === undefined
+    ) {
+      continue;
+    }
+
+    const orderedGroup = [...group].sort((left, right) => {
+      const indexOrder = compareNumbers(
+        left.partition.index,
+        right.partition.index,
+      );
+      return indexOrder || left.studyId.localeCompare(right.studyId, "en");
+    });
+    const receivedIndices = orderedGroup.map(({ partition }) => partition.index);
+    const indicesAreExact =
+      orderedGroup.length === expectedCount &&
+      receivedIndices.every((index, position) => index === position);
+    if (!indicesAreExact) {
+      errors.push(
+        `motion reference partition "${groupId}" must contain indices 0..${expectedCount - 1} exactly; received ${receivedIndices.join(", ")}.`,
+      );
+      continue;
+    }
+
+    let previousEnd: number | undefined;
+    for (const { evidence, partition, studyId } of orderedGroup) {
+      const segment = evidence.segment;
+      if (!segment) {
+        errors.push(
+          `motion reference partition "${groupId}" study "${studyId}" must declare an explicit segment.`,
+        );
+        continue;
+      }
+
+      if (segment.endSeconds <= segment.startSeconds) {
+        errors.push(
+          `motion reference partition "${groupId}" study "${studyId}" segment must have positive duration.`,
+        );
+      }
+      if (partition.index === 0 && segment.startSeconds !== scopeStart) {
+        errors.push(
+          `motion reference partition "${groupId}" segments must start at scope.startSeconds ${scopeStart}; received ${segment.startSeconds}.`,
+        );
+      }
+      if (previousEnd !== undefined && segment.startSeconds !== previousEnd) {
+        errors.push(
+          `motion reference partition "${groupId}" segments must be contiguous and non-overlapping; index ${partition.index} starts at ${segment.startSeconds} after ${previousEnd}.`,
+        );
+      }
+      previousEnd = segment.endSeconds;
+
+      const scopeCoversFullSource =
+        scopeStart === 0 && scopeEnd === evidence.durationSeconds;
+      if (
+        scopeCoversFullSource &&
+        partition.index !== 0 &&
+        evidence.detectedEvents.some((event) => event.kind === "loop-seam")
+      ) {
+        errors.push(
+          `motion reference partition "${groupId}" original loop-seam evidence must appear only in index 0.`,
+        );
+      }
+    }
+
+    if (previousEnd !== undefined && previousEnd !== scopeEnd) {
+      errors.push(
+        `motion reference partition "${groupId}" segments must end at scope.endSeconds ${scopeEnd}; received ${previousEnd}.`,
+      );
+    }
+  }
+
+  return errors;
+}

package/templates/starter/src/app/acceptance/motion-reference-study.ts

@@ -0,0 +1,90 @@
+import { validateBehaviorCoverage } from "./motion-reference-study-behaviors";
+import { validateStudyCoverage } from "./motion-reference-study-coverage";
+import {
+  getMotionReferenceSourceSha256,
+  validateStudyIdentity,
+} from "./motion-reference-study-identity";
+import { validatePartitionCoverage } from "./motion-reference-study-partitions";
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftTransferMode,
+} from "./types";
+
+export function getToolcraftMotionReferenceStudyErrors({
+  acceptance,
+  transferMode,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  transferMode: ToolcraftTransferMode;
+}): string[] {
+  const errors: string[] = [];
+  const acceptanceRowsById = new Map<string, ToolcraftComponentAcceptance[]>();
+  for (const entry of acceptance) {
+    acceptanceRowsById.set(entry.id, [
+      ...(acceptanceRowsById.get(entry.id) ?? []),
+      entry,
+    ]);
+  }
+  const referenceIds = new Set<string>();
+  const sourceOwners = new Map<string, string>();
+  const behaviorCountsByReferenceId = new Map<string, Map<string, number>>();
+
+  for (const input of transferMode.referenceInputs) {
+    if (referenceIds.has(input.referenceId)) {
+      errors.push(`motion reference id "${input.referenceId}" is duplicated.`);
+    }
+    referenceIds.add(input.referenceId);
+
+    errors.push(
+      ...validateStudyIdentity(input),
+      ...validateStudyCoverage(input),
+      ...validatePartitionCoverage(input),
+      ...validateBehaviorCoverage(input, acceptanceRowsById),
+    );
+
+    const sourceSha256 = getMotionReferenceSourceSha256(input);
+    if (sourceSha256) {
+      const existingOwner = sourceOwners.get(sourceSha256);
+      if (existingOwner) {
+        errors.push(
+          `motion reference sourceSha256 "${sourceSha256}" is declared by multiple reference inputs; merge their studies under one input.`,
+        );
+      } else {
+        sourceOwners.set(sourceSha256, input.referenceId);
+      }
+    }
+
+    const behaviorCounts =
+      behaviorCountsByReferenceId.get(input.referenceId) ??
+      new Map<string, number>();
+    for (const behavior of input.behaviors) {
+      behaviorCounts.set(
+        behavior.id,
+        (behaviorCounts.get(behavior.id) ?? 0) + 1,
+      );
+    }
+    behaviorCountsByReferenceId.set(input.referenceId, behaviorCounts);
+  }
+
+  for (const acceptanceEntry of acceptance) {
+    for (const coverage of acceptanceEntry.motionReferenceCoverage ?? []) {
+      const behaviorCount =
+        behaviorCountsByReferenceId
+          .get(coverage.referenceId)
+          ?.get(coverage.behaviorId) ?? 0;
+      if (behaviorCount === 0) {
+        errors.push(
+          `acceptance "${acceptanceEntry.id}" has dangling motion reference coverage for "${coverage.referenceId}" behavior "${coverage.behaviorId}".`,
+        );
+      } else if (behaviorCount > 1) {
+        errors.push(
+          `acceptance "${acceptanceEntry.id}" motion reference coverage for "${coverage.referenceId}" behavior "${coverage.behaviorId}" resolves to ${behaviorCount} behavior definitions; expected exactly one.`,
+        );
+      }
+    }
+  }
+
+  return [...new Set(errors)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}

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

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

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

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