@kubuild/schema 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -40,15 +40,19 @@ __export(index_exports, {
   ConditionOperatorSchema: () => ConditionOperatorSchema,
   CopyClipboardStepPayloadSchema: () => CopyClipboardStepPayloadSchema,
   CustomEventStepPayloadSchema: () => CustomEventStepPayloadSchema,
+  CustomTrackingProviderConfigSchema: () => CustomTrackingProviderConfigSchema,
   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,
+  GtmTrackingProviderConfigSchema: () => GtmTrackingProviderConfigSchema,
   MANIFEST_JSON_SCHEMA_V1: () => MANIFEST_JSON_SCHEMA_V1,
   ManifestAssetItemSchema: () => ManifestAssetItemSchema,
   ManifestSchema: () => ManifestSchema,
+  MetaTrackingProviderConfigSchema: () => MetaTrackingProviderConfigSchema,
   NavigateStepPayloadSchema: () => NavigateStepPayloadSchema,
   NodeSchema: () => NodeSchema,
   OpenModalStepPayloadSchema: () => OpenModalStepPayloadSchema,
@@ -66,6 +70,7 @@ __export(index_exports, {
   SafeThumbnailUrlSchema: () => SafeThumbnailUrlSchema,
   SetStateStepPayloadSchema: () => SetStateStepPayloadSchema,
   ShowToastStepPayloadSchema: () => ShowToastStepPayloadSchema,
+  StandardTrackingEventSchema: () => StandardTrackingEventSchema,
   StepPayloadSchemas: () => StepPayloadSchemas,
   StyleDefinitionSchema: () => StyleDefinitionSchema,
   StyleValueSchema: () => StyleValueSchema,
@@ -73,6 +78,11 @@ __export(index_exports, {
   TemplatePackageRefSchema: () => TemplatePackageRefSchema,
   TemplateRecordSchema: () => TemplateRecordSchema,
   TemplateRequirementsSchema: () => TemplateRequirementsSchema,
+  TikTokTrackingProviderConfigSchema: () => TikTokTrackingProviderConfigSchema,
+  TrackEventStepPayloadSchema: () => TrackEventStepPayloadSchema,
+  TrackingConfigSchema: () => TrackingConfigSchema,
+  TrackingDeliverySchema: () => TrackingDeliverySchema,
+  TrackingProviderTypeSchema: () => TrackingProviderTypeSchema,
   ValidateOnEventSchema: () => ValidateOnEventSchema,
   ValidationRuleSchema: () => ValidationRuleSchema,
   ValidationRuleTypeSchema: () => ValidationRuleTypeSchema,
@@ -103,6 +113,8 @@ __export(index_exports, {
   isSafeThumbnail: () => isSafeThumbnail,
   isSafeThumbnailUrl: () => isSafeThumbnailUrl,
   isTemplateRecord: () => isTemplateRecord,
+  isTrackEventStepPayload: () => isTrackEventStepPayload,
+  isTrackingConfig: () => isTrackingConfig,
   isValidateOnEvent: () => isValidateOnEvent,
   isValidationRule: () => isValidationRule,
   isValidationRuleType: () => isValidationRuleType,
@@ -121,11 +133,156 @@ __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),
+  /** Optional linked account/workspace credential ID */
+  credentialId: import_zod.z.string().optional(),
+  /** Meta Pixel ID (e.g. 123456789012345) */
+  pixelId: import_zod.z.string().optional().default(""),
+  /** Enable Server-Side Conversions API */
+  capiEnabled: import_zod.z.boolean().optional().default(false),
+  /**
+   * System User Access Token for Meta Graph API.
+   * Note: For security in production, prefer configuring tokens on your server backend
+   * or proxying via `serverRelayUrl`.
+   */
+  capiAccessToken: import_zod.z.string().optional().default(""),
+  /** Test Event Code from Meta Events Manager (e.g. "TEST12345") */
+  testEventCode: import_zod.z.string().optional().default(""),
+  /**
+   * Host Server Relay URL (e.g. "/api/tracking/meta").
+   * Recommended for browser clients to post CAPI events safely without exposing the secret token.
+   */
+  serverRelayUrl: import_zod.z.string().optional().default("")
+});
+var GoogleTrackingProviderConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  /** Optional linked account/workspace credential ID */
+  credentialId: import_zod.z.string().optional(),
+  /** GA4 Measurement ID (e.g. "G-XXXXXXXXXX") */
+  measurementId: import_zod.z.string().optional().default(""),
+  /** GA4 Measurement Protocol API Secret (for server-side events) */
+  measurementProtocolSecret: import_zod.z.string().optional().default(""),
+  /** Host Server Relay URL (e.g. "/api/tracking/ga4") */
+  serverRelayUrl: 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") */
+  containerId: import_zod.z.string().optional().default(""),
+  /** Host Server Relay URL */
+  serverRelayUrl: import_zod.z.string().optional().default("")
+});
+var TikTokTrackingProviderConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  /** Optional linked account/workspace credential ID */
+  credentialId: import_zod.z.string().optional(),
+  /** TikTok Pixel ID (e.g. "C1234567890") */
+  pixelId: import_zod.z.string().optional().default(""),
+  /** Enable TikTok Events API (server-side) */
+  eventsApiEnabled: import_zod.z.boolean().optional().default(false),
+  /** Long-term Access Token for TikTok Events API */
+  accessToken: import_zod.z.string().optional().default(""),
+  /** Test Event Code from TikTok Event Manager */
+  testEventCode: import_zod.z.string().optional().default(""),
+  /** Host Server Relay URL (e.g. "/api/tracking/tiktok") */
+  serverRelayUrl: import_zod.z.string().optional().default("")
+});
+var CustomTrackingProviderConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  /** Optional linked account/workspace credential ID */
+  credentialId: import_zod.z.string().optional(),
+  /** Custom Webhook endpoint URL */
+  endpointUrl: import_zod.z.string().optional().default(""),
+  /** Optional headers sent with the webhook POST request */
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional().default({})
+});
+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 StandardTrackingEventSchema = import_zod.z.enum([
+  "PageView",
+  "ViewContent",
+  "AddToCart",
+  "InitiateCheckout",
+  "Purchase",
+  "Lead",
+  "Contact",
+  "CompleteRegistration",
+  "Subscribe",
+  "Search",
+  "SubmitApplication",
+  "Schedule"
+]);
+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 */
+  provider: import_zod.z.enum(["all", "meta", "google", "tiktok", "custom"]).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)
+});
+function isTrackingConfig(value) {
+  return TrackingConfigSchema.safeParse(value).success;
+}
+function isTrackEventStepPayload(value) {
+  return TrackEventStepPayloadSchema.safeParse(value).success;
+}
+
+// src/actions.ts
+var ActionTriggerTypeSchema = import_zod2.z.enum([
   "click",
   "submit",
   "change",
@@ -134,7 +291,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",
@@ -143,9 +300,10 @@ var ActionStepTypeSchema = import_zod.z.enum([
   "open_modal",
   "close_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 +316,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 +330,68 @@ 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 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,
@@ -244,29 +402,30 @@ var StepPayloadSchemas = {
   open_modal: OpenModalStepPayloadSchema,
   close_modal: CloseModalStepPayloadSchema,
   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 +450,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 +540,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 +553,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;
@@ -437,55 +596,55 @@ 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 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 +657,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 +676,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 +789,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 +821,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;
@@ -1751,15 +1913,19 @@ function getFormFieldBindingJsonSchema() {
   ConditionOperatorSchema,
   CopyClipboardStepPayloadSchema,
   CustomEventStepPayloadSchema,
+  CustomTrackingProviderConfigSchema,
   DEFAULT_ANIMATION_CONFIG,
   DocumentMetadataSchema,
   FORM_CONFIG_JSON_SCHEMA_V1,
   FORM_FIELD_BINDING_JSON_SCHEMA_V1,
   FormConfigSchema,
   FormFieldBindingSchema,
+  GoogleTrackingProviderConfigSchema,
+  GtmTrackingProviderConfigSchema,
   MANIFEST_JSON_SCHEMA_V1,
   ManifestAssetItemSchema,
   ManifestSchema,
+  MetaTrackingProviderConfigSchema,
   NavigateStepPayloadSchema,
   NodeSchema,
   OpenModalStepPayloadSchema,
@@ -1777,6 +1943,7 @@ function getFormFieldBindingJsonSchema() {
   SafeThumbnailUrlSchema,
   SetStateStepPayloadSchema,
   ShowToastStepPayloadSchema,
+  StandardTrackingEventSchema,
   StepPayloadSchemas,
   StyleDefinitionSchema,
   StyleValueSchema,
@@ -1784,6 +1951,11 @@ function getFormFieldBindingJsonSchema() {
   TemplatePackageRefSchema,
   TemplateRecordSchema,
   TemplateRequirementsSchema,
+  TikTokTrackingProviderConfigSchema,
+  TrackEventStepPayloadSchema,
+  TrackingConfigSchema,
+  TrackingDeliverySchema,
+  TrackingProviderTypeSchema,
   ValidateOnEventSchema,
   ValidationRuleSchema,
   ValidationRuleTypeSchema,
@@ -1814,6 +1986,8 @@ function getFormFieldBindingJsonSchema() {
   isSafeThumbnail,
   isSafeThumbnailUrl,
   isTemplateRecord,
+  isTrackEventStepPayload,
+  isTrackingConfig,
   isValidateOnEvent,
   isValidationRule,
   isValidationRuleType,