@pixel-point/toolcraft 0.0.18 → 0.0.19

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

@@ -11,7 +11,7 @@ export function makeExportSettingsProductReadiness(
     interactionOwnership: [],
     mode: "product",
     productName: "Export settings fixture",
-    productSummary: "A synthetic product for image and video export settings.",
+    productSummary: "A synthetic product for image, SVG, and video export settings.",
     requestedBehavior: "Export the explicitly requested artifact types.",
     viewInteraction: {
       mode: "non-spatial",
@@ -127,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-export-settings.test.ts

@@ -11,11 +11,13 @@ import { makeControlAcceptance } from "./starter-acceptance.test-utils";
 
 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",

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,6 +94,19 @@ 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(
@@ -102,6 +115,7 @@ function readiness(
   return {
     exportIntent: {
       image: { mode: "toolcraft-default" },
+      svg: { mode: "not-requested" },
       video: { mode: "not-requested" },
     },
     interactionOwnership,
@@ -157,6 +171,7 @@ describe("Toolcraft interaction surface ownership", () => {
     const productReadiness = {
       exportIntent: {
         image: { mode: "toolcraft-default" },
+        svg: { mode: "not-requested" },
         video: { mode: "not-requested" },
       },
       mode: "product",
@@ -182,6 +197,7 @@ describe("Toolcraft interaction surface ownership", () => {
     const productReadiness = {
       exportIntent: {
         image: { mode: "toolcraft-default" },
+        svg: { mode: "not-requested" },
         video: { mode: "not-requested" },
       },
       mode: "product",

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.test.ts

@@ -17,6 +17,7 @@ import {
 const layeredMediaProductReadiness: ToolcraftProductReadiness = {
   exportIntent: {
     image: { mode: "toolcraft-default" },
+    svg: { mode: "not-requested" },
     video: { mode: "not-requested" },
   },
   interactionOwnership: [
@@ -38,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",
@@ -84,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.`,
   };
@@ -131,6 +158,7 @@ function createLayeredMediaAcceptance({
       ? [
           createLayerAcceptance({
             id: "layers.selected-transform",
+            interactionId: "layers-selected-transform",
             layerCoverage: "selected-layer-controls",
             mediaLifecycleCoverage: [
               "rotate",

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

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

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  alternateMotionReferenceId,
+  alternateMotionSourceSha256,
+  createMotionReferenceBehavior,
+  createMotionReferenceInput,
+  createOrdinalMotionReferenceStudy,
+  createPassiveMotionReferenceInput,
+  createTimedMotionReferenceStudy,
+  getMotionReferenceErrors,
+  motionReferenceId,
+  motionSourceSha256,
+} from "./starter-acceptance.motion-reference-test-utils";
+
+describe("Toolcraft motion reference identity", () => {
+  it("rejects duplicate semantic ids", () => {
+    const input = createMotionReferenceInput();
+    const study = input.studies[0];
+
+    expect(
+      getMotionReferenceErrors([
+        {
+          ...input,
+          studies: [
+            {
+              ...study,
+              phases: [
+                study.phases[0],
+                { ...study.phases[1], id: study.phases[0].id },
+              ],
+            },
+          ],
+        },
+      ]),
+    ).toContain(
+      'motion reference study "study-main" phase id "phase-before" is duplicated.',
+    );
+  });
+
+  it("rejects duplicate reference ids even when source identities differ", () => {
+    expect(
+      getMotionReferenceErrors([
+        createMotionReferenceInput(),
+        createPassiveMotionReferenceInput({
+          referenceId: motionReferenceId,
+          sourceSha256: alternateMotionSourceSha256,
+        }),
+      ]),
+    ).toContain(`motion reference id "${motionReferenceId}" is duplicated.`);
+  });
+
+  it("reports mixed source identities canonically for every study permutation", () => {
+    const primary = createTimedMotionReferenceStudy();
+    const alternate = createTimedMotionReferenceStudy({
+      framePrefix: "alternate-",
+      pathId: "study-alternate",
+      sourceBasename: "alternate.mp4",
+      sourceSha256: alternateMotionSourceSha256,
+      studyId: "study-alternate",
+    });
+    const forward = getMotionReferenceErrors([
+      createMotionReferenceInput({ studies: [primary, alternate] }),
+    ]);
+    const reverse = getMotionReferenceErrors([
+      createMotionReferenceInput({ studies: [alternate, primary] }),
+    ]);
+
+    expect(forward).toEqual(reverse);
+    expect(forward).toContain(
+      `motion reference "${motionReferenceId}" studies must share one sourceSha256; found ${motionSourceSha256}, ${alternateMotionSourceSha256}.`,
+    );
+  });
+
+  it("rejects duplicate inputs for one source identity", () => {
+    expect(
+      getMotionReferenceErrors([
+        createMotionReferenceInput(),
+        createPassiveMotionReferenceInput({
+          referenceId: alternateMotionReferenceId,
+        }),
+      ]),
+    ).toContain(
+      `motion reference sourceSha256 "${motionSourceSha256}" is declared by multiple reference inputs; merge their studies under one input.`,
+    );
+  });
+
+  it("keeps duplicate study ids ambiguous in every input permutation", () => {
+    const timed = createTimedMotionReferenceStudy({ pathId: "timed-study" });
+    const ordinal = createOrdinalMotionReferenceStudy({
+      framePrefix: "ordinal-",
+      pathId: "ordinal-study",
+    });
+    const errors = [
+      getMotionReferenceErrors([
+        createMotionReferenceInput({ studies: [timed, ordinal] }),
+      ]),
+      getMotionReferenceErrors([
+        createMotionReferenceInput({ studies: [ordinal, timed] }),
+      ]),
+    ];
+
+    expect(errors[0]).toEqual(errors[1]);
+    expect(errors[0]).toContain(
+      'motion reference behavior "delayed-retarget" timing claim "duration" studyId "study-main" resolves to 2 studies; expected exactly one.',
+    );
+  });
+
+  it("validates every duplicate behavior while relational uses remain ambiguous", () => {
+    const valid = createMotionReferenceBehavior();
+    const malformed = createMotionReferenceBehavior({ description: "" });
+    const errors = [
+      getMotionReferenceErrors([
+        createMotionReferenceInput({ behaviors: [valid, malformed] }),
+      ]),
+      getMotionReferenceErrors([
+        createMotionReferenceInput({ behaviors: [malformed, valid] }),
+      ]),
+    ];
+
+    expect(errors[0]).toEqual(errors[1]);
+    expect(errors[0]).toContain(
+      `motion reference "${motionReferenceId}" behavior id "delayed-retarget" is duplicated.`,
+    );
+    expect(errors[0]).toContain(
+      'motion reference behavior "delayed-retarget" must include a non-empty description.',
+    );
+    expect(errors[0]).toContain(
+      'motion reference study "study-main" phase "phase-before" cites ambiguous behaviorId "delayed-retarget" with 2 definitions.',
+    );
+    expect(errors[0]).toContain(
+      `acceptance "reference.anchor-retarget" motion reference coverage for "${motionReferenceId}" behavior "delayed-retarget" resolves to 2 behavior definitions; expected exactly one.`,
+    );
+  });
+
+  it("keeps control characters in timing study ids collision-proof", () => {
+    const controlStudyId = "study\u0000left";
+    const studies = [
+      createTimedMotionReferenceStudy({
+        framePrefix: "control-",
+        pathId: "control-study",
+        studyId: controlStudyId,
+      }),
+      createTimedMotionReferenceStudy({
+        framePrefix: "plain-",
+        pathId: "plain-study",
+        studyId: "study-right",
+      }),
+    ];
+    const behavior = createMotionReferenceBehavior({
+      timingClaims: [
+        { claim: "duration", studyId: controlStudyId },
+        { claim: "duration", studyId: "study-right" },
+      ],
+    });
+
+    expect(
+      getMotionReferenceErrors([
+        createMotionReferenceInput({ behaviors: [behavior], studies }),
+      ]),
+    ).toEqual([]);
+  });
+});

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

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  createMotionReferenceInput,
+  createOrdinalMotionReferenceStudy,
+  getMotionReferenceErrors,
+} from "./starter-acceptance.motion-reference-test-utils";
+
+describe("Toolcraft motion reference semantic coverage", () => {
+  it("accepts one normalized input with exact behavior and acceptance ownership", () => {
+    expect(getMotionReferenceErrors([createMotionReferenceInput()])).toEqual([]);
+  });
+
+  it("rejects phase gaps and overlaps across the ordered overview", () => {
+    const input = createMotionReferenceInput();
+    const study = input.studies[0];
+    const [firstPhase, secondPhase] = study.phases;
+
+    expect(
+      getMotionReferenceErrors([
+        {
+          ...input,
+          studies: [
+            {
+              ...study,
+              phases: [{ ...firstPhase, toFrameId: "f0" }, secondPhase],
+            },
+          ],
+        },
+      ]),
+    ).toContain(
+      'motion reference study "study-main" phases must be contiguous; "phase-after" starts at overview index 2 after index 0.',
+    );
+
+    expect(
+      getMotionReferenceErrors([
+        {
+          ...input,
+          studies: [
+            {
+              ...study,
+              phases: [{ ...firstPhase, toFrameId: "f2" }, secondPhase],
+            },
+          ],
+        },
+      ]),
+    ).toContain(
+      'motion reference study "study-main" phases must be contiguous; "phase-after" starts at overview index 2 after index 2.',
+    );
+  });
+
+  it("rejects machine events without exactly one authored classification", () => {
+    const input = createMotionReferenceInput();
+    const study = input.studies[0];
+
+    expect(
+      getMotionReferenceErrors([
+        { ...input, studies: [{ ...study, events: [] }] },
+      ]),
+    ).toContain(
+      'motion reference study "study-main" evidence event "machine-retarget" must have exactly one authored event; found 0.',
+    );
+  });
+
+  it("requires a non-empty reason for every nonproduct event", () => {
+    const input = structuredClone(createMotionReferenceInput());
+    Object.defineProperties(input.studies[0].events[0], {
+      behaviorIds: { configurable: true, value: [] },
+      classification: { configurable: true, value: "irrelevant-change" },
+      reason: { configurable: true, value: "   " },
+    });
+
+    expect(getMotionReferenceErrors([input])).toContain(
+      'motion reference study "study-main" event "event-retarget" classification "irrelevant-change" requires a non-empty reason.',
+    );
+  });
+
+  it("requires every nonproduct event to have zero behavior ids", () => {
+    const input = structuredClone(createMotionReferenceInput());
+    Object.defineProperties(input.studies[0].events[0], {
+      behaviorIds: { configurable: true, value: ["delayed-retarget"] },
+      classification: { configurable: true, value: "irrelevant-change" },
+      reason: {
+        configurable: true,
+        value: "The event is outside product scope.",
+      },
+    });
+
+    expect(getMotionReferenceErrors([input])).toContain(
+      'motion reference study "study-main" event "event-retarget" classification "irrelevant-change" must not cite behaviorIds.',
+    );
+  });
+
+  it("rejects product events that cite unknown behavior ids", () => {
+    const input = createMotionReferenceInput();
+    const study = input.studies[0];
+
+    expect(
+      getMotionReferenceErrors([
+        {
+          ...input,
+          studies: [
+            {
+              ...study,
+              events: [
+                {
+                  behaviorIds: ["unknown-behavior"],
+                  classification: "product-behavior",
+                  evidenceEventId: "machine-retarget",
+                  id: "event-retarget",
+                },
+              ],
+            },
+          ],
+        },
+      ]),
+    ).toContain(
+      'motion reference study "study-main" event "event-retarget" cites unknown behaviorId "unknown-behavior".',
+    );
+  });
+
+  it("rejects timing claims owned by ordinal evidence", () => {
+    expect(
+      getMotionReferenceErrors([
+        createMotionReferenceInput({
+          studies: [createOrdinalMotionReferenceStudy()],
+        }),
+      ]),
+    ).toContain(
+      'motion reference behavior "delayed-retarget" timing claim "duration" must name a seconds-timed study; "study-main" is ordinal.',
+    );
+  });
+});