@knime/hub-features 1.30.0 → 1.31.1

package/src/analytics/schema/editor-event-functions.ts

@@ -935,6 +935,29 @@ export const hintClosed = <T extends DefaultContext>(ctx: T) => (eventData: Even
   return event;
 };
 
+/**
+ * Fired when the user clicks Apply and Execute in the node configuration panel
+ */
+export const applyAndExecuteNodeConfig = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"applyAndExecuteNodeConfig">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "node_configuration_applied_and_executed",
+    event_source: "editor",
+    event_display_name: "Node configuration applied and executed",
+    interaction: {
+      location: "node_configuration",
+      trigger: "user",
+      type: "click",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
 export const configurationCompletedApply = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"configurationCompletedApply">): AnalyticsEvent => {
   const staticData = {
     ...toSnakeCaseDeep(ctx),
@@ -1140,3 +1163,731 @@ export const nodeConfigFeedbackSubmitted = <T extends DefaultContext>(ctx: T) =>
   return event;
 };
 
+/**
+ * Fired when the user executes all nodes via the context menu
+ */
+export const executeAllNodesCtxMenu = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_executed",
+    event_source: "editor",
+    event_display_name: "All Nodes Executed",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user executes all nodes via the keyboard shortcut
+ */
+export const executeAllNodesKeyboard = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_executed",
+    event_source: "editor",
+    event_display_name: "All Nodes Executed",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user executes all nodes via the workflow toolbar
+ */
+export const executeAllNodesToolbar = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_executed",
+    event_source: "editor",
+    event_display_name: "All Nodes Executed",
+    interaction: {
+      location: "workflow_toolbar",
+      trigger: "user",
+      type: "click",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user executes a selection of nodes via the context menu
+ */
+export const executeSelectedNodesCtxMenu = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"executeSelectedNodesCtxMenu">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_executed",
+    event_source: "editor",
+    event_display_name: "Nodes Executed",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user executes a selection of nodes via the keyboard shortcut
+ */
+export const executeSelectedNodesKeyboard = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"executeSelectedNodesKeyboard">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_executed",
+    event_source: "editor",
+    event_display_name: "Nodes Executed",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user executes a selection of nodes via the workflow toolbar
+ */
+export const executeSelectedNodesToolbar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"executeSelectedNodesToolbar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_executed",
+    event_source: "editor",
+    event_display_name: "Nodes Executed",
+    interaction: {
+      location: "workflow_toolbar",
+      trigger: "user",
+      type: "click",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user cancels all nodes via the context menu
+ */
+export const cancelAllNodesCtxMenu = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_cancelled",
+    event_source: "editor",
+    event_display_name: "All Nodes Cancelled",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user cancels all nodes via the keyboard shortcut
+ */
+export const cancelAllNodesKeyboard = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_cancelled",
+    event_source: "editor",
+    event_display_name: "All Nodes Cancelled",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user cancels all nodes via the workflow toolbar
+ */
+export const cancelAllNodesToolbar = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_cancelled",
+    event_source: "editor",
+    event_display_name: "All Nodes Cancelled",
+    interaction: {
+      location: "workflow_toolbar",
+      trigger: "user",
+      type: "click",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user cancels a selection of nodes via the context menu
+ */
+export const cancelSelectedNodesCtxMenu = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"cancelSelectedNodesCtxMenu">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_cancelled",
+    event_source: "editor",
+    event_display_name: "Nodes Cancelled",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user cancels a selection of nodes via the keyboard shortcut
+ */
+export const cancelSelectedNodesKeyboard = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"cancelSelectedNodesKeyboard">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_cancelled",
+    event_source: "editor",
+    event_display_name: "Nodes Cancelled",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user cancels a selection of nodes via the workflow toolbar
+ */
+export const cancelSelectedNodesToolbar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"cancelSelectedNodesToolbar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_cancelled",
+    event_source: "editor",
+    event_display_name: "Nodes Cancelled",
+    interaction: {
+      location: "workflow_toolbar",
+      trigger: "user",
+      type: "click",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resets all nodes via the context menu
+ */
+export const resetAllNodesCtxMenu = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_reset",
+    event_source: "editor",
+    event_display_name: "All Nodes Reset",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resets all nodes via the keyboard shortcut
+ */
+export const resetAllNodesKeyboard = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_reset",
+    event_source: "editor",
+    event_display_name: "All Nodes Reset",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resets all nodes via the workflow toolbar
+ */
+export const resetAllNodesToolbar = <T extends DefaultContext>(ctx: T) => (): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "all_nodes_reset",
+    event_source: "editor",
+    event_display_name: "All Nodes Reset",
+    interaction: {
+      location: "workflow_toolbar",
+      trigger: "user",
+      type: "click",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resets a selection of nodes via the context menu
+ */
+export const resetSelectedNodesCtxMenu = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"resetSelectedNodesCtxMenu">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_reset",
+    event_source: "editor",
+    event_display_name: "Nodes Reset",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resets a selection of nodes via the keyboard shortcut
+ */
+export const resetSelectedNodesKeyboard = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"resetSelectedNodesKeyboard">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_reset",
+    event_source: "editor",
+    event_display_name: "Nodes Reset",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resets a selection of nodes via the workflow toolbar
+ */
+export const resetSelectedNodesToolbar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"resetSelectedNodesToolbar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_reset",
+    event_source: "editor",
+    event_display_name: "Nodes Reset",
+    interaction: {
+      location: "workflow_toolbar",
+      trigger: "user",
+      type: "click",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user executes a single node via the node action bar
+ */
+export const executeNodeActionBar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"executeNodeActionBar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_executed",
+    event_source: "editor",
+    event_display_name: "Nodes Executed",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "node_action_bar",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user executes a single node via the workflow monitor
+ */
+export const executeNodeFromMonitor = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"executeNodeFromMonitor">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_executed",
+    event_source: "editor",
+    event_display_name: "Nodes Executed",
+    interaction: {
+      location: "node_monitor",
+      trigger: "user",
+      type: "click",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resets a single node via the node action bar
+ */
+export const resetNodeActionBar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"resetNodeActionBar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_reset",
+    event_source: "editor",
+    event_display_name: "Nodes Reset",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "node_action_bar",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user cancels execution of a single node via the node action bar
+ */
+export const cancelNodeActionBar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"cancelNodeActionBar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "nodes_cancelled",
+    event_source: "editor",
+    event_display_name: "Nodes Cancelled",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "node_action_bar",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user pauses loop execution via the keyboard shortcut
+ */
+export const pauseLoopExecutionKeyboard = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"pauseLoopExecutionKeyboard">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_paused",
+    event_source: "editor",
+    event_display_name: "Loop Paused",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user pauses loop execution via the node action bar
+ */
+export const pauseLoopExecutionActionBar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"pauseLoopExecutionActionBar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_paused",
+    event_source: "editor",
+    event_display_name: "Loop Paused",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "node_action_bar",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resumes loop execution via the keyboard shortcut
+ */
+export const resumeLoopExecutionKeyboard = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"resumeLoopExecutionKeyboard">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_resumed",
+    event_source: "editor",
+    event_display_name: "Loop Resumed",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resumes loop execution via the node action bar
+ */
+export const resumeLoopExecutionActionBar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"resumeLoopExecutionActionBar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_resumed",
+    event_source: "editor",
+    event_display_name: "Loop Resumed",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "node_action_bar",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user steps through loop execution via the keyboard shortcut
+ */
+export const stepLoopExecutionKeyboard = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"stepLoopExecutionKeyboard">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_stepped",
+    event_source: "editor",
+    event_display_name: "Loop Stepped",
+    interaction: {
+      location: "global",
+      trigger: "user",
+      type: "shortcut",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user steps through loop execution via the node action bar
+ */
+export const stepLoopExecutionActionBar = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"stepLoopExecutionActionBar">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_stepped",
+    event_source: "editor",
+    event_display_name: "Loop Stepped",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "node_action_bar",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user pauses loop execution via the context menu
+ */
+export const pauseLoopExecutionCtxMenu = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"pauseLoopExecutionCtxMenu">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_paused",
+    event_source: "editor",
+    event_display_name: "Loop Paused",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user resumes loop execution via the context menu
+ */
+export const resumeLoopExecutionCtxMenu = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"resumeLoopExecutionCtxMenu">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_resumed",
+    event_source: "editor",
+    event_display_name: "Loop Resumed",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+
+/**
+ * Fired when the user steps through loop execution via the context menu
+ */
+export const stepLoopExecutionCtxMenu = <T extends DefaultContext>(ctx: T) => (eventData: EventFunctionArgs<"stepLoopExecutionCtxMenu">): AnalyticsEvent => {
+  const staticData = {
+    ...toSnakeCaseDeep(ctx),
+    unique_event_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    event_name: "loop_stepped",
+    event_source: "editor",
+    event_display_name: "Loop Stepped",
+    interaction: {
+      location: "canvas",
+      trigger: "user",
+      type: "click",
+      ui_element: "context_menu",
+    },
+  } satisfies SchemaStaticFields & GeneratedStaticFields;
+
+  const event = { id: staticData.event_name, data: { ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } } };
+
+  return event;
+};
+