@pixel-point/toolcraft 0.0.13 → 0.0.15

package/templates/starter/src/app/acceptance/reference-runtime-timeline.ts

@@ -0,0 +1,291 @@
+import type { ResolvedToolcraftAppSchema } from "@repo/toolcraft-runtime";
+
+import {
+  isValidTimelineLoopDurationSource,
+} from "./timeline-loop";
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftReferenceCoverage,
+  ToolcraftReferenceTimelineCoverage,
+  ToolcraftTransferMode,
+} from "./types";
+
+const referenceTransportCoverage = new Set<ToolcraftReferenceCoverage>([
+  "export-at-time",
+  "pause-resume",
+  "restart",
+  "time-progress",
+]);
+
+const toolcraftReferenceTimelineCoverage = new Set<ToolcraftReferenceTimelineCoverage>([
+  "duration",
+  "export-at-time",
+  "keyframes",
+  "loop",
+  "playback",
+  "restart",
+  "scrub",
+  "time-progress",
+]);
+
+const customReferenceTimelineCoverage = new Set<ToolcraftReferenceTimelineCoverage>([
+  "all-range",
+  "export-range",
+  "jump-to-trim-start",
+  "range-playback",
+  "state-jump",
+  "trim-range",
+]);
+
+function getReferenceTimelineLoopDurationErrors({
+  referenceTimelineMode,
+  schema,
+  transferMode,
+}: {
+  referenceTimelineMode: "toolcraft-keyframes" | "toolcraft-playback";
+  schema: ResolvedToolcraftAppSchema;
+  transferMode: Extract<ToolcraftTransferMode, { mode: "reference-runtime-clone" }>;
+}): string[] {
+  const errors: string[] = [];
+  const referenceTimeline = transferMode.referenceTimeline;
+  const timelineDefaultDurationSeconds = schema.panels.timeline?.defaultDurationSeconds;
+  const loopDuration = referenceTimeline.loopDuration;
+
+  if (!loopDuration) {
+    errors.push(
+      `referenceTimeline mode "${referenceTimelineMode}" must declare loopDuration with source, seconds, and evidence. Do not let runtime/template fallback duration such as 8s stand in for reference loop intent.`,
+    );
+    return errors;
+  }
+
+  if (!Number.isFinite(loopDuration.seconds) || loopDuration.seconds <= 0) {
+    errors.push(
+      `referenceTimeline.loopDuration.seconds must be a positive finite duration; received ${String(loopDuration.seconds)}.`,
+    );
+  }
+
+  if (!isValidTimelineLoopDurationSource(loopDuration.source)) {
+    errors.push(
+      `referenceTimeline.loopDuration.source must be "reference", "user-request", or "product-derived"; received "${String(loopDuration.source)}". Runtime/template fallback is not a valid loop-duration source.`,
+    );
+  }
+
+  if (!loopDuration.evidence.trim()) {
+    errors.push(
+      "referenceTimeline.loopDuration.evidence must explain where the reference loop duration came from, such as measured reference timing, an explicit user request, or a product-derived timing rule.",
+    );
+  }
+
+  if (typeof timelineDefaultDurationSeconds !== "number") {
+    errors.push(
+      "Toolcraft reference playback/keyframe timelines must set panels.timeline.defaultDurationSeconds to referenceTimeline.loopDuration.seconds so the initial UI duration is not the runtime fallback.",
+    );
+  } else if (
+    Number.isFinite(loopDuration.seconds) &&
+    Math.abs(timelineDefaultDurationSeconds - loopDuration.seconds) > 0.001
+  ) {
+    errors.push(
+      `panels.timeline.defaultDurationSeconds (${timelineDefaultDurationSeconds}) must match referenceTimeline.loopDuration.seconds (${loopDuration.seconds}).`,
+    );
+  }
+
+  return errors;
+}
+
+function getReferenceTimelineAcceptanceCoverageErrors({
+  acceptance,
+  declaredReferenceTimelineCoverage,
+  referenceTimelineMode,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  declaredReferenceTimelineCoverage: ReadonlySet<ToolcraftReferenceTimelineCoverage>;
+  referenceTimelineMode: string;
+}): string[] {
+  const errors: string[] = [];
+
+  for (const coverage of declaredReferenceTimelineCoverage) {
+    if (
+      customReferenceTimelineCoverage.has(coverage) &&
+      referenceTimelineMode !== "custom-reference-timeline"
+    ) {
+      errors.push(
+        `referenceTimeline mode "${referenceTimelineMode}" cannot preserve custom reference timeline behavior "${coverage}". Use mode "custom-reference-timeline" and browser-backed referenceTimelineCoverage instead.`,
+      );
+    }
+
+    const entry = acceptance.find(
+      (acceptanceEntry) => acceptanceEntry.referenceTimelineCoverage === coverage,
+    );
+
+    if (!entry) {
+      errors.push(
+        `referenceTimeline behaviorCoverage "${coverage}" is missing an acceptance entry with referenceTimelineCoverage "${coverage}".`,
+      );
+      continue;
+    }
+
+    if (entry.kind !== "runtime") {
+      errors.push(
+        `${entry.id} must be a runtime acceptance entry proving reference timeline behavior "${coverage}".`,
+      );
+    }
+
+    if (!entry.automated || !entry.automatedTestName.trim()) {
+      errors.push(
+        `${entry.id} must have automated coverage proving reference timeline behavior "${coverage}".`,
+      );
+    }
+
+    if (!entry.browser || !entry.browserTestName.trim()) {
+      errors.push(
+        `${entry.id} must have browser coverage proving reference timeline behavior "${coverage}".`,
+      );
+    }
+
+    if (!entry.expectedObservable.trim()) {
+      errors.push(
+        `${entry.id} must describe the observable reference timeline behavior for "${coverage}".`,
+      );
+    }
+  }
+
+  return errors;
+}
+
+export function getReferenceTimelineErrors({
+  acceptance,
+  referenceTimelineCoverageFromInventory,
+  schema,
+  timelineMode,
+  transferMode,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  referenceTimelineCoverageFromInventory: ReadonlySet<ToolcraftReferenceTimelineCoverage>;
+  schema: ResolvedToolcraftAppSchema;
+  timelineMode: "keyframes" | "playback" | null;
+  transferMode: Extract<ToolcraftTransferMode, { mode: "reference-runtime-clone" }>;
+}): string[] {
+  const errors: string[] = [];
+  const referenceTimeline = transferMode.referenceTimeline;
+
+  if (!referenceTimeline) {
+    errors.push(
+      'reference-runtime-clone transferMode must declare referenceTimeline with mode "none", "toolcraft-playback", "toolcraft-keyframes", or "custom-reference-timeline".',
+    );
+    return errors;
+  }
+
+  const declaredReferenceCoverage = new Set(transferMode.behaviorCoverage);
+  const declaredReferenceTimelineCoverage = new Set(referenceTimeline.behaviorCoverage);
+  const declaredReferenceTransportCoverage = [...declaredReferenceCoverage].filter(
+    (coverage) => referenceTransportCoverage.has(coverage),
+  );
+  const declaredToolcraftTimelineCoverage = [...declaredReferenceTimelineCoverage].filter(
+    (coverage) => toolcraftReferenceTimelineCoverage.has(coverage),
+  );
+
+  for (const coverage of declaredReferenceTimelineCoverage) {
+    if (!referenceTimelineCoverageFromInventory.has(coverage)) {
+      errors.push(
+        `referenceTimeline behaviorCoverage "${coverage}" must be represented in referenceFeatureInventory by an item whose acceptanceId points to that referenceTimelineCoverage.`,
+      );
+    }
+  }
+
+  if (referenceTimeline.mode === "none" && declaredReferenceTimelineCoverage.size > 0) {
+    errors.push(
+      'referenceTimeline mode "none" must not declare reference timeline behaviorCoverage.',
+    );
+  }
+
+  if (
+    referenceTimeline.mode === "none" &&
+    declaredReferenceTransportCoverage.length > 0
+  ) {
+    errors.push(
+      `reference-runtime-clone transport behaviorCoverage ${declaredReferenceTransportCoverage.map((coverage) => `"${coverage}"`).join(", ")} requires referenceTimeline mode "toolcraft-playback", "toolcraft-keyframes", or "custom-reference-timeline"; mode "none" is only for references with no user-facing transport behavior.`,
+    );
+  }
+
+  if (
+    (referenceTimeline.mode === "toolcraft-playback" ||
+      referenceTimeline.mode === "toolcraft-keyframes") &&
+    declaredReferenceTimelineCoverage.size === 0
+  ) {
+    errors.push(
+      `referenceTimeline mode "${referenceTimeline.mode}" must list the concrete timeline transport behaviors in behaviorCoverage.`,
+    );
+  }
+
+  if (referenceTimeline.mode === "toolcraft-playback" && timelineMode !== "playback") {
+    errors.push(
+      'referenceTimeline mode "toolcraft-playback" requires panels.timeline mode "playback".',
+    );
+  }
+
+  if (referenceTimeline.mode === "toolcraft-keyframes" && timelineMode !== "keyframes") {
+    errors.push(
+      'referenceTimeline mode "toolcraft-keyframes" requires panels.timeline mode "keyframes".',
+    );
+  }
+
+  if (
+    referenceTimeline.mode === "toolcraft-playback" ||
+    referenceTimeline.mode === "toolcraft-keyframes"
+  ) {
+    errors.push(
+      ...getReferenceTimelineLoopDurationErrors({
+        referenceTimelineMode: referenceTimeline.mode,
+        schema,
+        transferMode,
+      }),
+    );
+  }
+
+  if (
+    referenceTimeline.mode === "toolcraft-playback" &&
+    declaredReferenceTimelineCoverage.has("keyframes")
+  ) {
+    errors.push(
+      'referenceTimeline behaviorCoverage "keyframes" requires referenceTimeline mode "toolcraft-keyframes".',
+    );
+  }
+
+  if (
+    referenceTimeline.mode === "toolcraft-keyframes" &&
+    !declaredReferenceTimelineCoverage.has("keyframes")
+  ) {
+    errors.push(
+      'referenceTimeline mode "toolcraft-keyframes" must include behaviorCoverage "keyframes".',
+    );
+  }
+
+  if (
+    (referenceTimeline.mode === "toolcraft-playback" ||
+      referenceTimeline.mode === "toolcraft-keyframes") &&
+    declaredToolcraftTimelineCoverage.length === 0
+  ) {
+    errors.push(
+      `referenceTimeline mode "${referenceTimeline.mode}" must include at least one Toolcraft timeline behavior such as "playback", "restart", "scrub", "duration", "loop", "time-progress", "export-at-time", or "keyframes".`,
+    );
+  }
+
+  if (
+    referenceTimeline.mode === "custom-reference-timeline" &&
+    declaredReferenceTimelineCoverage.size === 0
+  ) {
+    errors.push(
+      'referenceTimeline mode "custom-reference-timeline" must list every reference timeline behavior in behaviorCoverage.',
+    );
+  }
+
+  errors.push(
+    ...getReferenceTimelineAcceptanceCoverageErrors({
+      acceptance,
+      declaredReferenceTimelineCoverage,
+      referenceTimelineMode: referenceTimeline.mode,
+    }),
+  );
+
+  return errors;
+}

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

@@ -0,0 +1,99 @@
+import type { ResolvedToolcraftAppSchema } from "@repo/toolcraft-runtime";
+
+import {
+  getReferenceBehaviorCoverageErrors,
+  getUnmappedReferenceAcceptanceErrors,
+} from "./reference-runtime-coverage";
+import { getReferenceFeatureInventoryValidationResult } from "./reference-runtime-feature-inventory";
+import { getReferenceStudyErrors } from "./reference-runtime-study";
+import { getReferenceTimelineErrors } from "./reference-runtime-timeline";
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftTransferMode,
+} from "./types";
+
+export function getToolcraftReferenceRuntimeCloneErrors({
+  acceptance,
+  schema,
+  timelineMode,
+  transferMode,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  schema: ResolvedToolcraftAppSchema;
+  timelineMode: "keyframes" | "playback" | null;
+  transferMode: ToolcraftTransferMode;
+}): string[] {
+  const errors: string[] = [];
+
+  if (transferMode.mode !== "reference-runtime-clone") {
+    for (const entry of acceptance) {
+      if (entry.referenceCoverage) {
+        errors.push(
+          `${entry.id} declares referenceCoverage "${entry.referenceCoverage}" but transferMode is not "reference-runtime-clone".`,
+        );
+      }
+
+      if (entry.referenceTimelineCoverage) {
+        errors.push(
+          `${entry.id} declares referenceTimelineCoverage "${entry.referenceTimelineCoverage}" but transferMode is not "reference-runtime-clone".`,
+        );
+      }
+    }
+
+    return errors;
+  }
+
+  if (!schema.assembly.surfaces.canvas.enabled) {
+    errors.push(
+      "reference-runtime-clone must keep the Toolcraft canvas shell enabled; preserve the reference renderer inside ToolcraftApp canvasContent instead of replacing the app with the original UI.",
+    );
+  }
+
+  if (!transferMode.referenceName.trim()) {
+    errors.push(
+      "reference-runtime-clone transferMode must name the reference app or artifact.",
+    );
+  }
+
+  if (transferMode.sourceOfTruth !== "reference-runtime") {
+    errors.push(
+      'reference-runtime-clone transferMode must set sourceOfTruth to "reference-runtime".',
+    );
+  }
+
+  errors.push(...getReferenceStudyErrors(transferMode));
+
+  const featureInventoryResult = getReferenceFeatureInventoryValidationResult({
+    acceptance,
+    transferMode,
+  });
+
+  errors.push(...featureInventoryResult.errors);
+  errors.push(
+    ...getReferenceBehaviorCoverageErrors({
+      acceptance,
+      referenceCoverageFromInventory:
+        featureInventoryResult.referenceCoverageFromInventory,
+      transferMode,
+    }),
+  );
+  errors.push(
+    ...getReferenceTimelineErrors({
+      acceptance,
+      referenceTimelineCoverageFromInventory:
+        featureInventoryResult.referenceTimelineCoverageFromInventory,
+      schema,
+      timelineMode,
+      transferMode,
+    }),
+  );
+  errors.push(
+    ...getUnmappedReferenceAcceptanceErrors({
+      acceptance,
+      referenceFeatureAcceptanceIds:
+        featureInventoryResult.referenceFeatureAcceptanceIds,
+    }),
+  );
+
+  return errors;
+}

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

@@ -0,0 +1,290 @@
+import type {
+  ResolvedToolcraftAppSchema,
+  ToolcraftTimelineMode,
+} from "@repo/toolcraft-runtime";
+
+import {
+  hasTimelinePlaybackCoverage,
+  hasTimelinePlaybackCoveragePart,
+} from "./coverage";
+import {
+  schemaHasPngExportPanelAction,
+  schemaHasVideoExportPanelAction,
+} from "./output-export";
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftLayerCoverage,
+  ToolcraftTimelineLoopProof,
+  ToolcraftTimelinePlaybackCoverage,
+} from "./types";
+
+const requiredLayerCoverage = [
+  "selection",
+  "visibility",
+  "reorder",
+  "grouping",
+] satisfies readonly ToolcraftLayerCoverage[];
+
+const requiredTimelinePlaybackCoverage = [
+  "pause-resume",
+  "scrub",
+  "duration",
+  "loop",
+  "rendered-frame",
+] satisfies readonly ToolcraftTimelinePlaybackCoverage[];
+
+const requiredTimelineLoopProof = {
+  direction: "forward-only",
+  durationChange: "reproved-after-edit",
+  reversePlayback: "forbidden",
+  seam: "first-last-match",
+} satisfies ToolcraftTimelineLoopProof;
+
+export function getToolcraftLayerCoverageErrors({
+  acceptance,
+  layersEnabled,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  layersEnabled: boolean;
+}): string[] {
+  const errors: string[] = [];
+
+  if (layersEnabled) {
+    for (const coverage of requiredLayerCoverage) {
+      const entry = acceptance.find(
+        (acceptanceEntry) =>
+          acceptanceEntry.kind === "runtime" && acceptanceEntry.layerCoverage === coverage,
+      );
+
+      if (!entry) {
+        errors.push(
+          `panels.layers requires a runtime acceptance entry with layerCoverage "${coverage}" proving layer ${coverage} behavior.`,
+        );
+        continue;
+      }
+
+      if (!entry.automated || !entry.automatedTestName.trim()) {
+        errors.push(`${entry.id} must have automated coverage proving layer ${coverage}.`);
+      }
+
+      if (!entry.browser || !entry.browserTestName.trim()) {
+        errors.push(`${entry.id} must have browser coverage proving layer ${coverage}.`);
+      }
+
+      if (!entry.expectedObservable.trim()) {
+        errors.push(
+          `${entry.id} must describe the observable layer behavior for "${coverage}".`,
+        );
+      }
+    }
+  } else {
+    for (const entry of acceptance) {
+      if (entry.layerCoverage) {
+        errors.push(
+          `${entry.id} declares layerCoverage "${entry.layerCoverage}" but panels.layers is not enabled.`,
+        );
+      }
+    }
+  }
+
+  return errors;
+}
+
+export function getToolcraftTimelinePlaybackCoverageErrors({
+  acceptance,
+  timelineMode,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  timelineMode: ToolcraftTimelineMode | null;
+}): string[] {
+  const errors: string[] = [];
+
+  if (!timelineMode) {
+    return errors;
+  }
+
+  const playbackEntry = acceptance.find(
+    (entry) => entry.kind === "runtime" && entry.timelineCoverage === "playback",
+  );
+
+  if (!playbackEntry) {
+    errors.push(
+      `panels.timeline mode "${timelineMode}" requires a runtime acceptance entry with timelineCoverage "playback" proving pause, scrub, duration/loop, and rendered-frame behavior.`,
+    );
+    return errors;
+  }
+
+  if (
+    !hasTimelinePlaybackCoverage(
+      playbackEntry.timelinePlaybackCoverage,
+      requiredTimelinePlaybackCoverage,
+    )
+  ) {
+    errors.push(
+      `${playbackEntry.id} timelineCoverage "playback" must declare timelinePlaybackCoverage for pause-resume, scrub, duration, loop, and rendered-frame. Duration coverage must prove renderer progress maps 0..state.timeline.durationSeconds, not a local fixed animation duration.`,
+    );
+    return errors;
+  }
+
+  if (
+    hasTimelinePlaybackCoveragePart(playbackEntry.timelinePlaybackCoverage, "loop") &&
+    (playbackEntry.timelineLoopProof?.direction !==
+      requiredTimelineLoopProof.direction ||
+      playbackEntry.timelineLoopProof.durationChange !==
+        requiredTimelineLoopProof.durationChange ||
+      playbackEntry.timelineLoopProof.reversePlayback !==
+        requiredTimelineLoopProof.reversePlayback ||
+      playbackEntry.timelineLoopProof.seam !== requiredTimelineLoopProof.seam)
+  ) {
+    errors.push(
+      `${playbackEntry.id} timelinePlaybackCoverage "loop" must declare timelineLoopProof with forward-only direction, forbidden reverse playback, first-last-match seam, and reproved-after-edit duration behavior. Browser evidence still proves the real samples and seam.`,
+    );
+  }
+
+  return errors;
+}
+
+export function getToolcraftTimelineKeyframeCoverageErrors({
+  acceptance,
+  timelineMode,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  timelineMode: ToolcraftTimelineMode | null;
+}): string[] {
+  if (timelineMode !== "keyframes") {
+    return [];
+  }
+
+  const hasKeyframesCoverage = acceptance.some(
+    (entry) => entry.kind === "runtime" && entry.timelineCoverage === "keyframes",
+  );
+
+  if (hasKeyframesCoverage) {
+    return [];
+  }
+
+  return [
+    'panels.timeline mode "keyframes" requires a runtime acceptance entry with timelineCoverage "keyframes" proving expanded rows, diamonds, keyframe mutation, and renderer evaluation.',
+  ];
+}
+
+export function getToolcraftCanvasSizingCoverageErrors({
+  acceptance,
+  schema,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  schema: ResolvedToolcraftAppSchema;
+}): string[] {
+  const errors: string[] = [];
+
+  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" &&
+        entry.canvasSizingCoverage === "fixed-output-size",
+    );
+
+    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. 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 {
+      if (!fixedCanvasSizingEntry.automated || !fixedCanvasSizingEntry.automatedTestName.trim()) {
+        errors.push(
+          `${fixedCanvasSizingEntry.id} must have automated coverage proving fixed output dimensions.`,
+        );
+      }
+
+      if (!fixedCanvasSizingEntry.browser || !fixedCanvasSizingEntry.browserTestName.trim()) {
+        errors.push(
+          `${fixedCanvasSizingEntry.id} must have browser coverage proving fixed output dimensions.`,
+        );
+      }
+    }
+  }
+
+  if (
+    schema.canvas.enabled &&
+    schema.canvas.upload &&
+    schema.canvas.sizing.mode === "intrinsic-media"
+  ) {
+    const intrinsicCanvasSizingEntry = acceptance.find(
+      (entry) =>
+        entry.kind === "runtime" &&
+        entry.canvasSizingCoverage === "intrinsic-media-size",
+    );
+
+    if (!intrinsicCanvasSizingEntry) {
+      errors.push(
+        'canvas.sizing mode "intrinsic-media" with upload requires a runtime acceptance entry with canvasSizingCoverage "intrinsic-media-size" proving the app is a true media-viewer/source-native product where imported media natural dimensions intentionally own canvas.size. Uploaded background/source images inside product canvases must use "editable-output" and keep the current canvas size.',
+      );
+    } else {
+      if (!intrinsicCanvasSizingEntry.automated || !intrinsicCanvasSizingEntry.automatedTestName.trim()) {
+        errors.push(
+          `${intrinsicCanvasSizingEntry.id} must have automated coverage proving intrinsic media sizing.`,
+        );
+      }
+
+      if (!intrinsicCanvasSizingEntry.browser || !intrinsicCanvasSizingEntry.browserTestName.trim()) {
+        errors.push(
+          `${intrinsicCanvasSizingEntry.id} must have browser coverage proving intrinsic media sizing.`,
+        );
+      }
+    }
+  }
+
+  return errors;
+}
+
+export function getToolcraftPersistenceCoverageErrors({
+  acceptance,
+  schema,
+}: {
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  schema: ResolvedToolcraftAppSchema;
+}): string[] {
+  const errors: string[] = [];
+
+  if (schema.persistence.storage !== "localStorage") {
+    return errors;
+  }
+
+  const persistenceEntry = acceptance.find(
+    (entry) =>
+      entry.kind === "runtime" &&
+      entry.persistenceCoverage === "reload",
+  );
+
+  if (!persistenceEntry) {
+    errors.push(
+      'persistence.storage "localStorage" requires a runtime acceptance entry with persistenceCoverage "reload" proving user-edited persisted state restores after a real browser reload. Settings import/export is not a substitute for persistence.',
+    );
+    return errors;
+  }
+
+  if (!persistenceEntry.automated || !persistenceEntry.automatedTestName.trim()) {
+    errors.push(
+      `${persistenceEntry.id} must have automated coverage proving persistence reload behavior.`,
+    );
+  }
+
+  if (!persistenceEntry.browser || !persistenceEntry.browserTestName.trim()) {
+    errors.push(
+      `${persistenceEntry.id} must have browser coverage proving persistence reload behavior.`,
+    );
+  }
+
+  if (!persistenceEntry.expectedObservable.trim()) {
+    errors.push(
+      `${persistenceEntry.id} must describe the persisted state observable after reload.`,
+    );
+  }
+
+  return errors;
+}