@pixel-point/toolcraft 0.0.16 → 0.0.18

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

@@ -0,0 +1,131 @@
+import { defineToolcraft } from "@repo/toolcraft-runtime";
+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")[]) {
+  return defineToolcraft({
+    canvas: { enabled: true },
+    panels: {
+      controls: {
+        sections: [
+          {
+            controls: {
+              output: {
+                actions: roles.map((role) => ({
+                  label: role === "export-image" ? "Export Image" : "Export Video",
+                  role,
+                  value: role === "export-image" ? "export.image" : "export.video",
+                })),
+                target: "actions.output",
+                type: "panelActions",
+              },
+            },
+          },
+        ],
+        title: "Controls",
+      },
+    },
+  });
+}
+
+function createAcceptance(
+  overrides: Partial<ToolcraftComponentAcceptance> = {},
+): ToolcraftComponentAcceptance {
+  return {
+    actionCoverage: ["export.image"],
+    automated: true,
+    automatedTestName: "exports image",
+    browser: true,
+    browserTestName: "browser: exports image",
+    componentType: "panelActions",
+    evidence: "exported-bytes",
+    expectedObservable: "Downloads decoded image output.",
+    fixture: "image export fixture",
+    id: "actions.output",
+    kind: "control",
+    target: "actions.output",
+    userAction: "Click Export Image.",
+    ...overrides,
+  };
+}
+
+describe("Toolcraft export artifact acceptance", () => {
+  it("requires exact image coverage for an image action", () => {
+    const schema = createSchema(["export-image"]);
+
+    expect(
+      getToolcraftExportArtifactCoverageErrors({
+        acceptance: [createAcceptance()],
+        schema,
+      }),
+    ).toContainEqual(
+      expect.stringContaining("all-required-image-export-behavior"),
+    );
+    expect(
+      getToolcraftExportArtifactCoverageErrors({
+        acceptance: [
+          createAcceptance({
+            exportArtifactCoverage: "all-required-image-export-behavior",
+          }),
+        ],
+        schema,
+      }),
+    ).toEqual([]);
+  });
+
+  it("does not allow image coverage to satisfy video", () => {
+    const errors = getToolcraftExportArtifactCoverageErrors({
+      acceptance: [
+        createAcceptance({
+          actionCoverage: ["export.video"],
+          exportArtifactCoverage: "all-required-image-export-behavior",
+        }),
+      ],
+      schema: createSchema(["export-video"]),
+    });
+
+    expect(errors).toEqual([
+      expect.stringContaining("without a matching typed export action"),
+      expect.stringContaining("all-required-video-export-behavior"),
+    ]);
+  });
+
+  it("requires exported bytes plus automated browser proof", () => {
+    const errors = getToolcraftExportArtifactCoverageErrors({
+      acceptance: [
+        createAcceptance({
+          automated: false,
+          browser: false,
+          evidence: "command-side-effect",
+          exportArtifactCoverage: "all-required-image-export-behavior",
+        }),
+      ],
+      schema: createSchema(["export-image"]),
+    });
+
+    expect(errors).toEqual([
+      expect.stringContaining('evidence is not "exported-bytes"'),
+      expect.stringContaining("requires automated and browser proof"),
+      expect.stringContaining("all-required-image-export-behavior"),
+    ]);
+  });
+
+  it("allows one row to cover both typed actions explicitly", () => {
+    expect(
+      getToolcraftExportArtifactCoverageErrors({
+        acceptance: [
+          createAcceptance({
+            actionCoverage: ["export.image", "export.video"],
+            exportArtifactCoverage: [
+              "all-required-image-export-behavior",
+              "all-required-video-export-behavior",
+            ],
+          }),
+        ],
+        schema: createSchema(["export-image", "export-video"]),
+      }),
+    ).toEqual([]);
+  });
+});

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 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: {

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

@@ -3,12 +3,26 @@ 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" },
+  video: { mode: "not-requested" },
+});
+
+const imageAndVideoProductReadiness = makeExportSettingsProductReadiness({
+  image: { mode: "toolcraft-default" },
+  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 +72,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 +158,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 +166,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 +177,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 +229,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 +257,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 +326,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

@@ -100,6 +100,10 @@ function readiness(
   interactionOwnership: readonly ToolcraftInteractionOwnershipEntry[],
 ): ToolcraftProductReadiness {
   return {
+    exportIntent: {
+      image: { mode: "toolcraft-default" },
+      video: { mode: "not-requested" },
+    },
     interactionOwnership,
     mode: "product",
     productName: "Interaction fixture",
@@ -151,6 +155,10 @@ function acceptance({
 describe("Toolcraft interaction surface ownership", () => {
   it("runs ownership validation through the protected acceptance pipeline", () => {
     const productReadiness = {
+      exportIntent: {
+        image: { mode: "toolcraft-default" },
+        video: { mode: "not-requested" },
+      },
       mode: "product",
       productName: "Legacy fixture",
       productSummary: "A product declaration created before interaction ownership.",
@@ -172,6 +180,10 @@ describe("Toolcraft interaction surface ownership", () => {
 
   it("rejects product readiness that omits the ownership inventory", () => {
     const productReadiness = {
+      exportIntent: {
+        image: { mode: "toolcraft-default" },
+        video: { mode: "not-requested" },
+      },
       mode: "product",
       productName: "Legacy fixture",
       productSummary: "A product declaration created before interaction ownership.",

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

@@ -4,7 +4,6 @@ import type { ToolcraftControlSchema } from "@repo/toolcraft-runtime";
 import type { ToolcraftComponentAcceptance } from "./acceptance/types";
 import {
   defineContractSchemaFixture,
-  contractSchemaFixture,
   validateContractAcceptance,
 } from "./starter-acceptance.contract-fixtures";
 
@@ -63,9 +62,11 @@ function createKeyframesSchema(
   title = "Style",
 ) {
   return defineContractSchemaFixture({
-    ...contractSchemaFixture,
+    canvas: {
+      enabled: true,
+      upload: true,
+    },
     panels: {
-      ...contractSchemaFixture.panels,
       controls: {
         sections: [
           {
@@ -75,7 +76,16 @@ function createKeyframesSchema(
         ],
         title: "Controls",
       },
-      timeline: { defaultDurationSeconds: 8, enabled: true, mode: "keyframes" as const },
+      timeline: {
+        defaultDurationSeconds: 8,
+        enabled: true,
+        mode: "keyframes",
+      },
+    },
+    toolbar: {
+      history: true,
+      radar: true,
+      zoom: true,
     },
   });
 }

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,10 @@ import {
 } from "./starter-acceptance.media-upload.fixtures";
 
 const layeredMediaProductReadiness: ToolcraftProductReadiness = {
+  exportIntent: {
+    image: { mode: "toolcraft-default" },
+    video: { mode: "not-requested" },
+  },
   interactionOwnership: [
     {
       alternative: {
@@ -284,6 +288,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 = {