@kubuild/schema 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -20,103 +20,462 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ACTION_PIPELINE_JSON_SCHEMA_V1: () => ACTION_PIPELINE_JSON_SCHEMA_V1,
   ActionBindingSchema: () => ActionBindingSchema,
+  ActionPipelineSchema: () => ActionPipelineSchema,
+  ActionStepConditionSchema: () => ActionStepConditionSchema,
+  ActionStepSchema: () => ActionStepSchema,
+  ActionStepTypeSchema: () => ActionStepTypeSchema,
+  ActionTriggerSchema: () => ActionTriggerSchema,
+  ActionTriggerTypeSchema: () => ActionTriggerTypeSchema,
   AnimationConfigSchema: () => AnimationConfigSchema,
+  ApiRequestStepPayloadSchema: () => ApiRequestStepPayloadSchema,
   AssetReferenceSchema: () => AssetReferenceSchema,
   CURRENT_SCHEMA_VERSION: () => CURRENT_SCHEMA_VERSION,
+  CloseModalStepPayloadSchema: () => CloseModalStepPayloadSchema,
+  ConditionOperatorSchema: () => ConditionOperatorSchema,
+  CopyClipboardStepPayloadSchema: () => CopyClipboardStepPayloadSchema,
+  CustomEventStepPayloadSchema: () => CustomEventStepPayloadSchema,
   DEFAULT_ANIMATION_CONFIG: () => DEFAULT_ANIMATION_CONFIG,
   DocumentMetadataSchema: () => DocumentMetadataSchema,
+  FORM_CONFIG_JSON_SCHEMA_V1: () => FORM_CONFIG_JSON_SCHEMA_V1,
+  FORM_FIELD_BINDING_JSON_SCHEMA_V1: () => FORM_FIELD_BINDING_JSON_SCHEMA_V1,
+  FormConfigSchema: () => FormConfigSchema,
+  FormFieldBindingSchema: () => FormFieldBindingSchema,
   MANIFEST_JSON_SCHEMA_V1: () => MANIFEST_JSON_SCHEMA_V1,
   ManifestAssetItemSchema: () => ManifestAssetItemSchema,
   ManifestSchema: () => ManifestSchema,
+  NavigateStepPayloadSchema: () => NavigateStepPayloadSchema,
   NodeSchema: () => NodeSchema,
+  OpenModalStepPayloadSchema: () => OpenModalStepPayloadSchema,
   PAGE_DOCUMENT_JSON_SCHEMA_V1: () => PAGE_DOCUMENT_JSON_SCHEMA_V1,
   PageDocumentSchema: () => PageDocumentSchema,
   PseudoStateStylesSchema: () => PseudoStateStylesSchema,
+  ResetFormStepPayloadSchema: () => ResetFormStepPayloadSchema,
   ResponsiveStylesSchema: () => ResponsiveStylesSchema,
   RootPageNodeSchema: () => RootPageNodeSchema,
   SCHEMA_NAME: () => SCHEMA_NAME,
   SafeThumbnailObjectSchema: () => SafeThumbnailObjectSchema,
   SafeThumbnailSchema: () => SafeThumbnailSchema,
   SafeThumbnailUrlSchema: () => SafeThumbnailUrlSchema,
+  SetStateStepPayloadSchema: () => SetStateStepPayloadSchema,
+  ShowToastStepPayloadSchema: () => ShowToastStepPayloadSchema,
+  StepPayloadSchemas: () => StepPayloadSchemas,
   StyleDefinitionSchema: () => StyleDefinitionSchema,
   StyleValueSchema: () => StyleValueSchema,
   TEMPLATE_RECORD_JSON_SCHEMA_V1: () => TEMPLATE_RECORD_JSON_SCHEMA_V1,
   TemplatePackageRefSchema: () => TemplatePackageRefSchema,
   TemplateRecordSchema: () => TemplateRecordSchema,
   TemplateRequirementsSchema: () => TemplateRequirementsSchema,
+  ValidateOnEventSchema: () => ValidateOnEventSchema,
+  ValidationRuleSchema: () => ValidationRuleSchema,
+  ValidationRuleTypeSchema: () => ValidationRuleTypeSchema,
   VariableBindingSchema: () => VariableBindingSchema,
   collectNodeIds: () => collectNodeIds,
   generateDeterministicNodeId: () => generateDeterministicNodeId,
+  getActionPipelineJsonSchema: () => getActionPipelineJsonSchema,
+  getFormConfigJsonSchema: () => getFormConfigJsonSchema,
+  getFormFieldBindingJsonSchema: () => getFormFieldBindingJsonSchema,
   getManifestJsonSchema: () => getManifestJsonSchema,
   getPageDocumentJsonSchema: () => getPageDocumentJsonSchema,
   getTemplateRecordJsonSchema: () => getTemplateRecordJsonSchema,
   isActionBinding: () => isActionBinding,
+  isActionPipeline: () => isActionPipeline,
+  isActionStep: () => isActionStep,
+  isActionStepCondition: () => isActionStepCondition,
+  isActionStepType: () => isActionStepType,
+  isActionTriggerType: () => isActionTriggerType,
   isAnimationConfig: () => isAnimationConfig,
   isAssetReference: () => isAssetReference,
+  isConditionOperator: () => isConditionOperator,
+  isFormConfig: () => isFormConfig,
+  isFormFieldBinding: () => isFormFieldBinding,
   isManifest: () => isManifest,
+  isSafeActionUrl: () => isSafeActionUrl,
   isSafeThumbnail: () => isSafeThumbnail,
   isSafeThumbnailUrl: () => isSafeThumbnailUrl,
   isTemplateRecord: () => isTemplateRecord,
+  isValidateOnEvent: () => isValidateOnEvent,
+  isValidationRule: () => isValidationRule,
+  isValidationRuleType: () => isValidationRuleType,
   isVariableBinding: () => isVariableBinding,
+  sanitizeActionPayload: () => sanitizeActionPayload,
+  sanitizeActionPipeline: () => sanitizeActionPipeline,
+  sanitizeActionStep: () => sanitizeActionStep,
+  sanitizeActionString: () => sanitizeActionString,
+  sanitizeActionUrl: () => sanitizeActionUrl,
+  sanitizeActionValue: () => sanitizeActionValue,
   starterPageFixture: () => starterPageFixture,
+  validateActionStepPayload: () => validateActionStepPayload,
   validateNodeIdUniqueness: () => validateNodeIdUniqueness
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/document.ts
+var import_zod3 = require("zod");
+
+// src/actions.ts
 var import_zod = require("zod");
+var ActionTriggerTypeSchema = import_zod.z.enum([
+  "click",
+  "submit",
+  "change",
+  "blur",
+  "focus",
+  "load"
+]);
+var ActionTriggerSchema = ActionTriggerTypeSchema;
+var ActionStepTypeSchema = import_zod.z.enum([
+  "api_request",
+  "navigate",
+  "set_state",
+  "reset_form",
+  "show_toast",
+  "open_modal",
+  "close_modal",
+  "copy_clipboard",
+  "custom_event"
+]);
+var ConditionOperatorSchema = import_zod.z.enum([
+  "equals",
+  "not_equals",
+  "contains",
+  "not_contains",
+  "is_truthy",
+  "is_falsy",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "regex"
+]);
+var ActionStepConditionSchema = import_zod.z.object({
+  field: import_zod.z.string().min(1, "Condition field cannot be empty"),
+  operator: ConditionOperatorSchema,
+  value: import_zod.z.unknown().optional()
+});
+var DANGEROUS_URL_PATTERN = /(javascript:|vbscript:|data:text\/html)/i;
+var DANGEROUS_SCRIPT_PATTERN = /<\s*script/i;
+function isSafeActionUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  const trimmed = url.trim();
+  if (DANGEROUS_URL_PATTERN.test(trimmed)) return false;
+  if (DANGEROUS_SCRIPT_PATTERN.test(trimmed)) return false;
+  return true;
+}
+var SafeUrlStringSchema = import_zod.z.string().min(1, "URL cannot be empty").refine(isSafeActionUrl, {
+  message: "URL contains disallowed or unsafe protocol/script pattern"
+});
+var SafeEventNameSchema = import_zod.z.string().min(1, "Event name cannot be empty").regex(/^[a-zA-Z0-9_\-:]+$/, {
+  message: "Event name must contain only alphanumeric characters, dashes, colons, or underscores"
+});
+var ApiRequestStepPayloadSchema = import_zod.z.object({
+  url: SafeUrlStringSchema,
+  method: import_zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).default("GET"),
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  queryParams: import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()])).optional(),
+  body: import_zod.z.union([import_zod.z.string(), import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()), import_zod.z.array(import_zod.z.unknown())]).optional(),
+  bodyFormat: import_zod.z.enum(["json", "form-data", "formData", "urlencoded", "url-encoded", "raw", "text"]).optional(),
+  bodyType: import_zod.z.enum(["json", "form-data", "formData", "urlencoded", "url-encoded", "raw", "text"]).optional(),
+  timeout: import_zod.z.number().positive("Timeout must be greater than 0 ms").optional(),
+  responseMapping: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+});
+var NavigateStepPayloadSchema = import_zod.z.object({
+  url: SafeUrlStringSchema,
+  target: import_zod.z.enum(["_self", "_blank", "_parent", "_top"]).optional().default("_self"),
+  replace: import_zod.z.boolean().optional(),
+  scroll: import_zod.z.boolean().optional(),
+  behavior: import_zod.z.enum(["smooth", "auto"]).optional()
+});
+var SetStateStepPayloadSchema = import_zod.z.object({
+  key: import_zod.z.string().min(1, "State key cannot be empty"),
+  value: import_zod.z.unknown(),
+  scope: import_zod.z.enum(["runtime", "document", "session", "local"]).optional().default("runtime")
+});
+var ResetFormStepPayloadSchema = import_zod.z.object({
+  formId: import_zod.z.string().optional()
+});
+var ShowToastStepPayloadSchema = import_zod.z.object({
+  message: import_zod.z.string().min(1, "Toast message cannot be empty"),
+  type: import_zod.z.enum(["success", "error", "warning", "info"]).optional().default("info"),
+  variant: import_zod.z.enum(["success", "error", "warning", "info"]).optional(),
+  title: import_zod.z.string().optional(),
+  duration: import_zod.z.number().nonnegative("Duration must be >= 0 ms").optional(),
+  position: import_zod.z.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"]).optional()
+});
+var OpenModalStepPayloadSchema = import_zod.z.object({
+  modalId: import_zod.z.string().optional(),
+  modalNodeId: import_zod.z.string().optional()
+}).refine((data) => Boolean(data.modalId || data.modalNodeId), {
+  message: "Modal ID or Modal Node ID cannot be empty"
+});
+var CloseModalStepPayloadSchema = import_zod.z.object({
+  modalId: import_zod.z.string().optional(),
+  modalNodeId: import_zod.z.string().optional()
+});
+var CopyClipboardStepPayloadSchema = import_zod.z.object({
+  text: import_zod.z.string().optional(),
+  value: import_zod.z.unknown().optional(),
+  notify: import_zod.z.boolean().optional(),
+  toastMessage: import_zod.z.string().optional()
+});
+var CustomEventStepPayloadSchema = import_zod.z.object({
+  eventName: SafeEventNameSchema,
+  detail: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  bubbles: import_zod.z.boolean().optional().default(true),
+  cancelable: import_zod.z.boolean().optional().default(true)
+});
+var StepPayloadSchemas = {
+  api_request: ApiRequestStepPayloadSchema,
+  navigate: NavigateStepPayloadSchema,
+  set_state: SetStateStepPayloadSchema,
+  reset_form: ResetFormStepPayloadSchema,
+  show_toast: ShowToastStepPayloadSchema,
+  open_modal: OpenModalStepPayloadSchema,
+  close_modal: CloseModalStepPayloadSchema,
+  copy_clipboard: CopyClipboardStepPayloadSchema,
+  custom_event: CustomEventStepPayloadSchema
+};
+var ActionStepSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    id: import_zod.z.string().min(1, "Step ID cannot be empty"),
+    type: ActionStepTypeSchema,
+    label: import_zod.z.string().optional(),
+    payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().default({}),
+    condition: ActionStepConditionSchema.optional(),
+    timeout: import_zod.z.number().positive().optional(),
+    continueOnError: import_zod.z.boolean().optional(),
+    onSuccess: import_zod.z.array(ActionStepSchema).optional(),
+    onError: import_zod.z.array(ActionStepSchema).optional()
+  })
+);
+var ActionPipelineSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1, "Pipeline ID cannot be empty"),
+  trigger: ActionTriggerTypeSchema,
+  label: import_zod.z.string().optional(),
+  debounceMs: import_zod.z.number().nonnegative("Debounce ms must be >= 0").optional(),
+  preventDuplicate: import_zod.z.boolean().optional(),
+  enabled: import_zod.z.boolean().optional().default(true),
+  steps: import_zod.z.array(ActionStepSchema).min(1, "Action pipeline must contain at least one step")
+});
+function isActionTriggerType(value) {
+  return ActionTriggerTypeSchema.safeParse(value).success;
+}
+function isActionStepType(value) {
+  return ActionStepTypeSchema.safeParse(value).success;
+}
+function isConditionOperator(value) {
+  return ConditionOperatorSchema.safeParse(value).success;
+}
+function isActionStepCondition(value) {
+  return ActionStepConditionSchema.safeParse(value).success;
+}
+function isActionStep(value) {
+  return ActionStepSchema.safeParse(value).success;
+}
+function isActionPipeline(value) {
+  return ActionPipelineSchema.safeParse(value).success;
+}
+function validateActionStepPayload(type, payload) {
+  const schema = StepPayloadSchemas[type];
+  if (!schema) {
+    return {
+      success: false,
+      error: new import_zod.z.ZodError([
+        {
+          code: import_zod.z.ZodIssueCode.custom,
+          message: `Unknown step type: ${type}`,
+          path: ["type"]
+        }
+      ])
+    };
+  }
+  const result = schema.safeParse(payload);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+function sanitizeActionUrl(url, fallback = "") {
+  if (typeof url !== "string") return fallback;
+  const trimmed = url.trim();
+  if (!isSafeActionUrl(trimmed)) {
+    return fallback;
+  }
+  return trimmed;
+}
+function sanitizeActionString(value, fallback = "") {
+  if (typeof value !== "string") return fallback;
+  if (DANGEROUS_SCRIPT_PATTERN.test(value)) {
+    return value.replace(/<\s*script[^>]*>[\s\S]*?<\s*\/\s*script\s*>/gi, "").replace(/<\s*script[^>]*>/gi, "");
+  }
+  return value;
+}
+function sanitizeActionValue(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (DANGEROUS_URL_PATTERN.test(trimmed)) {
+      return "";
+    }
+    return sanitizeActionString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeActionValue(item));
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (/^(url|href|src|endpoint|targetUrl)$/i.test(k) && typeof v === "string") {
+        result[k] = sanitizeActionUrl(v);
+      } else {
+        result[k] = sanitizeActionValue(v);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+function sanitizeActionPayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return {};
+  }
+  return sanitizeActionValue(payload);
+}
+function sanitizeActionStep(step) {
+  const sanitized = {
+    ...step,
+    label: step.label ? sanitizeActionString(step.label) : step.label,
+    payload: sanitizeActionPayload(step.payload)
+  };
+  if (step.condition && step.condition.value !== void 0) {
+    sanitized.condition = {
+      ...step.condition,
+      value: sanitizeActionValue(step.condition.value)
+    };
+  }
+  if (step.onSuccess && Array.isArray(step.onSuccess)) {
+    sanitized.onSuccess = step.onSuccess.map((s) => sanitizeActionStep(s));
+  }
+  if (step.onError && Array.isArray(step.onError)) {
+    sanitized.onError = step.onError.map((s) => sanitizeActionStep(s));
+  }
+  return sanitized;
+}
+function sanitizeActionPipeline(pipeline) {
+  return {
+    ...pipeline,
+    label: pipeline.label ? sanitizeActionString(pipeline.label) : pipeline.label,
+    steps: Array.isArray(pipeline.steps) ? pipeline.steps.map((s) => sanitizeActionStep(s)) : []
+  };
+}
+
+// src/form.ts
+var import_zod2 = require("zod");
+var ValidationRuleTypeSchema = import_zod2.z.enum([
+  "required",
+  "email",
+  "url",
+  "min_length",
+  "max_length",
+  "numeric_min",
+  "numeric_max",
+  "pattern",
+  "match_field",
+  "custom_regex"
+]);
+var ValidateOnEventSchema = import_zod2.z.enum(["blur", "change", "submit"]);
+var ValidationRuleSchema = import_zod2.z.object({
+  type: ValidationRuleTypeSchema,
+  value: import_zod2.z.unknown().optional(),
+  message: import_zod2.z.string().min(1, "Validation error message cannot be empty")
+});
+var FormFieldBindingSchema = import_zod2.z.object({
+  name: import_zod2.z.string().min(1, "Field name cannot be empty"),
+  label: import_zod2.z.string().optional(),
+  defaultValue: import_zod2.z.unknown().optional(),
+  rules: import_zod2.z.array(ValidationRuleSchema).optional().default([]),
+  validateOn: ValidateOnEventSchema.optional().default("blur"),
+  transform: import_zod2.z.enum(["trim", "lowercase", "uppercase", "number"]).optional(),
+  disabled: import_zod2.z.boolean().optional(),
+  required: import_zod2.z.boolean().optional()
+});
+var FormConfigSchema = import_zod2.z.object({
+  formId: import_zod2.z.string().min(1, "Form ID cannot be empty"),
+  resetOnSubmit: import_zod2.z.boolean().optional().default(false),
+  scrollToFirstError: import_zod2.z.boolean().optional().default(true),
+  validateOn: ValidateOnEventSchema.optional().default("blur"),
+  initialValues: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+  rules: import_zod2.z.array(ValidationRuleSchema).optional()
+});
+function isValidationRuleType(value) {
+  return ValidationRuleTypeSchema.safeParse(value).success;
+}
+function isValidationRule(value) {
+  return ValidationRuleSchema.safeParse(value).success;
+}
+function isValidateOnEvent(value) {
+  return ValidateOnEventSchema.safeParse(value).success;
+}
+function isFormFieldBinding(value) {
+  return FormFieldBindingSchema.safeParse(value).success;
+}
+function isFormConfig(value) {
+  return FormConfigSchema.safeParse(value).success;
+}
+
+// src/document.ts
 var SCHEMA_NAME = "stora.page";
 var CURRENT_SCHEMA_VERSION = "1.0.0";
-var AssetReferenceSchema = import_zod.z.object({
-  type: import_zod.z.literal("asset"),
-  assetId: import_zod.z.string().min(1, "Asset ID cannot be empty"),
-  filename: import_zod.z.string().optional(),
-  mimeType: import_zod.z.string().optional(),
-  fallbackUrl: import_zod.z.string().url().optional()
+var AssetReferenceSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("asset"),
+  assetId: import_zod3.z.string().min(1, "Asset ID cannot be empty"),
+  filename: import_zod3.z.string().optional(),
+  mimeType: import_zod3.z.string().optional(),
+  fallbackUrl: import_zod3.z.string().url().optional()
 });
-var VariableBindingSchema = import_zod.z.object({
-  type: import_zod.z.literal("variable"),
-  key: import_zod.z.string().min(1, "Variable key cannot be empty"),
-  fallback: import_zod.z.unknown().optional()
+var VariableBindingSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("variable"),
+  key: import_zod3.z.string().min(1, "Variable key cannot be empty"),
+  fallback: import_zod3.z.unknown().optional()
 });
-var ActionBindingSchema = import_zod.z.object({
-  type: import_zod.z.string().min(1, "Action type cannot be empty"),
-  payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+var ActionBindingSchema = import_zod3.z.object({
+  type: import_zod3.z.string().min(1, "Action type cannot be empty"),
+  payload: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
 });
 var DANGEROUS_STYLE_VALUE_PATTERN = /javascript:|expression\(|@import|<script|vbscript:|data:text\/html/i;
-var StyleValueSchema = import_zod.z.union([
-  import_zod.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+var StyleValueSchema = import_zod3.z.union([
+  import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Style value contains a disallowed or unsafe pattern"
   }),
-  import_zod.z.number(),
-  import_zod.z.boolean(),
-  import_zod.z.null(),
-  import_zod.z.undefined()
+  import_zod3.z.number(),
+  import_zod3.z.boolean(),
+  import_zod3.z.null(),
+  import_zod3.z.undefined()
 ]);
-var StyleDefinitionSchema = import_zod.z.record(import_zod.z.string(), StyleValueSchema);
-var PseudoStateStylesSchema = import_zod.z.record(import_zod.z.string(), StyleDefinitionSchema);
-var ResponsiveStylesSchema = import_zod.z.object({
+var StyleDefinitionSchema = import_zod3.z.record(import_zod3.z.string(), StyleValueSchema);
+var PseudoStateStylesSchema = import_zod3.z.record(import_zod3.z.string(), StyleDefinitionSchema);
+var ResponsiveStylesSchema = import_zod3.z.object({
   base: StyleDefinitionSchema.optional(),
   desktop: StyleDefinitionSchema.optional(),
   tablet: StyleDefinitionSchema.optional(),
   mobile: StyleDefinitionSchema.optional(),
   states: PseudoStateStylesSchema.optional()
 }).passthrough().default({});
-var AnimationConfigSchema = import_zod.z.object({
-  type: import_zod.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+var AnimationConfigSchema = import_zod3.z.object({
+  type: import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Animation type contains a disallowed or unsafe pattern"
   }).optional().default("none"),
-  duration: import_zod.z.number().min(0, "Duration must be non-negative").optional().default(600),
-  delay: import_zod.z.number().min(0, "Delay must be non-negative").optional().default(0),
-  easing: import_zod.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+  duration: import_zod3.z.number().min(0, "Duration must be non-negative").optional().default(600),
+  delay: import_zod3.z.number().min(0, "Delay must be non-negative").optional().default(0),
+  easing: import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Animation easing contains a disallowed or unsafe pattern"
   }).optional().default("ease-out"),
-  once: import_zod.z.boolean().optional().default(true),
-  hoverEffect: import_zod.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+  once: import_zod3.z.boolean().optional().default(true),
+  hoverEffect: import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Hover effect contains a disallowed or unsafe pattern"
   }).optional().default("none"),
-  loopEffect: import_zod.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+  loopEffect: import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Loop effect contains a disallowed or unsafe pattern"
   }).optional().default("none")
 });
@@ -129,14 +488,16 @@ var DEFAULT_ANIMATION_CONFIG = {
   hoverEffect: "none",
   loopEffect: "none"
 };
-var NodeSchema = import_zod.z.lazy(
-  () => import_zod.z.object({
-    id: import_zod.z.string().min(1, "Node ID must be a non-empty string"),
-    type: import_zod.z.string().min(1, "Node type must be a non-empty string"),
-    props: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().default({}),
+var NodeSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    id: import_zod3.z.string().min(1, "Node ID must be a non-empty string"),
+    type: import_zod3.z.string().min(1, "Node type must be a non-empty string"),
+    props: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional().default({}),
     styles: ResponsiveStylesSchema.optional().default({}),
     animation: AnimationConfigSchema.optional(),
-    children: import_zod.z.array(NodeSchema).optional().default([])
+    actions: import_zod3.z.array(ActionPipelineSchema).optional(),
+    formConfig: FormConfigSchema.optional(),
+    children: import_zod3.z.array(NodeSchema).optional().default([])
   })
 );
 var RootPageNodeSchema = NodeSchema.refine(
@@ -146,20 +507,20 @@ var RootPageNodeSchema = NodeSchema.refine(
     path: ["type"]
   }
 );
-var DocumentMetadataSchema = import_zod.z.object({
-  title: import_zod.z.string().min(1, "Title is required").default("Untitled Page"),
-  description: import_zod.z.string().optional().default(""),
-  author: import_zod.z.string().optional().default(""),
-  createdAt: import_zod.z.string().optional(),
-  updatedAt: import_zod.z.string().optional(),
-  tags: import_zod.z.array(import_zod.z.string()).optional().default([]),
-  category: import_zod.z.string().optional().default("general"),
-  version: import_zod.z.string().optional().default("1.0.0"),
-  custom: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+var DocumentMetadataSchema = import_zod3.z.object({
+  title: import_zod3.z.string().min(1, "Title is required").default("Untitled Page"),
+  description: import_zod3.z.string().optional().default(""),
+  author: import_zod3.z.string().optional().default(""),
+  createdAt: import_zod3.z.string().optional(),
+  updatedAt: import_zod3.z.string().optional(),
+  tags: import_zod3.z.array(import_zod3.z.string()).optional().default([]),
+  category: import_zod3.z.string().optional().default("general"),
+  version: import_zod3.z.string().optional().default("1.0.0"),
+  custom: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
 });
-var PageDocumentSchema = import_zod.z.object({
-  schema: import_zod.z.literal(SCHEMA_NAME),
-  version: import_zod.z.string().min(1, "Schema version is required").default(CURRENT_SCHEMA_VERSION),
+var PageDocumentSchema = import_zod3.z.object({
+  schema: import_zod3.z.literal(SCHEMA_NAME),
+  version: import_zod3.z.string().min(1, "Schema version is required").default(CURRENT_SCHEMA_VERSION),
   metadata: DocumentMetadataSchema.optional(),
   document: RootPageNodeSchema
 });
@@ -206,30 +567,30 @@ function validateNodeIdUniqueness(node) {
 }
 
 // src/manifest.ts
-var import_zod2 = require("zod");
-var ManifestAssetItemSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1, "Asset ID cannot be empty"),
-  path: import_zod2.z.string().min(1, "Asset archive path cannot be empty"),
-  mimeType: import_zod2.z.string().min(1, "MIME type cannot be empty"),
-  size: import_zod2.z.number().nonnegative("Asset size must be non-negative"),
-  checksum: import_zod2.z.string().optional()
+var import_zod4 = require("zod");
+var ManifestAssetItemSchema = import_zod4.z.object({
+  id: import_zod4.z.string().min(1, "Asset ID cannot be empty"),
+  path: import_zod4.z.string().min(1, "Asset archive path cannot be empty"),
+  mimeType: import_zod4.z.string().min(1, "MIME type cannot be empty"),
+  size: import_zod4.z.number().nonnegative("Asset size must be non-negative"),
+  checksum: import_zod4.z.string().optional()
 });
-var ManifestSchema = import_zod2.z.object({
-  schema: import_zod2.z.literal(SCHEMA_NAME).default(SCHEMA_NAME),
-  schemaVersion: import_zod2.z.string().min(1, "Schema version cannot be empty").default("1.0.0"),
-  packageVersion: import_zod2.z.string().min(1, "Package version cannot be empty").default("1.0.0"),
-  builderCompatibility: import_zod2.z.string().default(">=0.1.0"),
-  requiredComponents: import_zod2.z.array(import_zod2.z.string()).default([]),
-  requiredCapabilities: import_zod2.z.array(import_zod2.z.string()).default([]),
-  assets: import_zod2.z.array(ManifestAssetItemSchema).default([]),
-  createdAt: import_zod2.z.string().optional()
+var ManifestSchema = import_zod4.z.object({
+  schema: import_zod4.z.literal(SCHEMA_NAME).default(SCHEMA_NAME),
+  schemaVersion: import_zod4.z.string().min(1, "Schema version cannot be empty").default("1.0.0"),
+  packageVersion: import_zod4.z.string().min(1, "Package version cannot be empty").default("1.0.0"),
+  builderCompatibility: import_zod4.z.string().default(">=0.1.0"),
+  requiredComponents: import_zod4.z.array(import_zod4.z.string()).default([]),
+  requiredCapabilities: import_zod4.z.array(import_zod4.z.string()).default([]),
+  assets: import_zod4.z.array(ManifestAssetItemSchema).default([]),
+  createdAt: import_zod4.z.string().optional()
 });
 function isManifest(value) {
   return ManifestSchema.safeParse(value).success;
 }
 
 // src/template.ts
-var import_zod3 = require("zod");
+var import_zod5 = require("zod");
 var DANGEROUS_URI_PATTERN = /^(javascript:|vbscript:|data:(?!image\/))|<script/i;
 function isSafeThumbnailUrl(url) {
   if (!url || typeof url !== "string") return false;
@@ -238,49 +599,49 @@ function isSafeThumbnailUrl(url) {
   if (DANGEROUS_URI_PATTERN.test(trimmed)) return false;
   return true;
 }
-var SafeThumbnailUrlSchema = import_zod3.z.string().min(1, "Thumbnail URL cannot be empty").refine(
+var SafeThumbnailUrlSchema = import_zod5.z.string().min(1, "Thumbnail URL cannot be empty").refine(
   (url) => isSafeThumbnailUrl(url),
   { message: "Thumbnail URL contains an unsafe protocol or payload" }
 );
-var SafeThumbnailObjectSchema = import_zod3.z.object({
+var SafeThumbnailObjectSchema = import_zod5.z.object({
   url: SafeThumbnailUrlSchema,
-  alt: import_zod3.z.string().optional(),
-  width: import_zod3.z.number().positive().optional(),
-  height: import_zod3.z.number().positive().optional()
+  alt: import_zod5.z.string().optional(),
+  width: import_zod5.z.number().positive().optional(),
+  height: import_zod5.z.number().positive().optional()
 });
-var SafeThumbnailSchema = import_zod3.z.union([
+var SafeThumbnailSchema = import_zod5.z.union([
   AssetReferenceSchema,
   SafeThumbnailObjectSchema,
   SafeThumbnailUrlSchema
 ]);
-var TemplatePackageRefSchema = import_zod3.z.object({
-  path: import_zod3.z.string().optional(),
+var TemplatePackageRefSchema = import_zod5.z.object({
+  path: import_zod5.z.string().optional(),
   url: SafeThumbnailUrlSchema.optional(),
-  checksum: import_zod3.z.string().optional(),
-  format: import_zod3.z.enum(["stora", "json"]).default("stora")
+  checksum: import_zod5.z.string().optional(),
+  format: import_zod5.z.enum(["stora", "json"]).default("stora")
 });
-var TemplateRequirementsSchema = import_zod3.z.object({
-  requiredComponents: import_zod3.z.array(import_zod3.z.string()).default([]),
-  requiredCapabilities: import_zod3.z.array(import_zod3.z.string()).default([])
+var TemplateRequirementsSchema = import_zod5.z.object({
+  requiredComponents: import_zod5.z.array(import_zod5.z.string()).default([]),
+  requiredCapabilities: import_zod5.z.array(import_zod5.z.string()).default([])
 });
-var TemplateRecordSchema = import_zod3.z.object({
-  id: import_zod3.z.string().min(1, "Template ID must be a non-empty string"),
-  name: import_zod3.z.string().min(1, "Template name must be a non-empty string"),
-  description: import_zod3.z.string().optional().default(""),
-  category: import_zod3.z.string().optional().default("general"),
-  tags: import_zod3.z.array(import_zod3.z.string()).optional().default([]),
+var TemplateRecordSchema = import_zod5.z.object({
+  id: import_zod5.z.string().min(1, "Template ID must be a non-empty string"),
+  name: import_zod5.z.string().min(1, "Template name must be a non-empty string"),
+  description: import_zod5.z.string().optional().default(""),
+  category: import_zod5.z.string().optional().default("general"),
+  tags: import_zod5.z.array(import_zod5.z.string()).optional().default([]),
   thumbnail: SafeThumbnailSchema.optional(),
-  author: import_zod3.z.string().optional().default(""),
-  version: import_zod3.z.string().optional().default("1.0.0"),
+  author: import_zod5.z.string().optional().default(""),
+  version: import_zod5.z.string().optional().default("1.0.0"),
   document: PageDocumentSchema.optional(),
   packageReference: TemplatePackageRefSchema.optional(),
   requirements: TemplateRequirementsSchema.default({
     requiredComponents: [],
     requiredCapabilities: []
   }),
-  createdAt: import_zod3.z.string().optional(),
-  updatedAt: import_zod3.z.string().optional(),
-  custom: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  createdAt: import_zod5.z.string().optional(),
+  updatedAt: import_zod5.z.string().optional(),
+  custom: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional()
 });
 function isTemplateRecord(value) {
   return TemplateRecordSchema.safeParse(value).success;
@@ -600,6 +961,111 @@ var PAGE_DOCUMENT_JSON_SCHEMA_V1 = {
       },
       additionalProperties: false
     },
+    actionStep: {
+      type: "object",
+      required: ["id", "type"],
+      properties: {
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        type: {
+          type: "string",
+          enum: [
+            "api_request",
+            "navigate",
+            "set_state",
+            "reset_form",
+            "show_toast",
+            "open_modal",
+            "close_modal",
+            "copy_clipboard",
+            "custom_event"
+          ]
+        },
+        label: { type: "string" },
+        payload: { type: "object" },
+        condition: {
+          type: "object",
+          required: ["field", "operator"],
+          properties: {
+            field: { type: "string", minLength: 1 },
+            operator: {
+              type: "string",
+              enum: [
+                "equals",
+                "not_equals",
+                "contains",
+                "not_contains",
+                "is_truthy",
+                "is_falsy",
+                "gt",
+                "gte",
+                "lt",
+                "lte",
+                "regex"
+              ]
+            },
+            value: {}
+          },
+          additionalProperties: false
+        },
+        timeout: { type: "number", minimum: 1 },
+        continueOnError: { type: "boolean" },
+        onSuccess: {
+          type: "array",
+          items: { $ref: "#/definitions/actionStep" }
+        },
+        onError: {
+          type: "array",
+          items: { $ref: "#/definitions/actionStep" }
+        }
+      },
+      additionalProperties: false
+    },
+    actionPipeline: {
+      type: "object",
+      required: ["id", "trigger", "steps"],
+      properties: {
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        trigger: {
+          type: "string",
+          enum: ["click", "submit", "change", "blur", "focus", "load"]
+        },
+        label: { type: "string" },
+        debounceMs: { type: "number", minimum: 0 },
+        preventDuplicate: { type: "boolean" },
+        enabled: { type: "boolean", default: true },
+        steps: {
+          type: "array",
+          items: { $ref: "#/definitions/actionStep" },
+          minItems: 1
+        }
+      },
+      additionalProperties: false
+    },
+    formConfig: {
+      type: "object",
+      required: ["formId"],
+      properties: {
+        formId: {
+          type: "string",
+          minLength: 1
+        },
+        resetOnSubmit: { type: "boolean", default: false },
+        scrollToFirstError: { type: "boolean", default: true },
+        validateOn: {
+          type: "string",
+          enum: ["blur", "change", "submit"],
+          default: "blur"
+        },
+        initialValues: { type: "object" }
+      },
+      additionalProperties: false
+    },
     node: {
       type: "object",
       required: ["id", "type"],
@@ -625,6 +1091,17 @@ var PAGE_DOCUMENT_JSON_SCHEMA_V1 = {
         animation: {
           $ref: "#/definitions/animationConfig"
         },
+        actions: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/actionPipeline"
+          },
+          description: "Multi-step action pipelines bound to component events"
+        },
+        formConfig: {
+          $ref: "#/definitions/formConfig",
+          description: "Form container configuration and behavior"
+        },
         children: {
           type: "array",
           items: {
@@ -961,48 +1438,326 @@ var TEMPLATE_RECORD_JSON_SCHEMA_V1 = {
 function getTemplateRecordJsonSchema() {
   return TEMPLATE_RECORD_JSON_SCHEMA_V1;
 }
+var ACTION_PIPELINE_JSON_SCHEMA_V1 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://schema.stora.page/v1/action-pipeline.json",
+  title: "StoraActionPipeline",
+  description: "Action Pipeline schema definition for KUBUILD event workflows",
+  type: "object",
+  required: ["id", "trigger", "steps"],
+  additionalProperties: false,
+  properties: {
+    id: {
+      type: "string",
+      minLength: 1,
+      description: "Unique pipeline identifier"
+    },
+    trigger: {
+      type: "string",
+      enum: ["click", "submit", "change", "blur", "focus", "load"],
+      description: "DOM or component event that triggers the action pipeline"
+    },
+    label: {
+      type: "string",
+      description: "Human readable label for the action pipeline"
+    },
+    debounceMs: {
+      type: "number",
+      minimum: 0,
+      description: "Debounce duration in milliseconds"
+    },
+    preventDuplicate: {
+      type: "boolean",
+      description: "Prevent concurrent duplicate pipeline executions"
+    },
+    enabled: {
+      type: "boolean",
+      default: true,
+      description: "Whether the pipeline is currently active"
+    },
+    steps: {
+      type: "array",
+      items: { $ref: "#/definitions/actionStep" },
+      minItems: 1,
+      description: "Ordered sequence of action steps to execute"
+    }
+  },
+  definitions: {
+    actionStep: {
+      type: "object",
+      required: ["id", "type"],
+      properties: {
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        type: {
+          type: "string",
+          enum: [
+            "api_request",
+            "navigate",
+            "set_state",
+            "reset_form",
+            "show_toast",
+            "open_modal",
+            "close_modal",
+            "copy_clipboard",
+            "custom_event"
+          ]
+        },
+        label: { type: "string" },
+        payload: { type: "object" },
+        condition: {
+          type: "object",
+          required: ["field", "operator"],
+          properties: {
+            field: { type: "string", minLength: 1 },
+            operator: {
+              type: "string",
+              enum: [
+                "equals",
+                "not_equals",
+                "contains",
+                "not_contains",
+                "is_truthy",
+                "is_falsy",
+                "gt",
+                "gte",
+                "lt",
+                "lte",
+                "regex"
+              ]
+            },
+            value: {}
+          },
+          additionalProperties: false
+        },
+        timeout: { type: "number", minimum: 1 },
+        continueOnError: { type: "boolean" },
+        onSuccess: {
+          type: "array",
+          items: { $ref: "#/definitions/actionStep" }
+        },
+        onError: {
+          type: "array",
+          items: { $ref: "#/definitions/actionStep" }
+        }
+      },
+      additionalProperties: false
+    }
+  }
+};
+function getActionPipelineJsonSchema() {
+  return ACTION_PIPELINE_JSON_SCHEMA_V1;
+}
+var FORM_CONFIG_JSON_SCHEMA_V1 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://schema.stora.page/v1/form-config.json",
+  title: "StoraFormConfig",
+  description: "Form container configuration and behavior definition for KUBUILD",
+  type: "object",
+  required: ["formId"],
+  additionalProperties: false,
+  properties: {
+    formId: {
+      type: "string",
+      minLength: 1,
+      description: "Unique identifier for the form boundary"
+    },
+    resetOnSubmit: {
+      type: "boolean",
+      default: false,
+      description: "Whether to reset form field values after successful submission"
+    },
+    scrollToFirstError: {
+      type: "boolean",
+      default: true,
+      description: "Auto-scroll viewport to the first invalid input on validation failure"
+    },
+    validateOn: {
+      type: "string",
+      enum: ["blur", "change", "submit"],
+      default: "blur",
+      description: "Default trigger event for field validation evaluation"
+    },
+    initialValues: {
+      type: "object",
+      description: "Initial state values populated in form fields"
+    }
+  }
+};
+function getFormConfigJsonSchema() {
+  return FORM_CONFIG_JSON_SCHEMA_V1;
+}
+var FORM_FIELD_BINDING_JSON_SCHEMA_V1 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://schema.stora.page/v1/form-field-binding.json",
+  title: "StoraFormFieldBinding",
+  description: "Form field binding definition connecting input elements to form state runtime",
+  type: "object",
+  required: ["name"],
+  additionalProperties: false,
+  properties: {
+    name: {
+      type: "string",
+      minLength: 1,
+      description: "Field state property key"
+    },
+    label: {
+      type: "string",
+      description: "Display label for the field"
+    },
+    defaultValue: {
+      description: "Initial default value if not overridden by form initialValues"
+    },
+    rules: {
+      type: "array",
+      items: { $ref: "#/definitions/validationRule" },
+      default: [],
+      description: "Validation rules applied to the field value"
+    },
+    validateOn: {
+      type: "string",
+      enum: ["blur", "change", "submit"],
+      default: "blur",
+      description: "Field-specific validation trigger timing"
+    },
+    transform: {
+      type: "string",
+      enum: ["trim", "lowercase", "uppercase", "number"],
+      description: "Value transformation applied prior to validation and state storage"
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the field is disabled"
+    },
+    required: {
+      type: "boolean",
+      description: "Whether the field is required (shorthand rule)"
+    }
+  },
+  definitions: {
+    validationRule: {
+      type: "object",
+      required: ["type", "message"],
+      properties: {
+        type: {
+          type: "string",
+          enum: [
+            "required",
+            "email",
+            "url",
+            "min_length",
+            "max_length",
+            "numeric_min",
+            "numeric_max",
+            "pattern",
+            "match_field",
+            "custom_regex"
+          ]
+        },
+        value: {},
+        message: {
+          type: "string",
+          minLength: 1
+        }
+      },
+      additionalProperties: false
+    }
+  }
+};
+function getFormFieldBindingJsonSchema() {
+  return FORM_FIELD_BINDING_JSON_SCHEMA_V1;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACTION_PIPELINE_JSON_SCHEMA_V1,
   ActionBindingSchema,
+  ActionPipelineSchema,
+  ActionStepConditionSchema,
+  ActionStepSchema,
+  ActionStepTypeSchema,
+  ActionTriggerSchema,
+  ActionTriggerTypeSchema,
   AnimationConfigSchema,
+  ApiRequestStepPayloadSchema,
   AssetReferenceSchema,
   CURRENT_SCHEMA_VERSION,
+  CloseModalStepPayloadSchema,
+  ConditionOperatorSchema,
+  CopyClipboardStepPayloadSchema,
+  CustomEventStepPayloadSchema,
   DEFAULT_ANIMATION_CONFIG,
   DocumentMetadataSchema,
+  FORM_CONFIG_JSON_SCHEMA_V1,
+  FORM_FIELD_BINDING_JSON_SCHEMA_V1,
+  FormConfigSchema,
+  FormFieldBindingSchema,
   MANIFEST_JSON_SCHEMA_V1,
   ManifestAssetItemSchema,
   ManifestSchema,
+  NavigateStepPayloadSchema,
   NodeSchema,
+  OpenModalStepPayloadSchema,
   PAGE_DOCUMENT_JSON_SCHEMA_V1,
   PageDocumentSchema,
   PseudoStateStylesSchema,
+  ResetFormStepPayloadSchema,
   ResponsiveStylesSchema,
   RootPageNodeSchema,
   SCHEMA_NAME,
   SafeThumbnailObjectSchema,
   SafeThumbnailSchema,
   SafeThumbnailUrlSchema,
+  SetStateStepPayloadSchema,
+  ShowToastStepPayloadSchema,
+  StepPayloadSchemas,
   StyleDefinitionSchema,
   StyleValueSchema,
   TEMPLATE_RECORD_JSON_SCHEMA_V1,
   TemplatePackageRefSchema,
   TemplateRecordSchema,
   TemplateRequirementsSchema,
+  ValidateOnEventSchema,
+  ValidationRuleSchema,
+  ValidationRuleTypeSchema,
   VariableBindingSchema,
   collectNodeIds,
   generateDeterministicNodeId,
+  getActionPipelineJsonSchema,
+  getFormConfigJsonSchema,
+  getFormFieldBindingJsonSchema,
   getManifestJsonSchema,
   getPageDocumentJsonSchema,
   getTemplateRecordJsonSchema,
   isActionBinding,
+  isActionPipeline,
+  isActionStep,
+  isActionStepCondition,
+  isActionStepType,
+  isActionTriggerType,
   isAnimationConfig,
   isAssetReference,
+  isConditionOperator,
+  isFormConfig,
+  isFormFieldBinding,
   isManifest,
+  isSafeActionUrl,
   isSafeThumbnail,
   isSafeThumbnailUrl,
   isTemplateRecord,
+  isValidateOnEvent,
+  isValidationRule,
+  isValidationRuleType,
   isVariableBinding,
+  sanitizeActionPayload,
+  sanitizeActionPipeline,
+  sanitizeActionStep,
+  sanitizeActionString,
+  sanitizeActionUrl,
+  sanitizeActionValue,
   starterPageFixture,
+  validateActionStepPayload,
   validateNodeIdUniqueness
 });
 //# sourceMappingURL=index.cjs.map