@kubuild/core 0.0.1 → 0.2.0

package/dist/index.js

@@ -851,7 +851,10 @@ function findMissingComponentNodes(rootNode, registry, knownTypes) {
 // src/commands.ts
 import {
   StyleDefinitionSchema,
-  ResponsiveStylesSchema
+  ResponsiveStylesSchema,
+  AnimationConfigSchema,
+  ActionPipelineSchema,
+  FormConfigSchema
 } from "@kubuild/schema";
 
 // src/command-tree-utils.ts
@@ -1280,6 +1283,97 @@ function duplicateNode(document, params) {
     }
   };
 }
+function updateAnimation(document, params) {
+  const { nodeId, animation, merge = true } = params;
+  const newDoc = deepClone(document);
+  const loc = findNodeLocation(newDoc.document, nodeId);
+  if (!loc) {
+    throw new Error(`Cannot update animation: Node with ID "${nodeId}" not found in document.`);
+  }
+  const targetNode = loc.node;
+  const previousAnimation = targetNode.animation ? deepClone(targetNode.animation) : void 0;
+  if (animation === null) {
+    delete targetNode.animation;
+  } else {
+    const currentAnimation = targetNode.animation ? deepClone(targetNode.animation) : {};
+    const candidate = merge ? { ...currentAnimation, ...deepClone(animation) } : deepClone(animation);
+    targetNode.animation = AnimationConfigSchema.parse(candidate);
+  }
+  return {
+    document: newDoc,
+    event: {
+      type: "ANIMATION_UPDATED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId,
+      parentId: loc.parent ? loc.parent.id : void 0,
+      payload: {
+        animation: targetNode.animation,
+        previousAnimation
+      }
+    }
+  };
+}
+function updateActions(document, params) {
+  const { nodeId, actions } = params;
+  const newDoc = deepClone(document);
+  const loc = findNodeLocation(newDoc.document, nodeId);
+  if (!loc) {
+    throw new Error(`Cannot update actions: Node with ID "${nodeId}" not found in document.`);
+  }
+  const targetNode = loc.node;
+  const previousActions = targetNode.actions ? deepClone(targetNode.actions) : void 0;
+  if (actions === null || Array.isArray(actions) && actions.length === 0) {
+    delete targetNode.actions;
+  } else {
+    targetNode.actions = ActionPipelineSchema.array().parse(actions);
+  }
+  return {
+    document: newDoc,
+    event: {
+      type: "ACTIONS_UPDATED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId,
+      parentId: loc.parent ? loc.parent.id : void 0,
+      payload: {
+        actions: targetNode.actions,
+        previousActions
+      }
+    }
+  };
+}
+function updateFormConfig(document, params) {
+  const { nodeId, formConfig, merge = true } = params;
+  const newDoc = deepClone(document);
+  const loc = findNodeLocation(newDoc.document, nodeId);
+  if (!loc) {
+    throw new Error(`Cannot update formConfig: Node with ID "${nodeId}" not found in document.`);
+  }
+  const targetNode = loc.node;
+  const previousFormConfig = targetNode.formConfig ? deepClone(targetNode.formConfig) : void 0;
+  if (formConfig === null) {
+    delete targetNode.formConfig;
+  } else {
+    const currentFormConfig = targetNode.formConfig ? deepClone(targetNode.formConfig) : { formId: nodeId };
+    const candidate = merge ? { ...currentFormConfig, ...deepClone(formConfig) } : deepClone(formConfig);
+    if (!candidate.formId) {
+      candidate.formId = nodeId;
+    }
+    targetNode.formConfig = FormConfigSchema.parse(candidate);
+  }
+  return {
+    document: newDoc,
+    event: {
+      type: "FORM_CONFIG_UPDATED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId,
+      parentId: loc.parent ? loc.parent.id : void 0,
+      payload: {
+        formConfig: targetNode.formConfig,
+        previousFormConfig
+      }
+    }
+  };
+}
 
 // src/history.ts
 var DEFAULT_MAX_HISTORY = 50;
@@ -3544,7 +3638,1205 @@ function areNodeIdsCompletelyDistinct(docA, docB) {
   }
   return true;
 }
+
+// src/interpolator.ts
+var FORBIDDEN_KEY_SEGMENTS3 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var TEMPLATE_EXPRESSION_REGEX = /\{\{\s*([a-zA-Z0-9_$.,\-[\]\s]+?)\s*\}\}/g;
+var EXACT_TEMPLATE_REGEX = /^\{\{\s*([a-zA-Z0-9_$.,\-[\]\s]+?)\s*\}\}$/;
+function hasTemplateExpressions(text) {
+  if (typeof text !== "string") return false;
+  return /\{\{\s*[\s\S]+?\s*\}\}/.test(text);
+}
+function extractTemplateVariables(text) {
+  if (!text || typeof text !== "string") return [];
+  const matches = [];
+  const regex = new RegExp(TEMPLATE_EXPRESSION_REGEX.source, "g");
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match[1]) {
+      const trimmed = match[1].trim();
+      if (trimmed && !matches.includes(trimmed)) {
+        matches.push(trimmed);
+      }
+    }
+  }
+  return matches;
+}
+function resolvePropertyPath(source, path, fallback) {
+  const defaultFallback = arguments.length < 3 ? "" : fallback;
+  if (!path || typeof path !== "string" || source === null || source === void 0) {
+    return defaultFallback;
+  }
+  const normalizedPath = path.replace(/\[(\d+)\]/g, ".$1");
+  const segments = normalizedPath.split(".").map((s) => s.trim()).filter(Boolean);
+  if (segments.length === 0) {
+    return defaultFallback;
+  }
+  let current = source;
+  for (const segment of segments) {
+    if (FORBIDDEN_KEY_SEGMENTS3.has(segment)) {
+      return defaultFallback;
+    }
+    if (current === null || current === void 0) {
+      return defaultFallback;
+    }
+    if (typeof current !== "object") {
+      return defaultFallback;
+    }
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      if (!Number.isInteger(index) || index < 0 || index >= current.length) {
+        return defaultFallback;
+      }
+      current = current[index];
+    } else if (Object.prototype.hasOwnProperty.call(current, segment)) {
+      current = current[segment];
+    } else {
+      return defaultFallback;
+    }
+  }
+  if (current === void 0 || typeof current === "function") {
+    return defaultFallback;
+  }
+  return current;
+}
+function interpolateTemplateString(template, context, fallback = "") {
+  if (!template || typeof template !== "string") return "";
+  if (!hasTemplateExpressions(template)) return template;
+  return template.replace(/\{\{\s*([a-zA-Z0-9_$.,\-[\]\s]+?)\s*\}\}/g, (_match, rawKey) => {
+    const key = rawKey.trim();
+    if (!key) return fallback;
+    const resolved = resolvePropertyPath(context, key, fallback);
+    if (resolved === void 0 || resolved === null) {
+      return fallback;
+    }
+    if (typeof resolved === "object") {
+      try {
+        return JSON.stringify(resolved);
+      } catch {
+        return fallback;
+      }
+    }
+    return String(resolved);
+  });
+}
+function interpolateValue(value, context) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const exactMatch = EXACT_TEMPLATE_REGEX.exec(trimmed);
+    if (exactMatch && exactMatch[1]) {
+      const key = exactMatch[1].trim();
+      return resolvePropertyPath(context, key, "");
+    }
+    return interpolateTemplateString(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateValue(item, context));
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (!FORBIDDEN_KEY_SEGMENTS3.has(k)) {
+        result[k] = interpolateValue(v, context);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/validation-engine.ts
+function isEmptyValue(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (typeof value === "boolean") {
+    return value === false;
+  }
+  return false;
+}
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var URL_REGEX = /^(https?:\/\/)([\w.-]+)(:[0-9]+)?(\/.*)?$/i;
+function applyFieldTransform(value, transform) {
+  if (value === void 0 || value === null || !transform) {
+    return value;
+  }
+  if (typeof value === "string") {
+    switch (transform) {
+      case "trim":
+        return value.trim();
+      case "lowercase":
+        return value.toLowerCase();
+      case "uppercase":
+        return value.toUpperCase();
+      case "number": {
+        const trimmed = value.trim();
+        if (trimmed === "") return value;
+        const num = Number(trimmed);
+        return Number.isNaN(num) ? value : num;
+      }
+      default:
+        return value;
+    }
+  }
+  if (typeof value === "number" && transform === "number") {
+    return value;
+  }
+  return value;
+}
+function evaluateRule(rule, value, allFormValues) {
+  const isValueEmpty2 = isEmptyValue(value);
+  if (rule.type !== "required" && isValueEmpty2) {
+    return null;
+  }
+  switch (rule.type) {
+    case "required": {
+      if (isValueEmpty2) {
+        return rule.message;
+      }
+      return null;
+    }
+    case "email": {
+      if (typeof value !== "string" || !EMAIL_REGEX.test(value.trim())) {
+        return rule.message;
+      }
+      return null;
+    }
+    case "url": {
+      if (typeof value !== "string" || !URL_REGEX.test(value.trim())) {
+        return rule.message;
+      }
+      return null;
+    }
+    case "min_length": {
+      const min = Number(rule.value);
+      if (Number.isFinite(min)) {
+        if (typeof value === "string" && value.length < min) {
+          return rule.message;
+        }
+        if (Array.isArray(value) && value.length < min) {
+          return rule.message;
+        }
+      }
+      return null;
+    }
+    case "max_length": {
+      const max = Number(rule.value);
+      if (Number.isFinite(max)) {
+        if (typeof value === "string" && value.length > max) {
+          return rule.message;
+        }
+        if (Array.isArray(value) && value.length > max) {
+          return rule.message;
+        }
+      }
+      return null;
+    }
+    case "numeric_min": {
+      const min = Number(rule.value);
+      const num = Number(value);
+      if (Number.isNaN(num) || !Number.isFinite(num) || num < min) {
+        return rule.message;
+      }
+      return null;
+    }
+    case "numeric_max": {
+      const max = Number(rule.value);
+      const num = Number(value);
+      if (Number.isNaN(num) || !Number.isFinite(num) || num > max) {
+        return rule.message;
+      }
+      return null;
+    }
+    case "pattern":
+    case "custom_regex": {
+      try {
+        const patternStr = String(rule.value || "");
+        const regex = new RegExp(patternStr);
+        if (!regex.test(String(value ?? ""))) {
+          return rule.message;
+        }
+      } catch {
+        return rule.message;
+      }
+      return null;
+    }
+    case "match_field": {
+      const targetFieldName = String(rule.value || "");
+      const targetValue = allFormValues?.[targetFieldName];
+      if (value !== targetValue) {
+        return rule.message;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function validateFieldValue(value, rules, allFormValues) {
+  if (!rules || !Array.isArray(rules) || rules.length === 0) {
+    return null;
+  }
+  for (const rule of rules) {
+    const error = evaluateRule(rule, value, allFormValues);
+    if (error) {
+      return error;
+    }
+  }
+  return null;
+}
+async function validateFieldValueAsync(value, rules, allFormValues) {
+  return validateFieldValue(value, rules, allFormValues);
+}
+function validateForm(values, fieldConfigs) {
+  const errors = {};
+  if (!fieldConfigs) {
+    return errors;
+  }
+  if (Array.isArray(fieldConfigs)) {
+    for (const field of fieldConfigs) {
+      if (!field?.name) continue;
+      let value = values?.[field.name];
+      if (field.transform) {
+        value = applyFieldTransform(value, field.transform);
+      }
+      const rules = [...field.rules || []];
+      if (field.required && !rules.some((r) => r.type === "required")) {
+        rules.unshift({
+          type: "required",
+          message: `${field.label || field.name} is required`
+        });
+      }
+      const error = validateFieldValue(value, rules, values);
+      if (error) {
+        errors[field.name] = error;
+      }
+    }
+  } else if (typeof fieldConfigs === "object") {
+    for (const [fieldName, config] of Object.entries(fieldConfigs)) {
+      let value = values?.[fieldName];
+      let rules = [];
+      if (Array.isArray(config)) {
+        rules = config;
+      } else if (config && typeof config === "object") {
+        if (config.transform) {
+          value = applyFieldTransform(value, config.transform);
+        }
+        rules = [...config.rules || []];
+        if (config.required && !rules.some((r) => r.type === "required")) {
+          rules.unshift({
+            type: "required",
+            message: `${config.label || fieldName} is required`
+          });
+        }
+      }
+      const error = validateFieldValue(value, rules, values);
+      if (error) {
+        errors[fieldName] = error;
+      }
+    }
+  }
+  return errors;
+}
+async function validateFormAsync(values, fieldConfigs) {
+  return validateForm(values, fieldConfigs);
+}
+function isFormValid(errors) {
+  return Object.keys(errors).length === 0;
+}
+
+// src/conditional-resolver.ts
+function isConditionGroup(item) {
+  return typeof item === "object" && item !== null && "combinator" in item && "conditions" in item;
+}
+function isValueEmpty(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
+function evaluateOperator(operator, actual, expected, options) {
+  let act = actual;
+  let exp = expected;
+  if (options?.trimStrings) {
+    if (typeof act === "string") act = act.trim();
+    if (typeof exp === "string") exp = exp.trim();
+  }
+  if (options?.caseInsensitive) {
+    if (typeof act === "string") act = act.toLowerCase();
+    if (typeof exp === "string") exp = exp.toLowerCase();
+  }
+  switch (operator) {
+    case "equals": {
+      if (act === exp) return true;
+      if (typeof act === "number" && typeof exp === "string" && exp.trim() !== "") {
+        const numExp = Number(exp);
+        return !Number.isNaN(numExp) && act === numExp;
+      }
+      if (typeof act === "string" && typeof exp === "number" && act.trim() !== "") {
+        const numAct = Number(act);
+        return !Number.isNaN(numAct) && numAct === exp;
+      }
+      if (typeof act === "boolean" && typeof exp === "string") {
+        return act === (exp.toLowerCase() === "true");
+      }
+      if (typeof act === "string" && typeof exp === "boolean") {
+        return act.toLowerCase() === "true" === exp;
+      }
+      return false;
+    }
+    case "not_equals":
+      return !evaluateOperator("equals", actual, expected, options);
+    case "is_truthy":
+      if (Array.isArray(act)) {
+        return act.length > 0;
+      }
+      if (act && typeof act === "object") {
+        return Object.keys(act).length > 0;
+      }
+      return Boolean(act);
+    case "is_falsy":
+      return !evaluateOperator("is_truthy", actual, void 0, options);
+    case "is_empty":
+      return isValueEmpty(actual);
+    case "is_not_empty":
+      return !isValueEmpty(actual);
+    case "contains": {
+      if (typeof act === "string") {
+        const needle = options?.caseInsensitive && typeof exp === "string" ? exp : String(exp ?? "");
+        return act.includes(needle);
+      }
+      if (Array.isArray(act)) {
+        if (options?.caseInsensitive && typeof exp === "string") {
+          return act.some((item) => typeof item === "string" && item.toLowerCase() === exp);
+        }
+        return act.includes(exp);
+      }
+      if (act && typeof act === "object") {
+        return exp !== void 0 && String(exp) in act;
+      }
+      return false;
+    }
+    case "not_contains":
+      return !evaluateOperator("contains", actual, expected, options);
+    case "starts_with": {
+      if (typeof act !== "string") return false;
+      const prefix = options?.caseInsensitive && typeof exp === "string" ? exp : String(exp ?? "");
+      return act.startsWith(prefix);
+    }
+    case "ends_with": {
+      if (typeof act !== "string") return false;
+      const suffix = options?.caseInsensitive && typeof exp === "string" ? exp : String(exp ?? "");
+      return act.endsWith(suffix);
+    }
+    case "gt": {
+      const actNum = Number(act);
+      const expNum = Number(exp);
+      return !Number.isNaN(actNum) && !Number.isNaN(expNum) && actNum > expNum;
+    }
+    case "gte": {
+      const actNum = Number(act);
+      const expNum = Number(exp);
+      return !Number.isNaN(actNum) && !Number.isNaN(expNum) && actNum >= expNum;
+    }
+    case "lt": {
+      const actNum = Number(act);
+      const expNum = Number(exp);
+      return !Number.isNaN(actNum) && !Number.isNaN(expNum) && actNum < expNum;
+    }
+    case "lte": {
+      const actNum = Number(act);
+      const expNum = Number(exp);
+      return !Number.isNaN(actNum) && !Number.isNaN(expNum) && actNum <= expNum;
+    }
+    case "in": {
+      if (Array.isArray(exp)) {
+        if (options?.caseInsensitive && typeof act === "string") {
+          return exp.some((item) => typeof item === "string" && item.toLowerCase() === act);
+        }
+        return exp.includes(act);
+      }
+      if (typeof exp === "string") {
+        return exp.includes(String(act ?? ""));
+      }
+      return false;
+    }
+    case "not_in":
+      return !evaluateOperator("in", actual, expected, options);
+    case "regex": {
+      try {
+        const patternStr = String(exp ?? "");
+        const flags = options?.caseInsensitive ? "i" : "";
+        const regex = new RegExp(patternStr, flags);
+        return regex.test(String(act ?? ""));
+      } catch {
+        return false;
+      }
+    }
+    default:
+      return true;
+  }
+}
+function evaluateCondition(condition, context, options) {
+  if (!condition) return true;
+  const rawField = condition.field;
+  if (!rawField || typeof rawField !== "string") return true;
+  const fieldPath = rawField.replace(/^\{\{\s*/, "").replace(/\s*\}\}$/, "").trim();
+  const actualValue = resolvePropertyPath(context, fieldPath, void 0);
+  return evaluateOperator(condition.operator, actualValue, condition.value, options);
+}
+function evaluateConditionGroup(group, context, options) {
+  if (!group || !Array.isArray(group.conditions) || group.conditions.length === 0) {
+    return true;
+  }
+  const combinator = group.combinator === "or" ? "or" : "and";
+  if (combinator === "and") {
+    return group.conditions.every((item) => {
+      if (isConditionGroup(item)) {
+        return evaluateConditionGroup(item, context, options);
+      }
+      return evaluateCondition(item, context, options);
+    });
+  }
+  return group.conditions.some((item) => {
+    if (isConditionGroup(item)) {
+      return evaluateConditionGroup(item, context, options);
+    }
+    return evaluateCondition(item, context, options);
+  });
+}
+function evaluateConditions(conditions, context, combinator = "and", options) {
+  return evaluateConditionGroup({ combinator, conditions }, context, options);
+}
+
+// src/pipeline-executor.ts
+var ActionTimeoutError = class extends Error {
+  stepId;
+  timeoutMs;
+  constructor(message, timeoutMs, stepId) {
+    super(message);
+    this.name = "ActionTimeoutError";
+    this.timeoutMs = timeoutMs;
+    this.stepId = stepId;
+  }
+};
+var ActionCancellationError = class extends Error {
+  stepId;
+  constructor(message = "Action execution cancelled", stepId) {
+    super(message);
+    this.name = "ActionCancellationError";
+    this.stepId = stepId;
+  }
+};
+function evaluateActionCondition(condition, context) {
+  return evaluateCondition(condition, context);
+}
+function normalizeAbortError(reason, stepId) {
+  if (reason instanceof ActionTimeoutError) {
+    return reason;
+  }
+  if (reason instanceof ActionCancellationError) {
+    return reason;
+  }
+  const msg = reason instanceof Error ? reason.message : "Action execution cancelled";
+  return new ActionCancellationError(msg, stepId);
+}
+function createTimeoutAbortSignal(parentSignal, timeoutMs, timeoutMessage, stepId) {
+  const controller = new AbortController();
+  let timerId;
+  const onParentAbort = () => {
+    controller.abort(normalizeAbortError(parentSignal?.reason, stepId));
+  };
+  if (parentSignal) {
+    if (parentSignal.aborted) {
+      onParentAbort();
+    } else {
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
+    }
+  }
+  if (timeoutMs !== void 0 && timeoutMs > 0) {
+    timerId = setTimeout(() => {
+      controller.abort(
+        new ActionTimeoutError(
+          timeoutMessage || `Action execution timed out after ${timeoutMs}ms`,
+          timeoutMs,
+          stepId
+        )
+      );
+    }, timeoutMs);
+  }
+  const cleanup = () => {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    if (parentSignal) {
+      parentSignal.removeEventListener("abort", onParentAbort);
+    }
+  };
+  return { signal: controller.signal, cleanup };
+}
+var ActionPipelineExecutor = class {
+  handlers = /* @__PURE__ */ new Map();
+  defaultTimeout;
+  throwOnError;
+  constructor(options) {
+    this.defaultTimeout = options?.defaultTimeout;
+    this.throwOnError = options?.throwOnError ?? false;
+    this.registerBuiltInHandlers();
+    if (options?.handlers) {
+      for (const [type, handler] of Object.entries(options.handlers)) {
+        this.registerHandler(type, handler);
+      }
+    }
+  }
+  /**
+   * Registers default built-in handlers for core step types like `set_state` and `reset_form`.
+   */
+  registerBuiltInHandlers() {
+    this.registerHandler("set_state", (step, context) => {
+      const key = String(step.payload?.key || "");
+      const value = step.payload?.value;
+      const scope = String(step.payload?.scope || "runtime");
+      if (!key) return;
+      if (!context.state) context.state = {};
+      if (!context.variables) context.variables = {};
+      if (scope === "runtime" || scope === "document") {
+        context.state[key] = value;
+        context.variables[key] = value;
+      } else {
+        context.state[key] = value;
+      }
+      return { key, value, scope };
+    });
+    this.registerHandler("reset_form", (_step, context) => {
+      if (context.form && typeof context.form === "object") {
+        for (const k of Object.keys(context.form)) {
+          context.form[k] = "";
+        }
+      }
+      return { reset: true };
+    });
+  }
+  /**
+   * Registers a handler for a step type.
+   */
+  registerHandler(type, handler) {
+    this.handlers.set(type, handler);
+    return this;
+  }
+  /**
+   * Unregisters a handler for a step type.
+   */
+  unregisterHandler(type) {
+    this.handlers.delete(type);
+    return this;
+  }
+  /**
+   * Checks if a handler exists for a step type.
+   */
+  hasHandler(type) {
+    return this.handlers.has(type);
+  }
+  /**
+   * Gets the registered handler for a step type.
+   */
+  getHandler(type) {
+    return this.handlers.get(type);
+  }
+  /**
+   * Executes a full ActionPipeline sequentially with support for timeouts, cancellation,
+   * condition evaluation, and branching.
+   */
+  async execute(pipeline, options) {
+    const startTime = Date.now();
+    const context = options?.context ?? {};
+    if (!context.variables) context.variables = {};
+    if (!context.state) context.state = {};
+    if (!context.form) context.form = {};
+    if (!context.stepResults) context.stepResults = {};
+    const timeoutMs = options?.timeout ?? this.defaultTimeout;
+    const { signal, cleanup } = createTimeoutAbortSignal(
+      options?.signal,
+      timeoutMs,
+      `Pipeline "${pipeline.id}" timed out after ${timeoutMs}ms`
+    );
+    let pipelineStatus = "completed";
+    let pipelineError = void 0;
+    const allStepResults = [];
+    try {
+      if (pipeline.enabled === false) {
+        return {
+          pipelineId: pipeline.id,
+          success: true,
+          status: "completed",
+          stepResults: [],
+          context,
+          durationMs: Date.now() - startTime
+        };
+      }
+      const { success, results, error } = await this.executeSteps(
+        pipeline.steps,
+        context,
+        signal,
+        options
+      );
+      allStepResults.push(...results);
+      if (!success) {
+        pipelineStatus = signal.aborted ? "cancelled" : "failed";
+        pipelineError = error;
+      }
+    } catch (err) {
+      pipelineStatus = signal.aborted ? "cancelled" : "failed";
+      pipelineError = err;
+    } finally {
+      cleanup();
+    }
+    const isSuccess = pipelineStatus === "completed";
+    const result = {
+      pipelineId: pipeline.id,
+      success: isSuccess,
+      status: pipelineStatus,
+      stepResults: allStepResults,
+      context,
+      error: pipelineError,
+      durationMs: Date.now() - startTime
+    };
+    const shouldThrow = options?.throwOnError ?? this.throwOnError;
+    if (!isSuccess && shouldThrow) {
+      throw pipelineError || new Error(`Action pipeline "${pipeline.id}" failed`);
+    }
+    return result;
+  }
+  /**
+   * Executes an ordered list of ActionSteps sequentially.
+   */
+  async executeSteps(steps, context, parentSignal, options) {
+    const results = [];
+    for (const step of steps) {
+      if (parentSignal.aborted) {
+        const cancelError = normalizeAbortError(parentSignal.reason, step.id);
+        const cancelledResult = {
+          stepId: step.id,
+          stepType: step.type,
+          status: "cancelled",
+          error: cancelError,
+          durationMs: 0
+        };
+        results.push(cancelledResult);
+        context.stepResults[step.id] = cancelledResult;
+        return { success: false, results, error: cancelError };
+      }
+      const stepResult = await this.executeSingleStep(step, context, parentSignal, options);
+      results.push(stepResult);
+      context.stepResults[step.id] = stepResult;
+      if (stepResult.status === "error" || stepResult.status === "cancelled") {
+        if (!step.continueOnError) {
+          return { success: false, results, error: stepResult.error };
+        }
+      }
+    }
+    return { success: true, results };
+  }
+  /**
+   * Executes a single ActionStep with condition checking, payload interpolation, timeout,
+   * handler execution, response context passing, and branch execution.
+   */
+  async executeSingleStep(step, context, parentSignal, options) {
+    const stepStartTime = Date.now();
+    if (step.condition && !evaluateActionCondition(step.condition, context)) {
+      const skippedResult = {
+        stepId: step.id,
+        stepType: step.type,
+        status: "skipped",
+        durationMs: Date.now() - stepStartTime
+      };
+      options?.onStepComplete?.(step, skippedResult, context);
+      return skippedResult;
+    }
+    options?.onStepStart?.(step, context);
+    const stepTimeout = step.timeout;
+    const { signal: stepSignal, cleanup: cleanupStepSignal } = createTimeoutAbortSignal(
+      parentSignal,
+      stepTimeout,
+      `Step "${step.id}" timed out after ${stepTimeout}ms`,
+      step.id
+    );
+    const rawPayload = step.payload || {};
+    const interpolatedPayload = interpolateValue(rawPayload, context) || {};
+    const resolvedStep = {
+      ...step,
+      payload: interpolatedPayload
+    };
+    const customHandler = options?.handlers?.[step.type];
+    const handler = customHandler || this.getHandler(step.type);
+    let stepOutput;
+    let stepError;
+    let stepStatus = "success";
+    const subResults = [];
+    try {
+      if (!handler) {
+        throw new Error(`No handler registered for action step type: "${step.type}"`);
+      }
+      if (stepSignal.aborted) {
+        throw normalizeAbortError(stepSignal.reason, step.id);
+      }
+      stepOutput = await handler(resolvedStep, context, stepSignal);
+      if (stepOutput !== void 0) {
+        context.response = stepOutput;
+      }
+      delete context.lastError;
+      if (interpolatedPayload.responseMapping && typeof interpolatedPayload.responseMapping === "object") {
+        const mapping = interpolatedPayload.responseMapping;
+        for (const [targetVar, sourcePath] of Object.entries(mapping)) {
+          const evalContext = {
+            ...context,
+            response: stepOutput !== void 0 ? stepOutput : context.response
+          };
+          const cleanPath = String(sourcePath).replace(/^\{\{\s*/, "").replace(/\s*\}\}$/, "").trim();
+          const mappedVal = resolvePropertyPath(evalContext, cleanPath, void 0);
+          if (mappedVal !== void 0) {
+            if (!context.variables) context.variables = {};
+            context.variables[targetVar] = mappedVal;
+          }
+        }
+      }
+      if (step.onSuccess && Array.isArray(step.onSuccess) && step.onSuccess.length > 0) {
+        const successBranch = await this.executeSteps(
+          step.onSuccess,
+          context,
+          stepSignal,
+          options
+        );
+        subResults.push(...successBranch.results);
+        if (!successBranch.success) {
+          stepStatus = "error";
+          stepError = successBranch.error;
+        }
+      }
+    } catch (err) {
+      stepError = err;
+      stepStatus = stepSignal.aborted ? "cancelled" : "error";
+      context.lastError = err;
+      context.error = err;
+      if (step.onError && Array.isArray(step.onError) && step.onError.length > 0) {
+        try {
+          const errorBranch = await this.executeSteps(
+            step.onError,
+            context,
+            parentSignal,
+            // Use parent signal so error branch can run even if step timed out
+            options
+          );
+          subResults.push(...errorBranch.results);
+        } catch (onErrorErr) {
+        }
+      }
+    } finally {
+      cleanupStepSignal();
+    }
+    const result = {
+      stepId: step.id,
+      stepType: step.type,
+      status: stepStatus,
+      data: stepOutput,
+      error: stepError,
+      durationMs: Date.now() - stepStartTime,
+      ...subResults.length > 0 ? { subResults } : {}
+    };
+    options?.onStepComplete?.(step, result, context);
+    return result;
+  }
+};
+async function executeActionPipeline(pipeline, options) {
+  const executor = new ActionPipelineExecutor();
+  return executor.execute(pipeline, options);
+}
+
+// src/state-store.ts
+var FORBIDDEN_KEY_SEGMENTS4 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function createDefaultFormState(initialValues) {
+  const init = initialValues ? { ...initialValues } : {};
+  return {
+    values: { ...init },
+    errors: {},
+    touched: {},
+    isSubmitting: false,
+    isValid: true,
+    dirty: false,
+    initialValues: { ...init }
+  };
+}
+function cloneState(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => cloneState(item));
+  }
+  const copy = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (!FORBIDDEN_KEY_SEGMENTS4.has(k)) {
+      copy[k] = cloneState(v);
+    }
+  }
+  return copy;
+}
+function setNestedPath(target, path, value) {
+  if (!path || typeof path !== "string" || !target || typeof target !== "object") {
+    return false;
+  }
+  const normalized = path.replace(/\[(\d+)\]/g, ".$1");
+  const segments = normalized.split(".").map((s) => s.trim()).filter(Boolean);
+  if (segments.length === 0) return false;
+  let current = target;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (FORBIDDEN_KEY_SEGMENTS4.has(seg)) return false;
+    if (current[seg] === void 0 || current[seg] === null || typeof current[seg] !== "object") {
+      current[seg] = {};
+    }
+    current = current[seg];
+  }
+  const lastSeg = segments[segments.length - 1];
+  if (FORBIDDEN_KEY_SEGMENTS4.has(lastSeg)) return false;
+  current[lastSeg] = value;
+  return true;
+}
+function deleteNestedPath(target, path) {
+  if (!path || typeof path !== "string" || !target || typeof target !== "object") {
+    return false;
+  }
+  const normalized = path.replace(/\[(\d+)\]/g, ".$1");
+  const segments = normalized.split(".").map((s) => s.trim()).filter(Boolean);
+  if (segments.length === 0) return false;
+  let current = target;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (FORBIDDEN_KEY_SEGMENTS4.has(seg) || !(seg in current) || typeof current[seg] !== "object") {
+      return false;
+    }
+    current = current[seg];
+  }
+  const lastSeg = segments[segments.length - 1];
+  if (FORBIDDEN_KEY_SEGMENTS4.has(lastSeg) || !(lastSeg in current)) {
+    return false;
+  }
+  delete current[lastSeg];
+  return true;
+}
+var RuntimeStateStore = class _RuntimeStateStore {
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  pathListeners = /* @__PURE__ */ new Map();
+  formListeners = /* @__PURE__ */ new Map();
+  isBatching = false;
+  batchOldState;
+  isNotifying = false;
+  constructor(initialState) {
+    this.state = {
+      variables: initialState?.variables ? { ...initialState.variables } : {},
+      forms: initialState?.forms ? cloneState(initialState.forms) : {},
+      state: initialState?.state ? { ...initialState.state } : {},
+      ...initialState
+    };
+  }
+  /**
+   * Retrieves a value at a specified path or the entire state snapshot.
+   */
+  get(path, fallback) {
+    if (!path || path.trim() === "") {
+      return this.getSnapshot();
+    }
+    const cleanPath = path.replace(/^\{\{\s*/, "").replace(/\s*\}\}$/, "").trim();
+    const resolved = resolvePropertyPath(this.state, cleanPath, fallback);
+    return resolved;
+  }
+  /**
+   * Gets an immutable snapshot of the current state.
+   */
+  getSnapshot() {
+    return cloneState(this.state);
+  }
+  /**
+   * Sets a value at a dotted path and notifies subscribers.
+   */
+  set(path, value) {
+    if (!path) return this;
+    const oldState = this.isBatching ? void 0 : cloneState(this.state);
+    const cleanPath = path.replace(/^\{\{\s*/, "").replace(/\s*\}\}$/, "").trim();
+    const success = setNestedPath(this.state, cleanPath, value);
+    if (!success) return this;
+    if (!this.isBatching && oldState) {
+      this.notifyChanges(oldState, this.state);
+    }
+    return this;
+  }
+  /**
+   * Performs multiple updates atomically, triggering subscriber notifications once.
+   */
+  setBatch(updates) {
+    if (!updates || typeof updates !== "object") return this;
+    const oldState = this.batchOldState || cloneState(this.state);
+    this.isBatching = true;
+    this.batchOldState = oldState;
+    try {
+      for (const [path, value] of Object.entries(updates)) {
+        this.set(path, value);
+      }
+    } finally {
+      this.isBatching = false;
+      this.batchOldState = void 0;
+      this.notifyChanges(oldState, this.state);
+    }
+    return this;
+  }
+  /**
+   * Deletes a property at the specified path.
+   */
+  delete(path) {
+    if (!path) return false;
+    const oldState = this.isBatching ? void 0 : cloneState(this.state);
+    const cleanPath = path.replace(/^\{\{\s*/, "").replace(/\s*\}\}$/, "").trim();
+    const deleted = deleteNestedPath(this.state, cleanPath);
+    if (deleted && !this.isBatching && oldState) {
+      this.notifyChanges(oldState, this.state);
+    }
+    return deleted;
+  }
+  /**
+   * Resets the store state to an initial or clean state.
+   */
+  reset(initialState) {
+    const oldState = cloneState(this.state);
+    this.state = {
+      variables: initialState?.variables ? { ...initialState.variables } : {},
+      forms: initialState?.forms ? cloneState(initialState.forms) : {},
+      state: initialState?.state ? { ...initialState.state } : {},
+      ...initialState
+    };
+    this.notifyChanges(oldState, this.state);
+    return this;
+  }
+  /**
+   * Subscribes a listener to any state changes.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Subscribes a listener to changes on a top-level key.
+   */
+  subscribeKey(key, listener) {
+    return this.subscribePath(key, listener);
+  }
+  /**
+   * Subscribes a listener to changes at a specific dotted path.
+   */
+  subscribePath(path, listener) {
+    const cleanPath = path.replace(/^\{\{\s*/, "").replace(/\s*\}\}$/, "").trim();
+    if (!this.pathListeners.has(cleanPath)) {
+      this.pathListeners.set(cleanPath, /* @__PURE__ */ new Set());
+    }
+    const set = this.pathListeners.get(cleanPath);
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+      if (set.size === 0) {
+        this.pathListeners.delete(cleanPath);
+      }
+    };
+  }
+  /**
+   * Subscribes a listener to changes of a specific form state.
+   */
+  subscribeForm(formId, listener) {
+    if (!this.formListeners.has(formId)) {
+      this.formListeners.set(formId, /* @__PURE__ */ new Set());
+    }
+    const set = this.formListeners.get(formId);
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+      if (set.size === 0) {
+        this.formListeners.delete(formId);
+      }
+    };
+  }
+  /**
+   * Notifies all relevant listeners when state changes.
+   */
+  notifyChanges(oldState, newState) {
+    if (this.isNotifying) return;
+    this.isNotifying = true;
+    try {
+      const readOnlyNew = Object.freeze(cloneState(newState));
+      const readOnlyOld = Object.freeze(cloneState(oldState));
+      for (const listener of this.listeners) {
+        try {
+          listener(readOnlyNew, readOnlyOld);
+        } catch {
+        }
+      }
+      for (const [path, listeners] of this.pathListeners.entries()) {
+        const oldVal = resolvePropertyPath(oldState, path, void 0);
+        const newVal = resolvePropertyPath(newState, path, void 0);
+        if (oldVal !== newVal) {
+          for (const listener of listeners) {
+            try {
+              listener(newVal, oldVal);
+            } catch {
+            }
+          }
+        }
+      }
+      for (const [formId, listeners] of this.formListeners.entries()) {
+        const oldForm = oldState.forms?.[formId];
+        const newForm = newState.forms?.[formId];
+        if (oldForm !== newForm) {
+          for (const listener of listeners) {
+            try {
+              listener(newForm || createDefaultFormState(), oldForm);
+            } catch {
+            }
+          }
+        }
+      }
+    } finally {
+      this.isNotifying = false;
+    }
+  }
+  // ==========================================
+  // Form State Management Helpers
+  // ==========================================
+  /**
+   * Retrieves the FormState for a formId, initializing default form state if not present.
+   */
+  getForm(formId) {
+    if (!this.state.forms[formId]) {
+      this.state.forms[formId] = createDefaultFormState();
+    }
+    return this.state.forms[formId];
+  }
+  /**
+   * Updates a single field value in a form and marks dirty if changed from initial.
+   */
+  setFormFieldValue(formId, fieldName, value) {
+    const form = this.getForm(formId);
+    const oldValues = { ...form.values };
+    form.values[fieldName] = value;
+    const initialVal = form.initialValues?.[fieldName];
+    form.dirty = Object.keys(form.values).some((k) => form.values[k] !== form.initialValues?.[k]);
+    this.set(`forms.${formId}.values.${fieldName}`, value);
+    return this;
+  }
+  /**
+   * Sets or clears an error for a form field.
+   */
+  setFormFieldError(formId, fieldName, error) {
+    const form = this.getForm(formId);
+    if (error) {
+      form.errors[fieldName] = error;
+    } else {
+      delete form.errors[fieldName];
+    }
+    form.isValid = Object.keys(form.errors).length === 0;
+    this.set(`forms.${formId}.errors`, { ...form.errors });
+    this.set(`forms.${formId}.isValid`, form.isValid);
+    return this;
+  }
+  /**
+   * Marks a form field as touched (or untouched).
+   */
+  setFormFieldTouched(formId, fieldName, touched = true) {
+    const form = this.getForm(formId);
+    form.touched[fieldName] = touched;
+    this.set(`forms.${formId}.touched.${fieldName}`, touched);
+    return this;
+  }
+  /**
+   * Updates multiple form errors simultaneously.
+   */
+  setFormErrors(formId, errors) {
+    const form = this.getForm(formId);
+    form.errors = { ...errors };
+    form.isValid = Object.keys(errors).length === 0;
+    this.set(`forms.${formId}.errors`, form.errors);
+    this.set(`forms.${formId}.isValid`, form.isValid);
+    return this;
+  }
+  /**
+   * Sets multiple form field values simultaneously.
+   */
+  setFormValues(formId, values, replace = false) {
+    const form = this.getForm(formId);
+    form.values = replace ? { ...values } : { ...form.values, ...values };
+    form.dirty = Object.keys(form.values).some((k) => form.values[k] !== form.initialValues?.[k]);
+    this.set(`forms.${formId}.values`, { ...form.values });
+    this.set(`forms.${formId}.dirty`, form.dirty);
+    return this;
+  }
+  /**
+   * Sets the submitting status of a form.
+   */
+  setFormSubmitting(formId, isSubmitting) {
+    const form = this.getForm(formId);
+    form.isSubmitting = isSubmitting;
+    this.set(`forms.${formId}.isSubmitting`, isSubmitting);
+    return this;
+  }
+  /**
+   * Resets a form's values, errors, touched, and submitting state to defaults or specified values.
+   */
+  resetForm(formId, initialValues) {
+    const newFormState = createDefaultFormState(
+      initialValues || this.state.forms[formId]?.initialValues
+    );
+    this.set(`forms.${formId}`, newFormState);
+    return this;
+  }
+  // ==========================================
+  // Scoping & Isolation
+  // ==========================================
+  /**
+   * Creates an isolated child scope store for a page or component container.
+   */
+  createScope(scopeId, initialValues) {
+    const scopedState = {
+      variables: { ...initialValues || {} },
+      forms: {},
+      state: {}
+    };
+    return new _RuntimeStateStore(scopedState);
+  }
+};
+function createRuntimeStore(initialState) {
+  return new RuntimeStateStore(initialState);
+}
 export {
+  ActionCancellationError,
+  ActionPipelineExecutor,
+  ActionTimeoutError,
   CORE_BUILTIN_COMPONENTS,
   DEFAULT_DOCUMENT_SECURITY_LIMITS,
   DEFAULT_MAX_HISTORY,
@@ -3552,6 +4844,8 @@ export {
   DocumentHistoryManager,
   HistoryEngine,
   MigrationRegistry,
+  RuntimeStateStore,
+  applyFieldTransform,
   areNodeIdsCompletelyDistinct,
   buildSampleVariablesFromCatalog,
   calculateChecksum,
@@ -3565,16 +4859,26 @@ export {
   compareManifestsSemantically,
   containsProhibitedKeys,
   createBlankDocument,
+  createDefaultFormState,
+  createRuntimeStore,
   createTemplateRecord,
   deepClone,
   defaultIdGenerator,
   defaultMigrationRegistry,
   defaultRenameAssetStrategy,
   duplicateNode,
+  evaluateActionCondition,
+  evaluateCondition,
+  evaluateConditionGroup,
+  evaluateConditions,
+  evaluateOperator,
+  evaluateRule,
+  executeActionPipeline,
   exportPackage,
   exportStoraPackage,
   extractRequirementsFromTree,
   extractTemplateRequirements,
+  extractTemplateVariables,
   findMissingComponentNodes,
   findNodeById,
   findNodeLocation,
@@ -3583,14 +4887,21 @@ export {
   getNavigationTarget,
   getNodeAncestors,
   getParentNodeId,
+  hasTemplateExpressions,
   importPackage,
   importStoraPackage,
   insertNode,
   inspectPackage,
+  interpolateTemplateString,
+  interpolateValue,
+  isConditionGroup,
   isDangerousAssetFilename,
   isDangerousPath,
   isDescendantOf,
+  isEmptyValue,
+  isFormValid,
   isSafeUrl,
+  isValueEmpty,
   migrateDocument,
   moveNode,
   preflightPackage,
@@ -3600,15 +4911,23 @@ export {
   removeNode,
   resolveBinding,
   resolveBindingValue,
+  resolvePropertyPath,
   sanitizeFilename,
   sanitizeHtml,
   sanitizeUrl,
   saveDraftAsTemplate,
   sha256Sync,
+  updateActions,
+  updateAnimation,
+  updateFormConfig,
   updateProps,
   updateStyle,
   validateDocument,
   validateDocumentSecurity,
+  validateFieldValue,
+  validateFieldValueAsync,
+  validateForm,
+  validateFormAsync,
   validateTemplate
 };
 //# sourceMappingURL=index.js.map