@pixel-point/toolcraft 0.0.17 → 0.0.19

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

@@ -3,6 +3,7 @@ import { defineToolcraft } from "@repo/toolcraft-runtime";
 
 import {
   schemaHasPngExportPanelAction,
+  schemaHasSvgExportPanelAction,
   schemaHasVideoExportPanelAction,
 } from "./output-export-actions";
 
@@ -16,6 +17,11 @@ function createOutputSchema() {
             controls: {
               output: {
                 actions: [
+                  {
+                    label: "Guardar vector",
+                    role: "export-svg",
+                    value: "salida.vector",
+                  },
                   {
                     label: "Guardar imagen",
                     role: "export-image",
@@ -41,10 +47,11 @@ function createOutputSchema() {
 }
 
 describe("Toolcraft typed output action roles", () => {
-  it("detects image and video export without parsing labels or values", () => {
+  it("detects image, SVG, and video export without parsing labels or values", () => {
     const schema = createOutputSchema();
 
     expect(schemaHasPngExportPanelAction(schema)).toBe(true);
+    expect(schemaHasSvgExportPanelAction(schema)).toBe(true);
     expect(schemaHasVideoExportPanelAction(schema)).toBe(true);
   });
 
@@ -71,6 +78,7 @@ describe("Toolcraft typed output action roles", () => {
     });
 
     expect(schemaHasPngExportPanelAction(schema)).toBe(false);
+    expect(schemaHasSvgExportPanelAction(schema)).toBe(false);
     expect(schemaHasVideoExportPanelAction(schema)).toBe(false);
   });
 });

package/templates/starter/src/app/acceptance/output-export-actions.ts

@@ -1,34 +1,26 @@
 import type {
   ResolvedToolcraftAppSchema,
-  ToolcraftActionSchema,
+  ToolcraftArtifactExportActionRole,
 } from "@repo/toolcraft-runtime";
+import { getToolcraftArtifactExportActions } from "@repo/toolcraft-runtime";
 
-import { getControlActions } from "./actions";
-
-function actionLooksLikePngExport(action: ToolcraftActionSchema | string): boolean {
-  return typeof action !== "string" && action.role === "export-image";
+function schemaHasExportPanelAction(
+  schema: ResolvedToolcraftAppSchema,
+  role: ToolcraftArtifactExportActionRole,
+): boolean {
+  return getToolcraftArtifactExportActions(schema).some(
+    (action) => action.role === role,
+  );
 }
 
-function actionLooksLikeVideoExport(action: ToolcraftActionSchema | string): boolean {
-  return typeof action !== "string" && action.role === "export-video";
+export function schemaHasPngExportPanelAction(schema: ResolvedToolcraftAppSchema): boolean {
+  return schemaHasExportPanelAction(schema, "export-image");
 }
 
-export function schemaHasPngExportPanelAction(schema: ResolvedToolcraftAppSchema): boolean {
-  return (schema.panels.controls?.sections ?? []).some((section) =>
-    Object.values(section.controls).some(
-      (control) =>
-        control.type === "panelActions" &&
-        getControlActions(control).some(actionLooksLikePngExport),
-    ),
-  );
+export function schemaHasSvgExportPanelAction(schema: ResolvedToolcraftAppSchema): boolean {
+  return schemaHasExportPanelAction(schema, "export-svg");
 }
 
 export function schemaHasVideoExportPanelAction(schema: ResolvedToolcraftAppSchema): boolean {
-  return (schema.panels.controls?.sections ?? []).some((section) =>
-    Object.values(section.controls).some(
-      (control) =>
-        control.type === "panelActions" &&
-        getControlActions(control).some(actionLooksLikeVideoExport),
-    ),
-  );
+  return schemaHasExportPanelAction(schema, "export-video");
 }

package/templates/starter/src/app/acceptance/output-export-layout-rules.ts

@@ -1,20 +1,31 @@
+import type { ToolcraftArtifactExportDelivery } from "./artifact-export-intent";
 import type { ToolcraftOutputExportFacts } from "./output-export-model";
 
-export function getToolcraftOutputExportLayoutErrors(
-  facts: ToolcraftOutputExportFacts,
-): string[] {
+export function getToolcraftOutputExportLayoutErrors({
+  delivery,
+  facts,
+}: {
+  delivery: ToolcraftArtifactExportDelivery;
+  facts: ToolcraftOutputExportFacts;
+}): string[] {
+  if (
+    !delivery.imageEnabled &&
+    !delivery.svgEnabled &&
+    !delivery.videoEnabled
+  ) {
+    return [];
+  }
+
   const errors: string[] = [];
 
   if (facts.backgroundSection) {
     errors.push(
-      'Product apps with Export PNG must not render a separate "Background" section; runtime Setup owns Background, Infinity canvas, and Color.',
+      'Product apps with artifact export must not render a separate "Background" section; runtime Setup owns Background, Infinity canvas, and Color.',
     );
   }
 
   if (!facts.setupSection || facts.setupSectionIndex !== 0) {
-    errors.push(
-      "Runtime Setup must remain the first controls block.",
-    );
+    errors.push("Runtime Setup must remain the first controls block.");
   }
 
   if (
@@ -23,18 +34,19 @@ export function getToolcraftOutputExportLayoutErrors(
     facts.finalExportSettingsIndex !== facts.panelActionsSectionIndex - 1
   ) {
     errors.push(
-      'Export settings must sit directly above sticky footer actions: Image Export for still apps, or Video Export after Image Export for animated apps.',
+      "The final enabled artifact export settings section must sit directly above sticky footer actions.",
     );
   }
 
   if (
-    facts.hasVideoExportAction &&
+    delivery.imageEnabled &&
+    delivery.videoEnabled &&
     facts.imageExportSectionIndex >= 0 &&
     facts.videoExportSectionIndex >= 0 &&
     facts.imageExportSectionIndex !== facts.videoExportSectionIndex - 1
   ) {
     errors.push(
-      'Animated apps with both Export PNG and Export Video must place Image Export immediately before Video Export.',
+      'Products with image and video delivery must place "Image Export" immediately before "Video Export".',
     );
   }
 

package/templates/starter/src/app/acceptance/output-export-model.ts

@@ -4,6 +4,11 @@ import type {
 } from "@repo/toolcraft-runtime";
 
 import { getControlLabelText } from "./controls";
+import {
+  schemaHasPngExportPanelAction,
+  schemaHasSvgExportPanelAction,
+  schemaHasVideoExportPanelAction,
+} from "./output-export-actions";
 import { normalizeToolcraftSemanticText } from "./semantic";
 
 export type ToolcraftControlsSection = NonNullable<
@@ -14,6 +19,8 @@ export type ToolcraftOutputExportFacts = {
   backgroundColorEntry: readonly [string, ToolcraftControlSchema] | undefined;
   backgroundSection: ToolcraftControlsSection | undefined;
   finalExportSettingsIndex: number;
+  hasImageExportAction: boolean;
+  hasSvgExportAction: boolean;
   hasVideoExportAction: boolean;
   imageExportSection: ToolcraftControlsSection | undefined;
   imageExportSectionIndex: number;
@@ -25,7 +32,10 @@ export type ToolcraftOutputExportFacts = {
   setupSection: ToolcraftControlsSection | undefined;
   setupSectionIndex: number;
   timelineEntry: readonly [string, ToolcraftControlSchema] | undefined;
+  videoExportSection: ToolcraftControlsSection | undefined;
   videoExportSectionIndex: number;
+  videoFormatEntry: readonly [string, ToolcraftControlSchema] | undefined;
+  videoResolutionEntry: readonly [string, ToolcraftControlSchema] | undefined;
 };
 
 export function getSearchableControlText({
@@ -47,9 +57,13 @@ export function getSearchableControlText({
     .replace(/([a-z])([A-Z])/g, "$1 $2");
 }
 
-function getFirstPanelActionsSectionIndex(schema: ResolvedToolcraftAppSchema): number {
+function getFirstPanelActionsSectionIndex(
+  schema: ResolvedToolcraftAppSchema,
+): number {
   return (schema.panels.controls?.sections ?? []).findIndex((section) =>
-    Object.values(section.controls).some((control) => control.type === "panelActions"),
+    Object.values(section.controls).some(
+      (control) => control.type === "panelActions",
+    ),
   );
 }
 
@@ -60,7 +74,8 @@ function getSchemaControlsSectionByTitle(
   const normalizedTitle = normalizeToolcraftSemanticText(title);
 
   return (schema.panels.controls?.sections ?? []).find(
-    (section) => normalizeToolcraftSemanticText(section.title) === normalizedTitle,
+    (section) =>
+      normalizeToolcraftSemanticText(section.title) === normalizedTitle,
   );
 }
 
@@ -83,7 +98,9 @@ function getSectionControlEntryByTarget(
     return undefined;
   }
 
-  return Object.entries(section.controls).find(([, control]) => control.target === target);
+  return Object.entries(section.controls).find(
+    ([, control]) => control.target === target,
+  );
 }
 
 function getOutputBackgroundColorEntry(
@@ -107,24 +124,45 @@ function getOutputBackgroundColorEntry(
 }
 
 export function buildToolcraftOutputExportFacts({
-  hasVideoExportAction,
   schema,
 }: {
-  hasVideoExportAction: boolean;
   schema: ResolvedToolcraftAppSchema;
 }): ToolcraftOutputExportFacts {
-  const backgroundSection = getSchemaControlsSectionByTitle(schema, "Background");
+  const backgroundSection = getSchemaControlsSectionByTitle(
+    schema,
+    "Background",
+  );
   const setupSection = getSchemaControlsSectionByTitle(schema, "Setup");
-  const imageExportSection = getSchemaControlsSectionByTitle(schema, "Image Export");
-  const imageExportSectionIndex = getSchemaControlsSectionIndexByTitle(schema, "Image Export");
-  const videoExportSectionIndex = getSchemaControlsSectionIndexByTitle(schema, "Video Export");
+  const imageExportSection = getSchemaControlsSectionByTitle(
+    schema,
+    "Image Export",
+  );
+  const videoExportSection = getSchemaControlsSectionByTitle(
+    schema,
+    "Video Export",
+  );
+  const imageExportSectionIndex = getSchemaControlsSectionIndexByTitle(
+    schema,
+    "Image Export",
+  );
+  const videoExportSectionIndex = getSchemaControlsSectionIndexByTitle(
+    schema,
+    "Video Export",
+  );
+  const hasImageExportAction = schemaHasPngExportPanelAction(schema);
+  const hasSvgExportAction = schemaHasSvgExportPanelAction(schema);
+  const hasVideoExportAction = schemaHasVideoExportPanelAction(schema);
 
   return {
     backgroundColorEntry: getOutputBackgroundColorEntry(setupSection),
     backgroundSection,
     finalExportSettingsIndex: hasVideoExportAction
       ? videoExportSectionIndex
-      : imageExportSectionIndex,
+      : hasImageExportAction
+        ? imageExportSectionIndex
+        : -1,
+    hasImageExportAction,
+    hasSvgExportAction,
     hasVideoExportAction,
     imageExportSection,
     imageExportSectionIndex,
@@ -151,6 +189,15 @@ export function buildToolcraftOutputExportFacts({
       setupSection,
       "panels.timeline.extended",
     ),
+    videoExportSection,
     videoExportSectionIndex,
+    videoFormatEntry: getSectionControlEntryByTarget(
+      videoExportSection,
+      "export.video.format",
+    ),
+    videoResolutionEntry: getSectionControlEntryByTarget(
+      videoExportSection,
+      "export.video.resolution",
+    ),
   };
 }

package/templates/starter/src/app/acceptance/output-export.ts

@@ -1,56 +1,71 @@
 import type { ResolvedToolcraftAppSchema } from "@repo/toolcraft-runtime";
 
+import { validateToolcraftArtifactExportIntentCorrespondence } from "./artifact-export-intent";
 import {
   getToolcraftOutputBackgroundErrors,
   isOutputBackgroundToggleControl,
 } from "./output-background-rules";
 import {
   schemaHasPngExportPanelAction,
+  schemaHasSvgExportPanelAction,
   schemaHasVideoExportPanelAction,
 } from "./output-export-actions";
 import { getToolcraftOutputExportLayoutErrors } from "./output-export-layout-rules";
 import { buildToolcraftOutputExportFacts } from "./output-export-model";
 import { getToolcraftImageExportErrors } from "./output-image-export-rules";
+import { getToolcraftVideoExportErrors } from "./output-video-export-rules";
 import { getToolcraftExportArtifactCoverageErrors } from "./export-artifact-coverage";
 import type {
   ToolcraftComponentAcceptance,
+  ToolcraftProductReadiness,
   ToolcraftVisibleControl,
 } from "./types";
 
 export {
   isOutputBackgroundToggleControl,
   schemaHasPngExportPanelAction,
+  schemaHasSvgExportPanelAction,
   schemaHasVideoExportPanelAction,
 };
 
 export function getToolcraftOutputExportErrors({
   acceptance,
   controls,
+  productReadiness,
   schema,
-  hasVideoExportAction = schemaHasVideoExportPanelAction(schema),
 }: {
   acceptance: readonly ToolcraftComponentAcceptance[];
   controls: readonly ToolcraftVisibleControl[];
-  hasVideoExportAction?: boolean;
+  productReadiness: ToolcraftProductReadiness;
   schema: ResolvedToolcraftAppSchema;
 }): string[] {
   const exportArtifactCoverageErrors = getToolcraftExportArtifactCoverageErrors({
     acceptance,
     schema,
   });
-  if (!schemaHasPngExportPanelAction(schema)) {
+  if (productReadiness.mode === "starter") {
     return exportArtifactCoverageErrors;
   }
 
-  const facts = buildToolcraftOutputExportFacts({
-    hasVideoExportAction,
-    schema,
-  });
+  const facts = buildToolcraftOutputExportFacts({ schema });
+  const { delivery, errors: intentErrors } =
+    validateToolcraftArtifactExportIntentCorrespondence({
+      hasImageExportAction: facts.hasImageExportAction,
+      hasImageExportSection: facts.imageExportSection !== undefined,
+      hasSvgExportAction: facts.hasSvgExportAction,
+      hasVideoExportAction: facts.hasVideoExportAction,
+      hasVideoExportSection: facts.videoExportSection !== undefined,
+      intent: productReadiness.exportIntent,
+    });
 
   return [
-    ...getToolcraftOutputExportLayoutErrors(facts),
-    ...getToolcraftOutputBackgroundErrors({ controls, facts }),
-    ...getToolcraftImageExportErrors(facts),
+    ...intentErrors,
+    ...(delivery.imageEnabled ? getToolcraftImageExportErrors(facts) : []),
+    ...(delivery.videoEnabled ? getToolcraftVideoExportErrors(facts) : []),
+    ...(delivery.imageEnabled || delivery.svgEnabled || delivery.videoEnabled
+      ? getToolcraftOutputBackgroundErrors({ controls, facts })
+      : []),
+    ...getToolcraftOutputExportLayoutErrors({ delivery, facts }),
     ...exportArtifactCoverageErrors,
   ];
 }

package/templates/starter/src/app/acceptance/output-video-export-rules.ts

@@ -0,0 +1,99 @@
+import { sectionHasInlineLayoutGroupForPair } from "./inline-layout";
+import type { ToolcraftOutputExportFacts } from "./output-export-model";
+
+function hasExactOptionValueSet(
+  actual: readonly string[],
+  expected: readonly string[],
+): boolean {
+  return (
+    actual.length === expected.length &&
+    new Set(actual).size === expected.length &&
+    expected.every((value) => actual.includes(value))
+  );
+}
+
+export function getToolcraftVideoExportErrors(
+  facts: ToolcraftOutputExportFacts,
+): string[] {
+  const errors: string[] = [];
+  const videoFormatControl = facts.videoFormatEntry?.[1];
+  const videoResolutionControl = facts.videoResolutionEntry?.[1];
+  const videoFormatOptionValues =
+    videoFormatControl?.options?.map((option) => option.value.toLowerCase()) ??
+    [];
+  const videoResolutionOptionValues =
+    videoResolutionControl?.options?.map((option) =>
+      option.value.toLowerCase(),
+    ) ?? [];
+
+  if (!facts.videoExportSection) {
+    errors.push(
+      'Apps with Export Video must expose video export settings in a separate controls section titled "Video Export" directly above sticky footer export actions.',
+    );
+  }
+
+  if (!videoFormatControl) {
+    errors.push(
+      'The separate "Video Export" section must include a format control with target "export.video.format".',
+    );
+  } else {
+    if (
+      videoFormatControl.type !== "select" &&
+      videoFormatControl.type !== "segmented"
+    ) {
+      errors.push("Video Export format must be a Select or Segmented control.");
+    }
+
+    if (!hasExactOptionValueSet(videoFormatOptionValues, ["mp4", "webm"])) {
+      errors.push(
+        'Video Export format options must be exactly "mp4" and "webm".',
+      );
+    }
+
+    if (videoFormatControl.defaultValue !== "mp4") {
+      errors.push('Video Export format must default to "mp4".');
+    }
+  }
+
+  if (!videoResolutionControl) {
+    errors.push(
+      'The separate "Video Export" section must include a resolution control with target "export.video.resolution".',
+    );
+  } else {
+    if (videoResolutionControl.type !== "select") {
+      errors.push("Video Export resolution must be a Select control.");
+    }
+
+    if (
+      !hasExactOptionValueSet(videoResolutionOptionValues, ["current", "4k"])
+    ) {
+      errors.push(
+        'Video Export resolution options must be exactly "current" and "4k".',
+      );
+    }
+
+    if (videoResolutionControl.defaultValue !== "current") {
+      errors.push('Video Export resolution must default to "current".');
+    }
+  }
+
+  const videoFormatControlId = facts.videoFormatEntry?.[0];
+  const videoResolutionControlId = facts.videoResolutionEntry?.[0];
+  const videoExportHasInlinePair =
+    facts.videoExportSection !== undefined &&
+    videoFormatControlId !== undefined &&
+    videoResolutionControlId !== undefined &&
+    sectionHasInlineLayoutGroupForPair(
+      facts.videoExportSection,
+      videoFormatControlId,
+      videoResolutionControlId,
+    );
+
+  if (!videoExportHasInlinePair) {
+    errors.push(
+      "Video Export format and resolution must render as one exact two-column inline row.",
+    );
+  }
+
+  return errors;
+}

package/templates/starter/src/app/acceptance/reference-study-types.ts

@@ -12,36 +12,186 @@ export type ToolcraftReferenceStudyEvidence = {
   status: ToolcraftReferenceStudyStatus;
 };
 
-export type ToolcraftVideoReferenceStoryboardFrame = {
-  behaviorObservation: string;
+export type ToolcraftMotionReferenceTimingMode = "ordinal" | "seconds";
+
+export type ToolcraftMotionReferenceSourceKind =
+  | "contact-sheet"
+  | "frame-sequence"
+  | "gif"
+  | "screen-recording"
+  | "video";
+
+type ToolcraftMotionReferenceFrameBase = {
+  cell: Readonly<{ column: number; row: number }>;
   frameId: string;
-  frameSource: string;
-  timeSeconds: number;
-  visualObservation: string;
+  sourceFrameIndex: number;
+  sourceLocator: string;
+  sourceSha256: string;
 };
 
-export type ToolcraftVideoReferenceTransition = {
-  behaviorDelta: string;
+export type ToolcraftMotionReferenceOrdinalFrame =
+  ToolcraftMotionReferenceFrameBase & { timeSeconds?: never };
+
+export type ToolcraftMotionReferenceTimedFrame =
+  ToolcraftMotionReferenceFrameBase & { timeSeconds: number };
+
+export type ToolcraftMotionReferenceEvidenceEvent = {
+  afterFrameId: string;
+  beforeFrameId: string;
+  eventId: string;
+  kind: "change" | "loop-seam";
+  peakFrameId: string;
+  score: number;
+  windowFrameIds: readonly string[];
+};
+
+type ToolcraftMotionReferenceEvidenceBase = {
+  changeMetric: "max-yuva-diff-v1";
+  contactSheet: Readonly<{
+    columns: number;
+    height: number;
+    path: `src/app/reference-studies/${string}/contact-sheet.png`;
+    rows: number;
+    sha256: string;
+    width: number;
+  }>;
+  decodedFrameCount: number;
+  detectedEvents: readonly ToolcraftMotionReferenceEvidenceEvent[];
+  evidenceVersion: 1;
+  ffmpegVersion: string;
+  ffprobeVersion: string;
+  height: number;
+  scannedFrameCount: number;
+  sourceBasename: string;
+  sourceSha256: string;
+  studyId: string;
+  width: number;
+};
+
+export type ToolcraftMotionReferenceEvidence =
+  ToolcraftMotionReferenceEvidenceBase &
+    (
+      | {
+          sourceGrid: Readonly<{ columns: number; rows: number }>;
+          sourceKind: "contact-sheet";
+        }
+      | {
+          sourceGrid?: never;
+          sourceKind: Exclude<
+            ToolcraftMotionReferenceSourceKind,
+            "contact-sheet"
+          >;
+        }
+    ) &
+    (
+      | {
+          focusWindows: readonly [];
+          overviewFrameIds: readonly string[];
+          reviewedFrames: readonly ToolcraftMotionReferenceOrdinalFrame[];
+          timingMode: "ordinal";
+        }
+      | {
+          durationSeconds: number;
+          focusWindows: readonly Readonly<{
+            endSeconds: number;
+            frameIds: readonly string[];
+            sourceFrameEndIndex: number;
+            sourceFrameStartIndex: number;
+            startSeconds: number;
+          }>[];
+          maximumSourceFrameGapSeconds: number;
+          nominalFrameRate?: number;
+          overviewFrameIds: readonly string[];
+          overviewTargetFps: number;
+          reviewPartition?: Readonly<{
+            count: number;
+            groupId: `motion-group-v1-${string}`;
+            index: number;
+            planSha256: string;
+            scope: Readonly<{ endSeconds: number; startSeconds: number }>;
+          }>;
+          reviewedFrames: readonly ToolcraftMotionReferenceTimedFrame[];
+          segment?: Readonly<{ endSeconds: number; startSeconds: number }>;
+          timing: Readonly<
+            | { authority: "decoded-timestamps" }
+            | { authority: "declared-fps"; framesPerSecond: number }
+            | {
+                authority: "declared-timestamps";
+                timestampsSha256: string;
+              }
+          >;
+          timingMode: "seconds";
+        }
+    );
+
+export type ToolcraftMotionReferencePhase = {
+  behaviorIds: readonly string[];
   fromFrameId: string;
   id: string;
   toFrameId: string;
+  visualState: string;
 };
 
-export type ToolcraftVideoReferenceAcceptanceMapping = {
+export type ToolcraftMotionReferenceEvent = {
+  evidenceEventId: string;
+  id: string;
+} &
+  (
+    | {
+        behaviorIds: readonly string[];
+        classification: "product-behavior";
+        reason?: never;
+      }
+    | {
+        behaviorIds: readonly [];
+        classification:
+          | "edit-boundary"
+          | "encoding-artifact"
+          | "irrelevant-change";
+        reason: string;
+      }
+  );
+
+export type ToolcraftMotionReferenceTimingClaim =
+  | "cadence"
+  | "duration"
+  | "easing"
+  | "loop-seam"
+  | "speed";
+
+export type ToolcraftMotionReferenceBehavior = {
   acceptanceId: string;
-  behavior: string;
-  frameIds: readonly string[];
+  description: string;
+  id: string;
+  implementationIntent: string;
+  timingClaims: readonly Readonly<{
+    claim: ToolcraftMotionReferenceTimingClaim;
+    studyId: string;
+  }>[];
 };
 
-export type ToolcraftVideoReferenceStudyEvidence = {
-  acceptanceMapping: readonly ToolcraftVideoReferenceAcceptanceMapping[];
-  behaviorDecomposition: string;
-  extractionEvidence: string;
-  referenceLocation: string;
-  storyboard: readonly ToolcraftVideoReferenceStoryboardFrame[];
-  transitionAnalysis: readonly ToolcraftVideoReferenceTransition[];
+export type ToolcraftMotionReferenceStudy = {
+  evidence: ToolcraftMotionReferenceEvidence;
+  evidencePath: `src/app/reference-studies/${string}/evidence.json`;
+  events: readonly ToolcraftMotionReferenceEvent[];
+  phases: readonly ToolcraftMotionReferencePhase[];
+  studyId: string;
 };
 
+export type ToolcraftMotionReferenceInput = {
+  behaviors: readonly ToolcraftMotionReferenceBehavior[];
+  kind: "motion-reference";
+  referenceId: `motion-reference-v1-${string}`;
+  studies: readonly ToolcraftMotionReferenceStudy[];
+};
+
+export type ToolcraftReferenceInput = ToolcraftMotionReferenceInput;
+
+export type ToolcraftMotionReferenceCoverage = Readonly<{
+  behaviorId: string;
+  referenceId: ToolcraftMotionReferenceInput["referenceId"];
+}>;
+
 export type ToolcraftReferenceFeatureStatus =
   | "intentionally-changed"
   | "ported"