@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/starter/src/app/starter-acceptance.control-state.test.ts

@@ -160,115 +160,4 @@ describe("starter acceptance control state contract", () => {
     );
   });
 
-  it("requires visibleWhen controls to reference a real target and prove hidden behavior", () => {
-    const schemaWithVisibleDependency = defineContractSchemaFixture({
-      canvas: { enabled: true },
-      panels: {
-        controls: {
-          sections: [
-            {
-              controls: {
-                shadeCount: {
-                  defaultValue: 2,
-                  label: "Shades",
-                  max: 5,
-                  min: 1,
-                  step: 1,
-                  target: "shapes.shadeCount",
-                  type: "slider",
-                  variant: "discrete",
-                },
-                shade3: {
-                  defaultValue: { hex: "#BBBBBB" },
-                  label: "Shade 3",
-                  target: "shapes.color3",
-                  type: "color",
-                  visibleWhen: {
-                    greaterThanOrEqual: 3,
-                    target: "shapes.count",
-                  },
-                },
-              },
-              title: "Shapes",
-            },
-          ],
-          title: "Controls",
-        },
-      },
-    });
-
-    expect(
-      validateContractAcceptance({
-        schema: schemaWithVisibleDependency,
-        acceptance: [
-          makeControlAcceptance("shapes.shadeCount", "slider"),
-          makeControlAcceptance("shapes.color3", "color"),
-        ],
-      }),
-    ).toEqual(
-      expect.arrayContaining([
-        expect.stringContaining(
-          "visibleWhen target shapes.count does not match another schema control target",
-        ),
-        expect.stringContaining(
-          "uses visibleWhen and must declare visibilityCoverage",
-        ),
-      ]),
-    );
-
-    const schemaWithValidVisibleDependency = defineContractSchemaFixture({
-      canvas: { enabled: true },
-      panels: {
-        controls: {
-          sections: [
-            {
-              controls: {
-                shadeCount: {
-                  defaultValue: 2,
-                  label: "Shades",
-                  max: 5,
-                  min: 1,
-                  step: 1,
-                  target: "shapes.shadeCount",
-                  type: "slider",
-                  variant: "discrete",
-                },
-                shade3: {
-                  defaultValue: { hex: "#BBBBBB" },
-                  label: "Shade 3",
-                  target: "shapes.color3",
-                  type: "color",
-                  visibleWhen: {
-                    greaterThanOrEqual: 3,
-                    target: "shapes.shadeCount",
-                  },
-                },
-              },
-              title: "Shapes",
-            },
-          ],
-          title: "Controls",
-        },
-      },
-    });
-    const errors = validateContractAcceptance({
-      schema: schemaWithValidVisibleDependency,
-      acceptance: [
-        makeControlAcceptance("shapes.shadeCount", "slider"),
-        {
-          ...makeControlAcceptance("shapes.color3", "color"),
-          expectedObservable: "Третий цвет доступен только для соответствующего состояния продукта.",
-          userAction: "Переключить количество оттенков и проверить оба состояния.",
-          visibilityCoverage: ["hidden", "visible"],
-        },
-      ],
-    });
-
-    expect(errors).not.toEqual(
-      expect.arrayContaining([
-        expect.stringContaining("visibleWhen target"),
-        expect.stringContaining("uses visibleWhen and must declare visibilityCoverage"),
-      ]),
-    );
-  });
 });

package/templates/starter/src/app/starter-acceptance.custom-control-collections.test.ts

@@ -6,7 +6,7 @@ import {
 } from "./starter-acceptance.contract-fixtures";
 
 describe("starter acceptance custom control collection contract", () => {
-  it("requires collection-like custom controls to compare actions and collectionActions", () => {
+  it("requires collection-like custom controls to compare both cardinality owners and actions", () => {
     const schema = defineContractSchemaFixture({
       canvas: { enabled: true },
       panels: {
@@ -71,6 +71,7 @@ describe("starter acceptance custom control collection contract", () => {
         ],
       }),
     ).toEqual([
+      "Masks / maskEditor (masks) builtInFitCheck.checkedBuiltIns must include sourceCollection when the custom control owns a repeated runtime item set whose cardinality could be source-owned.",
       "Masks / maskEditor (masks) builtInFitCheck.checkedBuiltIns must include collectionActions when the custom control owns a growable, removable, selectable, or reorderable runtime item set.",
       "Masks / maskEditor (masks) builtInFitCheck.checkedBuiltIns must include actions when the custom control exposes local command buttons such as add, remove, delete, duplicate, sort, normalize, or clear.",
     ]);
@@ -135,6 +136,7 @@ describe("starter acceptance custom control collection contract", () => {
         ],
       }),
     ).toEqual([
+      "Pattern / patternSet (pattern.set) builtInFitCheck.checkedBuiltIns must include sourceCollection when the custom control owns a repeated runtime item set whose cardinality could be source-owned.",
       "Pattern / patternSet (pattern.set) builtInFitCheck.checkedBuiltIns must include collectionActions when the custom control owns a growable, removable, selectable, or reorderable runtime item set.",
     ]);
   });

package/templates/starter/src/app/starter-acceptance.custom-control-fit-check.test.ts

@@ -82,7 +82,7 @@ describe("starter acceptance custom control built-in fit contract", () => {
               controls: {
                 shapeButtons: {
                   defaultValue: "rect",
-                  label: "Shape",
+                  label: false,
                   orderRole: "style",
                   target: "shape.kind",
                   type: "shapeButtons",

package/templates/starter/src/app/starter-acceptance.custom-control-valid.test.ts

@@ -48,7 +48,7 @@ describe("starter acceptance valid custom control contract", () => {
                 "reorder",
                 "selection",
               ],
-              checkedBuiltIns: ["actions", "collectionActions", "fileDrop", "imagePicker", "select"],
+              checkedBuiltIns: ["actions", "collectionActions", "fileDrop", "imagePicker", "select", "sourceCollection"],
               closestBuiltIn: "fileDrop",
               productObservable: "Ordering uploaded glyphs changes the rendered glyph ramp output.",
               whyInsufficient: "FileDrop imports source files, but it does not provide density ordering, per-glyph preview, reorder, and remove behavior in one runtime value.",

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

@@ -4,7 +4,9 @@ import { describe, expect, it } from "vitest";
 import { getToolcraftExportArtifactCoverageErrors } from "./acceptance/export-artifact-coverage";
 import type { ToolcraftComponentAcceptance } from "./acceptance/types";
 
-function createSchema(roles: readonly ("export-image" | "export-video")[]) {
+function createSchema(
+  roles: readonly ("export-image" | "export-svg" | "export-video")[],
+) {
   return defineToolcraft({
     canvas: { enabled: true },
     panels: {
@@ -14,9 +16,19 @@ function createSchema(roles: readonly ("export-image" | "export-video")[]) {
             controls: {
               output: {
                 actions: roles.map((role) => ({
-                  label: role === "export-image" ? "Export Image" : "Export Video",
+                  label:
+                    role === "export-image"
+                      ? "Export Image"
+                      : role === "export-svg"
+                        ? "Export SVG"
+                        : "Export Video",
                   role,
-                  value: role === "export-image" ? "export.image" : "export.video",
+                  value:
+                    role === "export-image"
+                      ? "export.image"
+                      : role === "export-svg"
+                        ? "export.svg"
+                        : "export.video",
                 })),
                 target: "actions.output",
                 type: "panelActions",
@@ -92,6 +104,65 @@ describe("Toolcraft export artifact acceptance", () => {
     ]);
   });
 
+  it("requires exact SVG exported-bytes coverage for a typed SVG action", () => {
+    const schema = createSchema(["export-svg"]);
+
+    expect(
+      getToolcraftExportArtifactCoverageErrors({
+        acceptance: [
+          createAcceptance({
+            actionCoverage: ["export.svg"],
+            exportArtifactCoverage: "all-required-svg-export-behavior",
+          }),
+        ],
+        schema,
+      }),
+    ).toEqual([]);
+    expect(
+      getToolcraftExportArtifactCoverageErrors({
+        acceptance: [
+          createAcceptance({
+            actionCoverage: ["export.svg"],
+            exportArtifactCoverage: "all-required-image-export-behavior",
+          }),
+        ],
+        schema,
+      }),
+    ).toEqual([
+      expect.stringContaining("without a matching typed export action"),
+      expect.stringContaining("all-required-svg-export-behavior"),
+    ]);
+  });
+
+  it("rejects typed export roles outside sticky panelActions", () => {
+    const schema = defineToolcraft({
+      canvas: { enabled: true },
+      panels: {
+        controls: {
+          sections: [
+            {
+              controls: {
+                local: {
+                  actions: [{ role: "export-svg", value: "export.svg" }],
+                  target: "local.actions",
+                  type: "actions",
+                },
+              },
+              id: "local",
+            },
+          ],
+          title: "Controls",
+        },
+      },
+    });
+
+    expect(
+      getToolcraftExportArtifactCoverageErrors({ acceptance: [], schema }),
+    ).toContain(
+      'Typed export-svg action "export.svg" must be declared in sticky panelActions.',
+    );
+  });
+
   it("requires exported bytes plus automated browser proof", () => {
     const errors = getToolcraftExportArtifactCoverageErrors({
       acceptance: [

package/templates/starter/src/app/starter-acceptance.export-test-utils.ts

@@ -1,3 +1,25 @@
+import type {
+  ToolcraftArtifactExportIntent,
+  ToolcraftProductReadiness,
+} from "./acceptance/types";
+
+export function makeExportSettingsProductReadiness(
+  exportIntent: ToolcraftArtifactExportIntent,
+): Extract<ToolcraftProductReadiness, { mode: "product" }> {
+  return {
+    exportIntent,
+    interactionOwnership: [],
+    mode: "product",
+    productName: "Export settings fixture",
+    productSummary: "A synthetic product for image, SVG, and video export settings.",
+    requestedBehavior: "Export the explicitly requested artifact types.",
+    viewInteraction: {
+      mode: "non-spatial",
+      reason: "The synthetic output is two-dimensional.",
+    },
+  };
+}
+
 export function makeBackgroundSection() {
   return {
     controls: {
@@ -105,3 +127,7 @@ export function textLooksLikePngExport(text: string): boolean {
 export function textLooksLikeVideoExport(text: string): boolean {
   return /\b(export|download)\b/i.test(text) && /\b(video|mp4|webm|mov)\b/i.test(text);
 }
+
+export function textLooksLikeSvgExport(text: string): boolean {
+  return /\b(export|download)\b/i.test(text) && /\bsvg\b|\bvector\b/i.test(text);
+}

package/templates/starter/src/app/{starter-acceptance.image-video-export-settings.test.ts → starter-acceptance.image-export-settings.test.ts}

@@ -3,12 +3,28 @@ import { describe, expect, it } from "vitest";
 import { defineContractSchemaFixture, validateContractAcceptance } from "./starter-acceptance.contract-fixtures";
 import {
   makeBackgroundSection,
+  makeExportSettingsProductReadiness,
   makeImageExportSection,
   makeVideoExportSection,
 } from "./starter-acceptance.export-test-utils";
 import { makeControlAcceptance } from "./starter-acceptance.test-utils";
 
-describe("Toolcraft image and video export settings acceptance contract", () => {
+const imageOnlyProductReadiness = makeExportSettingsProductReadiness({
+  image: { mode: "toolcraft-default" },
+  svg: { mode: "not-requested" },
+  video: { mode: "not-requested" },
+});
+
+const imageAndVideoProductReadiness = makeExportSettingsProductReadiness({
+  image: { mode: "toolcraft-default" },
+  svg: { mode: "not-requested" },
+  video: {
+    evidence: "The user explicitly requested video delivery.",
+    mode: "user-requested",
+  },
+});
+
+describe("Toolcraft image export settings acceptance contract", () => {
   it("requires still-output apps to expose image export format and resolution settings", () => {
     const schemaWithoutImageExportSettings = defineContractSchemaFixture({
       canvas: {
@@ -58,13 +74,15 @@ describe("Toolcraft image and video export settings acceptance contract", () =>
             componentType: "panelActions",
             evidence: "exported-bytes",
             expectedObservable: "Export PNG creates output bytes and reads image format, image resolution, background color, and include-background state.",
+            exportArtifactCoverage: "all-required-image-export-behavior",
             fixture: "export fixture",
             id: "actions.output",
             kind: "control",
             target: "actions.output",
-            userAction: "Toggle Include off, verify preview has no product background, export PNG with alpha, and verify video export keeps the background.",
+            userAction: "Toggle Include off, verify preview has no product background, export PNG with alpha, and verify the image artifact preserves transparency.",
           },
         ],
+        productReadiness: imageOnlyProductReadiness,
       }),
     ).toEqual(
       expect.arrayContaining([
@@ -142,6 +160,7 @@ describe("Toolcraft image and video export settings acceptance contract", () =>
             componentType: "panelActions",
             evidence: "exported-bytes",
             expectedObservable: "Export PNG creates output bytes and reads image format, image resolution, background color, and include-background state. JPG changes file type; 8K changes exported pixel dimensions to an 8192px long edge.",
+            exportArtifactCoverage: "all-required-image-export-behavior",
             fixture: "export fixture",
             id: "actions.output",
             kind: "control",
@@ -149,6 +168,7 @@ describe("Toolcraft image and video export settings acceptance contract", () =>
             userAction: "Set format to JPG and resolution to 8K, then export and decode the output image to verify file type and long-edge dimensions.",
           },
         ],
+        productReadiness: imageOnlyProductReadiness,
       }),
     ).not.toEqual(
       expect.arrayContaining([
@@ -159,7 +179,7 @@ describe("Toolcraft image and video export settings acceptance contract", () =>
     );
   });
 
-  it("requires animated apps with PNG and video actions to expose Image Export before Video Export", () => {
+  it("requires explicit image-plus-video delivery to expose Image Export before Video Export", () => {
     const schemaWithoutImageSettings = defineContractSchemaFixture({
       canvas: {
         enabled: true,
@@ -211,19 +231,24 @@ describe("Toolcraft image and video export settings acceptance contract", () =>
           {
             actionCoverage: ["export.video", "export.png"],
             automated: true,
-            automatedTestName: "exports animated and still output",
+            automatedTestName: "exports image and explicitly requested video output",
             browser: true,
             browserTestName: "browser: exports video and image output",
             componentType: "panelActions",
             evidence: "exported-bytes",
             expectedObservable: "Export Video and Export PNG both create output bytes and read their runtime export settings.",
-            fixture: "animated export fixture",
+            exportArtifactCoverage: [
+              "all-required-image-export-behavior",
+              "all-required-video-export-behavior",
+            ],
+            fixture: "explicit image-plus-video export fixture",
             id: "actions.output",
             kind: "control",
             target: "actions.output",
-            userAction: "Export video and PNG from the same timeline state, then verify both files exist.",
+            userAction: "Export video and PNG with their configured settings, then verify both files exist.",
           },
         ],
+        productReadiness: imageAndVideoProductReadiness,
       }),
     ).toEqual(
       expect.arrayContaining([
@@ -234,7 +259,7 @@ describe("Toolcraft image and video export settings acceptance contract", () =>
     );
   });
 
-  it("accepts animated apps with Image Export immediately before Video Export", () => {
+  it("accepts explicit image-plus-video delivery with Image Export immediately before Video Export", () => {
     const schemaWithDualExportSettings = defineContractSchemaFixture({
       canvas: {
         enabled: true,
@@ -303,19 +328,24 @@ describe("Toolcraft image and video export settings acceptance contract", () =>
           {
             actionCoverage: ["export.video", "export.png"],
             automated: true,
-            automatedTestName: "exports animated and still output",
+            automatedTestName: "exports image and explicitly requested video output",
             browser: true,
             browserTestName: "browser: exports video and image output",
             componentType: "panelActions",
             evidence: "exported-bytes",
             expectedObservable: "Export Video and Export PNG both create output bytes and read their runtime export settings.",
-            fixture: "animated export fixture",
+            exportArtifactCoverage: [
+              "all-required-image-export-behavior",
+              "all-required-video-export-behavior",
+            ],
+            fixture: "explicit image-plus-video export fixture",
             id: "actions.output",
             kind: "control",
             target: "actions.output",
             userAction: "Choose JPG and 8K, choose MP4 and Current, then export PNG and video and verify both outputs use their selected settings.",
           },
         ],
+        productReadiness: imageAndVideoProductReadiness,
       }),
     ).not.toEqual(
       expect.arrayContaining([

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

@@ -70,15 +70,15 @@ function ownership({
   source?: ToolcraftInteractionOwnershipEntry["evidence"]["source"];
   surface: ToolcraftInteractionSurface;
 }): ToolcraftInteractionOwnershipEntry {
-  return {
+  const base = {
     alternative: {
       reason:
         surface === "canvas"
           ? "A panel copy would separate the same operation from visible output without adding a useful capability."
           : "A canvas copy would add output chrome without improving this non-spatial operation.",
-      surface: surface === "canvas" ? "panel" : "canvas",
+      surface: (surface === "canvas" ? "panel" : "canvas") as
+        ToolcraftInteractionSurface,
     },
-    capability,
     evidence: {
       detail:
         source === "reference"
@@ -94,12 +94,30 @@ function ownership({
     surface,
     target: "output.position",
   };
+
+  if (
+    capability === "precise-value-entry" ||
+    capability === "property-edit"
+  ) {
+    return {
+      ...base,
+      capability,
+      selectionScope: { mode: "global" },
+    };
+  }
+
+  return { ...base, capability };
 }
 
 function readiness(
   interactionOwnership: readonly ToolcraftInteractionOwnershipEntry[],
 ): ToolcraftProductReadiness {
   return {
+    exportIntent: {
+      image: { mode: "toolcraft-default" },
+      svg: { mode: "not-requested" },
+      video: { mode: "not-requested" },
+    },
     interactionOwnership,
     mode: "product",
     productName: "Interaction fixture",
@@ -151,6 +169,11 @@ function acceptance({
 describe("Toolcraft interaction surface ownership", () => {
   it("runs ownership validation through the protected acceptance pipeline", () => {
     const productReadiness = {
+      exportIntent: {
+        image: { mode: "toolcraft-default" },
+        svg: { mode: "not-requested" },
+        video: { mode: "not-requested" },
+      },
       mode: "product",
       productName: "Legacy fixture",
       productSummary: "A product declaration created before interaction ownership.",
@@ -172,6 +195,11 @@ describe("Toolcraft interaction surface ownership", () => {
 
   it("rejects product readiness that omits the ownership inventory", () => {
     const productReadiness = {
+      exportIntent: {
+        image: { mode: "toolcraft-default" },
+        svg: { mode: "not-requested" },
+        video: { mode: "not-requested" },
+      },
       mode: "product",
       productName: "Legacy fixture",
       productSummary: "A product declaration created before interaction ownership.",

package/templates/starter/src/app/starter-acceptance.layers.test.ts

@@ -196,7 +196,8 @@ describe("starter acceptance layers contract", () => {
       }),
     ).toEqual(
       expect.arrayContaining([
-        'Layer / opacity (selectedLayer.opacity) targets selectedLayer.* and must have acceptance layerCoverage "selected-layer-controls" proving the control edits the currently selected layer output.',
+        'selectedLayer.opacity must declare selectionScopeCoverage "two-entity-isolation" proving edits stay on the selected entity.',
+        'selectedLayer.opacity targets selectedLayer.* and must declare layerCoverage "selected-layer-controls" together with two-entity isolation.',
       ]),
     );
   });

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

@@ -60,7 +60,11 @@ export function createSingleFileDropSchema({
   });
 }
 
-export function createMultipleFileDropSchema() {
+export function createMultipleFileDropSchema({
+  collectionActions = false,
+}: {
+  collectionActions?: boolean;
+} = {}) {
   return defineContractSchemaFixture({
     canvas: { enabled: true },
     panels: {
@@ -69,6 +73,12 @@ export function createMultipleFileDropSchema() {
           {
             controls: {
               sources: {
+                ...(collectionActions
+                  ? {
+                      assetKind: "file" as const,
+                      variant: "collection-actions",
+                    }
+                  : {}),
                 defaultValue: [],
                 label: "Source images",
                 multiple: true,

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

@@ -15,6 +15,11 @@ import {
 } from "./starter-acceptance.media-upload.fixtures";
 
 const layeredMediaProductReadiness: ToolcraftProductReadiness = {
+  exportIntent: {
+    image: { mode: "toolcraft-default" },
+    svg: { mode: "not-requested" },
+    video: { mode: "not-requested" },
+  },
   interactionOwnership: [
     {
       alternative: {
@@ -34,6 +39,28 @@ const layeredMediaProductReadiness: ToolcraftProductReadiness = {
       surface: "panel",
       target: "media.sources",
     },
+    {
+      alternative: {
+        reason:
+          "Canvas transform buttons would duplicate precise actions already owned by Layers.",
+        surface: "canvas",
+      },
+      capability: "property-edit",
+      evidence: {
+        detail:
+          "The product requires transforms to apply only to the layer selected in Layers.",
+        source: "user-request",
+      },
+      id: "layers-selected-transform",
+      reason:
+        "The Layers property action remains bound to the explicitly selected image.",
+      selectionScope: {
+        mode: "selected-entity",
+        selectionInteractionId: "layers-media-management",
+      },
+      surface: "panel",
+      target: "selectedLayer.transform",
+    },
   ],
   mode: "product",
   productName: "Layered media fixture",
@@ -80,6 +107,10 @@ function createLayerAcceptance({
     kind: "runtime",
     layerCoverage,
     mediaLifecycleCoverage,
+    selectionScopeCoverage:
+      layerCoverage === "selected-layer-controls"
+        ? "two-entity-isolation"
+        : undefined,
     target,
     userAction: `Exercise ${id} through the runtime Layers panel.`,
   };
@@ -127,6 +158,7 @@ function createLayeredMediaAcceptance({
       ? [
           createLayerAcceptance({
             id: "layers.selected-transform",
+            interactionId: "layers-selected-transform",
             layerCoverage: "selected-layer-controls",
             mediaLifecycleCoverage: [
               "rotate",
@@ -284,6 +316,30 @@ describe("Toolcraft media upload acceptance coverage", () => {
     ).toEqual([]);
   });
 
+  it("does not require reorder coverage from collection-actions upload slots", () => {
+    const schema = createMultipleFileDropSchema({ collectionActions: true });
+
+    const errors = validateContractAcceptance({
+      schema,
+      acceptance: [
+        createFileDropAcceptance({
+          automatedTestName: "source files add and remove slots",
+          browserTestName: "browser: source files add and remove slots",
+          expectedObservable:
+            "Compact plus adds an empty upload slot and compact minus removes the final slot or attached file.",
+          fixture: "source file fixture",
+          id: "media.sources",
+          mediaLifecycleCoverage: ["upload", "remove", "reset"],
+          target: "media.sources",
+          userAction:
+            "Add an upload slot, attach a file, remove the final slot, and reset.",
+        }),
+      ],
+    });
+
+    expect(errors.filter((error) => error.includes("reorder"))).toEqual([]);
+  });
+
   it("assigns reorder and selected image transform proof to Layers without duplicating fileDrop claims", () => {
     const fileDropSchema = createMultipleFileDropSchema();
     const layeredSchema = {

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

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  defineToolcraftMotionReferenceEvidence,
+} from "./acceptance/motion-reference-evidence.mjs";
+import type { ToolcraftMotionReferenceEvidence } from "./acceptance/reference-study-types";
+
+describe("Toolcraft motion reference evidence decoder", () => {
+  it("exposes an exact checked TypeScript boundary without a cast", () => {
+    const defineEvidence: (
+      value: unknown,
+    ) => ToolcraftMotionReferenceEvidence =
+      defineToolcraftMotionReferenceEvidence;
+
+    expect(() => defineEvidence({})).toThrow(/motion reference evidence/iu);
+  });
+});