@syntrologie/runtime-sdk 2.0.0 → 2.0.1-canary.0

package/dist/actions/validation.js

@@ -3,41 +3,41 @@
  *
  * Validates action steps before execution.
  */
-import { hasExecutor } from "./executors";
+import { hasExecutor } from './executors';
 /** Known action kinds */
 const VALID_KINDS = [
-    "overlays:highlight",
-    "overlays:pulse",
-    "overlays:badge",
-    "overlays:tooltip",
-    "overlays:modal",
-    "content:insertHtml",
-    "content:setText",
-    "content:setAttr",
-    "content:addClass",
-    "content:removeClass",
-    "content:setStyle",
-    "core:mountWidget",
-    "core:wait",
-    "core:sequence",
-    "core:parallel",
-    "core:tour",
-    "navigation:scrollTo",
-    "navigation:navigate",
+    'overlays:highlight',
+    'overlays:pulse',
+    'overlays:badge',
+    'overlays:tooltip',
+    'overlays:modal',
+    'content:insertHtml',
+    'content:setText',
+    'content:setAttr',
+    'content:addClass',
+    'content:removeClass',
+    'content:setStyle',
+    'core:mountWidget',
+    'core:wait',
+    'core:sequence',
+    'core:parallel',
+    'core:tour',
+    'navigation:scrollTo',
+    'navigation:navigate',
 ];
 /** Dangerous attribute names that should not be set */
 const DANGEROUS_ATTRS = new Set([
-    "onclick",
-    "onerror",
-    "onload",
-    "onmouseover",
-    "onfocus",
-    "onblur",
-    "onchange",
-    "onsubmit",
-    "onkeydown",
-    "onkeyup",
-    "onkeypress",
+    'onclick',
+    'onerror',
+    'onload',
+    'onmouseover',
+    'onfocus',
+    'onblur',
+    'onchange',
+    'onsubmit',
+    'onkeydown',
+    'onkeyup',
+    'onkeypress',
 ]);
 /** Maximum HTML content length */
 const MAX_HTML_LENGTH = 50000;
@@ -50,93 +50,93 @@ export function validateAction(action) {
     const errors = [];
     const warnings = [];
     // Check action has a kind
-    if (!action || typeof action !== "object") {
+    if (!action || typeof action !== 'object') {
         errors.push({
-            code: "INVALID_ACTION",
-            message: "Action must be an object",
+            code: 'INVALID_ACTION',
+            message: 'Action must be an object',
         });
         return { valid: false, errors, warnings };
     }
     const kind = action.kind;
     // Check kind is valid
-    if (!kind || typeof kind !== "string") {
+    if (!kind || typeof kind !== 'string') {
         errors.push({
-            code: "MISSING_KIND",
+            code: 'MISSING_KIND',
             message: "Action must have a 'kind' property",
         });
         return { valid: false, errors, warnings };
     }
     if (!VALID_KINDS.includes(kind)) {
         errors.push({
-            code: "UNKNOWN_KIND",
+            code: 'UNKNOWN_KIND',
             message: `Unknown action kind: ${kind}`,
-            field: "kind",
+            field: 'kind',
         });
         return { valid: false, errors, warnings };
     }
     // Check executor exists
-    if (!hasExecutor(kind) && kind !== "core:mountWidget") {
+    if (!hasExecutor(kind) && kind !== 'core:mountWidget') {
         errors.push({
-            code: "NO_EXECUTOR",
+            code: 'NO_EXECUTOR',
             message: `No executor registered for action kind: ${kind}`,
-            field: "kind",
+            field: 'kind',
         });
     }
     // Kind-specific validation
     switch (kind) {
-        case "overlays:highlight":
-        case "overlays:pulse":
-        case "navigation:scrollTo":
+        case 'overlays:highlight':
+        case 'overlays:pulse':
+        case 'navigation:scrollTo':
             validateAnchorAction(action, errors, warnings);
             break;
-        case "overlays:badge":
+        case 'overlays:badge':
             validateAnchorAction(action, errors, warnings);
             validateBadgeAction(action, errors, warnings);
             break;
-        case "overlays:tooltip":
+        case 'overlays:tooltip':
             validateAnchorAction(action, errors, warnings);
             validateTooltipAction(action, errors, warnings);
             break;
-        case "overlays:modal":
+        case 'overlays:modal':
             validateModalAction(action, errors, warnings);
             break;
-        case "content:insertHtml":
+        case 'content:insertHtml':
             validateAnchorAction(action, errors, warnings);
             validateInsertHtmlAction(action, errors, warnings);
             break;
-        case "content:setText":
+        case 'content:setText':
             validateAnchorAction(action, errors, warnings);
             validateSetTextAction(action, errors, warnings);
             break;
-        case "content:setAttr":
+        case 'content:setAttr':
             validateAnchorAction(action, errors, warnings);
             validateSetAttrAction(action, errors, warnings);
             break;
-        case "content:addClass":
-        case "content:removeClass":
+        case 'content:addClass':
+        case 'content:removeClass':
             validateAnchorAction(action, errors, warnings);
             validateClassAction(action, errors, warnings);
             break;
-        case "content:setStyle":
+        case 'content:setStyle':
             validateAnchorAction(action, errors, warnings);
             validateSetStyleAction(action, errors, warnings);
             break;
-        case "core:mountWidget":
+        case 'core:mountWidget':
             validateMountWidgetAction(action, errors, warnings);
             break;
-        case "core:wait":
+        case 'core:wait':
             validateWaitAction(action, errors, warnings);
             break;
-        case "core:sequence":
+        case 'core:sequence':
             validateSequenceAction(action, errors, warnings);
             break;
-        case "core:parallel":
+        case 'core:parallel':
             validateParallelAction(action, errors, warnings);
             break;
-        case "core:tour":
+        case 'core:tour':
             validateTourAction(action, errors, warnings);
             break;
-        case "navigation:navigate":
+        case 'navigation:navigate':
             validateNavigateAction(action, errors, warnings);
             break;
     }
@@ -147,148 +147,149 @@ export function validateAction(action) {
     };
 }
 function validateAnchorAction(action, errors, warnings) {
-    if (!action.anchorId || typeof action.anchorId !== "string") {
+    if (!action.anchorId || typeof action.anchorId !== 'string') {
         errors.push({
-            code: "MISSING_ANCHOR_ID",
+            code: 'MISSING_ANCHOR_ID',
             message: "Action requires an 'anchorId' property",
-            field: "anchorId",
+            field: 'anchorId',
         });
     }
     else if (action.anchorId.length > 200) {
         warnings.push({
-            code: "LONG_ANCHOR_ID",
-            message: "Anchor ID is unusually long",
-            suggestion: "Consider using a shorter, more descriptive ID",
+            code: 'LONG_ANCHOR_ID',
+            message: 'Anchor ID is unusually long',
+            suggestion: 'Consider using a shorter, more descriptive ID',
         });
     }
 }
 function validateBadgeAction(action, errors, warnings) {
-    if (!action.content || typeof action.content !== "string") {
+    if (!action.content || typeof action.content !== 'string') {
         errors.push({
-            code: "MISSING_CONTENT",
+            code: 'MISSING_CONTENT',
             message: "Badge action requires 'content' property",
-            field: "content",
+            field: 'content',
         });
     }
     else if (action.content.length > 100) {
         warnings.push({
-            code: "LONG_BADGE_CONTENT",
-            message: "Badge content is quite long",
-            suggestion: "Keep badge content short (under 100 characters)",
+            code: 'LONG_BADGE_CONTENT',
+            message: 'Badge content is quite long',
+            suggestion: 'Keep badge content short (under 100 characters)',
         });
     }
 }
-function validateTooltipAction(action, errors, warnings) {
-    if (!action.content || typeof action.content !== "object") {
+function validateTooltipAction(action, errors, _warnings) {
+    if (!action.content || typeof action.content !== 'object') {
         errors.push({
-            code: "MISSING_CONTENT",
+            code: 'MISSING_CONTENT',
             message: "Tooltip action requires 'content' object",
-            field: "content",
+            field: 'content',
         });
         return;
     }
-    if (!action.content.body || typeof action.content.body !== "string") {
+    if (!action.content.body || typeof action.content.body !== 'string') {
         errors.push({
-            code: "MISSING_BODY",
+            code: 'MISSING_BODY',
             message: "Tooltip content requires 'body' property",
-            field: "content.body",
+            field: 'content.body',
         });
     }
 }
-function validateInsertHtmlAction(action, errors, warnings) {
-    if (!action.html || typeof action.html !== "string") {
+function validateInsertHtmlAction(action, errors, _warnings) {
+    if (!action.html || typeof action.html !== 'string') {
         errors.push({
-            code: "MISSING_HTML",
+            code: 'MISSING_HTML',
             message: "insertHtml action requires 'html' property",
-            field: "html",
+            field: 'html',
         });
     }
     else if (action.html.length > MAX_HTML_LENGTH) {
         errors.push({
-            code: "HTML_TOO_LONG",
+            code: 'HTML_TOO_LONG',
             message: `HTML content exceeds maximum length of ${MAX_HTML_LENGTH}`,
-            field: "html",
+            field: 'html',
         });
     }
-    const validPositions = ["before", "after", "prepend", "append", "replace"];
+    const validPositions = ['before', 'after', 'prepend', 'append', 'replace'];
     if (!action.position || !validPositions.includes(action.position)) {
         errors.push({
-            code: "INVALID_POSITION",
-            message: `Position must be one of: ${validPositions.join(", ")}`,
-            field: "position",
+            code: 'INVALID_POSITION',
+            message: `Position must be one of: ${validPositions.join(', ')}`,
+            field: 'position',
         });
     }
 }
-function validateSetTextAction(action, errors, warnings) {
+function validateSetTextAction(action, errors, _warnings) {
     if (action.text === undefined || action.text === null) {
         errors.push({
-            code: "MISSING_TEXT",
+            code: 'MISSING_TEXT',
             message: "setText action requires 'text' property",
-            field: "text",
+            field: 'text',
         });
     }
 }
-function validateSetAttrAction(action, errors, warnings) {
-    if (!action.attr || typeof action.attr !== "string") {
+function validateSetAttrAction(action, errors, _warnings) {
+    if (!action.attr || typeof action.attr !== 'string') {
         errors.push({
-            code: "MISSING_ATTR",
+            code: 'MISSING_ATTR',
             message: "setAttr action requires 'attr' property",
-            field: "attr",
+            field: 'attr',
         });
     }
-    else if (DANGEROUS_ATTRS.has(action.attr.toLowerCase()) || action.attr.toLowerCase().startsWith("on")) {
+    else if (DANGEROUS_ATTRS.has(action.attr.toLowerCase()) ||
+        action.attr.toLowerCase().startsWith('on')) {
         errors.push({
-            code: "DANGEROUS_ATTR",
+            code: 'DANGEROUS_ATTR',
             message: `Event handler attributes are not allowed: ${action.attr}`,
-            field: "attr",
+            field: 'attr',
         });
     }
     if (action.value === undefined || action.value === null) {
         errors.push({
-            code: "MISSING_VALUE",
+            code: 'MISSING_VALUE',
             message: "setAttr action requires 'value' property",
-            field: "value",
+            field: 'value',
         });
     }
 }
 function validateClassAction(action, errors, warnings) {
-    if (!action.className || typeof action.className !== "string") {
+    if (!action.className || typeof action.className !== 'string') {
         errors.push({
-            code: "MISSING_CLASS_NAME",
+            code: 'MISSING_CLASS_NAME',
             message: "Class action requires 'className' property",
-            field: "className",
+            field: 'className',
         });
     }
     else if (!/^[a-zA-Z_-][a-zA-Z0-9_-]*$/.test(action.className)) {
         warnings.push({
-            code: "INVALID_CLASS_NAME",
-            message: "Class name contains unusual characters",
-            suggestion: "Use alphanumeric characters, hyphens, and underscores",
+            code: 'INVALID_CLASS_NAME',
+            message: 'Class name contains unusual characters',
+            suggestion: 'Use alphanumeric characters, hyphens, and underscores',
         });
     }
 }
-function validateSetStyleAction(action, errors, warnings) {
-    if (!action.styles || typeof action.styles !== "object") {
+function validateSetStyleAction(action, errors, _warnings) {
+    if (!action.styles || typeof action.styles !== 'object') {
         errors.push({
-            code: "MISSING_STYLES",
+            code: 'MISSING_STYLES',
             message: "setStyle action requires 'styles' object",
-            field: "styles",
+            field: 'styles',
         });
     }
     else {
         const styleCount = Object.keys(action.styles).length;
         if (styleCount > MAX_STYLE_COUNT) {
             errors.push({
-                code: "TOO_MANY_STYLES",
+                code: 'TOO_MANY_STYLES',
                 message: `Too many styles (${styleCount}). Maximum is ${MAX_STYLE_COUNT}`,
-                field: "styles",
+                field: 'styles',
             });
         }
         // Check for potentially dangerous style values
         for (const [prop, value] of Object.entries(action.styles)) {
-            if (typeof value === "string" && value.includes("expression(")) {
+            if (typeof value === 'string' && value.includes('expression(')) {
                 errors.push({
-                    code: "DANGEROUS_STYLE",
+                    code: 'DANGEROUS_STYLE',
                     message: `Style expressions are not allowed: ${prop}`,
                     field: `styles.${prop}`,
                 });
@@ -296,65 +297,65 @@ function validateSetStyleAction(action, errors, warnings) {
         }
     }
 }
-function validateMountWidgetAction(action, errors, warnings) {
-    if (!action.slot || typeof action.slot !== "string") {
+function validateMountWidgetAction(action, errors, _warnings) {
+    if (!action.slot || typeof action.slot !== 'string') {
         errors.push({
-            code: "MISSING_SLOT",
+            code: 'MISSING_SLOT',
             message: "mountWidget action requires 'slot' property",
-            field: "slot",
+            field: 'slot',
         });
     }
-    if (!action.widget || typeof action.widget !== "object") {
+    if (!action.widget || typeof action.widget !== 'object') {
         errors.push({
-            code: "MISSING_WIDGET",
+            code: 'MISSING_WIDGET',
             message: "mountWidget action requires 'widget' object",
-            field: "widget",
+            field: 'widget',
         });
     }
-    else if (!action.widget.widgetId || typeof action.widget.widgetId !== "string") {
+    else if (!action.widget.widgetId || typeof action.widget.widgetId !== 'string') {
         errors.push({
-            code: "MISSING_WIDGET_ID",
+            code: 'MISSING_WIDGET_ID',
             message: "Widget must have a 'widgetId' property",
-            field: "widget.widgetId",
+            field: 'widget.widgetId',
         });
     }
 }
-function validateWaitAction(action, errors, warnings) {
+function validateWaitAction(action, errors, _warnings) {
     if (action.durationMs === undefined && !action.event) {
         errors.push({
-            code: "MISSING_WAIT_CONFIG",
+            code: 'MISSING_WAIT_CONFIG',
             message: "wait action requires either 'durationMs' or 'event' property",
         });
     }
     if (action.durationMs !== undefined && action.durationMs < 0) {
         errors.push({
-            code: "INVALID_DURATION",
-            message: "durationMs must be a positive number",
-            field: "durationMs",
+            code: 'INVALID_DURATION',
+            message: 'durationMs must be a positive number',
+            field: 'durationMs',
         });
     }
-    if (action.event !== undefined && typeof action.event !== "string") {
+    if (action.event !== undefined && typeof action.event !== 'string') {
         errors.push({
-            code: "INVALID_EVENT",
-            message: "event must be a string",
-            field: "event",
+            code: 'INVALID_EVENT',
+            message: 'event must be a string',
+            field: 'event',
         });
     }
 }
 function validateSequenceAction(action, errors, warnings) {
     if (!action.actions || !Array.isArray(action.actions)) {
         errors.push({
-            code: "MISSING_ACTIONS",
+            code: 'MISSING_ACTIONS',
             message: "sequence action requires 'actions' array",
-            field: "actions",
+            field: 'actions',
         });
         return;
     }
     if (action.actions.length === 0) {
         warnings.push({
-            code: "EMPTY_SEQUENCE",
-            message: "sequence has no actions",
-            suggestion: "Add at least one action to the sequence",
+            code: 'EMPTY_SEQUENCE',
+            message: 'sequence has no actions',
+            suggestion: 'Add at least one action to the sequence',
         });
     }
     // Recursively validate nested actions
@@ -363,7 +364,7 @@ function validateSequenceAction(action, errors, warnings) {
         for (const error of result.errors) {
             errors.push({
                 ...error,
-                field: `actions[${i}]${error.field ? `.${error.field}` : ""}`,
+                field: `actions[${i}]${error.field ? `.${error.field}` : ''}`,
             });
         }
         for (const warning of result.warnings) {
@@ -374,24 +375,24 @@ function validateSequenceAction(action, errors, warnings) {
 function validateParallelAction(action, errors, warnings) {
     if (!action.actions || !Array.isArray(action.actions)) {
         errors.push({
-            code: "MISSING_ACTIONS",
+            code: 'MISSING_ACTIONS',
             message: "parallel action requires 'actions' array",
-            field: "actions",
+            field: 'actions',
         });
         return;
     }
     if (action.actions.length === 0) {
         warnings.push({
-            code: "EMPTY_PARALLEL",
-            message: "parallel has no actions",
-            suggestion: "Add at least one action to the parallel group",
+            code: 'EMPTY_PARALLEL',
+            message: 'parallel has no actions',
+            suggestion: 'Add at least one action to the parallel group',
         });
     }
-    if (action.waitFor && !["all", "any"].includes(action.waitFor)) {
+    if (action.waitFor && !['all', 'any'].includes(action.waitFor)) {
         errors.push({
-            code: "INVALID_WAIT_FOR",
+            code: 'INVALID_WAIT_FOR',
             message: "waitFor must be 'all' or 'any'",
-            field: "waitFor",
+            field: 'waitFor',
         });
     }
     // Recursively validate nested actions
@@ -400,7 +401,7 @@ function validateParallelAction(action, errors, warnings) {
         for (const error of result.errors) {
             errors.push({
                 ...error,
-                field: `actions[${i}]${error.field ? `.${error.field}` : ""}`,
+                field: `actions[${i}]${error.field ? `.${error.field}` : ''}`,
             });
         }
         for (const warning of result.warnings) {
@@ -409,76 +410,76 @@ function validateParallelAction(action, errors, warnings) {
     }
 }
 function validateNavigateAction(action, errors, warnings) {
-    if (!action.url || typeof action.url !== "string") {
+    if (!action.url || typeof action.url !== 'string') {
         errors.push({
-            code: "MISSING_URL",
+            code: 'MISSING_URL',
             message: "navigate action requires 'url' property",
-            field: "url",
+            field: 'url',
         });
     }
     else {
         const url = action.url.trim().toLowerCase();
-        if (url.startsWith("javascript:")) {
+        if (url.startsWith('javascript:')) {
             errors.push({
-                code: "DANGEROUS_URL",
-                message: "javascript: URLs are not allowed",
-                field: "url",
+                code: 'DANGEROUS_URL',
+                message: 'javascript: URLs are not allowed',
+                field: 'url',
             });
         }
         // Warn about data: URLs
-        if (url.startsWith("data:")) {
+        if (url.startsWith('data:')) {
             warnings.push({
-                code: "DATA_URL",
-                message: "data: URLs may have limited support",
-                suggestion: "Consider using a regular URL instead",
+                code: 'DATA_URL',
+                message: 'data: URLs may have limited support',
+                suggestion: 'Consider using a regular URL instead',
             });
         }
     }
 }
-function validateModalAction(action, errors, warnings) {
-    if (!action.content || typeof action.content !== "object") {
+function validateModalAction(action, errors, _warnings) {
+    if (!action.content || typeof action.content !== 'object') {
         errors.push({
-            code: "MISSING_CONTENT",
+            code: 'MISSING_CONTENT',
             message: "Modal action requires 'content' object",
-            field: "content",
+            field: 'content',
         });
         return;
     }
-    if (!action.content.body || typeof action.content.body !== "string") {
+    if (!action.content.body || typeof action.content.body !== 'string') {
         errors.push({
-            code: "MISSING_BODY",
+            code: 'MISSING_BODY',
             message: "Modal content requires 'body' property",
-            field: "content.body",
+            field: 'content.body',
         });
     }
-    if (action.size && !["sm", "md", "lg"].includes(action.size)) {
+    if (action.size && !['sm', 'md', 'lg'].includes(action.size)) {
         errors.push({
-            code: "INVALID_SIZE",
+            code: 'INVALID_SIZE',
             message: "Modal size must be 'sm', 'md', or 'lg'",
-            field: "size",
+            field: 'size',
         });
     }
     if (action.ctaButtons) {
         if (!Array.isArray(action.ctaButtons)) {
             errors.push({
-                code: "INVALID_CTA_BUTTONS",
-                message: "ctaButtons must be an array",
-                field: "ctaButtons",
+                code: 'INVALID_CTA_BUTTONS',
+                message: 'ctaButtons must be an array',
+                field: 'ctaButtons',
             });
         }
         else {
             for (let i = 0; i < action.ctaButtons.length; i++) {
                 const btn = action.ctaButtons[i];
-                if (!btn.label || typeof btn.label !== "string") {
+                if (!btn.label || typeof btn.label !== 'string') {
                     errors.push({
-                        code: "MISSING_BUTTON_LABEL",
+                        code: 'MISSING_BUTTON_LABEL',
                         message: `CTA button at index ${i} requires 'label' property`,
                         field: `ctaButtons[${i}].label`,
                     });
                 }
-                if (!btn.actionId || typeof btn.actionId !== "string") {
+                if (!btn.actionId || typeof btn.actionId !== 'string') {
                     errors.push({
-                        code: "MISSING_BUTTON_ACTION_ID",
+                        code: 'MISSING_BUTTON_ACTION_ID',
                         message: `CTA button at index ${i} requires 'actionId' property`,
                         field: `ctaButtons[${i}].actionId`,
                     });
@@ -488,34 +489,34 @@ function validateModalAction(action, errors, warnings) {
     }
 }
 function validateTourAction(action, errors, warnings) {
-    if (!action.tourId || typeof action.tourId !== "string") {
+    if (!action.tourId || typeof action.tourId !== 'string') {
         errors.push({
-            code: "MISSING_TOUR_ID",
+            code: 'MISSING_TOUR_ID',
             message: "Tour action requires 'tourId' property",
-            field: "tourId",
+            field: 'tourId',
         });
     }
     if (!action.steps || !Array.isArray(action.steps)) {
         errors.push({
-            code: "MISSING_STEPS",
+            code: 'MISSING_STEPS',
             message: "Tour action requires 'steps' array",
-            field: "steps",
+            field: 'steps',
         });
         return;
     }
     if (action.steps.length === 0) {
         errors.push({
-            code: "EMPTY_STEPS",
-            message: "Tour must have at least one step",
-            field: "steps",
+            code: 'EMPTY_STEPS',
+            message: 'Tour must have at least one step',
+            field: 'steps',
         });
     }
     const stepIds = new Set();
     for (let i = 0; i < action.steps.length; i++) {
         const step = action.steps[i];
-        if (!step.id || typeof step.id !== "string") {
+        if (!step.id || typeof step.id !== 'string') {
             errors.push({
-                code: "MISSING_STEP_ID",
+                code: 'MISSING_STEP_ID',
                 message: `Step at index ${i} requires 'id' property`,
                 field: `steps[${i}].id`,
             });
@@ -523,7 +524,7 @@ function validateTourAction(action, errors, warnings) {
         else {
             if (stepIds.has(step.id)) {
                 errors.push({
-                    code: "DUPLICATE_STEP_ID",
+                    code: 'DUPLICATE_STEP_ID',
                     message: `Duplicate step ID: ${step.id}`,
                     field: `steps[${i}].id`,
                 });
@@ -532,7 +533,7 @@ function validateTourAction(action, errors, warnings) {
         }
         if (!step.action) {
             errors.push({
-                code: "MISSING_STEP_ACTION",
+                code: 'MISSING_STEP_ACTION',
                 message: `Step at index ${i} requires 'action' property`,
                 field: `steps[${i}].action`,
             });
@@ -543,7 +544,7 @@ function validateTourAction(action, errors, warnings) {
             for (const error of result.errors) {
                 errors.push({
                     ...error,
-                    field: `steps[${i}].action${error.field ? `.${error.field}` : ""}`,
+                    field: `steps[${i}].action${error.field ? `.${error.field}` : ''}`,
                 });
             }
             for (const warning of result.warnings) {
@@ -552,10 +553,10 @@ function validateTourAction(action, errors, warnings) {
         }
         // Validate onAction references
         if (step.onAction) {
-            for (const [actionId, targetStepId] of Object.entries(step.onAction)) {
-                if (targetStepId !== "end" && !action.steps.some((s) => s.id === targetStepId)) {
+            for (const [_actionId, targetStepId] of Object.entries(step.onAction)) {
+                if (targetStepId !== 'end' && !action.steps.some((s) => s.id === targetStepId)) {
                     warnings.push({
-                        code: "UNKNOWN_TARGET_STEP",
+                        code: 'UNKNOWN_TARGET_STEP',
                         message: `Step "${step.id}" references unknown target step: ${targetStepId}`,
                         suggestion: `Make sure step "${targetStepId}" exists in the tour`,
                     });
@@ -572,8 +573,8 @@ export function validateActions(actions) {
     const warnings = [];
     if (!Array.isArray(actions)) {
         errors.push({
-            code: "INVALID_ACTIONS",
-            message: "Actions must be an array",
+            code: 'INVALID_ACTIONS',
+            message: 'Actions must be an array',
         });
         return { valid: false, errors, warnings };
     }
@@ -588,9 +589,7 @@ export function validateActions(actions) {
         for (const warning of result.warnings) {
             warnings.push({
                 ...warning,
-                suggestion: warning.suggestion
-                    ? `Action ${i}: ${warning.suggestion}`
-                    : undefined,
+                suggestion: warning.suggestion ? `Action ${i}: ${warning.suggestion}` : undefined,
             });
         }
     }