@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/starter/src/app/acceptance/control-section-inventory.ts

@@ -7,6 +7,12 @@ import {
 import { getToolcraftSectionLabel } from "./sections";
 import type { ToolcraftControlSectionInventoryEntry } from "./types";
 
+type ToolcraftInventorySchemaSection = Readonly<{
+  id: string;
+  label: string;
+  targets: readonly string[];
+}>;
+
 function getToolcraftControlSectionInventoryEntryId(
   entry: ToolcraftControlSectionInventoryEntry,
 ): string | null {
@@ -36,44 +42,31 @@ export function getToolcraftSectionInventoryById(
   return new Map(entries);
 }
 
-export function hasToolcraftInventorySplitEvidence({
-  sectionInventoryById,
-  sections,
-}: {
-  sectionInventoryById: ReadonlyMap<string, ToolcraftControlSectionInventoryEntry>;
-  sections: ReadonlySet<string>;
-}): boolean {
-  const entries = [...sections].map((sectionId) =>
-    sectionInventoryById.get(sectionId),
-  );
+function getToolcraftInventoryEntryByTarget(
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[],
+): ReadonlyMap<string, ToolcraftControlSectionInventoryEntry> {
+  const entries = new Map<string, ToolcraftControlSectionInventoryEntry>();
 
-  return (
-    entries.length === sections.size &&
-    entries.every(
-      (entry) =>
-        entry &&
-        (entry.workflowStage?.trim().length ?? 0) > 0 &&
-        (entry.splitReason?.trim().length ?? 0) >= 12,
-    )
-  );
+  for (const entry of sectionInventory) {
+    for (const target of entry.targets) {
+      if (!entries.has(target)) {
+        entries.set(target, entry);
+      }
+    }
+  }
+
+  return entries;
 }
 
-export function getToolcraftControlSectionInventoryErrors(
+function collectToolcraftInventorySchemaSections(
   schema: ResolvedToolcraftAppSchema,
   sectionInventory: readonly ToolcraftControlSectionInventoryEntry[],
-): string[] {
-  const errors: string[] = [];
-
-  if (sectionInventory.length === 0) {
-    return errors;
-  }
+): ToolcraftInventorySchemaSection[] {
+  const inventoryEntryByTarget =
+    getToolcraftInventoryEntryByTarget(sectionInventory);
 
-  const schemaSections = (schema.panels.controls?.sections ?? []).flatMap(
+  return (schema.panels.controls?.sections ?? []).flatMap(
     (section, sectionIndex) => {
-      if (section.id === "runtime.setup") {
-        return [];
-      }
-
       const targets = Object.values(section.controls)
         .filter(isToolcraftProductSectionControl)
         .map((control) => control.target);
@@ -82,15 +75,53 @@ export function getToolcraftControlSectionInventoryErrors(
         return [];
       }
 
-      return [
-        {
+      if (section.id !== "runtime.setup") {
+        return [{
           id: section.id,
           label: getToolcraftSectionLabel(section.title, sectionIndex),
           targets,
-        },
-      ];
+        }];
+      }
+
+      const relocatedSections = new Map<string, ToolcraftInventorySchemaSection>();
+
+      for (const target of targets) {
+        const inventoryEntry = inventoryEntryByTarget.get(target);
+        const inventoryId = inventoryEntry
+          ? getToolcraftControlSectionInventoryEntryId(inventoryEntry)
+          : null;
+        const id = inventoryId ?? section.id;
+        const existing = relocatedSections.get(id);
+
+        relocatedSections.set(id, {
+          id,
+          label:
+            inventoryId && inventoryEntry
+              ? inventoryEntry.title
+              : getToolcraftSectionLabel(section.title, sectionIndex),
+          targets: [...(existing?.targets ?? []), target],
+        });
+      }
+
+      return [...relocatedSections.values()];
     },
   );
+}
+
+export function getToolcraftControlSectionInventoryErrors(
+  schema: ResolvedToolcraftAppSchema,
+  sectionInventory: readonly ToolcraftControlSectionInventoryEntry[],
+): string[] {
+  const errors: string[] = [];
+
+  if (sectionInventory.length === 0) {
+    return errors;
+  }
+
+  const schemaSections = collectToolcraftInventorySchemaSections(
+    schema,
+    sectionInventory,
+  );
   const schemaSectionIds = new Set(schemaSections.map((section) => section.id));
   const schemaTargetToSection = new Map<string, string>();
 
@@ -107,9 +138,8 @@ export function getToolcraftControlSectionInventoryErrors(
     const id = getToolcraftControlSectionInventoryEntryId(entry);
     const title = entry.title.trim();
     const entity = entry.entity?.trim() ?? "";
-    const workflowStage = entry.workflowStage?.trim() ?? "";
+    const entityId = entry.entityId?.trim() ?? "";
     const groupingReason = entry.groupingReason.trim();
-    const splitReason = entry.splitReason?.trim() ?? "";
 
     if (!id) {
       errors.push(
@@ -133,21 +163,21 @@ export function getToolcraftControlSectionInventoryErrors(
       );
     }
 
-    if (!entity && !workflowStage) {
+    if (!entityId) {
       errors.push(
-        `Control Section Inventory entry "${title}" must declare entity or workflowStage so grouping is based on product meaning, not UI layout.`,
+        `Control Section Inventory entry "${title}" must declare a non-empty stable entityId.`,
       );
     }
 
-    if (groupingReason.length < 12) {
+    if (!entity) {
       errors.push(
-        `Control Section Inventory entry "${title}" must include a concrete groupingReason explaining why these controls belong together.`,
+        `Control Section Inventory entry "${title}" must declare a human-readable entity name.`,
       );
     }
 
-    if (splitReason && splitReason.length < 12) {
+    if (groupingReason.length < 12) {
       errors.push(
-        `Control Section Inventory entry "${title}" splitReason is too vague. Explain the product workflow split or omit splitReason.`,
+        `Control Section Inventory entry "${title}" must include a concrete groupingReason explaining why these controls belong together.`,
       );
     }
 
@@ -208,7 +238,7 @@ export function getToolcraftControlSectionInventoryErrors(
 
     if (!entry) {
       errors.push(
-        `Control Section Inventory is missing product section id "${section.id}" (${section.label}). Add the same explicit id, entity/workflow stage, targets, and groupingReason.`,
+        `Control Section Inventory is missing product section id "${section.id}" (${section.label}). Add the same explicit id, entityId, entity, targets, and groupingReason.`,
       );
       continue;
     }

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

@@ -109,10 +109,18 @@ export function getBuiltInFitCheckErrors(
     );
   }
 
+  const ownsRepeatedItems = capabilities.some((capability) =>
+    ["collection", "reorder", "selection"].includes(capability),
+  );
+
+  if (ownsRepeatedItems && !checkedBuiltIns.includes("sourceCollection")) {
+    errors.push(
+      `${label} builtInFitCheck.checkedBuiltIns must include sourceCollection when the custom control owns a repeated runtime item set whose cardinality could be source-owned.`,
+    );
+  }
+
   if (
-    capabilities.some((capability) =>
-      ["collection", "reorder", "selection"].includes(capability),
-    ) &&
+    ownsRepeatedItems &&
     !checkedBuiltIns.includes("collectionActions")
   ) {
     errors.push(

package/templates/starter/src/app/acceptance/export-artifact-coverage.ts

@@ -1,7 +1,8 @@
 import type {
   ResolvedToolcraftAppSchema,
-  ToolcraftActionSchema,
+  ToolcraftArtifactExportActionRole,
 } from "@repo/toolcraft-runtime";
+import { isToolcraftArtifactExportAction } from "@repo/toolcraft-runtime";
 
 import { getControlActions } from "./actions";
 import type {
@@ -11,9 +12,10 @@ import type {
 
 const requiredCoverageByRole = {
   "export-image": "all-required-image-export-behavior",
+  "export-svg": "all-required-svg-export-behavior",
   "export-video": "all-required-video-export-behavior",
 } as const satisfies Record<
-  "export-image" | "export-video",
+  ToolcraftArtifactExportActionRole,
   ToolcraftExportArtifactCoverage
 >;
 
@@ -26,24 +28,13 @@ function getCoverageValues(
     : entry.exportArtifactCoverage;
 }
 
-function isMediaExportAction(
-  action: ToolcraftActionSchema | string,
-): action is ToolcraftActionSchema & {
-  role: "export-image" | "export-video";
-} {
-  return (
-    typeof action !== "string" &&
-    (action.role === "export-image" || action.role === "export-video")
-  );
-}
-
-function collectMediaExportActions(schema: ResolvedToolcraftAppSchema) {
+function collectArtifactExportActions(schema: ResolvedToolcraftAppSchema) {
   return (schema.panels.controls?.sections ?? []).flatMap((section) =>
     Object.values(section.controls).flatMap((control) =>
       control.type !== "panelActions" || !control.target
         ? []
         : getControlActions(control)
-            .filter(isMediaExportAction)
+            .filter(isToolcraftArtifactExportAction)
             .map((action) => ({
               requiredCoverage: requiredCoverageByRole[action.role],
               role: action.role,
@@ -54,6 +45,23 @@ function collectMediaExportActions(schema: ResolvedToolcraftAppSchema) {
   );
 }
 
+function getMisplacedArtifactExportActionErrors(
+  schema: ResolvedToolcraftAppSchema,
+): string[] {
+  return (schema.panels.controls?.sections ?? []).flatMap((section) =>
+    Object.values(section.controls).flatMap((control) =>
+      control.type === "panelActions"
+        ? []
+        : getControlActions(control)
+            .filter(isToolcraftArtifactExportAction)
+            .map(
+              (action) =>
+                `Typed ${action.role} action "${action.value}" must be declared in sticky panelActions.`,
+            ),
+    ),
+  );
+}
+
 export function getToolcraftExportArtifactCoverageErrors({
   acceptance,
   schema,
@@ -61,8 +69,8 @@ export function getToolcraftExportArtifactCoverageErrors({
   acceptance: readonly ToolcraftComponentAcceptance[];
   schema: ResolvedToolcraftAppSchema;
 }>): string[] {
-  const errors: string[] = [];
-  const exportActions = collectMediaExportActions(schema);
+  const errors = getMisplacedArtifactExportActionErrors(schema);
+  const exportActions = collectArtifactExportActions(schema);
 
   for (const entry of acceptance) {
     const coverage = getCoverageValues(entry);

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

@@ -0,0 +1,295 @@
+import { defineToolcraft } from "@repo/toolcraft-runtime";
+import { describe, expect, it } from "vitest";
+
+import { createToolcraftFeatureVerificationSelection } from "./feature-verification-selection";
+import type {
+  ToolcraftComponentAcceptance,
+  ToolcraftControlSectionInventoryEntry,
+} from "./types";
+
+function acceptance(
+  id: string,
+  target: string,
+  kind: ToolcraftComponentAcceptance["kind"] = "control",
+): ToolcraftComponentAcceptance {
+  return {
+    automated: true,
+    automatedTestName: `${id} unit`,
+    browser: true,
+    browserTestName: `browser: ${id}`,
+    componentType: kind === "control" ? "control" : "runtime",
+    evidence: "product-output",
+    expectedObservable: `${id} changes output.`,
+    fixture: "feature verification fixture",
+    id,
+    kind,
+    target,
+    userAction: `Change ${id}.`,
+  };
+}
+
+const schema = defineToolcraft({
+  canvas: { enabled: true },
+  panels: {
+    controls: {
+      sections: [
+        {
+          controls: {
+            frosting: {
+              applicability: {
+                all: [{ equals: "frosted", target: "material.layer" }],
+                mode: "conditional",
+              },
+              defaultValue: "#FFFFFF",
+              label: "Frosting",
+              target: "material.frosting",
+              type: "color",
+            },
+            gloss: {
+              applicability: { mode: "always" },
+              defaultValue: 0.5,
+              label: "Gloss",
+              max: 1,
+              min: 0,
+              target: "material.gloss",
+              type: "slider",
+            },
+            layer: {
+              applicability: { mode: "always" },
+              defaultValue: "frosted",
+              label: "Layer",
+              options: [
+                { label: "Frosted", value: "frosted" },
+                { label: "Chocolate", value: "chocolate" },
+              ],
+              target: "material.layer",
+              type: "segmented",
+            },
+          },
+          id: "material",
+          title: "Material",
+        },
+        {
+          controls: {
+            intensity: {
+              applicability: { mode: "always" },
+              defaultValue: 0.5,
+              label: "Intensity",
+              max: 1,
+              min: 0,
+              target: "lighting.intensity",
+              type: "slider",
+            },
+          },
+          id: "lighting",
+          title: "Lighting",
+        },
+      ],
+      title: "Controls",
+    },
+  },
+});
+
+const sectionInventory = [
+  {
+    entity: "Material",
+    entityId: "material",
+    groupingReason: "Layer, frosting, and gloss define one material.",
+    id: "material",
+    targets: ["material.layer", "material.frosting", "material.gloss"],
+    title: "Material",
+  },
+  {
+    entity: "Lighting",
+    entityId: "lighting",
+    groupingReason: "Lighting owns its independent intensity.",
+    id: "lighting",
+    targets: ["lighting.intensity"],
+    title: "Lighting",
+  },
+] as const satisfies readonly ToolcraftControlSectionInventoryEntry[];
+
+const browserAcceptance = [
+  acceptance("lighting.intensity", "lighting.intensity"),
+  acceptance(
+    "material.exportedAppearance",
+    "material.frosting",
+    "runtime",
+  ),
+  acceptance("material.frosting", "material.frosting"),
+  acceptance("material.gloss", "material.gloss"),
+  acceptance("material.layer", "material.layer"),
+] as const;
+
+function select(
+  selection: { acceptanceIds?: readonly string[]; all?: boolean },
+  acceptanceRows: readonly ToolcraftComponentAcceptance[] = browserAcceptance,
+) {
+  return createToolcraftFeatureVerificationSelection({
+    acceptance: acceptanceRows,
+    schema,
+    sectionInventory,
+    ...selection,
+  });
+}
+
+describe("Toolcraft feature verification selection", () => {
+  it("keeps a leaf control focused", () => {
+    expect(select({ acceptanceIds: ["material.gloss"] }).acceptanceIds).toEqual([
+      "material.gloss",
+    ]);
+  });
+
+  it("expands a finite selector to semantic peers that derive branch cases", () => {
+    const selection = select({ acceptanceIds: ["material.layer"] });
+
+    expect(selection.acceptanceIds).toEqual([
+      "material.frosting",
+      "material.gloss",
+      "material.layer",
+    ]);
+    expect(selection.testNames).toEqual([
+      "browser: material.frosting",
+      "browser: material.gloss",
+      "browser: material.layer",
+    ]);
+  });
+
+  it("selects every browser acceptance row only for explicit all mode", () => {
+    expect(select({ all: true }).acceptanceIds).toEqual([
+      "lighting.intensity",
+      "material.exportedAppearance",
+      "material.frosting",
+      "material.gloss",
+      "material.layer",
+    ]);
+  });
+
+  it("reaches a fixed point without selecting unrelated or runtime rows", () => {
+    const chainedSchema = defineToolcraft({
+      canvas: { enabled: true },
+      panels: {
+        controls: {
+          sections: [
+            {
+              controls: {
+                detail: {
+                  applicability: { mode: "always" },
+                  defaultValue: "fine",
+                  label: "Detail",
+                  options: [
+                    { label: "Fine", value: "fine" },
+                    { label: "Coarse", value: "coarse" },
+                  ],
+                  target: "shape.detail",
+                  type: "segmented",
+                },
+                mode: {
+                  applicability: { mode: "always" },
+                  defaultValue: "solid",
+                  label: "Mode",
+                  options: [
+                    { label: "Solid", value: "solid" },
+                    { label: "Wire", value: "wire" },
+                  ],
+                  target: "shape.mode",
+                  type: "segmented",
+                },
+                width: {
+                  applicability: { mode: "always" },
+                  defaultValue: 10,
+                  label: "Width",
+                  max: 20,
+                  min: 1,
+                  target: "shape.width",
+                  type: "slider",
+                },
+              },
+              id: "shape",
+              title: "Shape",
+            },
+          ],
+          title: "Controls",
+        },
+      },
+    });
+    const chainedInventory = [
+      {
+        entity: "Shape",
+        entityId: "shape",
+        groupingReason: "Shape mode, detail, and width define one shape.",
+        id: "shape",
+        targets: ["shape.mode", "shape.detail", "shape.width"],
+        title: "Shape",
+      },
+    ] as const;
+    const selection = createToolcraftFeatureVerificationSelection({
+      acceptance: [
+        acceptance("shape.detail", "shape.detail"),
+        acceptance("shape.mode", "shape.mode"),
+        acceptance("shape.width", "shape.width"),
+        acceptance("shape.export", "shape.width", "runtime"),
+      ],
+      acceptanceIds: ["shape.mode"],
+      schema: chainedSchema,
+      sectionInventory: chainedInventory,
+    });
+
+    expect(selection.acceptanceIds).toEqual([
+      "shape.detail",
+      "shape.mode",
+      "shape.width",
+    ]);
+  });
+
+  it("fails closed for invalid seed and acceptance boundaries", () => {
+    expect(() => select({})).toThrow(/acceptance ids or all mode/iu);
+    expect(() =>
+      select({ acceptanceIds: ["material.layer"], all: true }),
+    ).toThrow(/not both/iu);
+    expect(() => select({ acceptanceIds: ["missing"] })).toThrow(
+      /unknown browser acceptance id.*missing/iu,
+    );
+    expect(() =>
+      select(
+        { acceptanceIds: ["material.layer"] },
+        [
+          ...browserAcceptance,
+          acceptance("material.layer", "material.layer"),
+        ],
+      ),
+    ).toThrow(/duplicate browser acceptance id.*material\.layer/iu);
+    expect(() =>
+      select(
+        { acceptanceIds: ["material.nonBrowser"] },
+        [
+          ...browserAcceptance,
+          {
+            ...acceptance("material.nonBrowser", "material.gloss"),
+            browser: false,
+            browserTestName: "",
+          },
+        ],
+      ),
+    ).toThrow(/unknown browser acceptance id.*material\.nonBrowser/iu);
+  });
+
+  it("rejects duplicate seeds and returns deeply frozen deterministic output", () => {
+    expect(() =>
+      select({ acceptanceIds: ["material.gloss", "material.gloss"] }),
+    ).toThrow(/duplicate acceptance id.*material\.gloss/iu);
+
+    const selection = select({
+      acceptanceIds: ["material.layer", "lighting.intensity"],
+    });
+    expect(selection.acceptanceIds).toEqual([
+      "lighting.intensity",
+      "material.frosting",
+      "material.gloss",
+      "material.layer",
+    ]);
+    expect(Object.isFrozen(selection)).toBe(true);
+    expect(Object.isFrozen(selection.acceptanceIds)).toBe(true);
+    expect(Object.isFrozen(selection.testNames)).toBe(true);
+  });
+});