@pixel-point/toolcraft 0.0.18 → 0.0.19

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

@@ -2,8 +2,10 @@ import {
   getToolcraftColorBankDescriptionError,
   getToolcraftColorBankLabelErrors,
 } from "./color-bank-labels";
+import { getToolcraftColorRowGroupingErrors } from "./color-row-grouping";
 import {
   getToolcraftControlDescriptionError,
+  getToolcraftDuplicateSectionTitleLabelError,
   getToolcraftGenericControlLabelError,
 } from "./control-labels";
 import type { ToolcraftControlLayoutFacts } from "./control-layout-model";
@@ -61,6 +63,10 @@ export function getToolcraftControlLayoutSectionInvariantErrors(
       );
     }
     errors.push(
+      ...getToolcraftColorRowGroupingErrors({
+        controls,
+        sectionLabel,
+      }),
       ...getToolcraftColorBankLabelErrors({
         controls,
         sectionLabel,
@@ -69,6 +75,18 @@ export function getToolcraftControlLayoutSectionInvariantErrors(
     );
 
     for (const [controlId, control] of controls) {
+      const duplicateSectionTitleLabelError =
+        getToolcraftDuplicateSectionTitleLabelError({
+          control,
+          controlId,
+          sectionLabel,
+          sectionTitle,
+        });
+
+      if (duplicateSectionTitleLabelError) {
+        errors.push(duplicateSectionTitleLabelError);
+      }
+
       const genericLabelError = getToolcraftGenericControlLabelError({
         control,
         controlId,

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);
+  });
+});

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/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);