@getrheo/contracts 1.0.0

package/dist/manifest.js

@@ -0,0 +1,2163 @@
+import { z } from 'zod';
+
+// src/manifest/version.ts
+var MANIFEST_SCHEMA_VERSION = 7;
+var ThemeSchema = z.object({
+  primary: z.string().optional(),
+  primaryForeground: z.string().optional(),
+  background: z.string().optional(),
+  foreground: z.string().optional(),
+  accent: z.string().optional(),
+  borderRadius: z.number().optional(),
+  fontFamily: z.string().optional()
+});
+var BuilderMetaSchema = z.object({
+  layout: z.object({
+    nodes: z.array(
+      z.object({
+        id: z.string(),
+        kind: z.enum(["screen", "decision"]).optional(),
+        x: z.number(),
+        y: z.number()
+      })
+    ).optional(),
+    canvas: z.object({
+      zoom: z.number().optional(),
+      x: z.number().optional(),
+      y: z.number().optional()
+    }).optional()
+  }).optional()
+}).passthrough().optional();
+
+// src/layers/layerSchemaRef.ts
+var layerSchemaStore = {};
+var LocaleCode = z.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/, 'locale must be like "en" or "en-US"');
+var LocalizedTextSchema = z.object({
+  default: z.string().min(1, "default copy is required"),
+  translations: z.record(LocaleCode, z.string()).optional()
+});
+
+// src/hyperlinkHref.ts
+var parseHyperlinkHref = (raw) => {
+  const t = raw.trim();
+  if (!t) return { ok: false };
+  let u;
+  try {
+    u = new URL(t);
+  } catch {
+    return { ok: false };
+  }
+  const scheme = u.protocol.replace(/:$/, "").toLowerCase();
+  if (scheme === "https") {
+    if (!u.hostname) return { ok: false };
+    return { ok: true, scheme: "https", host: u.hostname };
+  }
+  if (scheme === "mailto") {
+    return { ok: true, scheme: "mailto" };
+  }
+  return { ok: false };
+};
+
+// src/constants/index.ts
+var FIELD_CLASSIFICATIONS = ["safe", "sensitive"];
+var MEDIA_TYPES = ["image", "font", "lottie", "video"];
+
+// src/media.ts
+var MediaTypeSchema = z.enum(MEDIA_TYPES);
+var MediaReferenceSchema = z.object({
+  mediaAssetId: z.string().uuid()
+});
+z.object({
+  id: z.string().uuid(),
+  orgId: z.string().uuid(),
+  type: MediaTypeSchema,
+  url: z.string().url(),
+  name: z.string().nullable().optional(),
+  contentType: z.string(),
+  sizeBytes: z.number().int().nonnegative(),
+  archivedAt: z.string().datetime().nullable().optional(),
+  createdAt: z.string().datetime()
+});
+var LayerIdSchema = z.string().min(1).max(64).regex(/^lyr_[a-z0-9_]+$/i, "layer id must look like lyr_<id>");
+var ScreenIdSchema = z.string().min(1).max(64).regex(/^scr_[a-z0-9_]+$/i, "screen id must look like scr_<id>");
+var RESTING_MOTION_PRESETS = ["translate", "bounce", "scale", "pulse", "rotate"];
+var RestingMotionPresetSchema = z.enum(RESTING_MOTION_PRESETS);
+var RESTING_MOTION_SCALE_DIRECTIONS = ["up", "down"];
+var RestingMotionScaleDirectionSchema = z.enum(RESTING_MOTION_SCALE_DIRECTIONS);
+var RESTING_MOTION_ROTATE_DIRECTIONS = ["clockwise", "counterclockwise"];
+var RestingMotionRotateDirectionSchema = z.enum(RESTING_MOTION_ROTATE_DIRECTIONS);
+var RestingMotionSchema = z.object({
+  preset: RestingMotionPresetSchema,
+  /**
+   * Timeline segment length (ms): motion is active from start until
+   * start + durationMs. When {@link loop} is true, the preset pattern repeats
+   * every {@link cycleDurationMs} (or preset default) within this window.
+   */
+  durationMs: z.number().int().min(200).max(2e4).optional(),
+  /** When true, repeat the motion pattern within the timeline segment; default is one shot. */
+  loop: z.boolean().optional(),
+  /**
+   * Duration (ms) of one full pattern cycle when looping. Defaults per {@link RESTING_MOTION_DEFAULT_DURATION_MS}.
+   */
+  cycleDurationMs: z.number().int().min(200).max(2e4).optional(),
+  intensity: z.number().min(0).max(2).optional(),
+  /** Bounce preset only: vertical lift in px. When omitted, uses `14 * intensity` (default intensity 1 → 14). */
+  bounceAmplitudePx: z.number().min(1).max(80).optional(),
+  /** Scale preset: grow (+) or shrink (−) toward a peak, then return to 100%. */
+  scaleDirection: RestingMotionScaleDirectionSchema.optional(),
+  /**
+   * Scale preset: when true (default), each cycle goes rest → peak scale → rest.
+   * When false, ramps rest → peak and holds; with loop, the next cycle restarts from rest.
+   */
+  scaleSpringBack: z.boolean().optional(),
+  /**
+   * Scale preset: magnitude in % — growth above 100% (up to +400% = 5× at peak) or shrink toward
+   * 100%− (up to 90% so peak can be 10% size). See authoring caps in the layer editor.
+   */
+  scalePercent: z.number().min(0).max(400).optional(),
+  /**
+   * Scale preset: ms for one full out-and-back (rest → peak → rest). Timeline bar still sets
+   * {@link durationMs} (when the layer may animate); this controls how fast each cycle runs.
+   */
+  scalePatternDurationMs: z.number().int().min(200).max(2e4).optional(),
+  /** @deprecated Use {@link scalePercent} + {@link scaleDirection}. Kept for legacy manifests. */
+  scaleUpPercent: z.number().min(0).max(400).optional(),
+  /** @deprecated Use {@link scalePercent} + {@link scaleDirection}. Kept for legacy manifests. */
+  scaleDownPercent: z.number().min(0).max(90).optional(),
+  /**
+   * @deprecated Legacy vertical-only float (px). Prefer {@link translatePeakXPercent} / {@link translatePeakYPercent}.
+   */
+  translateRangePx: z.number().min(0).max(40).optional(),
+  /** @deprecated Legacy peak offsets in px. Prefer {@link translatePeakXPercent} / {@link translatePeakYPercent}. */
+  translatePeakXPx: z.number().min(-200).max(200).optional(),
+  /** @deprecated Legacy peak offsets in px. Prefer {@link translatePeakXPercent} / {@link translatePeakYPercent}. */
+  translatePeakYPx: z.number().min(-200).max(200).optional(),
+  /** Translate preset: peak X offset as % of the layer box (−200–200). Scaled by intensity. */
+  translatePeakXPercent: z.number().min(-200).max(200).optional(),
+  /** Translate preset: peak Y offset as % of the layer box (−200–200). Scaled by intensity. */
+  translatePeakYPercent: z.number().min(-200).max(200).optional(),
+  /**
+   * Translate preset: when true (default), each cycle goes rest → peak offset → rest. When false, ramp to
+   * peak and hold; with loop, the next cycle restarts from the origin.
+   */
+  translateSpringBack: z.boolean().optional(),
+  /** Rotate preset: target rotation in degrees (0–360), scaled by intensity. */
+  rotateMaxDeg: z.number().min(0).max(360).optional(),
+  /** Rotate preset: spin direction; omitted or `clockwise` → positive angles (default). */
+  rotateDirection: RestingMotionRotateDirectionSchema.optional(),
+  /**
+   * Rotate preset: when true (default), each cycle oscillates 0° → peak → 0°.
+   * When false, each cycle ramps 0° → peak and holds; with loop, the next cycle snaps to 0° and ramps again.
+   */
+  rotateSpringBack: z.boolean().optional(),
+  /** Pulse preset: minimum opacity at the dip (0–1). Omitted → `1 - 0.38 * intensity`. */
+  pulseMinOpacity: z.number().min(0).max(1).optional(),
+  /** Ms after the last mount/stagger clip ends before motion applies (authoring + scrub). */
+  delayMsAfterMountEnd: z.number().int().min(0).max(6e4).optional(),
+  /**
+   * Absolute start time (ms from screen mount). When set, overrides
+   * {@link delayMsAfterMountEnd} + mount-clip end so motion can sit between
+   * clips (e.g. after first entry, before exit) when multiple mounts exist.
+   */
+  timelineStartMs: z.number().int().min(0).max(36e5).optional()
+}).strict();
+var RestingMotionEntrySchema = RestingMotionSchema.extend({
+  id: z.string().min(1)
+});
+
+// src/layers/base.ts
+var baseLayerShape = {
+  id: LayerIdSchema,
+  name: z.string().max(80).optional(),
+  restingMotion: RestingMotionSchema.optional(),
+  restingMotions: z.array(RestingMotionEntrySchema).optional()
+};
+var ThemedColorModesSchema = z.object({
+  light: z.string().min(1).optional(),
+  dark: z.string().min(1).optional()
+}).strict().refine((o) => o.light !== void 0 || o.dark !== void 0, {
+  message: "at least one of light or dark is required"
+});
+var ThemedColorSchema = z.union([z.string().min(1), ThemedColorModesSchema]);
+var WIDTH_PRESETS = ["auto", "full", "1/2", "1/3", "2/3", "1/4", "3/4"];
+var WidthValueSchema = z.union([z.enum(WIDTH_PRESETS), z.number().int().min(0).max(2e3)]);
+var HEIGHT_PRESETS = ["auto", "full", "fill"];
+var CommonLayoutHeightSchema = z.union([
+  z.enum(HEIGHT_PRESETS),
+  z.number().int().min(0).max(2e3)
+]);
+
+// src/layers/styleCommon.ts
+var NonNegativePxSchema = z.number().int().min(0);
+var PaddingSchema = z.object({
+  t: NonNegativePxSchema.optional(),
+  r: NonNegativePxSchema.optional(),
+  b: NonNegativePxSchema.optional(),
+  l: NonNegativePxSchema.optional()
+}).partial();
+var BorderSchema = z.object({
+  width: z.number().int().min(0).max(20).optional(),
+  color: ThemedColorSchema.optional()
+}).partial();
+var DropShadowSchema = z.object({
+  offsetX: z.number().int().min(-100).max(100).optional(),
+  offsetY: z.number().int().min(-100).max(100).optional(),
+  blur: z.number().int().min(0).max(100).optional(),
+  spread: z.number().int().min(-50).max(50).optional(),
+  color: ThemedColorSchema.optional(),
+  opacity: z.number().min(0).max(1).optional()
+}).partial();
+var CommonStyleSchema = z.object({
+  padding: PaddingSchema.optional(),
+  margin: PaddingSchema.optional(),
+  radius: z.number().int().min(0).max(96).optional(),
+  background: ThemedColorSchema.optional(),
+  border: BorderSchema.optional(),
+  shadow: DropShadowSchema.optional(),
+  opacity: z.number().min(0).max(1).optional(),
+  width: WidthValueSchema.optional(),
+  /** Omit for normal flow; `'absolute'` removes the layer from flex flow (non-root only). */
+  position: z.literal("absolute").optional(),
+  /** Pixel insets when `position === 'absolute'` (same shape as padding). */
+  inset: PaddingSchema.optional(),
+  zIndex: z.number().int().min(-999).max(999).optional(),
+  /** Static rotation in degrees (CSS `rotate`); not timeline animation. */
+  rotate: z.number().min(-360).max(360).optional(),
+  /** Cross-axis size: `auto` (hug), `full`/`fill` (parent height), or fixed px. No fractions. */
+  height: CommonLayoutHeightSchema.optional(),
+  /** Stroke thickness in px for layers that render a stroke primitive (e.g. loader ring). */
+  strokeWidth: z.number().int().min(0).max(64).optional()
+}).partial();
+var TextStyleSchema = CommonStyleSchema.extend({
+  /**
+   * Logical font family: manifest `theme.fontFamily` when omitted, {@link TEXT_FONT_FAMILY_SYSTEM_UI}
+   * for the platform stack, or a custom name (matches `Branding.fontFamilies[].name` for uploaded fonts).
+   */
+  fontFamily: z.string().min(1).max(128).optional(),
+  fontSize: z.number().int().min(8).max(96).optional(),
+  fontWeight: z.number().int().min(100).max(900).optional(),
+  color: ThemedColorSchema.optional(),
+  align: z.enum(["left", "center", "right"]).optional(),
+  lineHeight: z.number().min(0.8).max(3).optional(),
+  /** Multiplier (0–1) applied to the resolved background color alpha only; text stays fully opaque unless `opacity` is set. */
+  backgroundOpacity: z.number().min(0).max(1).optional()
+});
+var ImageStyleSchema = CommonStyleSchema.extend({
+  fit: z.enum(["cover", "contain", "fill"]).optional(),
+  aspectRatio: z.number().positive().max(10).optional()
+});
+var IconStyleSchema = CommonStyleSchema.extend({
+  color: ThemedColorSchema.optional()
+});
+var ICON_FAMILIES = ["ionicons"];
+var ButtonStyleSchema = CommonStyleSchema.extend({
+  fontSize: z.number().int().min(8).max(96).optional(),
+  fontWeight: z.number().int().min(100).max(900).optional(),
+  color: ThemedColorSchema.optional(),
+  align: z.enum(["left", "center", "right"]).optional()
+});
+var BUTTON_LAYER_VARIANTS = ["primary", "secondary", "ghost", "destructive"];
+var ButtonLayerVariantSchema = z.enum(BUTTON_LAYER_VARIANTS);
+var CommonStyleBreakpointsSchema = z.object({
+  sm: CommonStyleSchema.partial().optional(),
+  md: CommonStyleSchema.partial().optional(),
+  lg: CommonStyleSchema.partial().optional(),
+  xl: CommonStyleSchema.partial().optional(),
+  "2xl": CommonStyleSchema.partial().optional()
+}).partial().optional();
+var TextStyleBreakpointsSchema = z.object({
+  sm: TextStyleSchema.partial().optional(),
+  md: TextStyleSchema.partial().optional(),
+  lg: TextStyleSchema.partial().optional(),
+  xl: TextStyleSchema.partial().optional(),
+  "2xl": TextStyleSchema.partial().optional()
+}).partial().optional();
+var ImageStyleBreakpointsSchema = z.object({
+  sm: ImageStyleSchema.partial().optional(),
+  md: ImageStyleSchema.partial().optional(),
+  lg: ImageStyleSchema.partial().optional(),
+  xl: ImageStyleSchema.partial().optional(),
+  "2xl": ImageStyleSchema.partial().optional()
+}).partial().optional();
+var IconStyleBreakpointsSchema = z.object({
+  sm: IconStyleSchema.partial().optional(),
+  md: IconStyleSchema.partial().optional(),
+  lg: IconStyleSchema.partial().optional(),
+  xl: IconStyleSchema.partial().optional(),
+  "2xl": IconStyleSchema.partial().optional()
+}).partial().optional();
+var ButtonStyleBreakpointsSchema = z.object({
+  sm: ButtonStyleSchema.partial().optional(),
+  md: ButtonStyleSchema.partial().optional(),
+  lg: ButtonStyleSchema.partial().optional(),
+  xl: ButtonStyleSchema.partial().optional(),
+  "2xl": ButtonStyleSchema.partial().optional()
+}).partial().optional();
+var StackLayoutBreakpointPatchSchema = z.object({
+  gap: NonNegativePxSchema.optional(),
+  direction: z.enum(["vertical", "horizontal"]).optional()
+}).partial();
+var StackLayoutBreakpointsSchema = z.object({
+  sm: StackLayoutBreakpointPatchSchema.optional(),
+  md: StackLayoutBreakpointPatchSchema.optional(),
+  lg: StackLayoutBreakpointPatchSchema.optional(),
+  xl: StackLayoutBreakpointPatchSchema.optional(),
+  "2xl": StackLayoutBreakpointPatchSchema.optional()
+}).partial().optional();
+var ButtonLayoutBreakpointPatchSchema = z.object({
+  gap: NonNegativePxSchema.optional(),
+  direction: z.enum(["vertical", "horizontal"]).optional()
+}).partial();
+var ButtonLayoutBreakpointsSchema = z.object({
+  sm: ButtonLayoutBreakpointPatchSchema.optional(),
+  md: ButtonLayoutBreakpointPatchSchema.optional(),
+  lg: ButtonLayoutBreakpointPatchSchema.optional(),
+  xl: ButtonLayoutBreakpointPatchSchema.optional(),
+  "2xl": ButtonLayoutBreakpointPatchSchema.optional()
+}).partial().optional();
+var OS_PERMISSION_KEYS = [
+  "notifications",
+  "camera",
+  "microphone",
+  "photo_library",
+  "contacts",
+  "calendar",
+  "reminders",
+  "location_when_in_use",
+  "location_always",
+  "motion",
+  "bluetooth",
+  "app_tracking_transparency",
+  "speech_recognition",
+  "face_id",
+  "health_kit",
+  "media_library",
+  "local_network",
+  "nearby_interactions",
+  "nfc",
+  "full_screen_intent_android",
+  "sms_android",
+  "phone_android"
+];
+var OsPermissionKeySchema = z.enum(OS_PERMISSION_KEYS);
+var PERMISSION_CAPTURE_FIELD_KEY_PREFIX = "permission:";
+var permissionCaptureFieldKey = (key) => `${PERMISSION_CAPTURE_FIELD_KEY_PREFIX}${key}`;
+var PERMISSION_OUTCOME_VALUES = ["granted", "denied", "blocked"];
+z.enum(PERMISSION_OUTCOME_VALUES);
+var OS_PERMISSION_OUTCOME_CONTINUE = "continue";
+var OS_PERMISSION_OUTCOME_END = "end";
+var OsPermissionOutcomeBranchTargetSchema = z.union([
+  ScreenIdSchema,
+  z.literal(OS_PERMISSION_OUTCOME_CONTINUE),
+  z.literal(OS_PERMISSION_OUTCOME_END)
+]);
+var OsPermissionOutcomesSchema = z.object({
+  granted: OsPermissionOutcomeBranchTargetSchema,
+  denied: OsPermissionOutcomeBranchTargetSchema,
+  blocked: OsPermissionOutcomeBranchTargetSchema
+}).strict();
+var APP_REVIEW_OUTCOMES = ["not_shown", "dismissed"];
+z.enum(APP_REVIEW_OUTCOMES);
+var ButtonActionSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("none") }),
+  z.object({ kind: z.literal("continue") }),
+  z.object({ kind: z.literal("skip") }),
+  z.object({ kind: z.literal("end_flow") }),
+  z.object({
+    kind: z.literal("go_back_one_screen"),
+    fallbackScreenId: ScreenIdSchema.optional()
+  }),
+  z.object({ kind: z.literal("go_to_step"), screenId: ScreenIdSchema }),
+  z.object({
+    kind: z.literal("request_os_permission"),
+    permissionKey: OsPermissionKeySchema,
+    outcomes: OsPermissionOutcomesSchema
+  }),
+  z.object({
+    kind: z.literal("play_media"),
+    targetLayerIds: z.array(z.string().min(1)).min(1)
+  }),
+  z.object({ kind: z.literal("request_app_review") })
+]);
+var TEXT_INPUT_TYPES = ["plain", "email", "phone", "url", "multiline"];
+var TextInputTypeSchema = z.enum(TEXT_INPUT_TYPES);
+var COUNTER_DISPLAY_KINDS = ["number", "time"];
+var COUNTER_TIME_FORMATS = ["mm_ss", "hh_mm_ss", "dd_hh_mm_ss"];
+var CheckboxGlyphStyleSchema = z.object({
+  /** Square edge length in px. */
+  size: z.number().int().min(8).max(128).optional(),
+  radius: z.number().int().min(0).max(96).optional(),
+  background: ThemedColorSchema.optional(),
+  border: BorderSchema.optional(),
+  shadow: DropShadowSchema.optional(),
+  opacity: z.number().min(0).max(1).optional(),
+  /** Fill color for the check mark when checked. */
+  checkColor: ThemedColorSchema.optional()
+}).partial();
+var OAUTH_LOGIN_PRESETS = ["github", "google", "apple"];
+var OAuthPresetButtonChromeSchema = CommonStyleSchema.pick({
+  width: true,
+  padding: true,
+  margin: true,
+  radius: true
+}).partial();
+var OAuthPresetButtonChromeBreakpointsSchema = z.object({
+  sm: OAuthPresetButtonChromeSchema.partial().optional(),
+  md: OAuthPresetButtonChromeSchema.partial().optional(),
+  lg: OAuthPresetButtonChromeSchema.partial().optional(),
+  xl: OAuthPresetButtonChromeSchema.partial().optional(),
+  "2xl": OAuthPresetButtonChromeSchema.partial().optional()
+}).partial().optional();
+var EMAIL_PASSWORD_AUTH_MODES = ["sign_in", "sign_up"];
+var EMAIL_PASSWORD_SLOTS = ["email", "password", "confirm"];
+
+// src/layers/kinds/chrome.ts
+var lazyLayer = () => layerSchemaStore.schema;
+var ButtonLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("button"),
+  children: z.lazy(() => z.array(lazyLayer())),
+  action: ButtonActionSchema,
+  variant: ButtonLayerVariantSchema,
+  direction: z.enum(["vertical", "horizontal"]).optional(),
+  gap: z.number().int().min(0).optional(),
+  align: z.enum(["start", "center", "end", "stretch"]).optional(),
+  distribution: z.enum(["start", "center", "end", "between", "around"]).optional(),
+  style: ButtonStyleSchema.optional(),
+  styleBreakpoints: ButtonStyleBreakpointsSchema,
+  buttonLayoutBreakpoints: ButtonLayoutBreakpointsSchema
+});
+var BackButtonLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("back_button"),
+  children: z.lazy(() => z.array(lazyLayer())),
+  variant: ButtonLayerVariantSchema,
+  direction: z.enum(["vertical", "horizontal"]).optional(),
+  gap: z.number().int().min(0).optional(),
+  align: z.enum(["start", "center", "end", "stretch"]).optional(),
+  distribution: z.enum(["start", "center", "end", "between", "around"]).optional(),
+  style: ButtonStyleSchema.optional(),
+  styleBreakpoints: ButtonStyleBreakpointsSchema,
+  buttonLayoutBreakpoints: ButtonLayoutBreakpointsSchema,
+  fallbackScreenId: ScreenIdSchema.optional()
+});
+var ProgressLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("progress"),
+  trackColor: ThemedColorSchema.optional(),
+  fillColor: ThemedColorSchema.optional(),
+  style: CommonStyleSchema.optional()
+});
+var LoaderOnCompleteSchema = z.discriminatedUnion("mode", [
+  z.object({ mode: z.literal("none") }),
+  z.object({ mode: z.literal("next") }),
+  z.object({ mode: z.literal("screen"), screenId: ScreenIdSchema })
+]);
+var LoaderLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("loader"),
+  variant: z.enum(["linear", "circular"]).optional(),
+  targetPercent: z.number().int().min(0).max(100).optional(),
+  fillDelayMs: z.number().int().min(0).max(1e4).optional(),
+  durationMs: z.number().int().min(0).max(36e5).optional(),
+  onComplete: LoaderOnCompleteSchema.optional(),
+  trackColor: ThemedColorSchema.optional(),
+  trackOpacity: z.number().min(0).max(1).optional(),
+  fillColor: ThemedColorSchema.optional(),
+  /** Horizontal alignment of the bar or ring within the layer box (default start). */
+  align: z.enum(["start", "center", "end"]).optional(),
+  style: CommonStyleSchema.optional()
+}).superRefine((data, ctx) => {
+  if (data.variant !== "circular") return;
+  const w = data.style?.width;
+  const h = data.style?.height;
+  if (typeof w === "number" && typeof h === "number" && w !== h) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "circular loader requires style.width === style.height",
+      path: ["style", "height"]
+    });
+  }
+});
+var CounterLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("counter"),
+  startValue: z.number().finite(),
+  endValue: z.number().finite(),
+  durationMs: z.number().int().min(0).max(36e5).optional(),
+  delayMs: z.number().int().min(0).max(36e5).optional(),
+  decimalPlaces: z.number().int().min(0).max(10).optional(),
+  displayKind: z.enum(COUNTER_DISPLAY_KINDS).optional(),
+  timeFormat: z.enum(COUNTER_TIME_FORMATS).optional(),
+  style: TextStyleSchema.optional(),
+  styleBreakpoints: TextStyleBreakpointsSchema
+});
+var CheckboxLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("checkbox"),
+  fieldKey: z.string().min(1),
+  blocking: z.boolean().optional(),
+  uncheckedStyle: CheckboxGlyphStyleSchema.optional(),
+  checkedStyle: CheckboxGlyphStyleSchema.optional(),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema
+});
+
+// src/layers/kinds/layout.ts
+var lazyLayer2 = () => layerSchemaStore.schema;
+var StackLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("stack"),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema,
+  stackLayoutBreakpoints: StackLayoutBreakpointsSchema,
+  selectedStyle: CommonStyleSchema.optional(),
+  direction: z.enum(["vertical", "horizontal"]),
+  gap: z.number().int().min(0).optional(),
+  align: z.enum(["start", "center", "end", "stretch"]).optional(),
+  justify: z.enum(["start", "center", "end"]).optional(),
+  distribution: z.enum(["start", "center", "end", "between", "around"]).optional(),
+  wrap: z.boolean().optional(),
+  children: z.lazy(() => z.array(lazyLayer2()))
+});
+var TextLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("text"),
+  text: LocalizedTextSchema,
+  style: TextStyleSchema.optional(),
+  styleBreakpoints: TextStyleBreakpointsSchema
+});
+var migrateLegacyHyperlinkForParse = (raw) => {
+  if (!raw || typeof raw !== "object") return raw;
+  const o = raw;
+  if (o.kind !== "hyperlink") return raw;
+  const existing = o.children;
+  if (Array.isArray(existing) && existing.length > 0) return raw;
+  const idSrc = typeof o.id === "string" ? o.id.replace(/[^a-zA-Z0-9_]/g, "_") : "lyr_hyperlink";
+  const textChildId = `${idSrc}_lnktxt`.slice(0, 64);
+  const children = [
+    {
+      id: textChildId,
+      kind: "text",
+      text: o.text ?? { default: "Link" },
+      ...typeof o.style === "object" && o.style !== null ? { style: o.style } : {},
+      ...typeof o.styleBreakpoints === "object" && o.styleBreakpoints !== null ? { styleBreakpoints: o.styleBreakpoints } : {}
+    }
+  ];
+  const next = {
+    ...o,
+    children
+  };
+  delete next.text;
+  delete next.style;
+  delete next.styleBreakpoints;
+  return next;
+};
+var HyperlinkLayerSchemaInner = z.object({
+  ...baseLayerShape,
+  kind: z.literal("hyperlink"),
+  href: z.string().min(1).max(2048),
+  children: z.lazy(() => z.array(lazyLayer2()).min(1)),
+  direction: z.enum(["vertical", "horizontal"]).optional(),
+  gap: z.number().int().min(0).optional(),
+  align: z.enum(["start", "center", "end", "stretch"]).optional(),
+  distribution: z.enum(["start", "center", "end", "between", "around"]).optional(),
+  wrap: z.boolean().optional(),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema
+}).superRefine((data, ctx) => {
+  const p = parseHyperlinkHref(data.href.trim());
+  if (!p.ok) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "hyperlink href must be a valid https: or mailto: URL",
+      path: ["href"]
+    });
+  }
+});
+var HyperlinkLayerSchema = z.preprocess(
+  migrateLegacyHyperlinkForParse,
+  HyperlinkLayerSchemaInner
+);
+var ImageLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("image"),
+  media: MediaReferenceSchema.optional(),
+  alt: z.string().max(280).optional(),
+  style: ImageStyleSchema.optional(),
+  styleBreakpoints: ImageStyleBreakpointsSchema
+});
+var LottieLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("lottie"),
+  media: MediaReferenceSchema.optional(),
+  loop: z.boolean().optional(),
+  autoPlay: z.boolean().optional(),
+  triggerLayerId: z.string().min(1).optional(),
+  onComplete: LoaderOnCompleteSchema.optional(),
+  style: ImageStyleSchema.optional(),
+  styleBreakpoints: ImageStyleBreakpointsSchema
+});
+var VideoLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("video"),
+  media: MediaReferenceSchema.optional(),
+  loop: z.boolean().optional(),
+  autoPlay: z.boolean().optional(),
+  triggerLayerId: z.string().min(1).optional(),
+  onComplete: LoaderOnCompleteSchema.optional(),
+  audioEnabled: z.boolean().optional(),
+  style: ImageStyleSchema.optional(),
+  styleBreakpoints: ImageStyleBreakpointsSchema
+});
+var IconLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("icon"),
+  family: z.enum(ICON_FAMILIES),
+  iconName: z.string().min(1).max(128),
+  style: IconStyleSchema.optional(),
+  styleBreakpoints: IconStyleBreakpointsSchema
+});
+var lazyLayer3 = () => layerSchemaStore.schema;
+var OAuthProviderPresetLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("oauth_provider"),
+  variant: z.literal("preset"),
+  provider: z.enum(OAUTH_LOGIN_PRESETS),
+  label: LocalizedTextSchema.optional(),
+  style: OAuthPresetButtonChromeSchema.optional(),
+  styleBreakpoints: OAuthPresetButtonChromeBreakpointsSchema.optional()
+});
+var migrateOAuthProviderCustomIncoming = (raw) => {
+  if (!raw || typeof raw !== "object") return raw;
+  const o = raw;
+  if (o.kind !== "oauth_provider" || o.variant !== "custom") return raw;
+  const ch = o.children;
+  if (Array.isArray(ch) && ch.length > 0) {
+    const next2 = { ...o };
+    if (next2.buttonVariant === void 0) next2.buttonVariant = "secondary";
+    return next2;
+  }
+  const pid = typeof o.id === "string" ? o.id : "lyr_oauth_custom";
+  const slug = pid.replace(/[^a-z0-9_]/gi, "_").slice(0, 40) || "oauth";
+  const label = o.label ?? { default: "Custom" };
+  let family = o.family ?? "ionicons";
+  let iconName = o.iconName ?? "shield-outline";
+  if (family === "sf_symbol") {
+    family = "ionicons";
+    iconName = "star-outline";
+  }
+  const cid = slug;
+  const iconId = `lyr_${cid}_ico`.slice(0, 64);
+  const textId = `lyr_${cid}_txt`.slice(0, 64);
+  const next = { ...o };
+  delete next.label;
+  delete next.family;
+  delete next.iconName;
+  return {
+    ...next,
+    buttonVariant: o.buttonVariant ?? "secondary",
+    children: [
+      { id: iconId, kind: "icon", family, iconName },
+      { id: textId, kind: "text", text: label }
+    ]
+  };
+};
+var OAuthProviderCustomLayerSchemaValidated = z.object({
+  ...baseLayerShape,
+  kind: z.literal("oauth_provider"),
+  variant: z.literal("custom"),
+  rowId: z.string().uuid(),
+  buttonVariant: ButtonLayerVariantSchema,
+  direction: z.enum(["vertical", "horizontal"]).optional(),
+  gap: z.number().int().min(0).optional(),
+  align: z.enum(["start", "center", "end", "stretch"]).optional(),
+  distribution: z.enum(["start", "center", "end", "between", "around"]).optional(),
+  children: z.lazy(() => z.array(lazyLayer3()).min(1)),
+  style: ButtonStyleSchema.optional(),
+  styleBreakpoints: ButtonStyleBreakpointsSchema,
+  buttonLayoutBreakpoints: ButtonLayoutBreakpointsSchema
+});
+var OAuthProviderCustomLayerSchema = z.preprocess(
+  migrateOAuthProviderCustomIncoming,
+  OAuthProviderCustomLayerSchemaValidated
+);
+var OAuthProviderLayerSchema = z.union([
+  OAuthProviderPresetLayerSchema,
+  OAuthProviderCustomLayerSchema
+]);
+var OAuthLoginPresetProviderSchema = z.object({
+  type: z.literal("preset"),
+  provider: z.enum(OAUTH_LOGIN_PRESETS)
+});
+var OAuthLoginCustomProviderSchema = z.object({
+  type: z.literal("custom"),
+  rowId: z.string().uuid(),
+  label: LocalizedTextSchema,
+  family: z.enum(ICON_FAMILIES),
+  iconName: z.string().min(1).max(128)
+});
+var OAuthLoginProviderSchema = z.discriminatedUnion("type", [
+  OAuthLoginPresetProviderSchema,
+  OAuthLoginCustomProviderSchema
+]);
+var oauthLoginChildrenUniquePresets = (children, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < children.length; i++) {
+    const c = children[i];
+    if (!c || c.kind !== "oauth_provider" || c.variant !== "preset") continue;
+    const preset = c.provider;
+    if (seen.has(preset)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate OAuth preset "${preset}"`,
+        path: ["children", i, "provider"]
+      });
+      return;
+    }
+    seen.add(preset);
+  }
+};
+var migrateOAuthLoginIncoming = (raw) => {
+  if (!raw || typeof raw !== "object") return raw;
+  const o = raw;
+  if (o.kind !== "oauth_login") return raw;
+  if (Array.isArray(o.children) && o.children.length > 0) return raw;
+  const provs = o.providers;
+  if (!Array.isArray(provs) || provs.length === 0) return raw;
+  const pid = typeof o.id === "string" ? o.id : "lyr_oauth_legacy";
+  const slug = pid.replace(/^lyr_/i, "").replace(/[^a-z0-9_]/gi, "_").replace(/^_+/, "").slice(0, 48) || "oauth";
+  const children = provs.map((p, idx) => {
+    const prov = p ?? {};
+    const cid = `lyr_${slug}_opr_${idx}`.slice(0, 64);
+    if (prov.type === "preset") {
+      return {
+        id: cid,
+        kind: "oauth_provider",
+        variant: "preset",
+        provider: prov.provider
+      };
+    }
+    return {
+      id: cid,
+      kind: "oauth_provider",
+      variant: "custom",
+      rowId: String(prov.rowId),
+      buttonVariant: "secondary",
+      children: [
+        {
+          id: `${cid}_ico`.slice(0, 64),
+          kind: "icon",
+          family: prov.family ?? "ionicons",
+          iconName: String(prov.iconName ?? "shield")
+        },
+        {
+          id: `${cid}_txt`.slice(0, 64),
+          kind: "text",
+          text: prov.label ?? { default: "Custom" }
+        }
+      ]
+    };
+  });
+  const { providers: _omit, ...rest } = o;
+  return { ...rest, children };
+};
+var OAuthLoginLayerSchemaValidated = z.object({
+  ...baseLayerShape,
+  kind: z.literal("oauth_login"),
+  children: z.lazy(
+    () => z.array(OAuthProviderLayerSchema).min(1).superRefine(oauthLoginChildrenUniquePresets)
+  ),
+  gap: z.number().int().min(0).optional(),
+  align: z.enum(["start", "center", "end", "stretch"]).optional(),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema
+});
+var OAuthLoginLayerSchema = z.preprocess(
+  migrateOAuthLoginIncoming,
+  OAuthLoginLayerSchemaValidated
+);
+z.array(OAuthLoginProviderSchema).min(1).superRefine((providers, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < providers.length; i++) {
+    const p = providers[i];
+    if (!p || p.type !== "preset") continue;
+    const preset = p.provider;
+    if (seen.has(preset)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate OAuth preset "${preset}"`,
+        path: [i, "provider"]
+      });
+      return;
+    }
+    seen.add(preset);
+  }
+});
+var FIELD_KEY_RE = /^[a-z][a-z0-9_]*$/;
+var FieldKeySchema = z.string().min(1).max(64).regex(FIELD_KEY_RE, "field key must be snake_case");
+var FieldClassificationSchema = z.enum(FIELD_CLASSIFICATIONS);
+
+// src/layers/kinds/auth/emailPasswordAuth.ts
+var lazyLayer4 = () => layerSchemaStore.schema;
+var EmailPasswordAuthModeSchema = z.enum(EMAIL_PASSWORD_AUTH_MODES);
+var migrateEmailPasswordAuthIncoming = (raw) => {
+  if (!raw || typeof raw !== "object") return raw;
+  const o = raw;
+  if (o.kind !== "email_password_auth") return raw;
+  if (Array.isArray(o.children) && o.children.length > 0) return raw;
+  const idBase = typeof o.id === "string" ? o.id : "lyr_email_password_auth";
+  const slugRaw = idBase.replace(/^lyr_/i, "").replace(/[^a-z0-9_]/gi, "_");
+  const slug = slugRaw.length > 0 ? slugRaw.slice(0, 40) : "ep_auth";
+  const mode = o.mode === "sign_up" ? "sign_up" : "sign_in";
+  const pickLt = (v, fallback) => v && typeof v === "object" && v !== null && "default" in v ? v : { default: fallback };
+  const mkField = (suf, slot, labelSource, fallbackPlaceholder) => ({
+    id: `lyr_${slug}_fld_${suf}`.slice(0, 64),
+    kind: "email_password_field",
+    slot,
+    ...labelSource ? { placeholder: pickLt(labelSource, fallbackPlaceholder) } : { placeholder: { default: fallbackPlaceholder } },
+    children: []
+  });
+  const children = [];
+  children.push(mkField("email", "email", o.emailLabel, "Email"));
+  children.push(mkField("pw", "password", o.passwordLabel, "Password"));
+  if (mode === "sign_up") {
+    children.push(mkField("cf", "confirm", o.confirmPasswordLabel, "Confirm password"));
+  }
+  const submitLbl = o.submitLabel ?? { default: mode === "sign_in" ? "Sign in" : "Create account" };
+  children.push({
+    id: `lyr_${slug}_submit`.slice(0, 64),
+    kind: "email_password_submit",
+    buttonVariant: "primary",
+    direction: "horizontal",
+    align: "center",
+    distribution: "center",
+    gap: 8,
+    children: [
+      {
+        id: `lyr_${slug}_submit_txt`.slice(0, 64),
+        kind: "text",
+        text: submitLbl
+      }
+    ]
+  });
+  const {
+    emailLabel: _e,
+    passwordLabel: _p,
+    confirmPasswordLabel: _c,
+    submitLabel: _s,
+    ...rest
+  } = o;
+  return { ...rest, mode, children };
+};
+var refineEmailPasswordAuthChildren = (data, ctx) => {
+  const fields = data.children.filter((c) => c.kind === "email_password_field");
+  const submits = data.children.filter((c) => c.kind === "email_password_submit");
+  const slotSeen = /* @__PURE__ */ new Set();
+  for (const f of fields) {
+    if (slotSeen.has(f.slot)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate email_password_field slot "${f.slot}"`,
+        path: ["children"]
+      });
+    }
+    slotSeen.add(f.slot);
+  }
+  const slotHas = new Set(fields.map((f) => f.slot));
+  const requiredSlots = data.mode === "sign_up" ? ["email", "password", "confirm"] : ["email", "password"];
+  for (const s of requiredSlots) {
+    if (!slotHas.has(s)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: data.mode === "sign_up" ? `sign_up requires an email_password_field with slot "${s}"` : `sign_in requires an email_password_field with slot "${s}"`,
+        path: ["children"]
+      });
+    }
+  }
+  if (data.mode === "sign_in" && slotHas.has("confirm")) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: 'sign_in must not include email_password_field with slot "confirm"',
+      path: ["children"]
+    });
+  }
+  if (submits.length !== 1) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `email_password_auth must have exactly one email_password_submit (found ${submits.length})`,
+      path: ["children"]
+    });
+  }
+};
+var EmailPasswordFieldLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("email_password_field"),
+  slot: z.enum(EMAIL_PASSWORD_SLOTS),
+  placeholder: LocalizedTextSchema.optional(),
+  children: z.lazy(() => z.array(lazyLayer4())).optional(),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema
+});
+var EmailPasswordSubmitLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("email_password_submit"),
+  buttonVariant: ButtonLayerVariantSchema,
+  direction: z.enum(["vertical", "horizontal"]).optional(),
+  gap: z.number().int().min(0).optional(),
+  align: z.enum(["start", "center", "end", "stretch"]).optional(),
+  distribution: z.enum(["start", "center", "end", "between", "around"]).optional(),
+  children: z.lazy(() => z.array(lazyLayer4()).min(1)),
+  style: ButtonStyleSchema.optional(),
+  styleBreakpoints: ButtonStyleBreakpointsSchema,
+  buttonLayoutBreakpoints: ButtonLayoutBreakpointsSchema
+});
+var EmailPasswordAuthLayerSchemaValidated = z.object({
+  ...baseLayerShape,
+  kind: z.literal("email_password_auth"),
+  mode: EmailPasswordAuthModeSchema,
+  fieldKey: FieldKeySchema,
+  minPasswordLength: z.number().int().min(4).max(128).optional(),
+  children: z.lazy(
+    () => z.array(z.union([EmailPasswordFieldLayerSchema, EmailPasswordSubmitLayerSchema])).min(1)
+  ),
+  gap: z.number().int().min(0).optional(),
+  align: z.enum(["start", "center", "end", "stretch"]).optional(),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema
+}).superRefine(refineEmailPasswordAuthChildren);
+var EmailPasswordAuthLayerSchema = z.preprocess(
+  migrateEmailPasswordAuthIncoming,
+  EmailPasswordAuthLayerSchemaValidated
+);
+var ChoiceOptionBindingSchema = z.object({
+  optionId: z.string().min(1).max(64),
+  rootLayerId: LayerIdSchema
+});
+var BranchConditionSchema = z.object({
+  choiceId: z.string().min(1),
+  goTo: ScreenIdSchema
+});
+var ChoiceBranchingSchema = z.object({
+  enabled: z.boolean(),
+  conditions: z.array(BranchConditionSchema)
+});
+
+// src/layers/kinds/input.ts
+var lazyLayer5 = () => layerSchemaStore.schema;
+var ChoiceChildrenAndBindingsRefinement = (data, ctx) => {
+  const childIds = /* @__PURE__ */ new Set();
+  for (const c of data.children) {
+    if (childIds.has(c.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate option child id "${c.id}"`,
+        path: ["children"]
+      });
+    }
+    childIds.add(c.id);
+  }
+  const seenOptionIds = /* @__PURE__ */ new Set();
+  const seenRootIds = /* @__PURE__ */ new Set();
+  for (const b of data.optionBindings) {
+    if (seenOptionIds.has(b.optionId)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate optionId "${b.optionId}" in optionBindings`,
+        path: ["optionBindings"]
+      });
+    }
+    seenOptionIds.add(b.optionId);
+    if (seenRootIds.has(b.rootLayerId)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate rootLayerId "${b.rootLayerId}" in optionBindings`,
+        path: ["optionBindings"]
+      });
+    }
+    seenRootIds.add(b.rootLayerId);
+    if (!childIds.has(b.rootLayerId)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `optionBindings rootLayerId "${b.rootLayerId}" does not match any direct child stack`,
+        path: ["optionBindings"]
+      });
+    }
+  }
+  if (data.optionBindings.length !== data.children.length) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "optionBindings length must equal children length",
+      path: ["optionBindings"]
+    });
+  }
+};
+var SingleChoiceLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("single_choice"),
+  fieldKey: FieldKeySchema,
+  children: z.lazy(
+    () => z.array(StackLayerSchema).min(2)
+  ),
+  optionBindings: z.array(ChoiceOptionBindingSchema).min(2),
+  branching: ChoiceBranchingSchema,
+  direction: z.enum(["vertical", "horizontal", "grid"]).optional(),
+  gap: z.number().int().min(0).optional(),
+  columns: z.number().int().min(1).max(12).optional(),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema
+});
+var MultipleChoiceLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("multiple_choice"),
+  fieldKey: FieldKeySchema,
+  children: z.lazy(
+    () => z.array(StackLayerSchema).min(2)
+  ),
+  optionBindings: z.array(ChoiceOptionBindingSchema).min(2),
+  minSelections: z.number().int().nonnegative().optional(),
+  maxSelections: z.number().int().positive().optional(),
+  branching: ChoiceBranchingSchema,
+  direction: z.enum(["vertical", "horizontal", "grid"]).optional(),
+  gap: z.number().int().min(0).optional(),
+  columns: z.number().int().min(1).max(12).optional(),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema
+});
+var validateChoiceChildrenAndBindings = ChoiceChildrenAndBindingsRefinement;
+var TextInputLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("text_input"),
+  fieldKey: FieldKeySchema,
+  placeholder: LocalizedTextSchema.optional(),
+  inputType: TextInputTypeSchema.optional(),
+  required: z.boolean().optional(),
+  minLength: z.number().int().min(0).max(2e3).optional(),
+  maxLength: z.number().int().positive().max(2e3).optional(),
+  classification: FieldClassificationSchema,
+  children: z.lazy(() => z.array(lazyLayer5())).optional(),
+  style: CommonStyleSchema.optional()
+});
+var ScaleInputLabelStyleSchema = z.object({
+  fontFamily: z.string().min(1).max(128).optional(),
+  fontSize: z.number().int().min(8).max(96).optional(),
+  fontWeight: z.number().int().min(100).max(900).optional(),
+  color: ThemedColorSchema.optional(),
+  align: z.enum(["left", "center", "right"]).optional(),
+  lineHeight: z.number().min(0.8).max(3).optional(),
+  opacity: z.number().min(0).max(1).optional()
+}).partial();
+var ScaleInputLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("scale_input"),
+  fieldKey: FieldKeySchema,
+  min: z.number(),
+  max: z.number(),
+  step: z.number().positive().optional(),
+  defaultValue: z.number().optional(),
+  minLabel: LocalizedTextSchema.optional(),
+  maxLabel: LocalizedTextSchema.optional(),
+  labelStyle: ScaleInputLabelStyleSchema.optional(),
+  valueStyle: ScaleInputLabelStyleSchema.optional(),
+  showLabels: z.boolean().optional(),
+  showValue: z.boolean().optional(),
+  trackHeight: z.number().int().min(2).max(32).optional(),
+  trackColor: ThemedColorSchema.optional(),
+  fillColor: ThemedColorSchema.optional(),
+  thumbSize: z.number().int().min(8).max(48).optional(),
+  thumbColor: ThemedColorSchema.optional(),
+  children: z.lazy(() => z.array(lazyLayer5())).optional(),
+  style: CommonStyleSchema.optional()
+});
+var CarouselIndicatorsStyleSchema = z.object({
+  width: z.number().int().min(1).max(64).optional(),
+  height: z.number().int().min(1).max(64).optional(),
+  defaultColor: ThemedColorSchema.optional(),
+  defaultOpacity: z.number().min(0).max(1).optional(),
+  activeColor: ThemedColorSchema.optional(),
+  activeOpacity: z.number().min(0).max(1).optional(),
+  activeWidth: z.number().int().min(1).max(64).optional(),
+  activeHeight: z.number().int().min(1).max(64).optional(),
+  border: BorderSchema.optional(),
+  activeBorder: BorderSchema.optional()
+}).partial();
+var CarouselPageControlSchema = z.object({
+  position: z.enum(["top", "bottom"]),
+  spacing: z.number().int().min(0).optional(),
+  padding: PaddingSchema.optional(),
+  margin: PaddingSchema.optional(),
+  indicators: CarouselIndicatorsStyleSchema.optional(),
+  border: BorderSchema.optional(),
+  shadow: DropShadowSchema.optional()
+});
+var CarouselLayerSchema = z.object({
+  ...baseLayerShape,
+  kind: z.literal("carousel"),
+  slides: z.lazy(() => z.array(StackLayerSchema).min(1)),
+  pageAlignment: z.enum(["top", "center", "bottom"]).optional(),
+  pageSpacing: z.number().int().min(0).optional(),
+  pagePeek: z.number().int().min(0).max(400).optional(),
+  openOn: z.number().int().min(0).optional(),
+  loop: z.boolean().optional(),
+  autoAdvance: z.boolean().optional(),
+  autoAdvanceMs: z.number().int().min(500).max(6e4).optional(),
+  pageControl: CarouselPageControlSchema.optional(),
+  style: CommonStyleSchema.optional(),
+  styleBreakpoints: CommonStyleBreakpointsSchema
+});
+
+// src/layers/initLayerSchema.ts
+layerSchemaStore.schema = z.lazy(
+  () => z.union([
+    StackLayerSchema,
+    TextLayerSchema,
+    HyperlinkLayerSchema,
+    ImageLayerSchema,
+    LottieLayerSchema,
+    VideoLayerSchema,
+    IconLayerSchema,
+    ButtonLayerSchema,
+    BackButtonLayerSchema,
+    ProgressLayerSchema,
+    LoaderLayerSchema,
+    CounterLayerSchema,
+    CheckboxLayerSchema,
+    SingleChoiceLayerSchema,
+    MultipleChoiceLayerSchema,
+    TextInputLayerSchema,
+    ScaleInputLayerSchema,
+    OAuthLoginLayerSchema,
+    OAuthProviderPresetLayerSchema,
+    OAuthProviderCustomLayerSchema,
+    EmailPasswordAuthLayerSchema,
+    EmailPasswordFieldLayerSchema,
+    EmailPasswordSubmitLayerSchema,
+    CarouselLayerSchema
+  ])
+);
+
+// src/layers/tree.ts
+var STYLE_BREAKPOINT_KEYS = ["sm", "md", "lg", "xl", "2xl"];
+var commonStyleHasAbsolutePosition = (style, breakpoints) => {
+  if (style?.position === "absolute") return true;
+  if (!breakpoints) return false;
+  for (const k of STYLE_BREAKPOINT_KEYS) {
+    if (breakpoints[k]?.position === "absolute") return true;
+  }
+  return false;
+};
+var layerHasAbsolutePositionAuthored = (layer) => {
+  switch (layer.kind) {
+    case "stack":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints) || layer.selectedStyle?.position === "absolute";
+    case "text":
+    case "counter":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "image":
+    case "lottie":
+    case "video":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "icon":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "button":
+    case "back_button":
+    case "hyperlink":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "progress":
+    case "loader":
+      return commonStyleHasAbsolutePosition(layer.style, void 0);
+    case "text_input":
+    case "scale_input":
+      return commonStyleHasAbsolutePosition(layer.style, void 0);
+    case "oauth_provider":
+      if (layer.variant === "preset") {
+        return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+      }
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "oauth_login":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "email_password_auth":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "email_password_field":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "email_password_submit":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    case "carousel":
+      return commonStyleHasAbsolutePosition(layer.style, void 0);
+    case "checkbox":
+    case "single_choice":
+    case "multiple_choice":
+      return commonStyleHasAbsolutePosition(layer.style, layer.styleBreakpoints);
+    default:
+      return false;
+  }
+};
+
+// src/layers/layerUnion.ts
+var isInputLayer = (l) => l.kind === "single_choice" || l.kind === "multiple_choice" || l.kind === "text_input" || l.kind === "scale_input";
+
+// src/decisions.ts
+var DecisionNodeIdSchema = z.string().min(1).max(64).regex(/^dec_[a-z0-9_]+$/i, "decision node id must look like dec_<id>");
+var ExternalSurfaceJumpIdSchema = z.string().min(1).max(64).regex(/^surf_[a-z0-9_]+$/i, "external surface node id must look like surf_<id>");
+var EXTERNAL_SURFACE_NO_NEXT = "__onb_surface_no_next__";
+var ExternalSurfaceTerminalTargetSchema = z.literal(EXTERNAL_SURFACE_NO_NEXT);
+var FlowJumpTargetSchema = ScreenIdSchema.or(DecisionNodeIdSchema).or(ExternalSurfaceJumpIdSchema).or(ExternalSurfaceTerminalTargetSchema).nullable();
+var DecisionBuiltinNameSchema = z.enum(["locale", "platform"]);
+var DecisionVariableRefSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("builtin"), name: DecisionBuiltinNameSchema }),
+  z.object({ kind: z.literal("sdk"), key: z.string().min(1).max(128) }),
+  z.object({ kind: z.literal("field"), fieldKey: z.string().min(1).max(128) })
+]);
+var DecisionStringPredicateSchema = z.discriminatedUnion("op", [
+  z.object({ op: z.literal("eq"), value: z.string() }),
+  z.object({ op: z.literal("neq"), value: z.string() }),
+  z.object({ op: z.literal("contains"), value: z.string() })
+]);
+var DecisionNumberPredicateSchema = z.discriminatedUnion("op", [
+  z.object({ op: z.literal("eq"), value: z.number() }),
+  z.object({ op: z.literal("neq"), value: z.number() }),
+  z.object({ op: z.literal("lt"), value: z.number() }),
+  z.object({ op: z.literal("lte"), value: z.number() }),
+  z.object({ op: z.literal("gt"), value: z.number() }),
+  z.object({ op: z.literal("gte"), value: z.number() })
+]);
+var DecisionChoicePredicateSchema = z.discriminatedUnion("op", [
+  z.object({ op: z.literal("eq"), optionId: z.string().min(1) }),
+  z.object({ op: z.literal("one_of"), optionIds: z.array(z.string().min(1)).min(1) })
+]);
+var DecisionMultiPredicateSchema = z.discriminatedUnion("op", [
+  z.object({
+    op: z.literal("intersects"),
+    optionIds: z.array(z.string().min(1)).min(1)
+  }),
+  z.object({
+    op: z.literal("contains_all"),
+    optionIds: z.array(z.string().min(1)).min(1)
+  }),
+  z.object({
+    op: z.literal("subset_of"),
+    optionIds: z.array(z.string().min(1)).min(1)
+  })
+]);
+var DecisionBooleanPredicateSchema = z.discriminatedUnion("op", [
+  z.object({ op: z.literal("eq"), value: z.boolean() }),
+  z.object({ op: z.literal("neq"), value: z.boolean() })
+]);
+var DecisionPredicatePayloadSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("string"), pred: DecisionStringPredicateSchema }),
+  z.object({ type: z.literal("number"), pred: DecisionNumberPredicateSchema }),
+  z.object({ type: z.literal("boolean"), pred: DecisionBooleanPredicateSchema }),
+  z.object({ type: z.literal("choice"), pred: DecisionChoicePredicateSchema }),
+  z.object({ type: z.literal("multi"), pred: DecisionMultiPredicateSchema })
+]);
+var DecisionExprSchema = z.lazy(
+  () => z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("empty") }),
+    z.object({
+      kind: z.literal("group"),
+      op: z.enum(["and", "or"]),
+      children: z.array(DecisionExprSchema).min(1)
+    }),
+    z.object({
+      kind: z.literal("predicate"),
+      variable: DecisionVariableRefSchema,
+      predicate: DecisionPredicatePayloadSchema
+    })
+  ])
+);
+var DecisionCaseSchema = z.object({
+  id: z.string().min(1).max(80),
+  /** Display label in the editor (e.g. “Engaged users”). */
+  name: z.string().min(1).max(80).optional(),
+  expression: DecisionExprSchema,
+  next: FlowJumpTargetSchema
+});
+var DecisionNodeSchema = z.object({
+  id: DecisionNodeIdSchema,
+  name: z.string().min(1).max(80).optional(),
+  cases: z.array(DecisionCaseSchema).min(1).max(16),
+  elseNext: FlowJumpTargetSchema
+});
+var migrateLegacyDecisionNodeInPlace = (node) => {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node.cases)) return;
+  if (!("expression" in node)) return;
+  const id = typeof node.id === "string" ? node.id : "dec_unknown";
+  const expression = node.expression;
+  const onTrue = "onTrue" in node ? node.onTrue ?? null : null;
+  const onFalse = "onFalse" in node ? node.onFalse ?? null : null;
+  delete node.expression;
+  delete node.onTrue;
+  delete node.onFalse;
+  node.cases = [
+    {
+      id: `${id}_case_0`,
+      name: "Group 1",
+      expression,
+      next: onTrue
+    }
+  ];
+  node.elseNext = onFalse;
+};
+var collectDecisionSdkKeys = (expr) => {
+  const out = [];
+  const walk = (e) => {
+    if (e.kind === "empty") return;
+    if (e.kind === "predicate") {
+      if (e.variable.kind === "sdk") out.push(e.variable.key);
+      return;
+    }
+    for (const c of e.children) walk(c);
+  };
+  walk(expr);
+  return out;
+};
+var collectDecisionFieldKeys = (expr) => {
+  const out = [];
+  const walk = (e) => {
+    if (e.kind === "empty") return;
+    if (e.kind === "predicate") {
+      if (e.variable.kind === "field") out.push(e.variable.fieldKey);
+      return;
+    }
+    for (const c of e.children) walk(c);
+  };
+  walk(expr);
+  return out;
+};
+var collectDecisionFieldKeysFromNode = (node) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const c of node.cases) {
+    for (const k of collectDecisionFieldKeys(c.expression)) seen.add(k);
+  }
+  return [...seen];
+};
+
+// src/manifest/migrate.ts
+var migrateLayerInPlace = (layer) => {
+  if (!layer || typeof layer !== "object") return;
+  const l = layer;
+  if (l.kind === "progress_bar") {
+    l.kind = "progress";
+  }
+  if (l.kind === "icon" && l.family === "sf_symbol") {
+    l.family = "ionicons";
+    l.iconName = "star-outline";
+  }
+  if (l.kind === "button") {
+    const hasChildren = Array.isArray(l.children);
+    const hasLegacyLabel = !!l.label && typeof l.label === "object";
+    if (!hasChildren && hasLegacyLabel) {
+      const id = typeof l.id === "string" ? `${l.id}_text` : "lyr_btn_text";
+      l.children = [
+        {
+          id,
+          kind: "text",
+          text: l.label
+        }
+      ];
+      delete l.label;
+    } else if (!hasChildren) {
+      l.children = [];
+    }
+  }
+  if (l.kind === "hyperlink") {
+    const hasKids = Array.isArray(l.children) && l.children.length > 0;
+    const hasLegacyText = l.text !== void 0 && l.text !== null;
+    if (!hasKids && hasLegacyText) {
+      const baseId = typeof l.id === "string" ? `${l.id}_lnktxt` : "lyr_hyperlink_lnktxt";
+      const row = {
+        id: String(baseId).slice(0, 64),
+        kind: "text",
+        text: l.text
+      };
+      if (l.style !== void 0) row.style = l.style;
+      if (l.styleBreakpoints !== void 0) row.styleBreakpoints = l.styleBreakpoints;
+      l.children = [row];
+      delete l.text;
+      delete l.style;
+      delete l.styleBreakpoints;
+    } else if (!Array.isArray(l.children)) {
+      l.children = [];
+    }
+  }
+  if (l.kind === "stack" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  } else if (l.kind === "carousel" && Array.isArray(l.slides)) {
+    for (const s of l.slides) migrateLayerInPlace(s);
+  } else if (l.kind === "button" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  } else if (l.kind === "back_button" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  } else if (l.kind === "hyperlink" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  } else if (l.kind === "oauth_login" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  } else if (l.kind === "oauth_provider" && l.variant === "custom" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  } else if (l.kind === "email_password_auth" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  } else if (l.kind === "email_password_field" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  } else if (l.kind === "email_password_submit" && Array.isArray(l.children)) {
+    for (const c of l.children) migrateLayerInPlace(c);
+  }
+};
+var migrateScreenInPlace = (screen) => {
+  if (!screen || typeof screen !== "object") return;
+  const s = screen;
+  if (s.regions) {
+    if (s.regions.header) migrateLayerInPlace(s.regions.header);
+    if (s.regions.body) migrateLayerInPlace(s.regions.body);
+    if (s.regions.footer) migrateLayerInPlace(s.regions.footer);
+  }
+  if (s.animations === void 0) {
+    delete s.animations;
+  }
+};
+var migrateManifestInPlace = (data) => {
+  if (!data || typeof data !== "object") return data;
+  const d = data;
+  if (Array.isArray(d.screens)) {
+    for (const s of d.screens) migrateScreenInPlace(s);
+  }
+  if (!Array.isArray(d.decisionNodes)) d.decisionNodes = [];
+  if (Array.isArray(d.decisionNodes)) {
+    for (const node of d.decisionNodes) {
+      if (node && typeof node === "object") {
+        migrateLegacyDecisionNodeInPlace(node);
+      }
+    }
+  }
+  if (!Array.isArray(d.externalSurfaceNodes)) d.externalSurfaceNodes = [];
+  if (!Array.isArray(d.sdkAttributeKeys)) d.sdkAttributeKeys = [];
+  if (d.schemaVersion === 6) d.schemaVersion = MANIFEST_SCHEMA_VERSION;
+  if (d.schemaVersion === 5) d.schemaVersion = MANIFEST_SCHEMA_VERSION;
+  if (d.schemaVersion === 4) d.schemaVersion = MANIFEST_SCHEMA_VERSION;
+  return data;
+};
+var migrateLegacyManifest = (raw) => {
+  if (!raw || typeof raw !== "object") return raw;
+  const clone = JSON.parse(JSON.stringify(raw));
+  return migrateManifestInPlace(clone);
+};
+var ScreenBackgroundFitSchema = z.enum(["cover", "contain", "fill"]);
+var ScreenBackgroundScrimSchema = z.object({
+  color: ThemedColorSchema.optional(),
+  opacity: z.number().min(0).max(1).optional()
+}).partial();
+var screenBackgroundMediaShape = {
+  media: MediaReferenceSchema.optional(),
+  fit: ScreenBackgroundFitSchema.optional(),
+  opacity: z.number().min(0).max(1).optional(),
+  scrim: ScreenBackgroundScrimSchema.optional()
+};
+var ScreenBackgroundColorFillSchema = z.object({
+  kind: z.literal("color"),
+  color: ThemedColorSchema.optional(),
+  opacity: z.number().min(0).max(1).optional()
+});
+var ScreenBackgroundImageFillSchema = z.object({
+  kind: z.literal("image"),
+  ...screenBackgroundMediaShape
+});
+var ScreenBackgroundVideoFillSchema = z.object({
+  kind: z.literal("video"),
+  ...screenBackgroundMediaShape,
+  loop: z.boolean().optional(),
+  autoPlay: z.boolean().optional(),
+  triggerLayerId: z.string().min(1).optional(),
+  onComplete: LoaderOnCompleteSchema.optional(),
+  audioEnabled: z.boolean().optional()
+});
+var ScreenBackgroundFillSchema = z.discriminatedUnion("kind", [
+  ScreenBackgroundColorFillSchema,
+  ScreenBackgroundImageFillSchema,
+  ScreenBackgroundVideoFillSchema
+]);
+var ScreenBackgroundFillPatchSchema = z.object({
+  color: ThemedColorSchema.optional(),
+  fit: ScreenBackgroundFitSchema.optional(),
+  opacity: z.number().min(0).max(1).optional(),
+  scrim: ScreenBackgroundScrimSchema.optional(),
+  loop: z.boolean().optional(),
+  autoPlay: z.boolean().optional(),
+  triggerLayerId: z.string().min(1).optional(),
+  onComplete: LoaderOnCompleteSchema.optional(),
+  audioEnabled: z.boolean().optional()
+}).partial();
+var ScreenContainerBreakpointPatchSchema = z.object({
+  padding: PaddingSchema.optional(),
+  margin: PaddingSchema.optional(),
+  insetSafeArea: z.boolean().optional(),
+  backgroundFillPatch: ScreenBackgroundFillPatchSchema.optional()
+}).partial();
+var ScreenContainerStyleBreakpointsSchema = z.object({
+  sm: ScreenContainerBreakpointPatchSchema.optional(),
+  md: ScreenContainerBreakpointPatchSchema.optional(),
+  lg: ScreenContainerBreakpointPatchSchema.optional(),
+  xl: ScreenContainerBreakpointPatchSchema.optional(),
+  "2xl": ScreenContainerBreakpointPatchSchema.optional()
+}).partial().optional();
+var ANIMATABLE_PROPERTIES = [
+  "opacity",
+  "translateX",
+  "translateY",
+  "scale"
+];
+var AnimatablePropertySchema = z.enum(ANIMATABLE_PROPERTIES);
+var EASING_TOKENS = [
+  "linear",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "standard",
+  "emphasized"
+];
+var EasingTokenSchema = z.enum(EASING_TOKENS);
+var KeyframeSchema = z.object({
+  t: z.number().min(0).max(1),
+  value: z.number(),
+  /** Easing applied from this keyframe to the next; defaults to linear. */
+  easing: EasingTokenSchema.optional()
+}).strict();
+var KeyframeTrackSchema = z.object({
+  property: AnimatablePropertySchema,
+  keyframes: z.array(KeyframeSchema).min(2)
+}).strict().superRefine((track, ctx) => {
+  let last = -Infinity;
+  for (const k of track.keyframes) {
+    if (k.t < last) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `keyframe times must be monotonically non-decreasing on track "${track.property}"`
+      });
+      return;
+    }
+    last = k.t;
+  }
+  if (track.keyframes[0].t !== 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `track "${track.property}" first keyframe must start at t=0`
+    });
+  }
+  if (track.keyframes[track.keyframes.length - 1].t !== 1) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `track "${track.property}" last keyframe must end at t=1`
+    });
+  }
+});
+var ANIMATION_TRIGGERS = ["mount", "stagger", "unmount"];
+var AnimationTriggerSchema = z.enum(ANIMATION_TRIGGERS);
+var AnimationClipSchema = z.object({
+  id: z.string().min(1).max(64),
+  targetLayerId: LayerIdSchema,
+  trigger: AnimationTriggerSchema,
+  /** Position in the screen's stagger order. Required when trigger is `stagger`. */
+  staggerIndex: z.number().int().min(0).max(64).optional(),
+  /** Total clip duration in milliseconds (renderer scales 0..1 keyframes by this). */
+  durationMs: z.number().int().min(0).max(36e5),
+  /** Pre-roll delay before the clip begins, in ms. Stagger adds on top of this. */
+  delayMs: z.number().int().min(0).max(36e5).optional(),
+  tracks: z.array(KeyframeTrackSchema).min(1)
+}).strict().superRefine((clip, ctx) => {
+  if (clip.trigger === "unmount" && clip.staggerIndex !== void 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `clip "${clip.id}" with trigger "unmount" must not set staggerIndex`,
+      path: ["staggerIndex"]
+    });
+  }
+  if (clip.trigger === "stagger" && clip.staggerIndex === void 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `clip "${clip.id}" with trigger "stagger" must define staggerIndex`,
+      path: ["staggerIndex"]
+    });
+  }
+  const seenProps = /* @__PURE__ */ new Set();
+  for (const track of clip.tracks) {
+    if (seenProps.has(track.property)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `clip "${clip.id}" has duplicate track for property "${track.property}"`
+      });
+    }
+    seenProps.add(track.property);
+  }
+});
+var ScreenStaggerSchema = z.object({
+  /** Per-index delay multiplier in ms. */
+  stepMs: z.number().int().min(0).max(2e3)
+}).strict();
+
+// src/screens.ts
+var ScreenNextSchema = z.object({
+  default: FlowJumpTargetSchema
+});
+var ScreenRegionsSchema = z.object({
+  header: StackLayerSchema.optional(),
+  body: StackLayerSchema,
+  footer: StackLayerSchema.optional()
+});
+var ScreenContainerStyleSchema = z.object({
+  padding: PaddingSchema.optional(),
+  margin: PaddingSchema.optional(),
+  /** When true, runtimes add device safe-area insets to shell padding (in addition to manual padding). */
+  insetSafeArea: z.boolean().optional(),
+  backgroundFill: ScreenBackgroundFillSchema.optional()
+}).partial();
+var ScreenSchema = z.object({
+  id: ScreenIdSchema,
+  name: z.string().min(1).max(80),
+  regions: ScreenRegionsSchema,
+  next: ScreenNextSchema,
+  /** Ordered animation clips bound to layers on this screen. */
+  animations: z.array(AnimationClipSchema).optional(),
+  /** Defaults for clips with `trigger: stagger`. */
+  stagger: ScreenStaggerSchema.optional(),
+  /** Chrome on the outer screen container (wraps all regions). */
+  containerStyle: ScreenContainerStyleSchema.optional(),
+  containerStyleBreakpoints: ScreenContainerStyleBreakpointsSchema
+});
+var walkScreenLayersWithLayoutContext = (screen, fn) => {
+  const visit = (l, ctx) => {
+    fn(l, ctx);
+    const childCtx = (opts = {}) => ({
+      region: ctx.region,
+      isRegionRoot: false,
+      insideChoiceOption: opts.insideChoiceOption ?? ctx.insideChoiceOption,
+      parentKind: l.kind
+    });
+    if (l.kind === "stack") {
+      for (const c of l.children) visit(c, childCtx());
+    } else if (l.kind === "carousel") {
+      for (const s of l.slides) visit(s, childCtx());
+    } else if (l.kind === "button" || l.kind === "back_button") {
+      for (const c of l.children) visit(c, childCtx());
+    } else if (l.kind === "hyperlink") {
+      for (const c of l.children) visit(c, childCtx());
+    } else if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+      for (const c of l.children) {
+        visit(c, childCtx({ insideChoiceOption: true }));
+      }
+    } else if (l.kind === "text_input" || l.kind === "scale_input") {
+      for (const c of l.children ?? []) visit(c, childCtx());
+    } else if (l.kind === "oauth_login") {
+      for (const c of l.children) visit(c, childCtx());
+    } else if (l.kind === "oauth_provider" && l.variant === "custom") {
+      for (const c of l.children) visit(c, childCtx());
+    } else if (l.kind === "email_password_auth") {
+      for (const c of l.children) visit(c, childCtx());
+    } else if (l.kind === "email_password_field") {
+      for (const c of l.children ?? []) visit(c, childCtx());
+    } else if (l.kind === "email_password_submit") {
+      for (const c of l.children) visit(c, childCtx());
+    }
+  };
+  const regionCtx = (region) => ({
+    region,
+    isRegionRoot: true,
+    insideChoiceOption: false,
+    parentKind: null
+  });
+  if (screen.regions.header) visit(screen.regions.header, regionCtx("header"));
+  visit(screen.regions.body, regionCtx("body"));
+  if (screen.regions.footer) visit(screen.regions.footer, regionCtx("footer"));
+};
+var walkScreenLayers = (screen, fn) => {
+  const visit = (l) => {
+    fn(l);
+    if (l.kind === "stack") l.children.forEach(visit);
+    else if (l.kind === "carousel") l.slides.forEach(visit);
+    else if (l.kind === "button") l.children.forEach(visit);
+    else if (l.kind === "back_button") l.children.forEach(visit);
+    else if (l.kind === "hyperlink") l.children.forEach(visit);
+    else if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+      l.children.forEach(visit);
+    } else if (l.kind === "text_input" || l.kind === "scale_input") {
+      l.children?.forEach(visit);
+    } else if (l.kind === "oauth_login") {
+      l.children.forEach(visit);
+    } else if (l.kind === "oauth_provider" && l.variant === "custom") {
+      l.children.forEach(visit);
+    } else if (l.kind === "email_password_auth") {
+      l.children.forEach(visit);
+    } else if (l.kind === "email_password_field") {
+      l.children?.forEach(visit);
+    } else if (l.kind === "email_password_submit") {
+      l.children.forEach(visit);
+    }
+  };
+  if (screen.regions.header) visit(screen.regions.header);
+  visit(screen.regions.body);
+  if (screen.regions.footer) visit(screen.regions.footer);
+};
+var ExternalSurfaceNodeIdSchema = z.string().min(1).max(64).regex(/^surf_[a-z0-9_]+$/i, "external surface node id must look like surf_<id>");
+var NORMALIZED_SURFACE_OUTCOMES = [
+  "purchase_completed",
+  "purchase_cancelled",
+  "dismissed",
+  "failed",
+  "restore_completed"
+];
+z.enum(NORMALIZED_SURFACE_OUTCOMES);
+z.enum(["unspecified", "revenuecat"]);
+var UnspecifiedExternalSurfaceConfigSchema = z.object({
+  provider: z.literal("unspecified")
+});
+var RevenueCatSurfacePresentationSchema = z.enum(["paywall", "paywall_if_needed"]);
+var RevenueCatSurfaceConfigSchema = z.object({
+  provider: z.literal("revenuecat"),
+  offeringId: z.string().min(1).max(128).optional(),
+  placementId: z.string().min(1).max(128).optional(),
+  presentation: RevenueCatSurfacePresentationSchema.optional()
+});
+var ExternalSurfaceConfigSchema = z.discriminatedUnion("provider", [
+  UnspecifiedExternalSurfaceConfigSchema,
+  RevenueCatSurfaceConfigSchema
+]);
+var ExternalSurfaceOutcomesMapSchema = z.object({
+  purchase_completed: FlowJumpTargetSchema.optional(),
+  purchase_cancelled: FlowJumpTargetSchema.optional(),
+  dismissed: FlowJumpTargetSchema.optional(),
+  failed: FlowJumpTargetSchema.optional(),
+  restore_completed: FlowJumpTargetSchema.optional()
+}).strict();
+var ExternalSurfaceNodeSchema = z.object({
+  id: ExternalSurfaceNodeIdSchema,
+  name: z.string().min(1).max(80).optional(),
+  config: ExternalSurfaceConfigSchema,
+  /** Per-outcome jump targets. Outcomes not listed here fall through to `fallback`. */
+  outcomes: ExternalSurfaceOutcomesMapSchema,
+  /** Required: used for any outcome not in `outcomes` (e.g. provider quirks, unmapped events). */
+  fallback: FlowJumpTargetSchema
+});
+
+// src/manifest/flowManifestObjectBaseSchema.ts
+var FlowManifestObjectBaseSchema = z.object({
+  flowId: z.string().uuid(),
+  /** Manifest schema version — see {@link MANIFEST_SCHEMA_VERSION}. */
+  schemaVersion: z.literal(MANIFEST_SCHEMA_VERSION).optional(),
+  version: z.number().int().positive(),
+  defaultLocale: LocaleCode,
+  locales: z.array(LocaleCode),
+  /** When null, the draft has no wired entry target (builder connects the canvas entry node). */
+  entryScreenId: z.union([z.string().min(1), z.null()]),
+  screens: z.array(ScreenSchema),
+  decisionNodes: z.union([z.array(DecisionNodeSchema), z.undefined()]).transform((x) => x ?? []),
+  externalSurfaceNodes: z.union([z.array(ExternalSurfaceNodeSchema), z.undefined()]).transform((x) => x ?? []),
+  sdkAttributeKeys: z.union([z.array(z.string().min(1).max(128)), z.undefined()]).transform((x) => x ?? []),
+  theme: ThemeSchema.optional(),
+  builderMeta: BuilderMetaSchema
+});
+
+// src/sdkAttributes.ts
+var RESERVED_RC_SDK_KEYS = [
+  /** Last RC event observed by the SDK (e.g. `purchase_completed`, `purchase_cancelled`). */
+  "onb_rc_last_event",
+  /** Product identifier from the most recent successful purchase. */
+  "onb_rc_last_product_id",
+  /** Period type (`normal`, `intro`, `trial`) from the most recent purchase. */
+  "onb_rc_last_period_type",
+  /** RevenueCat offering id surfaced by the most recent paywall presentation. */
+  "onb_rc_last_offering_id"
+];
+var RESERVED_SDK_KEYS_SET = new Set(RESERVED_RC_SDK_KEYS);
+var isReservedSdkKey = (key) => RESERVED_SDK_KEYS_SET.has(key);
+
+// src/manifest/refineManifestGraph.ts
+var buildManifestJumpTargets = (manifest) => {
+  const screenIds = new Set(manifest.screens.map((s) => s.id));
+  const decisionIds = new Set(manifest.decisionNodes.map((d) => d.id));
+  const surfaceIds = new Set(manifest.externalSurfaceNodes.map((s) => s.id));
+  return /* @__PURE__ */ new Set([
+    ...screenIds,
+    ...decisionIds,
+    ...surfaceIds,
+    EXTERNAL_SURFACE_NO_NEXT
+  ]);
+};
+var refineManifestGraph = (manifest, ctx, jumpTargets) => {
+  const screenIds = /* @__PURE__ */ new Set();
+  for (const s of manifest.screens) {
+    if (screenIds.has(s.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate screen id "${s.id}"`,
+        path: ["screens"]
+      });
+    }
+    screenIds.add(s.id);
+  }
+  const decisionIds = new Set(manifest.decisionNodes.map((d) => d.id));
+  const surfaceIds = new Set(manifest.externalSurfaceNodes.map((s) => s.id));
+  if (manifest.entryScreenId != null && !jumpTargets.has(manifest.entryScreenId)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `entryScreenId "${manifest.entryScreenId}" not found in screens, decisionNodes, or externalSurfaceNodes`,
+      path: ["entryScreenId"]
+    });
+  }
+  const seenDecisionId = /* @__PURE__ */ new Set();
+  const sdkAllow = new Set(manifest.sdkAttributeKeys);
+  manifest.decisionNodes.forEach((dn, di) => {
+    if (seenDecisionId.has(dn.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate decision node id "${dn.id}"`,
+        path: ["decisionNodes", di]
+      });
+    }
+    seenDecisionId.add(dn.id);
+    if (screenIds.has(dn.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `decision node id "${dn.id}" collides with a screen id`,
+        path: ["decisionNodes", di]
+      });
+    }
+    if (surfaceIds.has(dn.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `decision node id "${dn.id}" collides with an external surface id`,
+        path: ["decisionNodes", di]
+      });
+    }
+    dn.cases.forEach((c, ci) => {
+      if (c.next != null && !jumpTargets.has(c.next)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `decision "${dn.id}" case "${c.id}" next "${c.next}" not found`,
+          path: ["decisionNodes", di, "cases", ci, "next"]
+        });
+      }
+      for (const sk of collectDecisionSdkKeys(c.expression)) {
+        if (isReservedSdkKey(sk)) continue;
+        if (!sdkAllow.has(sk)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `decision "${dn.id}" case "${c.id}" references sdk key "${sk}" not in sdkAttributeKeys`,
+            path: ["decisionNodes", di, "cases", ci, "expression"]
+          });
+        }
+      }
+    });
+    if (dn.elseNext != null && !jumpTargets.has(dn.elseNext)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `decision "${dn.id}" elseNext "${dn.elseNext}" not found`,
+        path: ["decisionNodes", di, "elseNext"]
+      });
+    }
+  });
+  const seenSurfaceId = /* @__PURE__ */ new Set();
+  manifest.externalSurfaceNodes.forEach((sn, si) => {
+    if (seenSurfaceId.has(sn.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate external surface id "${sn.id}"`,
+        path: ["externalSurfaceNodes", si]
+      });
+    }
+    seenSurfaceId.add(sn.id);
+    if (screenIds.has(sn.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `external surface id "${sn.id}" collides with a screen id`,
+        path: ["externalSurfaceNodes", si]
+      });
+    }
+    if (decisionIds.has(sn.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `external surface id "${sn.id}" collides with a decision node id`,
+        path: ["externalSurfaceNodes", si]
+      });
+    }
+    for (const [outcome, target] of Object.entries(sn.outcomes)) {
+      if (target != null && !jumpTargets.has(target)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `external surface "${sn.id}" outcome "${outcome}" target "${target}" not found`,
+          path: ["externalSurfaceNodes", si, "outcomes", outcome]
+        });
+      }
+    }
+    if (sn.fallback != null && !jumpTargets.has(sn.fallback)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `external surface "${sn.id}" fallback "${sn.fallback}" not found`,
+        path: ["externalSurfaceNodes", si, "fallback"]
+      });
+    }
+  });
+  return { screenIds, decisionIds, surfaceIds };
+};
+var refineManifestScreens = (manifest, ctx, jumpTargets, screenIds, allFieldKeys) => {
+  const layerIds = /* @__PURE__ */ new Set();
+  manifest.screens.forEach((screen, screenIdx) => {
+    let inputCount = 0;
+    const layerIdsForScreen = /* @__PURE__ */ new Set();
+    walkScreenLayers(screen, (l) => {
+      layerIdsForScreen.add(l.id);
+    });
+    walkScreenLayers(screen, (l) => {
+      if (layerIds.has(l.id)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `duplicate layer id "${l.id}"`,
+          path: ["screens", screenIdx, "regions"]
+        });
+      }
+      layerIds.add(l.id);
+      if (isInputLayer(l)) {
+        inputCount += 1;
+        if (allFieldKeys.has(l.fieldKey)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `duplicate fieldKey "${l.fieldKey}" across screens or on the same screen`,
+            path: ["screens", screenIdx]
+          });
+        }
+        allFieldKeys.set(l.fieldKey, screen.id);
+      }
+      if (l.kind === "checkbox") {
+        if (allFieldKeys.has(l.fieldKey)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `duplicate fieldKey "${l.fieldKey}" across screens or on the same screen`,
+            path: ["screens", screenIdx]
+          });
+        }
+        allFieldKeys.set(l.fieldKey, screen.id);
+      }
+      if (l.kind === "button" && l.action.kind === "request_os_permission") {
+        const fk = permissionCaptureFieldKey(l.action.permissionKey);
+        if (!allFieldKeys.has(fk)) allFieldKeys.set(fk, screen.id);
+      }
+    });
+    if (inputCount > 1) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `screen "${screen.id}" has ${inputCount} input layers (max 1 allowed)`,
+        path: ["screens", screenIdx, "regions"]
+      });
+    }
+    walkScreenLayersWithLayoutContext(screen, (l, layoutCtx) => {
+      if (!layerHasAbsolutePositionAuthored(l)) return;
+      if (layoutCtx.isRegionRoot) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `layer "${l.id}" cannot use absolute positioning on a screen region root`,
+          path: ["screens", screenIdx, "regions"]
+        });
+      }
+      if (layoutCtx.insideChoiceOption) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `layer "${l.id}" cannot use absolute positioning inside a choice option`,
+          path: ["screens", screenIdx, "regions"]
+        });
+      }
+    });
+    walkScreenLayersWithLayoutContext(screen, (l, layoutCtx) => {
+      if (l.kind === "oauth_provider" && layoutCtx.parentKind !== "oauth_login") {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `OAuth button "${l.id}" must be nested under an OAuth login layer`,
+          path: ["screens", screenIdx, "regions"]
+        });
+      }
+      if ((l.kind === "email_password_field" || l.kind === "email_password_submit") && layoutCtx.parentKind !== "email_password_auth") {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Layer "${l.id}" (${l.kind}) must be nested under an Email / password login layer`,
+          path: ["screens", screenIdx, "regions"]
+        });
+      }
+    });
+    const nextDefault = screen.next.default;
+    if (nextDefault && !jumpTargets.has(nextDefault)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `screen "${screen.id}" next.default "${nextDefault}" not found`,
+        path: ["screens", screenIdx, "next", "default"]
+      });
+    }
+    walkScreenLayers(screen, (l) => {
+      if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+        validateChoiceChildrenAndBindings(
+          { children: l.children, optionBindings: l.optionBindings },
+          ctx
+        );
+        const knownOptionIds = new Set(l.optionBindings.map((b) => b.optionId));
+        for (const cond of l.branching.conditions) {
+          if (!screenIds.has(cond.goTo)) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `screen "${screen.id}" branch condition "${cond.choiceId}" -> "${cond.goTo}" not found`,
+              path: ["screens", screenIdx]
+            });
+          }
+          if (!knownOptionIds.has(cond.choiceId)) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `screen "${screen.id}" branch condition references unknown choice "${cond.choiceId}"`,
+              path: ["screens", screenIdx]
+            });
+          }
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "go_to_step") {
+        if (!screenIds.has(l.action.screenId)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `screen "${screen.id}" button action go_to_step "${l.action.screenId}" not found`,
+            path: ["screens", screenIdx]
+          });
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "go_back_one_screen" && manifest.entryScreenId != null && screen.id === manifest.entryScreenId) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `screen "${screen.id}" is the flow entry screen; buttons cannot use go_back_one_screen`,
+          path: ["screens", screenIdx]
+        });
+      }
+      if (l.kind === "button" && l.action.kind === "request_os_permission") {
+        for (const [label, sid] of [
+          ["granted", l.action.outcomes.granted],
+          ["denied", l.action.outcomes.denied],
+          ["blocked", l.action.outcomes.blocked]
+        ]) {
+          if (sid === OS_PERMISSION_OUTCOME_END) ; else if (sid === OS_PERMISSION_OUTCOME_CONTINUE) {
+            const def = screen.next.default;
+            if (def != null && !jumpTargets.has(def)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `screen "${screen.id}" request_os_permission outcomes.${label} uses default next (continue) but screen.next.default "${def}" is not a valid target`,
+                path: ["screens", screenIdx]
+              });
+            }
+          } else if (!jumpTargets.has(sid)) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `screen "${screen.id}" request_os_permission outcomes.${label} "${sid}" not found`,
+              path: ["screens", screenIdx]
+            });
+          }
+        }
+      }
+      if (l.kind === "back_button" && l.fallbackScreenId && !screenIds.has(l.fallbackScreenId)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `screen "${screen.id}" back_button fallback "${l.fallbackScreenId}" not found`,
+          path: ["screens", screenIdx]
+        });
+      }
+      if (l.kind === "button" && l.action.kind === "go_back_one_screen" && l.action.fallbackScreenId && !screenIds.has(l.action.fallbackScreenId)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `screen "${screen.id}" button go_back_one_screen fallback "${l.action.fallbackScreenId}" not found`,
+          path: ["screens", screenIdx]
+        });
+      }
+      if (l.kind === "text_input") {
+        const minL = l.minLength;
+        const maxL = l.maxLength;
+        if (minL !== void 0 && maxL !== void 0 && minL > maxL) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `text_input "${l.id}" minLength cannot exceed maxLength`,
+            path: ["screens", screenIdx]
+          });
+        }
+      }
+      if (l.kind === "scale_input") {
+        if (l.min >= l.max) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `scale_input "${l.id}" max must be greater than min`,
+            path: ["screens", screenIdx]
+          });
+        }
+        const step = l.step ?? 1;
+        if (l.defaultValue !== void 0) {
+          if (l.defaultValue < l.min || l.defaultValue > l.max) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `scale_input "${l.id}" defaultValue must be between min and max`,
+              path: ["screens", screenIdx]
+            });
+          } else {
+            const rem = (l.defaultValue - l.min) / step;
+            if (Math.abs(rem - Math.round(rem)) > 1e-6) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `scale_input "${l.id}" defaultValue must align with min and step`,
+                path: ["screens", screenIdx]
+              });
+            }
+          }
+        }
+      }
+    });
+    if (screen.animations) {
+      const clipIds = /* @__PURE__ */ new Set();
+      for (const clip of screen.animations) {
+        if (clipIds.has(clip.id)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `screen "${screen.id}" has duplicate clip id "${clip.id}"`,
+            path: ["screens", screenIdx, "animations"]
+          });
+        }
+        clipIds.add(clip.id);
+        if (!layerIdsForScreen.has(clip.targetLayerId)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `clip "${clip.id}" targets layer "${clip.targetLayerId}" not on screen "${screen.id}"`,
+            path: ["screens", screenIdx, "animations"]
+          });
+        }
+      }
+    }
+  });
+};
+
+// src/manifest/refineFlowManifest.ts
+var refineFlowManifest = (manifest, ctx) => {
+  const jumpTargets = buildManifestJumpTargets(manifest);
+  const { screenIds } = refineManifestGraph(manifest, ctx, jumpTargets);
+  const allFieldKeys = /* @__PURE__ */ new Map();
+  refineManifestScreens(manifest, ctx, jumpTargets, screenIds, allFieldKeys);
+  manifest.decisionNodes.forEach((dn, di) => {
+    for (const fk of collectDecisionFieldKeysFromNode(dn)) {
+      if (!allFieldKeys.has(fk)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `decision "${dn.id}" references unknown fieldKey "${fk}"`,
+          path: ["decisionNodes", di, "cases"]
+        });
+      }
+    }
+  });
+  if (manifest.locales.length > 0 && !manifest.locales.includes(manifest.defaultLocale)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `defaultLocale "${manifest.defaultLocale}" must be in locales`,
+      path: ["defaultLocale"]
+    });
+  }
+};
+
+// src/manifest/flowManifestSchema.ts
+var FlowManifestObjectSchema = FlowManifestObjectBaseSchema.superRefine(refineFlowManifest);
+var FlowManifestSchema = FlowManifestObjectSchema;
+
+export { BuilderMetaSchema, FlowManifestObjectBaseSchema, FlowManifestObjectSchema, FlowManifestSchema, MANIFEST_SCHEMA_VERSION, ThemeSchema, migrateLegacyManifest };
+//# sourceMappingURL=manifest.js.map
+//# sourceMappingURL=manifest.js.map