@kubuild/schema 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -40,15 +40,23 @@ __export(index_exports, {
   ConditionOperatorSchema: () => ConditionOperatorSchema,
   CopyClipboardStepPayloadSchema: () => CopyClipboardStepPayloadSchema,
   CustomEventStepPayloadSchema: () => CustomEventStepPayloadSchema,
+  CustomTrackingProviderConfigSchema: () => CustomTrackingProviderConfigSchema,
+  CustomTrackingSecretsSchema: () => CustomTrackingSecretsSchema,
   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,
+  GoogleTrackingProviderConfigSchema: () => GoogleTrackingProviderConfigSchema,
+  GoogleTrackingSecretsSchema: () => GoogleTrackingSecretsSchema,
+  GtmTrackingProviderConfigSchema: () => GtmTrackingProviderConfigSchema,
+  LEGACY_TRACKING_SECRET_KEYS: () => LEGACY_TRACKING_SECRET_KEYS,
   MANIFEST_JSON_SCHEMA_V1: () => MANIFEST_JSON_SCHEMA_V1,
   ManifestAssetItemSchema: () => ManifestAssetItemSchema,
   ManifestSchema: () => ManifestSchema,
+  MetaTrackingProviderConfigSchema: () => MetaTrackingProviderConfigSchema,
+  MetaTrackingSecretsSchema: () => MetaTrackingSecretsSchema,
   NavigateStepPayloadSchema: () => NavigateStepPayloadSchema,
   NodeSchema: () => NodeSchema,
   OpenModalStepPayloadSchema: () => OpenModalStepPayloadSchema,
@@ -64,15 +72,30 @@ __export(index_exports, {
   SafeThumbnailObjectSchema: () => SafeThumbnailObjectSchema,
   SafeThumbnailSchema: () => SafeThumbnailSchema,
   SafeThumbnailUrlSchema: () => SafeThumbnailUrlSchema,
+  ServerTrackingEventSchema: () => ServerTrackingEventSchema,
   SetStateStepPayloadSchema: () => SetStateStepPayloadSchema,
   ShowToastStepPayloadSchema: () => ShowToastStepPayloadSchema,
+  StandardTrackingEventSchema: () => StandardTrackingEventSchema,
   StepPayloadSchemas: () => StepPayloadSchemas,
   StyleDefinitionSchema: () => StyleDefinitionSchema,
   StyleValueSchema: () => StyleValueSchema,
   TEMPLATE_RECORD_JSON_SCHEMA_V1: () => TEMPLATE_RECORD_JSON_SCHEMA_V1,
+  TRACKING_RELAY_PROTOCOL_VERSION: () => TRACKING_RELAY_PROTOCOL_VERSION,
   TemplatePackageRefSchema: () => TemplatePackageRefSchema,
   TemplateRecordSchema: () => TemplateRecordSchema,
   TemplateRequirementsSchema: () => TemplateRequirementsSchema,
+  TikTokTrackingProviderConfigSchema: () => TikTokTrackingProviderConfigSchema,
+  TikTokTrackingSecretsSchema: () => TikTokTrackingSecretsSchema,
+  ToggleModalStepPayloadSchema: () => ToggleModalStepPayloadSchema,
+  TrackEventProviderSchema: () => TrackEventProviderSchema,
+  TrackEventStepPayloadSchema: () => TrackEventStepPayloadSchema,
+  TrackingConfigSchema: () => TrackingConfigSchema,
+  TrackingDeliverySchema: () => TrackingDeliverySchema,
+  TrackingProviderTypeSchema: () => TrackingProviderTypeSchema,
+  TrackingRelayErrorCodeSchema: () => TrackingRelayErrorCodeSchema,
+  TrackingRelayProviderResultSchema: () => TrackingRelayProviderResultSchema,
+  TrackingRelayRequestSchema: () => TrackingRelayRequestSchema,
+  TrackingRelayResponseSchema: () => TrackingRelayResponseSchema,
   ValidateOnEventSchema: () => ValidateOnEventSchema,
   ValidationRuleSchema: () => ValidationRuleSchema,
   ValidationRuleTypeSchema: () => ValidationRuleTypeSchema,
@@ -85,6 +108,9 @@ __export(index_exports, {
   getManifestJsonSchema: () => getManifestJsonSchema,
   getPageDocumentJsonSchema: () => getPageDocumentJsonSchema,
   getTemplateRecordJsonSchema: () => getTemplateRecordJsonSchema,
+  getTrackingProviderSecretsJsonSchema: () => getTrackingProviderSecretsJsonSchema,
+  getTrackingRelayRequestJsonSchema: () => getTrackingRelayRequestJsonSchema,
+  getTrackingRelayResponseJsonSchema: () => getTrackingRelayResponseJsonSchema,
   isActionBinding: () => isActionBinding,
   isActionPipeline: () => isActionPipeline,
   isActionStep: () => isActionStep,
@@ -103,6 +129,9 @@ __export(index_exports, {
   isSafeThumbnail: () => isSafeThumbnail,
   isSafeThumbnailUrl: () => isSafeThumbnailUrl,
   isTemplateRecord: () => isTemplateRecord,
+  isTrackEventStepPayload: () => isTrackEventStepPayload,
+  isTrackingConfig: () => isTrackingConfig,
+  isTrackingRelayRequest: () => isTrackingRelayRequest,
   isValidateOnEvent: () => isValidateOnEvent,
   isValidationRule: () => isValidationRule,
   isValidationRuleType: () => isValidationRuleType,
@@ -121,11 +150,212 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/document.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/actions.ts
+var import_zod2 = require("zod");
+
+// src/tracking.ts
 var import_zod = require("zod");
-var ActionTriggerTypeSchema = import_zod.z.enum([
+var TrackingProviderTypeSchema = import_zod.z.enum([
+  "meta",
+  "google",
+  "gtm",
+  "tiktok",
+  "custom"
+]);
+var TrackingDeliverySchema = import_zod.z.enum(["both", "client_only", "server_only"]);
+var MetaTrackingProviderConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  /** Host credential id; the server resolves the CAPI access token from it. */
+  credentialId: import_zod.z.string().optional(),
+  /** Meta Pixel ID (e.g. 123456789012345) — public */
+  pixelId: import_zod.z.string().optional().default(""),
+  /** Enable Server-Side Conversions API (delivered through the host relay) */
+  capiEnabled: import_zod.z.boolean().optional().default(false),
+  /** Test Event Code from Meta Events Manager (e.g. "TEST12345") — not a secret */
+  testEventCode: import_zod.z.string().optional().default("")
+});
+var GoogleTrackingProviderConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  /** Host credential id; the server resolves the Measurement Protocol API secret from it. */
+  credentialId: import_zod.z.string().optional(),
+  /** GA4 Measurement ID (e.g. "G-XXXXXXXXXX") — public */
+  measurementId: import_zod.z.string().optional().default("")
+});
+var GtmTrackingProviderConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  /** Optional linked account/workspace credential ID */
+  credentialId: import_zod.z.string().optional(),
+  /** GTM Container ID (e.g. "GTM-XXXXXXX") — public */
+  containerId: import_zod.z.string().optional().default("")
+});
+var TikTokTrackingProviderConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  /** Host credential id; the server resolves the Events API access token from it. */
+  credentialId: import_zod.z.string().optional(),
+  /** TikTok Pixel ID (e.g. "C1234567890") — public */
+  pixelId: import_zod.z.string().optional().default(""),
+  /** Enable TikTok Events API (server-side, delivered through the host relay) */
+  eventsApiEnabled: import_zod.z.boolean().optional().default(false),
+  /** Test Event Code from TikTok Event Manager — not a secret */
+  testEventCode: import_zod.z.string().optional().default("")
+});
+var CustomTrackingProviderConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  /** Host credential id; the server resolves the webhook `endpointUrl` + `headers` from it. */
+  credentialId: import_zod.z.string().optional()
+});
+var LEGACY_TRACKING_SECRET_KEYS = Object.freeze({
+  meta: ["capiAccessToken", "serverRelayUrl"],
+  google: ["measurementProtocolSecret", "serverRelayUrl"],
+  gtm: ["serverRelayUrl"],
+  tiktok: ["accessToken", "serverRelayUrl"],
+  custom: ["endpointUrl", "headers"]
+});
+var TrackingConfigSchema = import_zod.z.object({
+  /** Master toggle: dynamically enables or disables all tracking operations */
+  enabled: import_zod.z.boolean().default(true),
+  /** When enabled, events are logged to console and can bypass live API calls for safe debugging */
+  debugMode: import_zod.z.boolean().optional().default(false),
+  /** Automatically trigger PageView event upon page load */
+  autoPageView: import_zod.z.boolean().optional().default(true),
+  /** Default delivery method when not explicitly overridden in an action step */
+  defaultDelivery: TrackingDeliverySchema.optional().default("both"),
+  /** Provider-specific settings */
+  providers: import_zod.z.object({
+    meta: MetaTrackingProviderConfigSchema.optional(),
+    google: GoogleTrackingProviderConfigSchema.optional(),
+    gtm: GtmTrackingProviderConfigSchema.optional(),
+    tiktok: TikTokTrackingProviderConfigSchema.optional(),
+    custom: CustomTrackingProviderConfigSchema.optional()
+  }).optional().default({})
+});
+var MetaTrackingSecretsSchema = import_zod.z.object({
+  /** System User access token for the Meta Graph API. */
+  capiAccessToken: import_zod.z.string().min(1)
+});
+var GoogleTrackingSecretsSchema = import_zod.z.object({
+  /** Measurement Protocol `api_secret`. */
+  measurementProtocolSecret: import_zod.z.string().min(1)
+});
+var TikTokTrackingSecretsSchema = import_zod.z.object({
+  /** Long-term Events API access token. */
+  accessToken: import_zod.z.string().min(1)
+});
+var CustomTrackingSecretsSchema = import_zod.z.object({
+  endpointUrl: import_zod.z.string().url(),
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+});
+var StandardTrackingEventSchema = import_zod.z.enum([
+  "PageView",
+  "ViewContent",
+  "AddToCart",
+  "InitiateCheckout",
+  "Purchase",
+  "Lead",
+  "Contact",
+  "CompleteRegistration",
+  "Subscribe",
+  "Search",
+  "SubmitApplication",
+  "Schedule"
+]);
+var TrackEventProviderSchema = import_zod.z.enum(["all", "meta", "google", "gtm", "tiktok", "custom"]);
+var TrackEventStepPayloadSchema = import_zod.z.object({
+  /** Event name: e.g. "Purchase", "Lead", or custom string */
+  eventName: import_zod.z.string().min(1, "Event name cannot be empty"),
+  /** Standard event vs custom event identifier */
+  eventType: import_zod.z.enum(["standard", "custom"]).optional().default("standard"),
+  /**
+   * Target provider: 'all' or a specific provider.
+   * 'gtm' pushes the event to `window.dataLayer` (client-side only).
+   */
+  provider: TrackEventProviderSchema.optional().default("all"),
+  /** Delivery channel: 'both', 'client_only', or 'server_only' */
+  delivery: TrackingDeliverySchema.optional().default("both"),
+  /**
+   * Deduplication Event ID.
+   * If omitted, a unique ID is automatically generated so Meta/TikTok CAPI
+   * deduplicates cleanly with the browser pixel.
+   */
+  eventId: import_zod.z.string().optional(),
+  /**
+   * Event parameters/properties (e.g. currency, value, content_name, order_id).
+   * Supports runtime variable interpolation (e.g. {{ form.price }} or {{ variables.currency }}).
+   */
+  params: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().default({}),
+  /**
+   * User Data for advanced matching and server CAPI (e.g. email, phone, firstName, lastName).
+   * Supports runtime variable interpolation (e.g. {{ form.email }}).
+   */
+  userData: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().default({}),
+  /** Step-level active toggle */
+  enabled: import_zod.z.boolean().optional().default(true)
+});
+var TRACKING_RELAY_PROTOCOL_VERSION = 1;
+var ServerTrackingEventSchema = import_zod.z.object({
+  eventName: import_zod.z.string().min(1).max(256),
+  eventType: import_zod.z.enum(["standard", "custom"]).optional(),
+  eventId: import_zod.z.string().max(256).optional(),
+  /** Unix epoch seconds. */
+  eventTime: import_zod.z.number().int().nonnegative().optional(),
+  eventSourceUrl: import_zod.z.string().max(4096).optional(),
+  actionSource: import_zod.z.enum(["website", "app", "system_generated"]).optional(),
+  params: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  /** Raw (unhashed) user data; the relay hashes PII per provider spec before forwarding. */
+  userData: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  customData: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var TrackingRelayRequestSchema = import_zod.z.object({
+  version: import_zod.z.literal(TRACKING_RELAY_PROTOCOL_VERSION),
+  event: ServerTrackingEventSchema,
+  provider: TrackEventProviderSchema.optional().default("all"),
+  /** Optional hint only; the relay uses the credentialId from its trusted config. */
+  credentialId: import_zod.z.string().max(256).optional(),
+  /** Host document/page id so the relay can look up the trusted tracking config. */
+  documentId: import_zod.z.string().max(256).optional()
+});
+var TrackingRelayProviderResultSchema = import_zod.z.object({
+  provider: import_zod.z.string(),
+  success: import_zod.z.boolean(),
+  status: import_zod.z.number().int().optional(),
+  skipped: import_zod.z.boolean().optional(),
+  reason: import_zod.z.string().optional(),
+  error: import_zod.z.string().optional()
+});
+var TrackingRelayErrorCodeSchema = import_zod.z.enum([
+  "INVALID_REQUEST",
+  "UNSUPPORTED_VERSION",
+  "FORBIDDEN_ORIGIN",
+  "METHOD_NOT_ALLOWED",
+  "CONFIG_NOT_FOUND",
+  "INTERNAL_ERROR"
+]);
+var TrackingRelayResponseSchema = import_zod.z.object({
+  version: import_zod.z.literal(TRACKING_RELAY_PROTOCOL_VERSION),
+  success: import_zod.z.boolean(),
+  eventId: import_zod.z.string().optional(),
+  skipped: import_zod.z.boolean().optional(),
+  reason: import_zod.z.string().optional(),
+  results: import_zod.z.record(import_zod.z.string(), TrackingRelayProviderResultSchema).optional(),
+  error: import_zod.z.object({
+    code: TrackingRelayErrorCodeSchema,
+    message: import_zod.z.string()
+  }).optional()
+});
+function isTrackingConfig(value) {
+  return TrackingConfigSchema.safeParse(value).success;
+}
+function isTrackEventStepPayload(value) {
+  return TrackEventStepPayloadSchema.safeParse(value).success;
+}
+function isTrackingRelayRequest(value) {
+  return TrackingRelayRequestSchema.safeParse(value).success;
+}
+
+// src/actions.ts
+var ActionTriggerTypeSchema = import_zod2.z.enum([
   "click",
   "submit",
   "change",
@@ -134,7 +364,7 @@ var ActionTriggerTypeSchema = import_zod.z.enum([
   "load"
 ]);
 var ActionTriggerSchema = ActionTriggerTypeSchema;
-var ActionStepTypeSchema = import_zod.z.enum([
+var ActionStepTypeSchema = import_zod2.z.enum([
   "api_request",
   "navigate",
   "set_state",
@@ -142,10 +372,12 @@ var ActionStepTypeSchema = import_zod.z.enum([
   "show_toast",
   "open_modal",
   "close_modal",
+  "toggle_modal",
   "copy_clipboard",
-  "custom_event"
+  "custom_event",
+  "track_event"
 ]);
-var ConditionOperatorSchema = import_zod.z.enum([
+var ConditionOperatorSchema = import_zod2.z.enum([
   "equals",
   "not_equals",
   "contains",
@@ -158,10 +390,10 @@ var ConditionOperatorSchema = import_zod.z.enum([
   "lte",
   "regex"
 ]);
-var ActionStepConditionSchema = import_zod.z.object({
-  field: import_zod.z.string().min(1, "Condition field cannot be empty"),
+var ActionStepConditionSchema = import_zod2.z.object({
+  field: import_zod2.z.string().min(1, "Condition field cannot be empty"),
   operator: ConditionOperatorSchema,
-  value: import_zod.z.unknown().optional()
+  value: import_zod2.z.unknown().optional()
 });
 var DANGEROUS_URL_PATTERN = /(javascript:|vbscript:|data:text\/html)/i;
 var DANGEROUS_SCRIPT_PATTERN = /<\s*script/i;
@@ -172,68 +404,81 @@ function isSafeActionUrl(url) {
   if (DANGEROUS_SCRIPT_PATTERN.test(trimmed)) return false;
   return true;
 }
-var SafeUrlStringSchema = import_zod.z.string().min(1, "URL cannot be empty").refine(isSafeActionUrl, {
+var SafeUrlStringSchema = import_zod2.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_\-:]+$/, {
+var SafeEventNameSchema = import_zod2.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({
+var ApiRequestStepPayloadSchema = import_zod2.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()
+  method: import_zod2.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).default("GET"),
+  headers: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+  queryParams: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()])).optional(),
+  body: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()), import_zod2.z.array(import_zod2.z.unknown())]).optional(),
+  bodyFormat: import_zod2.z.enum(["json", "form-data", "formData", "urlencoded", "url-encoded", "raw", "text"]).optional(),
+  bodyType: import_zod2.z.enum(["json", "form-data", "formData", "urlencoded", "url-encoded", "raw", "text"]).optional(),
+  timeout: import_zod2.z.number().positive("Timeout must be greater than 0 ms").optional(),
+  responseMapping: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
 });
-var NavigateStepPayloadSchema = import_zod.z.object({
+var NavigateStepPayloadSchema = import_zod2.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()
+  target: import_zod2.z.enum(["_self", "_blank", "_parent", "_top"]).optional().default("_self"),
+  replace: import_zod2.z.boolean().optional(),
+  scroll: import_zod2.z.boolean().optional(),
+  behavior: import_zod2.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 SetStateStepPayloadSchema = import_zod2.z.object({
+  key: import_zod2.z.string().min(1, "State key cannot be empty"),
+  value: import_zod2.z.unknown(),
+  scope: import_zod2.z.enum(["runtime", "document", "session", "local"]).optional().default("runtime")
 });
-var ResetFormStepPayloadSchema = import_zod.z.object({
-  formId: import_zod.z.string().optional()
+var ResetFormStepPayloadSchema = import_zod2.z.object({
+  formId: import_zod2.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 ShowToastStepPayloadSchema = import_zod2.z.object({
+  message: import_zod2.z.string().min(1, "Toast message cannot be empty"),
+  type: import_zod2.z.enum(["success", "error", "warning", "info"]).optional().default("info"),
+  variant: import_zod2.z.enum(["success", "error", "warning", "info"]).optional(),
+  title: import_zod2.z.string().optional(),
+  duration: import_zod2.z.number().nonnegative("Duration must be >= 0 ms").optional(),
+  position: import_zod2.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(),
-  toggle: import_zod.z.boolean().optional()
+var OpenModalStepPayloadSchema = import_zod2.z.object({
+  modalId: import_zod2.z.string().optional(),
+  modalNodeId: import_zod2.z.string().optional(),
+  toggle: import_zod2.z.boolean().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 CloseModalStepPayloadSchema = import_zod2.z.object({
+  modalId: import_zod2.z.string().optional(),
+  modalNodeId: import_zod2.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 ToggleModalStepPayloadSchema = import_zod2.z.object({
+  modalId: import_zod2.z.string().optional(),
+  modalNodeId: import_zod2.z.string().optional(),
+  targetNodeId: import_zod2.z.string().optional(),
+  nodeId: import_zod2.z.string().optional()
+}).refine(
+  (data) => [data.modalId, data.modalNodeId, data.targetNodeId, data.nodeId].some(
+    (id) => typeof id === "string" && id.trim().length > 0
+  ),
+  {
+    message: "Modal ID or Modal Node ID cannot be empty"
+  }
+);
+var CopyClipboardStepPayloadSchema = import_zod2.z.object({
+  text: import_zod2.z.string().optional(),
+  value: import_zod2.z.unknown().optional(),
+  notify: import_zod2.z.boolean().optional(),
+  toastMessage: import_zod2.z.string().optional()
 });
-var CustomEventStepPayloadSchema = import_zod.z.object({
+var CustomEventStepPayloadSchema = import_zod2.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)
+  detail: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+  bubbles: import_zod2.z.boolean().optional().default(true),
+  cancelable: import_zod2.z.boolean().optional().default(true)
 });
 var StepPayloadSchemas = {
   api_request: ApiRequestStepPayloadSchema,
@@ -243,30 +488,32 @@ var StepPayloadSchemas = {
   show_toast: ShowToastStepPayloadSchema,
   open_modal: OpenModalStepPayloadSchema,
   close_modal: CloseModalStepPayloadSchema,
+  toggle_modal: ToggleModalStepPayloadSchema,
   copy_clipboard: CopyClipboardStepPayloadSchema,
-  custom_event: CustomEventStepPayloadSchema
+  custom_event: CustomEventStepPayloadSchema,
+  track_event: TrackEventStepPayloadSchema
 };
-var ActionStepSchema = import_zod.z.lazy(
-  () => import_zod.z.object({
-    id: import_zod.z.string().min(1, "Step ID cannot be empty"),
+var ActionStepSchema = import_zod2.z.lazy(
+  () => import_zod2.z.object({
+    id: import_zod2.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({}),
+    label: import_zod2.z.string().optional(),
+    payload: import_zod2.z.record(import_zod2.z.string(), import_zod2.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()
+    timeout: import_zod2.z.number().positive().optional(),
+    continueOnError: import_zod2.z.boolean().optional(),
+    onSuccess: import_zod2.z.array(ActionStepSchema).optional(),
+    onError: import_zod2.z.array(ActionStepSchema).optional()
   })
 );
-var ActionPipelineSchema = import_zod.z.object({
-  id: import_zod.z.string().min(1, "Pipeline ID cannot be empty"),
+var ActionPipelineSchema = import_zod2.z.object({
+  id: import_zod2.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")
+  label: import_zod2.z.string().optional(),
+  debounceMs: import_zod2.z.number().nonnegative("Debounce ms must be >= 0").optional(),
+  preventDuplicate: import_zod2.z.boolean().optional(),
+  enabled: import_zod2.z.boolean().optional().default(true),
+  steps: import_zod2.z.array(ActionStepSchema).min(1, "Action pipeline must contain at least one step")
 });
 function isActionTriggerType(value) {
   return ActionTriggerTypeSchema.safeParse(value).success;
@@ -291,9 +538,9 @@ function validateActionStepPayload(type, payload) {
   if (!schema) {
     return {
       success: false,
-      error: new import_zod.z.ZodError([
+      error: new import_zod2.z.ZodError([
         {
-          code: import_zod.z.ZodIssueCode.custom,
+          code: import_zod2.z.ZodIssueCode.custom,
           message: `Unknown step type: ${type}`,
           path: ["type"]
         }
@@ -381,8 +628,8 @@ function sanitizeActionPipeline(pipeline) {
 }
 
 // src/form.ts
-var import_zod2 = require("zod");
-var ValidationRuleTypeSchema = import_zod2.z.enum([
+var import_zod3 = require("zod");
+var ValidationRuleTypeSchema = import_zod3.z.enum([
   "required",
   "email",
   "url",
@@ -394,29 +641,29 @@ var ValidationRuleTypeSchema = import_zod2.z.enum([
   "match_field",
   "custom_regex"
 ]);
-var ValidateOnEventSchema = import_zod2.z.enum(["blur", "change", "submit"]);
-var ValidationRuleSchema = import_zod2.z.object({
+var ValidateOnEventSchema = import_zod3.z.enum(["blur", "change", "submit"]);
+var ValidationRuleSchema = import_zod3.z.object({
   type: ValidationRuleTypeSchema,
-  value: import_zod2.z.unknown().optional(),
-  message: import_zod2.z.string().min(1, "Validation error message cannot be empty")
+  value: import_zod3.z.unknown().optional(),
+  message: import_zod3.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([]),
+var FormFieldBindingSchema = import_zod3.z.object({
+  name: import_zod3.z.string().min(1, "Field name cannot be empty"),
+  label: import_zod3.z.string().optional(),
+  defaultValue: import_zod3.z.unknown().optional(),
+  rules: import_zod3.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()
+  transform: import_zod3.z.enum(["trim", "lowercase", "uppercase", "number"]).optional(),
+  disabled: import_zod3.z.boolean().optional(),
+  required: import_zod3.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),
+var FormConfigSchema = import_zod3.z.object({
+  formId: import_zod3.z.string().min(1, "Form ID cannot be empty"),
+  resetOnSubmit: import_zod3.z.boolean().optional().default(false),
+  scrollToFirstError: import_zod3.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()
+  initialValues: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
+  rules: import_zod3.z.array(ValidationRuleSchema).optional()
 });
 function isValidationRuleType(value) {
   return ValidationRuleTypeSchema.safeParse(value).success;
@@ -436,56 +683,56 @@ function isFormConfig(value) {
 
 // src/document.ts
 var SCHEMA_NAME = "stora.page";
-var CURRENT_SCHEMA_VERSION = "1.0.0";
-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 CURRENT_SCHEMA_VERSION = "1.1.0";
+var AssetReferenceSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("asset"),
+  assetId: import_zod4.z.string().min(1, "Asset ID cannot be empty"),
+  filename: import_zod4.z.string().optional(),
+  mimeType: import_zod4.z.string().optional(),
+  fallbackUrl: import_zod4.z.string().url().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 VariableBindingSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("variable"),
+  key: import_zod4.z.string().min(1, "Variable key cannot be empty"),
+  fallback: import_zod4.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 ActionBindingSchema = import_zod4.z.object({
+  type: import_zod4.z.string().min(1, "Action type cannot be empty"),
+  payload: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
 });
 var DANGEROUS_STYLE_VALUE_PATTERN = /javascript:|expression\(|@import|<script|vbscript:|data:text\/html/i;
-var StyleValueSchema = import_zod3.z.union([
-  import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+var StyleValueSchema = import_zod4.z.union([
+  import_zod4.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Style value contains a disallowed or unsafe pattern"
   }),
-  import_zod3.z.number(),
-  import_zod3.z.boolean(),
-  import_zod3.z.null(),
-  import_zod3.z.undefined()
+  import_zod4.z.number(),
+  import_zod4.z.boolean(),
+  import_zod4.z.null(),
+  import_zod4.z.undefined()
 ]);
-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({
+var StyleDefinitionSchema = import_zod4.z.record(import_zod4.z.string(), StyleValueSchema);
+var PseudoStateStylesSchema = import_zod4.z.record(import_zod4.z.string(), StyleDefinitionSchema);
+var ResponsiveStylesSchema = import_zod4.z.object({
   base: StyleDefinitionSchema.optional(),
   desktop: StyleDefinitionSchema.optional(),
   tablet: StyleDefinitionSchema.optional(),
   mobile: StyleDefinitionSchema.optional(),
   states: PseudoStateStylesSchema.optional()
 }).passthrough().default({});
-var AnimationConfigSchema = import_zod3.z.object({
-  type: import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+var AnimationConfigSchema = import_zod4.z.object({
+  type: import_zod4.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Animation type contains a disallowed or unsafe pattern"
   }).optional().default("none"),
-  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), {
+  duration: import_zod4.z.number().min(0, "Duration must be non-negative").optional().default(600),
+  delay: import_zod4.z.number().min(0, "Delay must be non-negative").optional().default(0),
+  easing: import_zod4.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_zod3.z.boolean().optional().default(true),
-  hoverEffect: import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+  once: import_zod4.z.boolean().optional().default(true),
+  hoverEffect: import_zod4.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Hover effect contains a disallowed or unsafe pattern"
   }).optional().default("none"),
-  loopEffect: import_zod3.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
+  loopEffect: import_zod4.z.string().refine((value) => !DANGEROUS_STYLE_VALUE_PATTERN.test(value), {
     message: "Loop effect contains a disallowed or unsafe pattern"
   }).optional().default("none")
 });
@@ -498,16 +745,16 @@ var DEFAULT_ANIMATION_CONFIG = {
   hoverEffect: "none",
   loopEffect: "none"
 };
-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({}),
+var NodeSchema = import_zod4.z.lazy(
+  () => import_zod4.z.object({
+    id: import_zod4.z.string().min(1, "Node ID must be a non-empty string"),
+    type: import_zod4.z.string().min(1, "Node type must be a non-empty string"),
+    props: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional().default({}),
     styles: ResponsiveStylesSchema.optional().default({}),
     animation: AnimationConfigSchema.optional(),
-    actions: import_zod3.z.array(ActionPipelineSchema).optional(),
+    actions: import_zod4.z.array(ActionPipelineSchema).optional(),
     formConfig: FormConfigSchema.optional(),
-    children: import_zod3.z.array(NodeSchema).optional().default([])
+    children: import_zod4.z.array(NodeSchema).optional().default([])
   })
 );
 var RootPageNodeSchema = NodeSchema.refine(
@@ -517,61 +764,64 @@ var RootPageNodeSchema = NodeSchema.refine(
     path: ["type"]
   }
 );
-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 DocumentMetadataSchema = import_zod4.z.object({
+  title: import_zod4.z.string().min(1, "Title is required").default("Untitled Page"),
+  description: import_zod4.z.string().optional().default(""),
+  author: import_zod4.z.string().optional().default(""),
+  createdAt: import_zod4.z.string().optional(),
+  updatedAt: import_zod4.z.string().optional(),
+  tags: import_zod4.z.array(import_zod4.z.string()).optional().default([]),
+  category: import_zod4.z.string().optional().default("general"),
+  version: import_zod4.z.string().optional().default("1.0.0"),
+  custom: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional(),
+  tracking: TrackingConfigSchema.optional()
 });
-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),
+var PageDocumentSchema = import_zod4.z.object({
+  schema: import_zod4.z.literal(SCHEMA_NAME),
+  version: import_zod4.z.string().min(1, "Schema version is required").default(CURRENT_SCHEMA_VERSION),
   metadata: DocumentMetadataSchema.optional(),
+  tracking: TrackingConfigSchema.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 = import_zod3.z.enum(["page", "component"]);
-var ArtboardSchema = import_zod3.z.object({
-  id: import_zod3.z.string().min(1, "Artboard ID is required"),
-  name: import_zod3.z.string().min(1, "Artboard name is required"),
+var ArtboardTypeSchema = import_zod4.z.enum(["page", "component"]);
+var ArtboardSchema = import_zod4.z.object({
+  id: import_zod4.z.string().min(1, "Artboard ID is required"),
+  name: import_zod4.z.string().min(1, "Artboard name is required"),
   artboardType: ArtboardTypeSchema,
   /** Route for page artboards (e.g. "/about"). */
-  slug: import_zod3.z.string().optional(),
+  slug: import_zod4.z.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: import_zod3.z.string().optional(),
+  triggerId: import_zod4.z.string().optional(),
   /**
    * Viewport/breakpoint this artboard is currently authored at. Declared inline
    * (rather than imported) because viewport is otherwise an editor/renderer concept.
    */
-  viewport: import_zod3.z.enum(["desktop", "tablet", "mobile"]).optional(),
+  viewport: import_zod4.z.enum(["desktop", "tablet", "mobile"]).optional(),
   /** Persisted artboard width in px, matching the canvas ViewportResizer's `width`. */
-  width: import_zod3.z.number().positive().optional(),
+  width: import_zod4.z.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: import_zod3.z.object({
-    x: import_zod3.z.number(),
-    y: import_zod3.z.number()
+  position: import_zod4.z.object({
+    x: import_zod4.z.number(),
+    y: import_zod4.z.number()
   }).optional(),
   document: PageDocumentSchema
 });
-var ProjectDocumentSchema = import_zod3.z.object({
-  schema: import_zod3.z.literal(PROJECT_SCHEMA_NAME),
-  version: import_zod3.z.string().min(1, "Schema version is required").default(CURRENT_PROJECT_SCHEMA_VERSION),
+var ProjectDocumentSchema = import_zod4.z.object({
+  schema: import_zod4.z.literal(PROJECT_SCHEMA_NAME),
+  version: import_zod4.z.string().min(1, "Schema version is required").default(CURRENT_PROJECT_SCHEMA_VERSION),
   metadata: DocumentMetadataSchema.optional(),
-  artboards: import_zod3.z.array(ArtboardSchema).min(1, "A project needs at least one artboard"),
-  activeArtboardId: import_zod3.z.string().optional()
+  tracking: TrackingConfigSchema.optional(),
+  artboards: import_zod4.z.array(ArtboardSchema).min(1, "A project needs at least one artboard"),
+  activeArtboardId: import_zod4.z.string().optional()
 });
 function isAssetReference(value) {
   return AssetReferenceSchema.safeParse(value).success;
@@ -627,30 +877,30 @@ function validateNodeIdUniqueness(node) {
 }
 
 // src/manifest.ts
-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 import_zod5 = require("zod");
+var ManifestAssetItemSchema = import_zod5.z.object({
+  id: import_zod5.z.string().min(1, "Asset ID cannot be empty"),
+  path: import_zod5.z.string().min(1, "Asset archive path cannot be empty"),
+  mimeType: import_zod5.z.string().min(1, "MIME type cannot be empty"),
+  size: import_zod5.z.number().nonnegative("Asset size must be non-negative"),
+  checksum: import_zod5.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()
+var ManifestSchema = import_zod5.z.object({
+  schema: import_zod5.z.literal(SCHEMA_NAME).default(SCHEMA_NAME),
+  schemaVersion: import_zod5.z.string().min(1, "Schema version cannot be empty").default("1.0.0"),
+  packageVersion: import_zod5.z.string().min(1, "Package version cannot be empty").default("1.0.0"),
+  builderCompatibility: import_zod5.z.string().default(">=0.1.0"),
+  requiredComponents: import_zod5.z.array(import_zod5.z.string()).default([]),
+  requiredCapabilities: import_zod5.z.array(import_zod5.z.string()).default([]),
+  assets: import_zod5.z.array(ManifestAssetItemSchema).default([]),
+  createdAt: import_zod5.z.string().optional()
 });
 function isManifest(value) {
   return ManifestSchema.safeParse(value).success;
 }
 
 // src/template.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var DANGEROUS_URI_PATTERN = /^(javascript:|vbscript:|data:(?!image\/))|<script/i;
 function isSafeThumbnailUrl(url) {
   if (!url || typeof url !== "string") return false;
@@ -659,49 +909,49 @@ function isSafeThumbnailUrl(url) {
   if (DANGEROUS_URI_PATTERN.test(trimmed)) return false;
   return true;
 }
-var SafeThumbnailUrlSchema = import_zod5.z.string().min(1, "Thumbnail URL cannot be empty").refine(
+var SafeThumbnailUrlSchema = import_zod6.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_zod5.z.object({
+var SafeThumbnailObjectSchema = import_zod6.z.object({
   url: SafeThumbnailUrlSchema,
-  alt: import_zod5.z.string().optional(),
-  width: import_zod5.z.number().positive().optional(),
-  height: import_zod5.z.number().positive().optional()
+  alt: import_zod6.z.string().optional(),
+  width: import_zod6.z.number().positive().optional(),
+  height: import_zod6.z.number().positive().optional()
 });
-var SafeThumbnailSchema = import_zod5.z.union([
+var SafeThumbnailSchema = import_zod6.z.union([
   AssetReferenceSchema,
   SafeThumbnailObjectSchema,
   SafeThumbnailUrlSchema
 ]);
-var TemplatePackageRefSchema = import_zod5.z.object({
-  path: import_zod5.z.string().optional(),
+var TemplatePackageRefSchema = import_zod6.z.object({
+  path: import_zod6.z.string().optional(),
   url: SafeThumbnailUrlSchema.optional(),
-  checksum: import_zod5.z.string().optional(),
-  format: import_zod5.z.enum(["stora", "json"]).default("stora")
+  checksum: import_zod6.z.string().optional(),
+  format: import_zod6.z.enum(["stora", "json"]).default("stora")
 });
-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 TemplateRequirementsSchema = import_zod6.z.object({
+  requiredComponents: import_zod6.z.array(import_zod6.z.string()).default([]),
+  requiredCapabilities: import_zod6.z.array(import_zod6.z.string()).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([]),
+var TemplateRecordSchema = import_zod6.z.object({
+  id: import_zod6.z.string().min(1, "Template ID must be a non-empty string"),
+  name: import_zod6.z.string().min(1, "Template name must be a non-empty string"),
+  description: import_zod6.z.string().optional().default(""),
+  category: import_zod6.z.string().optional().default("general"),
+  tags: import_zod6.z.array(import_zod6.z.string()).optional().default([]),
   thumbnail: SafeThumbnailSchema.optional(),
-  author: import_zod5.z.string().optional().default(""),
-  version: import_zod5.z.string().optional().default("1.0.0"),
+  author: import_zod6.z.string().optional().default(""),
+  version: import_zod6.z.string().optional().default("1.0.0"),
   document: PageDocumentSchema.optional(),
   packageReference: TemplatePackageRefSchema.optional(),
   requirements: TemplateRequirementsSchema.default({
     requiredComponents: [],
     requiredCapabilities: []
   }),
-  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()
+  createdAt: import_zod6.z.string().optional(),
+  updatedAt: import_zod6.z.string().optional(),
+  custom: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional()
 });
 function isTemplateRecord(value) {
   return TemplateRecordSchema.safeParse(value).success;
@@ -713,7 +963,7 @@ function isSafeThumbnail(value) {
 // src/fixtures/starter-page.json
 var starter_page_default = {
   schema: "stora.page",
-  version: "1.0.0",
+  version: "1.1.0",
   metadata: {
     title: "Welcome to KUBUILD",
     description: "A starter template built with KUBUILD portable web builder",
@@ -872,6 +1122,7 @@ var starter_page_default = {
 var starterPageFixture = starter_page_default;
 
 // src/json-schema.ts
+var import_zod7 = require("zod");
 var PAGE_DOCUMENT_JSON_SCHEMA_V1 = {
   $schema: "http://json-schema.org/draft-07/schema#",
   $id: "https://schema.stora.page/v1/page.json",
@@ -890,16 +1141,84 @@ var PAGE_DOCUMENT_JSON_SCHEMA_V1 = {
       type: "string",
       pattern: "^\\d+(\\.\\d+)*$",
       description: "Schema version of the document",
-      default: "1.0.0"
+      default: "1.1.0"
     },
     metadata: {
       $ref: "#/definitions/documentMetadata"
     },
     document: {
       $ref: "#/definitions/rootPageNode"
+    },
+    tracking: {
+      $ref: "#/definitions/trackingConfig"
     }
   },
   definitions: {
+    trackingConfig: {
+      type: "object",
+      description: "Tracking configuration. Contains only public ids, flags and opaque credential ids \u2014 secrets are host-owned.",
+      properties: {
+        enabled: { type: "boolean", default: true },
+        debugMode: { type: "boolean", default: false },
+        autoPageView: { type: "boolean", default: true },
+        defaultDelivery: { type: "string", enum: ["both", "client_only", "server_only"], default: "both" },
+        providers: {
+          type: "object",
+          properties: {
+            meta: {
+              type: "object",
+              properties: {
+                enabled: { type: "boolean" },
+                credentialId: { type: "string" },
+                pixelId: { type: "string" },
+                capiEnabled: { type: "boolean" },
+                testEventCode: { type: "string" }
+              },
+              additionalProperties: false
+            },
+            google: {
+              type: "object",
+              properties: {
+                enabled: { type: "boolean" },
+                credentialId: { type: "string" },
+                measurementId: { type: "string" }
+              },
+              additionalProperties: false
+            },
+            gtm: {
+              type: "object",
+              properties: {
+                enabled: { type: "boolean" },
+                credentialId: { type: "string" },
+                containerId: { type: "string" }
+              },
+              additionalProperties: false
+            },
+            tiktok: {
+              type: "object",
+              properties: {
+                enabled: { type: "boolean" },
+                credentialId: { type: "string" },
+                pixelId: { type: "string" },
+                eventsApiEnabled: { type: "boolean" },
+                testEventCode: { type: "string" }
+              },
+              additionalProperties: false
+            },
+            custom: {
+              type: "object",
+              properties: {
+                enabled: { type: "boolean" },
+                credentialId: { type: "string" }
+              },
+              additionalProperties: false
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      additionalProperties: false
+    },
     styleValue: {
       type: ["string", "number", "boolean", "null"],
       description: "A CSS property or design token value"
@@ -1039,8 +1358,10 @@ var PAGE_DOCUMENT_JSON_SCHEMA_V1 = {
             "show_toast",
             "open_modal",
             "close_modal",
+            "toggle_modal",
             "copy_clipboard",
-            "custom_event"
+            "custom_event",
+            "track_event"
           ]
         },
         label: { type: "string" },
@@ -1561,8 +1882,10 @@ var ACTION_PIPELINE_JSON_SCHEMA_V1 = {
             "show_toast",
             "open_modal",
             "close_modal",
+            "toggle_modal",
             "copy_clipboard",
-            "custom_event"
+            "custom_event",
+            "track_event"
           ]
         },
         label: { type: "string" },
@@ -1729,6 +2052,48 @@ var FORM_FIELD_BINDING_JSON_SCHEMA_V1 = {
 function getFormFieldBindingJsonSchema() {
   return FORM_FIELD_BINDING_JSON_SCHEMA_V1;
 }
+function toDraft7(schema, id, title, io) {
+  return {
+    ...import_zod7.z.toJSONSchema(schema, { target: "draft-7", io }),
+    $id: id,
+    title
+  };
+}
+var trackingRelayRequestJsonSchema;
+var trackingRelayResponseJsonSchema;
+var trackingProviderSecretsJsonSchema;
+function getTrackingRelayRequestJsonSchema() {
+  trackingRelayRequestJsonSchema ??= toDraft7(
+    TrackingRelayRequestSchema,
+    "https://schema.stora.page/v1/tracking-relay-request.json",
+    "StoraTrackingRelayRequest",
+    "input"
+  );
+  return trackingRelayRequestJsonSchema;
+}
+function getTrackingRelayResponseJsonSchema() {
+  trackingRelayResponseJsonSchema ??= toDraft7(
+    TrackingRelayResponseSchema,
+    "https://schema.stora.page/v1/tracking-relay-response.json",
+    "StoraTrackingRelayResponse",
+    "output"
+  );
+  return trackingRelayResponseJsonSchema;
+}
+function getTrackingProviderSecretsJsonSchema() {
+  trackingProviderSecretsJsonSchema ??= toDraft7(
+    import_zod7.z.object({
+      meta: MetaTrackingSecretsSchema.optional(),
+      google: GoogleTrackingSecretsSchema.optional(),
+      tiktok: TikTokTrackingSecretsSchema.optional(),
+      custom: CustomTrackingSecretsSchema.optional()
+    }),
+    "https://schema.stora.page/v1/tracking-provider-secrets.json",
+    "StoraTrackingProviderSecrets",
+    "input"
+  );
+  return trackingProviderSecretsJsonSchema;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACTION_PIPELINE_JSON_SCHEMA_V1,
@@ -1751,15 +2116,23 @@ function getFormFieldBindingJsonSchema() {
   ConditionOperatorSchema,
   CopyClipboardStepPayloadSchema,
   CustomEventStepPayloadSchema,
+  CustomTrackingProviderConfigSchema,
+  CustomTrackingSecretsSchema,
   DEFAULT_ANIMATION_CONFIG,
   DocumentMetadataSchema,
   FORM_CONFIG_JSON_SCHEMA_V1,
   FORM_FIELD_BINDING_JSON_SCHEMA_V1,
   FormConfigSchema,
   FormFieldBindingSchema,
+  GoogleTrackingProviderConfigSchema,
+  GoogleTrackingSecretsSchema,
+  GtmTrackingProviderConfigSchema,
+  LEGACY_TRACKING_SECRET_KEYS,
   MANIFEST_JSON_SCHEMA_V1,
   ManifestAssetItemSchema,
   ManifestSchema,
+  MetaTrackingProviderConfigSchema,
+  MetaTrackingSecretsSchema,
   NavigateStepPayloadSchema,
   NodeSchema,
   OpenModalStepPayloadSchema,
@@ -1775,15 +2148,30 @@ function getFormFieldBindingJsonSchema() {
   SafeThumbnailObjectSchema,
   SafeThumbnailSchema,
   SafeThumbnailUrlSchema,
+  ServerTrackingEventSchema,
   SetStateStepPayloadSchema,
   ShowToastStepPayloadSchema,
+  StandardTrackingEventSchema,
   StepPayloadSchemas,
   StyleDefinitionSchema,
   StyleValueSchema,
   TEMPLATE_RECORD_JSON_SCHEMA_V1,
+  TRACKING_RELAY_PROTOCOL_VERSION,
   TemplatePackageRefSchema,
   TemplateRecordSchema,
   TemplateRequirementsSchema,
+  TikTokTrackingProviderConfigSchema,
+  TikTokTrackingSecretsSchema,
+  ToggleModalStepPayloadSchema,
+  TrackEventProviderSchema,
+  TrackEventStepPayloadSchema,
+  TrackingConfigSchema,
+  TrackingDeliverySchema,
+  TrackingProviderTypeSchema,
+  TrackingRelayErrorCodeSchema,
+  TrackingRelayProviderResultSchema,
+  TrackingRelayRequestSchema,
+  TrackingRelayResponseSchema,
   ValidateOnEventSchema,
   ValidationRuleSchema,
   ValidationRuleTypeSchema,
@@ -1796,6 +2184,9 @@ function getFormFieldBindingJsonSchema() {
   getManifestJsonSchema,
   getPageDocumentJsonSchema,
   getTemplateRecordJsonSchema,
+  getTrackingProviderSecretsJsonSchema,
+  getTrackingRelayRequestJsonSchema,
+  getTrackingRelayResponseJsonSchema,
   isActionBinding,
   isActionPipeline,
   isActionStep,
@@ -1814,6 +2205,9 @@ function getFormFieldBindingJsonSchema() {
   isSafeThumbnail,
   isSafeThumbnailUrl,
   isTemplateRecord,
+  isTrackEventStepPayload,
+  isTrackingConfig,
+  isTrackingRelayRequest,
   isValidateOnEvent,
   isValidationRule,
   isValidationRuleType,