@kubuild/schema 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,56 +1,369 @@
 // src/document.ts
+import { z as z3 } from "zod";
+
+// src/actions.ts
 import { z } from "zod";
+var ActionTriggerTypeSchema = z.enum([
+  "click",
+  "submit",
+  "change",
+  "blur",
+  "focus",
+  "load"
+]);
+var ActionTriggerSchema = ActionTriggerTypeSchema;
+var ActionStepTypeSchema = z.enum([
+  "api_request",
+  "navigate",
+  "set_state",
+  "reset_form",
+  "show_toast",
+  "open_modal",
+  "close_modal",
+  "copy_clipboard",
+  "custom_event"
+]);
+var ConditionOperatorSchema = z.enum([
+  "equals",
+  "not_equals",
+  "contains",
+  "not_contains",
+  "is_truthy",
+  "is_falsy",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "regex"
+]);
+var ActionStepConditionSchema = z.object({
+  field: z.string().min(1, "Condition field cannot be empty"),
+  operator: ConditionOperatorSchema,
+  value: 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 = z.string().min(1, "URL cannot be empty").refine(isSafeActionUrl, {
+  message: "URL contains disallowed or unsafe protocol/script pattern"
+});
+var SafeEventNameSchema = 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 = z.object({
+  url: SafeUrlStringSchema,
+  method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).default("GET"),
+  headers: z.record(z.string(), z.string()).optional(),
+  queryParams: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+  body: z.union([z.string(), z.record(z.string(), z.unknown()), z.array(z.unknown())]).optional(),
+  bodyFormat: z.enum(["json", "form-data", "formData", "urlencoded", "url-encoded", "raw", "text"]).optional(),
+  bodyType: z.enum(["json", "form-data", "formData", "urlencoded", "url-encoded", "raw", "text"]).optional(),
+  timeout: z.number().positive("Timeout must be greater than 0 ms").optional(),
+  responseMapping: z.record(z.string(), z.string()).optional()
+});
+var NavigateStepPayloadSchema = z.object({
+  url: SafeUrlStringSchema,
+  target: z.enum(["_self", "_blank", "_parent", "_top"]).optional().default("_self"),
+  replace: z.boolean().optional(),
+  scroll: z.boolean().optional(),
+  behavior: z.enum(["smooth", "auto"]).optional()
+});
+var SetStateStepPayloadSchema = z.object({
+  key: z.string().min(1, "State key cannot be empty"),
+  value: z.unknown(),
+  scope: z.enum(["runtime", "document", "session", "local"]).optional().default("runtime")
+});
+var ResetFormStepPayloadSchema = z.object({
+  formId: z.string().optional()
+});
+var ShowToastStepPayloadSchema = z.object({
+  message: z.string().min(1, "Toast message cannot be empty"),
+  type: z.enum(["success", "error", "warning", "info"]).optional().default("info"),
+  variant: z.enum(["success", "error", "warning", "info"]).optional(),
+  title: z.string().optional(),
+  duration: z.number().nonnegative("Duration must be >= 0 ms").optional(),
+  position: z.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"]).optional()
+});
+var OpenModalStepPayloadSchema = z.object({
+  modalId: z.string().optional(),
+  modalNodeId: z.string().optional(),
+  toggle: z.boolean().optional()
+}).refine((data) => Boolean(data.modalId || data.modalNodeId), {
+  message: "Modal ID or Modal Node ID cannot be empty"
+});
+var CloseModalStepPayloadSchema = z.object({
+  modalId: z.string().optional(),
+  modalNodeId: z.string().optional()
+});
+var CopyClipboardStepPayloadSchema = z.object({
+  text: z.string().optional(),
+  value: z.unknown().optional(),
+  notify: z.boolean().optional(),
+  toastMessage: z.string().optional()
+});
+var CustomEventStepPayloadSchema = z.object({
+  eventName: SafeEventNameSchema,
+  detail: z.record(z.string(), z.unknown()).optional(),
+  bubbles: z.boolean().optional().default(true),
+  cancelable: 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 = z.lazy(
+  () => z.object({
+    id: z.string().min(1, "Step ID cannot be empty"),
+    type: ActionStepTypeSchema,
+    label: z.string().optional(),
+    payload: z.record(z.string(), z.unknown()).optional().default({}),
+    condition: ActionStepConditionSchema.optional(),
+    timeout: z.number().positive().optional(),
+    continueOnError: z.boolean().optional(),
+    onSuccess: z.array(ActionStepSchema).optional(),
+    onError: z.array(ActionStepSchema).optional()
+  })
+);
+var ActionPipelineSchema = z.object({
+  id: z.string().min(1, "Pipeline ID cannot be empty"),
+  trigger: ActionTriggerTypeSchema,
+  label: z.string().optional(),
+  debounceMs: z.number().nonnegative("Debounce ms must be >= 0").optional(),
+  preventDuplicate: z.boolean().optional(),
+  enabled: z.boolean().optional().default(true),
+  steps: 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 z.ZodError([
+        {
+          code: 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
+import { z as z2 } from "zod";
+var ValidationRuleTypeSchema = z2.enum([
+  "required",
+  "email",
+  "url",
+  "min_length",
+  "max_length",
+  "numeric_min",
+  "numeric_max",
+  "pattern",
+  "match_field",
+  "custom_regex"
+]);
+var ValidateOnEventSchema = z2.enum(["blur", "change", "submit"]);
+var ValidationRuleSchema = z2.object({
+  type: ValidationRuleTypeSchema,
+  value: z2.unknown().optional(),
+  message: z2.string().min(1, "Validation error message cannot be empty")
+});
+var FormFieldBindingSchema = z2.object({
+  name: z2.string().min(1, "Field name cannot be empty"),
+  label: z2.string().optional(),
+  defaultValue: z2.unknown().optional(),
+  rules: z2.array(ValidationRuleSchema).optional().default([]),
+  validateOn: ValidateOnEventSchema.optional().default("blur"),
+  transform: z2.enum(["trim", "lowercase", "uppercase", "number"]).optional(),
+  disabled: z2.boolean().optional(),
+  required: z2.boolean().optional()
+});
+var FormConfigSchema = z2.object({
+  formId: z2.string().min(1, "Form ID cannot be empty"),
+  resetOnSubmit: z2.boolean().optional().default(false),
+  scrollToFirstError: z2.boolean().optional().default(true),
+  validateOn: ValidateOnEventSchema.optional().default("blur"),
+  initialValues: z2.record(z2.string(), z2.unknown()).optional(),
+  rules: z2.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 = z.object({
-  type: z.literal("asset"),
-  assetId: z.string().min(1, "Asset ID cannot be empty"),
-  filename: z.string().optional(),
-  mimeType: z.string().optional(),
-  fallbackUrl: z.string().url().optional()
+var AssetReferenceSchema = z3.object({
+  type: z3.literal("asset"),
+  assetId: z3.string().min(1, "Asset ID cannot be empty"),
+  filename: z3.string().optional(),
+  mimeType: z3.string().optional(),
+  fallbackUrl: z3.string().url().optional()
 });
-var VariableBindingSchema = z.object({
-  type: z.literal("variable"),
-  key: z.string().min(1, "Variable key cannot be empty"),
-  fallback: z.unknown().optional()
+var VariableBindingSchema = z3.object({
+  type: z3.literal("variable"),
+  key: z3.string().min(1, "Variable key cannot be empty"),
+  fallback: z3.unknown().optional()
 });
-var ActionBindingSchema = z.object({
-  type: z.string().min(1, "Action type cannot be empty"),
-  payload: z.record(z.string(), z.unknown()).optional()
+var ActionBindingSchema = z3.object({
+  type: z3.string().min(1, "Action type cannot be empty"),
+  payload: z3.record(z3.string(), z3.unknown()).optional()
 });
 var DANGEROUS_STYLE_VALUE_PATTERN = /javascript:|expression\(|@import|<script|vbscript:|data:text\/html/i;
-var StyleValueSchema = z.union([
-  z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+var StyleValueSchema = z3.union([
+  z3.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Style value contains a disallowed or unsafe pattern"
   }),
-  z.number(),
-  z.boolean(),
-  z.null(),
-  z.undefined()
+  z3.number(),
+  z3.boolean(),
+  z3.null(),
+  z3.undefined()
 ]);
-var StyleDefinitionSchema = z.record(z.string(), StyleValueSchema);
-var PseudoStateStylesSchema = z.record(z.string(), StyleDefinitionSchema);
-var ResponsiveStylesSchema = z.object({
+var StyleDefinitionSchema = z3.record(z3.string(), StyleValueSchema);
+var PseudoStateStylesSchema = z3.record(z3.string(), StyleDefinitionSchema);
+var ResponsiveStylesSchema = z3.object({
   base: StyleDefinitionSchema.optional(),
   desktop: StyleDefinitionSchema.optional(),
   tablet: StyleDefinitionSchema.optional(),
   mobile: StyleDefinitionSchema.optional(),
   states: PseudoStateStylesSchema.optional()
 }).passthrough().default({});
-var AnimationConfigSchema = z.object({
-  type: z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+var AnimationConfigSchema = z3.object({
+  type: z3.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Animation type contains a disallowed or unsafe pattern"
   }).optional().default("none"),
-  duration: z.number().min(0, "Duration must be non-negative").optional().default(600),
-  delay: z.number().min(0, "Delay must be non-negative").optional().default(0),
-  easing: z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+  duration: z3.number().min(0, "Duration must be non-negative").optional().default(600),
+  delay: z3.number().min(0, "Delay must be non-negative").optional().default(0),
+  easing: z3.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Animation easing contains a disallowed or unsafe pattern"
   }).optional().default("ease-out"),
-  once: z.boolean().optional().default(true),
-  hoverEffect: z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+  once: z3.boolean().optional().default(true),
+  hoverEffect: z3.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Hover effect contains a disallowed or unsafe pattern"
   }).optional().default("none"),
-  loopEffect: z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+  loopEffect: z3.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Loop effect contains a disallowed or unsafe pattern"
   }).optional().default("none")
 });
@@ -63,14 +376,16 @@ var DEFAULT_ANIMATION_CONFIG = {
   hoverEffect: "none",
   loopEffect: "none"
 };
-var NodeSchema = z.lazy(
-  () => z.object({
-    id: z.string().min(1, "Node ID must be a non-empty string"),
-    type: z.string().min(1, "Node type must be a non-empty string"),
-    props: z.record(z.string(), z.unknown()).optional().default({}),
+var NodeSchema = z3.lazy(
+  () => z3.object({
+    id: z3.string().min(1, "Node ID must be a non-empty string"),
+    type: z3.string().min(1, "Node type must be a non-empty string"),
+    props: z3.record(z3.string(), z3.unknown()).optional().default({}),
     styles: ResponsiveStylesSchema.optional().default({}),
     animation: AnimationConfigSchema.optional(),
-    children: z.array(NodeSchema).optional().default([])
+    actions: z3.array(ActionPipelineSchema).optional(),
+    formConfig: FormConfigSchema.optional(),
+    children: z3.array(NodeSchema).optional().default([])
   })
 );
 var RootPageNodeSchema = NodeSchema.refine(
@@ -80,23 +395,62 @@ var RootPageNodeSchema = NodeSchema.refine(
     path: ["type"]
   }
 );
-var DocumentMetadataSchema = z.object({
-  title: z.string().min(1, "Title is required").default("Untitled Page"),
-  description: z.string().optional().default(""),
-  author: z.string().optional().default(""),
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional(),
-  tags: z.array(z.string()).optional().default([]),
-  category: z.string().optional().default("general"),
-  version: z.string().optional().default("1.0.0"),
-  custom: z.record(z.string(), z.unknown()).optional()
+var DocumentMetadataSchema = z3.object({
+  title: z3.string().min(1, "Title is required").default("Untitled Page"),
+  description: z3.string().optional().default(""),
+  author: z3.string().optional().default(""),
+  createdAt: z3.string().optional(),
+  updatedAt: z3.string().optional(),
+  tags: z3.array(z3.string()).optional().default([]),
+  category: z3.string().optional().default("general"),
+  version: z3.string().optional().default("1.0.0"),
+  custom: z3.record(z3.string(), z3.unknown()).optional()
 });
-var PageDocumentSchema = z.object({
-  schema: z.literal(SCHEMA_NAME),
-  version: z.string().min(1, "Schema version is required").default(CURRENT_SCHEMA_VERSION),
+var PageDocumentSchema = z3.object({
+  schema: z3.literal(SCHEMA_NAME),
+  version: z3.string().min(1, "Schema version is required").default(CURRENT_SCHEMA_VERSION),
   metadata: DocumentMetadataSchema.optional(),
   document: RootPageNodeSchema
 });
+var PROJECT_SCHEMA_NAME = "stora.project";
+var CURRENT_PROJECT_SCHEMA_VERSION = "1.0.0";
+var ARTBOARD_REFERENCE_NODE_TYPE = "artboard-reference";
+var ArtboardTypeSchema = z3.enum(["page", "component"]);
+var ArtboardSchema = z3.object({
+  id: z3.string().min(1, "Artboard ID is required"),
+  name: z3.string().min(1, "Artboard name is required"),
+  artboardType: ArtboardTypeSchema,
+  /** Route for page artboards (e.g. "/about"). */
+  slug: z3.string().optional(),
+  /**
+   * For component artboards: the id that `open_modal` / `close_modal` actions target.
+   * Mirrors the detached node's own `props.modalId` so ModalManager keeps working unchanged.
+   */
+  triggerId: z3.string().optional(),
+  /**
+   * Viewport/breakpoint this artboard is currently authored at. Declared inline
+   * (rather than imported) because viewport is otherwise an editor/renderer concept.
+   */
+  viewport: z3.enum(["desktop", "tablet", "mobile"]).optional(),
+  /** Persisted artboard width in px, matching the canvas ViewportResizer's `width`. */
+  width: z3.number().positive().optional(),
+  /**
+   * Free position on the builder's infinite canvas, in unscaled canvas px. Absent means
+   * "not placed yet" — the canvas then falls back to laying the artboard out in a row.
+   */
+  position: z3.object({
+    x: z3.number(),
+    y: z3.number()
+  }).optional(),
+  document: PageDocumentSchema
+});
+var ProjectDocumentSchema = z3.object({
+  schema: z3.literal(PROJECT_SCHEMA_NAME),
+  version: z3.string().min(1, "Schema version is required").default(CURRENT_PROJECT_SCHEMA_VERSION),
+  metadata: DocumentMetadataSchema.optional(),
+  artboards: z3.array(ArtboardSchema).min(1, "A project needs at least one artboard"),
+  activeArtboardId: z3.string().optional()
+});
 function isAssetReference(value) {
   return AssetReferenceSchema.safeParse(value).success;
 }
@@ -109,6 +463,17 @@ function isActionBinding(value) {
 function isAnimationConfig(value) {
   return AnimationConfigSchema.safeParse(value).success;
 }
+function isProjectDocument(value) {
+  return ProjectDocumentSchema.safeParse(value).success;
+}
+function looksLikeProjectDocument(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.schema === PROJECT_SCHEMA_NAME || Array.isArray(candidate.artboards);
+}
+function isArtboardReferenceNode(node) {
+  return node.type === ARTBOARD_REFERENCE_NODE_TYPE;
+}
 function generateDeterministicNodeId(prefix, indexOrKey) {
   const cleanPrefix = prefix.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
   return `${cleanPrefix}_${indexOrKey}`;
@@ -140,30 +505,30 @@ function validateNodeIdUniqueness(node) {
 }
 
 // src/manifest.ts
-import { z as z2 } from "zod";
-var ManifestAssetItemSchema = z2.object({
-  id: z2.string().min(1, "Asset ID cannot be empty"),
-  path: z2.string().min(1, "Asset archive path cannot be empty"),
-  mimeType: z2.string().min(1, "MIME type cannot be empty"),
-  size: z2.number().nonnegative("Asset size must be non-negative"),
-  checksum: z2.string().optional()
+import { z as z4 } from "zod";
+var ManifestAssetItemSchema = z4.object({
+  id: z4.string().min(1, "Asset ID cannot be empty"),
+  path: z4.string().min(1, "Asset archive path cannot be empty"),
+  mimeType: z4.string().min(1, "MIME type cannot be empty"),
+  size: z4.number().nonnegative("Asset size must be non-negative"),
+  checksum: z4.string().optional()
 });
-var ManifestSchema = z2.object({
-  schema: z2.literal(SCHEMA_NAME).default(SCHEMA_NAME),
-  schemaVersion: z2.string().min(1, "Schema version cannot be empty").default("1.0.0"),
-  packageVersion: z2.string().min(1, "Package version cannot be empty").default("1.0.0"),
-  builderCompatibility: z2.string().default(">=0.1.0"),
-  requiredComponents: z2.array(z2.string()).default([]),
-  requiredCapabilities: z2.array(z2.string()).default([]),
-  assets: z2.array(ManifestAssetItemSchema).default([]),
-  createdAt: z2.string().optional()
+var ManifestSchema = z4.object({
+  schema: z4.literal(SCHEMA_NAME).default(SCHEMA_NAME),
+  schemaVersion: z4.string().min(1, "Schema version cannot be empty").default("1.0.0"),
+  packageVersion: z4.string().min(1, "Package version cannot be empty").default("1.0.0"),
+  builderCompatibility: z4.string().default(">=0.1.0"),
+  requiredComponents: z4.array(z4.string()).default([]),
+  requiredCapabilities: z4.array(z4.string()).default([]),
+  assets: z4.array(ManifestAssetItemSchema).default([]),
+  createdAt: z4.string().optional()
 });
 function isManifest(value) {
   return ManifestSchema.safeParse(value).success;
 }
 
 // src/template.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 var DANGEROUS_URI_PATTERN = /^(javascript:|vbscript:|data:(?!image\/))|<script/i;
 function isSafeThumbnailUrl(url) {
   if (!url || typeof url !== "string") return false;
@@ -172,49 +537,49 @@ function isSafeThumbnailUrl(url) {
   if (DANGEROUS_URI_PATTERN.test(trimmed)) return false;
   return true;
 }
-var SafeThumbnailUrlSchema = z3.string().min(1, "Thumbnail URL cannot be empty").refine(
+var SafeThumbnailUrlSchema = z5.string().min(1, "Thumbnail URL cannot be empty").refine(
   (url) => isSafeThumbnailUrl(url),
   { message: "Thumbnail URL contains an unsafe protocol or payload" }
 );
-var SafeThumbnailObjectSchema = z3.object({
+var SafeThumbnailObjectSchema = z5.object({
   url: SafeThumbnailUrlSchema,
-  alt: z3.string().optional(),
-  width: z3.number().positive().optional(),
-  height: z3.number().positive().optional()
+  alt: z5.string().optional(),
+  width: z5.number().positive().optional(),
+  height: z5.number().positive().optional()
 });
-var SafeThumbnailSchema = z3.union([
+var SafeThumbnailSchema = z5.union([
   AssetReferenceSchema,
   SafeThumbnailObjectSchema,
   SafeThumbnailUrlSchema
 ]);
-var TemplatePackageRefSchema = z3.object({
-  path: z3.string().optional(),
+var TemplatePackageRefSchema = z5.object({
+  path: z5.string().optional(),
   url: SafeThumbnailUrlSchema.optional(),
-  checksum: z3.string().optional(),
-  format: z3.enum(["stora", "json"]).default("stora")
+  checksum: z5.string().optional(),
+  format: z5.enum(["stora", "json"]).default("stora")
 });
-var TemplateRequirementsSchema = z3.object({
-  requiredComponents: z3.array(z3.string()).default([]),
-  requiredCapabilities: z3.array(z3.string()).default([])
+var TemplateRequirementsSchema = z5.object({
+  requiredComponents: z5.array(z5.string()).default([]),
+  requiredCapabilities: z5.array(z5.string()).default([])
 });
-var TemplateRecordSchema = z3.object({
-  id: z3.string().min(1, "Template ID must be a non-empty string"),
-  name: z3.string().min(1, "Template name must be a non-empty string"),
-  description: z3.string().optional().default(""),
-  category: z3.string().optional().default("general"),
-  tags: z3.array(z3.string()).optional().default([]),
+var TemplateRecordSchema = z5.object({
+  id: z5.string().min(1, "Template ID must be a non-empty string"),
+  name: z5.string().min(1, "Template name must be a non-empty string"),
+  description: z5.string().optional().default(""),
+  category: z5.string().optional().default("general"),
+  tags: z5.array(z5.string()).optional().default([]),
   thumbnail: SafeThumbnailSchema.optional(),
-  author: z3.string().optional().default(""),
-  version: z3.string().optional().default("1.0.0"),
+  author: z5.string().optional().default(""),
+  version: z5.string().optional().default("1.0.0"),
   document: PageDocumentSchema.optional(),
   packageReference: TemplatePackageRefSchema.optional(),
   requirements: TemplateRequirementsSchema.default({
     requiredComponents: [],
     requiredCapabilities: []
   }),
-  createdAt: z3.string().optional(),
-  updatedAt: z3.string().optional(),
-  custom: z3.record(z3.string(), z3.unknown()).optional()
+  createdAt: z5.string().optional(),
+  updatedAt: z5.string().optional(),
+  custom: z5.record(z5.string(), z5.unknown()).optional()
 });
 function isTemplateRecord(value) {
   return TemplateRecordSchema.safeParse(value).success;
@@ -534,6 +899,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"],
@@ -559,6 +1029,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: {
@@ -895,47 +1376,334 @@ 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;
+}
 export {
+  ACTION_PIPELINE_JSON_SCHEMA_V1,
+  ARTBOARD_REFERENCE_NODE_TYPE,
   ActionBindingSchema,
+  ActionPipelineSchema,
+  ActionStepConditionSchema,
+  ActionStepSchema,
+  ActionStepTypeSchema,
+  ActionTriggerSchema,
+  ActionTriggerTypeSchema,
   AnimationConfigSchema,
+  ApiRequestStepPayloadSchema,
+  ArtboardSchema,
+  ArtboardTypeSchema,
   AssetReferenceSchema,
+  CURRENT_PROJECT_SCHEMA_VERSION,
   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,
+  PROJECT_SCHEMA_NAME,
   PageDocumentSchema,
+  ProjectDocumentSchema,
   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,
+  isArtboardReferenceNode,
   isAssetReference,
+  isConditionOperator,
+  isFormConfig,
+  isFormFieldBinding,
   isManifest,
+  isProjectDocument,
+  isSafeActionUrl,
   isSafeThumbnail,
   isSafeThumbnailUrl,
   isTemplateRecord,
+  isValidateOnEvent,
+  isValidationRule,
+  isValidationRuleType,
   isVariableBinding,
+  looksLikeProjectDocument,
+  sanitizeActionPayload,
+  sanitizeActionPipeline,
+  sanitizeActionStep,
+  sanitizeActionString,
+  sanitizeActionUrl,
+  sanitizeActionValue,
   starterPageFixture,
+  validateActionStepPayload,
   validateNodeIdUniqueness
 };
 //# sourceMappingURL=index.js.map