@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/starter/src/app/acceptance/feature-verification-selection.ts

@@ -0,0 +1,161 @@
+import type { ResolvedToolcraftAppSchema } from "@repo/toolcraft-runtime";
+
+import { getToolcraftControlApplicabilityCases } from "./control-applicability-cases";
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftControlSectionInventoryEntry,
+} from "./types";
+
+export type ToolcraftFeatureVerificationSelection = Readonly<{
+  acceptanceIds: readonly string[];
+  testNames: readonly string[];
+  version: 1;
+}>;
+
+type ToolcraftFeatureVerificationSelectionInput = Readonly<{
+  acceptance: readonly ToolcraftComponentAcceptance[];
+  acceptanceIds?: readonly string[];
+  all?: boolean;
+  schema: Pick<ResolvedToolcraftAppSchema, "panels">;
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[];
+}>;
+
+const compareCodeUnits = (left: string, right: string): number =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+function indexBrowserAcceptance(
+  acceptance: readonly ToolcraftComponentAcceptance[],
+): Map<string, ToolcraftComponentAcceptance> {
+  const byId = new Map<string, ToolcraftComponentAcceptance>();
+
+  for (const entry of acceptance) {
+    if (!entry.browser || !entry.browserTestName.trim()) continue;
+    if (byId.has(entry.id)) {
+      throw new Error(
+        `Toolcraft feature verification found duplicate browser acceptance id "${entry.id}".`,
+      );
+    }
+    byId.set(entry.id, entry);
+  }
+
+  return byId;
+}
+
+function getSeedIds({
+  acceptanceIds,
+  all,
+  browserAcceptance,
+}: {
+  acceptanceIds: readonly string[] | undefined;
+  all: boolean | undefined;
+  browserAcceptance: ReadonlyMap<string, ToolcraftComponentAcceptance>;
+}): string[] {
+  if (all && acceptanceIds !== undefined) {
+    throw new Error(
+      "Toolcraft feature verification accepts all mode or acceptance ids, not both.",
+    );
+  }
+  if (all) return [...browserAcceptance.keys()];
+  if (!acceptanceIds || acceptanceIds.length === 0) {
+    throw new Error(
+      "Toolcraft feature verification requires acceptance ids or all mode.",
+    );
+  }
+  if (new Set(acceptanceIds).size !== acceptanceIds.length) {
+    const duplicate = acceptanceIds.find(
+      (id, index) => acceptanceIds.indexOf(id) !== index,
+    );
+    throw new Error(
+      `Toolcraft feature verification received duplicate acceptance id "${duplicate}".`,
+    );
+  }
+  for (const id of acceptanceIds) {
+    if (!browserAcceptance.has(id)) {
+      throw new Error(
+        `Toolcraft feature verification received unknown browser acceptance id "${id}".`,
+      );
+    }
+  }
+  return [...acceptanceIds];
+}
+
+function indexDependentsBySelectorTarget({
+  browserAcceptance,
+  schema,
+  sectionInventory,
+}: {
+  browserAcceptance: ReadonlyMap<string, ToolcraftComponentAcceptance>;
+  schema: Pick<ResolvedToolcraftAppSchema, "panels">;
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[];
+}): Map<string, Set<string>> {
+  const dependents = new Map<string, Set<string>>();
+
+  for (const entry of browserAcceptance.values()) {
+    if (entry.kind !== "control" || !entry.target) continue;
+    const selectorTargets = new Set(
+      getToolcraftControlApplicabilityCases({
+        schema,
+        sectionInventory,
+        target: entry.target,
+      }).map(({ selectorTarget }) => selectorTarget),
+    );
+    for (const selectorTarget of selectorTargets) {
+      const ids = dependents.get(selectorTarget) ?? new Set<string>();
+      ids.add(entry.id);
+      dependents.set(selectorTarget, ids);
+    }
+  }
+
+  return dependents;
+}
+
+export function createToolcraftFeatureVerificationSelection(
+  input: ToolcraftFeatureVerificationSelectionInput,
+): ToolcraftFeatureVerificationSelection {
+  const browserAcceptance = indexBrowserAcceptance(input.acceptance);
+  if (browserAcceptance.size === 0) {
+    throw new Error(
+      "Toolcraft feature verification requires at least one browser acceptance row.",
+    );
+  }
+  const selectedIds = new Set(
+    getSeedIds({
+      acceptanceIds: input.acceptanceIds,
+      all: input.all,
+      browserAcceptance,
+    }),
+  );
+  const dependentsBySelectorTarget = indexDependentsBySelectorTarget({
+    browserAcceptance,
+    schema: input.schema,
+    sectionInventory: input.sectionInventory,
+  });
+  const queue = [...selectedIds];
+
+  for (let index = 0; index < queue.length; index += 1) {
+    const selected = browserAcceptance.get(queue[index]!);
+    if (selected?.kind !== "control" || !selected.target) continue;
+    for (const dependentId of
+      dependentsBySelectorTarget.get(selected.target) ?? []) {
+      if (selectedIds.has(dependentId)) continue;
+      selectedIds.add(dependentId);
+      queue.push(dependentId);
+    }
+  }
+
+  const acceptanceIds = Object.freeze([...selectedIds].sort(compareCodeUnits));
+  const testNames = acceptanceIds.map(
+    (id) => browserAcceptance.get(id)!.browserTestName,
+  );
+  if (new Set(testNames).size !== testNames.length) {
+    throw new Error(
+      "Toolcraft feature verification requires one unique browser test name per selected acceptance id.",
+    );
+  }
+
+  return Object.freeze({
+    acceptanceIds,
+    testNames: Object.freeze([...testNames].sort(compareCodeUnits)),
+    version: 1,
+  });
+}

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

@@ -2,6 +2,7 @@ import type { ResolvedToolcraftAppSchema } from "@repo/toolcraft-runtime";
 
 import {
   schemaHasPngExportPanelAction,
+  schemaHasSvgExportPanelAction,
   schemaHasVideoExportPanelAction,
 } from "./output-export-actions";
 import type {
@@ -66,6 +67,15 @@ export function getToolcraftInfinityCanvasCoverageErrors({
     });
   }
 
+  if (schemaHasSvgExportPanelAction(schema)) {
+    requiredProofs.push({
+      coverage: "scene-bounds-svg-export",
+      evidence: "exported-bytes",
+      message:
+        'Export SVG with editable-output canvas requires a runtime acceptance entry with infinityCanvasCoverage "scene-bounds-svg-export" proving infinite export uses the exact visible scene union through ToolcraftAppComposition.sceneBoundsProvider.',
+    });
+  }
+
   if (schemaHasVideoExportPanelAction(schema)) {
     requiredProofs.push({
       coverage: "scene-bounds-video-export",

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

@@ -1,7 +1,7 @@
-import type {
-  ResolvedToolcraftAppSchema,
-  ResolvedToolcraftControlSchema,
-  ToolcraftControlSchema,
+import {
+  type ResolvedToolcraftAppSchema,
+  type ResolvedToolcraftControlSchema,
+  type ToolcraftControlSchema,
 } from "@repo/toolcraft-runtime";
 
 import {
@@ -9,10 +9,23 @@ import {
   isToolcraftProductSectionControl,
 } from "./controls";
 import { getToolcraftSectionLabel } from "./sections";
-import { getToolcraftLooseTargetPrefix } from "./semantic";
+import {
+  getToolcraftLooseTargetPrefix,
+  normalizeToolcraftSemanticText,
+} from "./semantic";
 
 const maxInlineSwitchLabelLength = 16;
 const maxInlineSwitchLabelWordCount = 2;
+const normalizedVideoExportSectionTitle =
+  normalizeToolcraftSemanticText("Video Export");
+
+type ToolcraftControlsSection = NonNullable<
+  ResolvedToolcraftAppSchema["panels"]["controls"]
+>["sections"][number];
+
+type ToolcraftControlLayoutGroup = NonNullable<
+  ToolcraftControlsSection["layoutGroups"]
+>[number];
 
 function getInlineSwitchLabelText(
   controlId: string,
@@ -56,8 +69,42 @@ function controlsShareToolcraftTargetEntity(
   return Boolean(firstPrefix && firstPrefix === secondPrefix);
 }
 
+function isToolcraftVideoExportSegmentedInlinePair({
+  layoutGroup,
+  section,
+  segmentedControlId,
+}: {
+  layoutGroup: ToolcraftControlLayoutGroup;
+  section: ToolcraftControlsSection;
+  segmentedControlId: string;
+}): boolean {
+  if (
+    normalizeToolcraftSemanticText(section.title) !==
+      normalizedVideoExportSectionTitle ||
+    layoutGroup.columns !== 2 ||
+    layoutGroup.controls.length !== 2
+  ) {
+    return false;
+  }
+
+  const formatControl = section.controls[segmentedControlId];
+  const resolutionControlId = layoutGroup.controls.find(
+    (controlId) => controlId !== segmentedControlId,
+  );
+  const resolutionControl = resolutionControlId
+    ? section.controls[resolutionControlId]
+    : undefined;
+
+  return (
+    formatControl?.type === "segmented" &&
+    formatControl.target === "export.video.format" &&
+    resolutionControl?.type === "select" &&
+    resolutionControl.target === "export.video.resolution"
+  );
+}
+
 export function sectionHasInlineLayoutGroupForPair(
-  section: NonNullable<ResolvedToolcraftAppSchema["panels"]["controls"]>["sections"][number],
+  section: ToolcraftControlsSection,
   firstControlId: string,
   secondControlId: string,
 ): boolean {
@@ -95,7 +142,13 @@ export function getToolcraftInlineLayoutErrors(
       }
 
       const segmentedIds = layoutGroup.controls.filter(
-        (controlId) => section.controls[controlId]?.type === "segmented",
+        (controlId) =>
+          section.controls[controlId]?.type === "segmented" &&
+          !isToolcraftVideoExportSegmentedInlinePair({
+            layoutGroup,
+            section,
+            segmentedControlId: controlId,
+          }),
       );
 
       if (segmentedIds.length > 0) {
@@ -181,8 +234,10 @@ export function getToolcraftInlineLayoutErrors(
         !secondControlId ||
         !firstControl ||
         !secondControl ||
-        firstControl.visibleWhen ||
-        secondControl.visibleWhen ||
+        firstControl.applicability.mode ===
+          "conditional" ||
+        secondControl.applicability.mode ===
+          "conditional" ||
         !isBooleanControl(firstControl) ||
         !isBooleanControl(secondControl) ||
         !isInlineSwitchLabelSafe(firstControlId, firstControl) ||

package/templates/starter/src/app/acceptance/interaction-ownership-intent.ts

@@ -14,7 +14,7 @@ export type ToolcraftInteractionEvidenceSource =
   | "usability-analysis"
   | "user-request";
 
-export type ToolcraftInteractionOwnershipEntry = {
+type ToolcraftInteractionOwnershipBase = {
   alternative: {
     reason: string;
     surface: ToolcraftInteractionSurface;
@@ -29,3 +29,21 @@ export type ToolcraftInteractionOwnershipEntry = {
   surface: ToolcraftInteractionSurface;
   target: string;
 };
+
+export type ToolcraftInteractionOwnershipEntry =
+  | (ToolcraftInteractionOwnershipBase & {
+      capability: "precise-value-entry" | "property-edit";
+      selectionScope:
+        | Readonly<{ mode: "global" }>
+        | Readonly<{
+            mode: "selected-entity";
+            selectionInteractionId: string;
+          }>;
+    })
+  | (ToolcraftInteractionOwnershipBase & {
+      capability: Exclude<
+        ToolcraftInteractionCapability,
+        "precise-value-entry" | "property-edit"
+      >;
+      selectionScope?: never;
+    });

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

@@ -56,6 +56,7 @@ function getAcceptanceTarget(
 function getEntryShapeErrors(
   entry: ToolcraftInteractionOwnershipEntry,
   controlTargets: ReadonlySet<string>,
+  acceptanceTargets: ReadonlySet<string>,
 ): string[] {
   const errors: string[] = [];
   const expectedAlternative = entry.surface === "canvas" ? "panel" : "canvas";
@@ -66,7 +67,14 @@ function getEntryShapeErrors(
 
   if (!entry.target.trim()) {
     errors.push(`${entry.id || "interactionOwnership entry"} target must be non-empty.`);
-  } else if (!isToolcraftSupportedInteractionTarget(entry.target, controlTargets)) {
+  } else if (
+    !(
+      (entry.capability === "spatial-selection" ||
+        entry.capability === "structured-selection") &&
+      acceptanceTargets.has(entry.target)
+    ) &&
+    !isToolcraftSupportedInteractionTarget(entry.target, controlTargets)
+  ) {
     errors.push(
       `${entry.id} target ${entry.target} does not match a schema target or supported editor command.`,
     );
@@ -168,6 +176,12 @@ export function getToolcraftInteractionOwnershipErrors({
 
   const errors: string[] = [];
   const controlTargets = new Set(controls.map(({ control }) => control.target));
+  const acceptanceTargets = new Set(
+    acceptance.flatMap((entry) => {
+      const target = getAcceptanceTarget(entry);
+      return target ? [target] : [];
+    }),
+  );
   const visibleControlByTarget = new Map(
     controls.map((control) => [control.control.target, control] as const),
   );
@@ -182,7 +196,9 @@ export function getToolcraftInteractionOwnershipErrors({
   const duplicateIds = new Set<string>();
 
   for (const entry of inventory) {
-    errors.push(...getEntryShapeErrors(entry, controlTargets));
+    errors.push(
+      ...getEntryShapeErrors(entry, controlTargets, acceptanceTargets),
+    );
 
     if (inventoryById.has(entry.id)) {
       duplicateIds.add(entry.id);

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

@@ -148,7 +148,11 @@ export function getFileDropLifecycleCoverageErrors({
     );
   }
 
-  if (control.multiple === true && !layersOwnMediaManagement) {
+  if (
+    control.multiple === true &&
+    control.variant !== "collection-actions" &&
+    !layersOwnMediaManagement
+  ) {
     if (!coverage.has("reorder") || !coverage.has("order-output")) {
       errors.push(
         `${label} multiple fileDrop acceptance must prove thumbnail/file reorder updates runtime media order and that preview, renderer, or export consumes that order.`,

package/templates/starter/src/app/acceptance/motion-reference-evidence-validation.mjs

@@ -0,0 +1,65 @@
+const SHA256 = /^[a-f0-9]{64}$/u;
+const STUDY_ID = /^motion-v1-[a-f0-9]{64}$/u;
+const GROUP_ID = /^motion-group-v1-[a-f0-9]{64}$/u;
+
+export function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) &&
+    (Object.getPrototypeOf(value) === Object.prototype ||
+      Object.getPrototypeOf(value) === null);
+}
+
+export function hasExactKeys(
+  value,
+  required,
+  optional,
+  label,
+  errors,
+) {
+  if (!isRecord(value)) {
+    errors.push(`${label} must be an object.`);
+    return false;
+  }
+  const allowed = new Set([...required, ...optional]);
+  let exact = true;
+  for (const key of required) {
+    if (!Object.hasOwn(value, key)) {
+      errors.push(`${label} is missing ${key}.`);
+      exact = false;
+    }
+  }
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      errors.push(`${label} has unknown property ${key}.`);
+      exact = false;
+    }
+  }
+  return exact;
+}
+
+export function finite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+export function positive(value) {
+  return finite(value) && value > 0;
+}
+export function positiveInteger(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+export function nonnegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+export function nonemptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+export function isSha256(value) {
+  return typeof value === "string" && SHA256.test(value);
+}
+export function isStudyId(value) {
+  return typeof value === "string" && STUDY_ID.test(value);
+}
+export function isGroupId(value) {
+  return typeof value === "string" && GROUP_ID.test(value);
+}
+export function requireValue(condition, message, errors) {
+  if (!condition) errors.push(message);
+}