@getrheo/flow-runtime 1.0.0

package/dist/index.js

@@ -0,0 +1,4200 @@
+import { permissionCaptureFieldKey, appReviewCaptureFieldKey, oauthLoginResponseKey, emailPasswordAuthResponseKey, OS_PERMISSION_OUTCOME_END, OS_PERMISSION_OUTCOME_CONTINUE, isInputLayer } from '@getrheo/contracts/layers';
+import { resolveLocalizedText } from '@getrheo/contracts/localized';
+import { EXTERNAL_SURFACE_NO_NEXT, collectDecisionFieldKeysFromNode } from '@getrheo/contracts/decisions';
+import { migrateLegacyManifest, FlowManifestSchema, screenBackgroundPlaybackId, isScreenBackgroundPlaybackId } from '@getrheo/contracts';
+import { FIELD_KEY_RE as FIELD_KEY_RE$1 } from '@getrheo/contracts/fields';
+import { walkScreenLayers } from '@getrheo/contracts/screens';
+import { deepMergeStyle } from '@getrheo/flow-runtime/responsive/merge';
+
+// src/stateMachine/stepResponse.ts
+var externalSurfaceResponseKey = (nodeId) => `surface_${nodeId}`;
+var isEligibleConsumedDraft = (r) => {
+  switch (r.kind) {
+    case "text":
+    case "choice":
+    case "multiChoice":
+    case "scale":
+    case "cta":
+    case "carousel":
+      return true;
+    default:
+      return false;
+  }
+};
+
+// src/stateMachine/flowSession.ts
+var findScreen = (manifest, screenId) => manifest.screens.find((s) => s.id === screenId);
+var findExternalSurface = (manifest, nodeId) => (
+  // Older / hand-constructed manifests may omit `externalSurfaceNodes` entirely;
+  // treat that as "no surfaces" rather than crashing the state machine.
+  (manifest.externalSurfaceNodes ?? []).find((n) => n.id === nodeId)
+);
+var initFlowState = (manifest, sessionPartial) => ({
+  manifest,
+  currentScreenId: null,
+  pendingExternalSurface: null,
+  history: [],
+  responses: {},
+  session: {
+    locale: sessionPartial?.locale ?? manifest.defaultLocale,
+    platform: sessionPartial?.platform ?? "unknown",
+    sdkAttributes: sessionPartial?.sdkAttributes ?? {}
+  },
+  status: "idle",
+  startedAt: null,
+  completedAt: null
+});
+
+// src/brandGradient.ts
+var BRAND_GRADIENT_PREFIX = "$brandGradient:";
+var brandGradientToCss = (g) => {
+  const stops = g.stops.map((s) => `${s.color} ${(s.offset * 100).toFixed(0)}%`).join(", ");
+  if (g.type === "linear") {
+    const angle = g.angle ?? 180;
+    return `linear-gradient(${angle}deg, ${stops})`;
+  }
+  return `radial-gradient(circle, ${stops})`;
+};
+var isBrandGradientToken = (s) => s.startsWith(BRAND_GRADIENT_PREFIX);
+var resolveBrandGradientToken = (branding, token) => {
+  if (!isBrandGradientToken(token)) return void 0;
+  const id = token.slice(BRAND_GRADIENT_PREFIX.length);
+  const preset = branding?.gradientPresets.find((x) => x.id === id);
+  return preset ? brandGradientToCss(preset) : void 0;
+};
+var rawThemedString = (palette, value) => {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  return palette === "dark" ? value.dark ?? value.light : value.light ?? value.dark;
+};
+var brandGradientFromThemedColor = (branding, palette, value) => {
+  const raw = rawThemedString(palette, value);
+  if (raw === void 0 || !isBrandGradientToken(raw)) return void 0;
+  const id = raw.slice(BRAND_GRADIENT_PREFIX.length);
+  return branding?.gradientPresets.find((x) => x.id === id);
+};
+var brandGradientNativeLinear = (g) => {
+  if (g.type !== "linear") return null;
+  const angleDeg = g.angle ?? 180;
+  const \u03B8 = angleDeg * Math.PI / 180;
+  const ux = Math.sin(\u03B8);
+  const uy = -Math.cos(\u03B8);
+  return {
+    colors: g.stops.map((s) => s.color),
+    locations: g.stops.map((s) => s.offset),
+    start: { x: 0.5 - ux * 0.5, y: 0.5 - uy * 0.5 },
+    end: { x: 0.5 + ux * 0.5, y: 0.5 + uy * 0.5 }
+  };
+};
+var brandGradientSolidFallback = (g) => g.stops[0]?.color ?? "#808080";
+var HEX_FOR_GRADIENT = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var normalizeHexForGradient = (hex) => {
+  const t = hex.trim();
+  if (!HEX_FOR_GRADIENT.test(t)) return t;
+  if (t.length === 4) {
+    const [, r, g, b] = t;
+    return `#${r}${r}${g}${g}${b}${b}`.toLowerCase();
+  }
+  if (t.length === 9) return t.slice(0, 7).toLowerCase();
+  return t.toLowerCase();
+};
+var clampPct = (n) => Math.min(100, Math.max(0, n));
+var buildLinearGradientCss = (angleDeg, stops) => {
+  const a = Number.isFinite(angleDeg) ? angleDeg : 180;
+  const sorted = [...stops].map((s) => ({
+    offsetPct: clampPct(Number.isFinite(s.offsetPct) ? s.offsetPct : 0),
+    color: normalizeHexForGradient(s.color)
+  })).sort((x, y) => x.offsetPct - y.offsetPct);
+  if (sorted.length < 2) {
+    throw new Error("linear gradient requires at least 2 color stops");
+  }
+  for (const s of sorted) {
+    if (!HEX_FOR_GRADIENT.test(s.color)) {
+      throw new Error(`invalid gradient stop color: ${s.color}`);
+    }
+  }
+  const body = sorted.map((s) => `${s.color} ${s.offsetPct.toFixed(0)}%`).join(", ");
+  return `linear-gradient(${a}deg, ${body})`;
+};
+var buildTwoStopLinearGradientCss = (angleDeg, color0, color1) => buildLinearGradientCss(angleDeg, [
+  { color: color0, offsetPct: 0 },
+  { color: color1, offsetPct: 100 }
+]);
+var isStoredLinearGradientCss = (s) => /^\s*linear-gradient\s*\(/i.test(s.trim());
+var parseLinearGradientCss = (s) => {
+  const t = s.trim();
+  const head = t.match(/^\s*linear-gradient\s*\(\s*([-0-9.]+)\s*deg\s*,\s*(.*)\)\s*$/is);
+  if (!head) return null;
+  const angleStr = head[1];
+  const innerRaw = head[2];
+  if (angleStr === void 0 || innerRaw === void 0) return null;
+  const angleDeg = Number(angleStr);
+  if (!Number.isFinite(angleDeg)) return null;
+  const inner = innerRaw.trim();
+  if (!inner) return null;
+  const parts = inner.split(/,(?=\s*#)/);
+  const stops = [];
+  for (const part of parts) {
+    const p = part.trim();
+    const m = p.match(/^(#[0-9a-fA-F]{3,8})\s+([-0-9.]+)\s*%$/i);
+    if (!m) return null;
+    const hex = m[1];
+    const offsetStr = m[2];
+    if (hex === void 0 || offsetStr === void 0) return null;
+    const color = normalizeHexForGradient(hex);
+    const offsetPct = Number(offsetStr);
+    if (!Number.isFinite(offsetPct)) return null;
+    if (!HEX_FOR_GRADIENT.test(color)) return null;
+    stops.push({ color, offsetPct });
+  }
+  if (stops.length < 2) return null;
+  return { angleDeg, stops };
+};
+var parseTwoStopLinearGradientCss = (s) => {
+  const p = parseLinearGradientCss(s);
+  if (!p || p.stops.length !== 2) return null;
+  const sorted = [...p.stops].sort((a, b) => a.offsetPct - b.offsetPct);
+  const s0 = sorted[0];
+  const s1 = sorted[1];
+  if (!s0 || !s1 || s0.offsetPct !== 0 || s1.offsetPct !== 100) return null;
+  return { angleDeg: p.angleDeg, color0: s0.color, color1: s1.color };
+};
+var nativeLinearFromAngleAndStops = (angleDeg, stops) => {
+  const sorted = [...stops].map((s) => ({
+    color: normalizeHexForGradient(s.color),
+    offsetPct: clampPct(Number.isFinite(s.offsetPct) ? s.offsetPct : 0)
+  })).sort((a, b) => a.offsetPct - b.offsetPct);
+  const \u03B8 = angleDeg * Math.PI / 180;
+  const ux = Math.sin(\u03B8);
+  const uy = -Math.cos(\u03B8);
+  return {
+    colors: sorted.map((s) => s.color),
+    locations: sorted.map((s) => s.offsetPct / 100),
+    start: { x: 0.5 - ux * 0.5, y: 0.5 - uy * 0.5 },
+    end: { x: 0.5 + ux * 0.5, y: 0.5 + uy * 0.5 }
+  };
+};
+var nativeLinearFromAngleAndTwoColors = (angleDeg, color0, color1) => nativeLinearFromAngleAndStops(angleDeg, [
+  { color: color0, offsetPct: 0 },
+  { color: color1, offsetPct: 100 }
+]);
+var walkLayers = (root, fn) => {
+  const visit = (l, depth) => {
+    fn(l, depth);
+    if (l.kind === "stack") l.children.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "carousel") l.slides.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "button") l.children.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "back_button") l.children.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "hyperlink") l.children.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "text_input" || l.kind === "scale_input") {
+      l.children?.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "oauth_login") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "oauth_provider" && l.variant === "custom") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "email_password_auth") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "email_password_field") {
+      l.children?.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "email_password_submit") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    }
+  };
+  visit(root, 0);
+};
+var walkScreen = (screen, fn) => {
+  if (screen.regions.header) walkLayers(screen.regions.header, fn);
+  walkLayers(screen.regions.body, fn);
+  if (screen.regions.footer) walkLayers(screen.regions.footer, fn);
+};
+var findInputLayer = (screen) => {
+  let found = null;
+  walkScreen(screen, (l) => {
+    if (!found && isInputLayer(l)) found = l;
+  });
+  return found;
+};
+var findManualSubmitInputLayer = (screen) => {
+  const input = findInputLayer(screen);
+  if (!input) return null;
+  if (input.kind === "multiple_choice" || input.kind === "text_input" || input.kind === "scale_input") {
+    return input;
+  }
+  return null;
+};
+var screenHasContinueButton = (screen) => {
+  let found = false;
+  walkScreen(screen, (l) => {
+    if (l.kind === "button" && l.action.kind === "continue") found = true;
+  });
+  return found;
+};
+var findOptionStackForChoice = (layer, optionId) => {
+  const binding = layer.optionBindings.find((b) => b.optionId === optionId);
+  if (!binding) return null;
+  const stack = layer.children.find((c) => c.id === binding.rootLayerId);
+  return stack ?? null;
+};
+var choiceOptionLabel = (layer, optionId, locale) => {
+  const stack = findOptionStackForChoice(layer, optionId);
+  if (!stack) return "";
+  let foundText = null;
+  walkLayers(stack, (l) => {
+    if (foundText) return;
+    if (l.kind === "text") foundText = l.text;
+  });
+  if (foundText) return resolveLocalizedText(foundText, locale);
+  return optionId;
+};
+var findLayerById = (screen, id) => {
+  let found = null;
+  walkScreen(screen, (l) => {
+    if (!found && l.id === id) found = l;
+  });
+  return found;
+};
+var collectFieldKeys = (manifest) => {
+  const out = [];
+  for (const screen of manifest.screens) {
+    walkScreen(screen, (l) => {
+      if (isInputLayer(l)) out.push({ fieldKey: l.fieldKey, screenId: screen.id });
+      if (l.kind === "checkbox") out.push({ fieldKey: l.fieldKey, screenId: screen.id });
+      if (l.kind === "email_password_auth") {
+        out.push({ fieldKey: l.fieldKey, screenId: screen.id });
+      }
+    });
+  }
+  return out;
+};
+var nextUniqueFieldKey = (base, used) => {
+  const set = used instanceof Set ? used : new Set(used);
+  if (!set.has(base)) return base;
+  let n = 2;
+  while (set.has(`${base}_${n}`)) n += 1;
+  return `${base}_${n}`;
+};
+var resolveTokens = (theme, value) => {
+  if (value === void 0) return value;
+  if (typeof value !== "string" || !value.startsWith("$")) return value;
+  const key = value.slice(1);
+  const literal = theme?.[key];
+  if (typeof literal === "string") return literal;
+  return value;
+};
+var resolveThemedColor = (theme, palette, value) => {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return resolveTokens(theme, value);
+  const raw = palette === "dark" ? value.dark ?? value.light : value.light ?? value.dark;
+  if (raw === void 0) return void 0;
+  return resolveTokens(theme, raw);
+};
+var resolveThemedBackground = (theme, branding, palette, value) => {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") {
+    if (value.startsWith("$brandGradient:")) {
+      return resolveBrandGradientToken(branding, value);
+    }
+    return resolveTokens(theme, value);
+  }
+  const raw = palette === "dark" ? value.dark ?? value.light : value.light ?? value.dark;
+  if (raw === void 0) return void 0;
+  if (raw.startsWith("$brandGradient:")) {
+    return resolveBrandGradientToken(branding, raw);
+  }
+  return resolveTokens(theme, raw);
+};
+var nativeBrandBackgroundFromThemedColor = (theme, branding, palette, value) => {
+  const preset = brandGradientFromThemedColor(branding, palette, value);
+  if (preset) {
+    const lin = brandGradientNativeLinear(preset);
+    if (lin) return { linear: lin };
+    return { solid: brandGradientSolidFallback(preset) };
+  }
+  const bg = resolveThemedBackground(theme, branding, palette, value);
+  if (!bg) return {};
+  const parsed = parseLinearGradientCss(bg);
+  if (parsed) {
+    return {
+      linear: nativeLinearFromAngleAndStops(
+        parsed.angleDeg,
+        parsed.stops.map((s) => ({ color: s.color, offsetPct: s.offsetPct }))
+      )
+    };
+  }
+  if (isStoredLinearGradientCss(bg)) {
+    const first = bg.match(/#[0-9a-fA-F]{3,8}/);
+    return { solid: first ? first[0] : "#808080" };
+  }
+  return { solid: bg };
+};
+
+// src/decisionEval.ts
+var findDecisionNode = (manifest, id) => (manifest.decisionNodes ?? []).find((d) => d.id === id);
+var decisionTargetIds = (manifest) => new Set((manifest.decisionNodes ?? []).map((d) => d.id));
+var stableSerialize = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableSerialize).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  const parts = keys.map((k) => `${JSON.stringify(k)}:${stableSerialize(value[k])}`);
+  return `{${parts.join(",")}}`;
+};
+var digestDecisionExpression = (expr) => {
+  const s = stableSerialize(expr);
+  let h = 5381;
+  for (let i = 0; i < s.length; i += 1) {
+    h = h * 33 ^ s.charCodeAt(i);
+  }
+  return `d${(h >>> 0).toString(16)}`;
+};
+var responseForField = (fieldKey, responses) => responses[fieldKey];
+var normalizeResponseValue = (r) => {
+  if (!r || typeof r !== "object") return void 0;
+  const o = r;
+  switch (o.kind) {
+    case "choice":
+      return typeof o.choiceId === "string" ? o.choiceId : void 0;
+    case "multiChoice":
+      return Array.isArray(o.choiceIds) ? o.choiceIds : void 0;
+    case "text":
+      return typeof o.value === "string" ? o.value : void 0;
+    case "scale":
+      return typeof o.value === "number" ? o.value : void 0;
+    case "checkbox":
+      return typeof o.value === "boolean" ? o.value : void 0;
+    default:
+      return void 0;
+  }
+};
+var normalizeScalarForStringPred = (raw) => {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+  return void 0;
+};
+var normalizeNumber = (raw) => {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return void 0;
+  return raw;
+};
+var normalizeChoiceId = (raw) => typeof raw === "string" && raw.length > 0 ? raw : void 0;
+var normalizeChoiceIds = (raw) => {
+  if (!Array.isArray(raw)) return void 0;
+  const ids = raw.filter((x) => typeof x === "string" && x.length > 0);
+  return ids;
+};
+var normalizeBoolean = (raw) => {
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw !== 0;
+  if (typeof raw === "string") {
+    const s = raw.trim().toLowerCase();
+    if (s === "true" || s === "1" || s === "yes") return true;
+    if (s === "false" || s === "0" || s === "no") return false;
+  }
+  return void 0;
+};
+var resolveVariableValue = (variable, ctx) => {
+  if (variable.kind === "builtin") {
+    if (variable.name === "locale") return ctx.locale;
+    return ctx.platform;
+  }
+  if (variable.kind === "sdk") return ctx.sdkAttributes[variable.key];
+  const r = responseForField(variable.fieldKey, ctx.responses);
+  return normalizeResponseValue(r);
+};
+var evalStringPred = (left, pred) => {
+  switch (pred.op) {
+    case "eq":
+      return left === pred.value;
+    case "neq":
+      return left !== pred.value;
+    case "contains":
+      return left.includes(pred.value);
+    default:
+      return false;
+  }
+};
+var evalNumberPred = (left, pred) => {
+  switch (pred.op) {
+    case "eq":
+      return left === pred.value;
+    case "neq":
+      return left !== pred.value;
+    case "lt":
+      return left < pred.value;
+    case "lte":
+      return left <= pred.value;
+    case "gt":
+      return left > pred.value;
+    case "gte":
+      return left >= pred.value;
+    default:
+      return false;
+  }
+};
+var evalChoicePred = (choiceId, pred) => {
+  if (pred.op === "eq") return choiceId === pred.optionId;
+  return pred.optionIds.includes(choiceId);
+};
+var setIntersect = (a, b) => {
+  const bs = new Set(b);
+  return a.filter((x) => bs.has(x));
+};
+var evalBooleanPred = (left, pred) => {
+  if (pred.op === "eq") return left === pred.value;
+  return left !== pred.value;
+};
+var evalMultiPred = (selected, pred) => {
+  const required = pred.optionIds;
+  switch (pred.op) {
+    case "intersects":
+      return setIntersect(selected, required).length > 0;
+    case "contains_all": {
+      const sel = new Set(selected);
+      return required.every((id) => sel.has(id));
+    }
+    case "subset_of": {
+      const allow = new Set(required);
+      return selected.every((id) => allow.has(id));
+    }
+    default:
+      return false;
+  }
+};
+var evaluateDecisionExpression = (expr, ctx) => {
+  if (expr.kind === "empty") return false;
+  if (expr.kind === "group") {
+    if (expr.op === "and") {
+      for (const c of expr.children) {
+        if (!evaluateDecisionExpression(c, ctx)) return false;
+      }
+      return true;
+    }
+    for (const c of expr.children) {
+      if (evaluateDecisionExpression(c, ctx)) return true;
+    }
+    return false;
+  }
+  const raw = resolveVariableValue(expr.variable, ctx);
+  const { predicate } = expr;
+  switch (predicate.type) {
+    case "string": {
+      const s = normalizeScalarForStringPred(raw);
+      if (s === void 0) return false;
+      return evalStringPred(s, predicate.pred);
+    }
+    case "number": {
+      const n = normalizeNumber(raw);
+      if (n === void 0) return false;
+      return evalNumberPred(n, predicate.pred);
+    }
+    case "choice": {
+      const id = normalizeChoiceId(raw);
+      if (!id) return false;
+      return evalChoicePred(id, predicate.pred);
+    }
+    case "multi": {
+      const ids = normalizeChoiceIds(raw);
+      if (!ids) return false;
+      return evalMultiPred(ids, predicate.pred);
+    }
+    case "boolean": {
+      const b = normalizeBoolean(raw);
+      if (b === void 0) return false;
+      return evalBooleanPred(b, predicate.pred);
+    }
+    default:
+      return false;
+  }
+};
+var evaluateDecisionNode = (node, ctx) => {
+  for (const c of node.cases) {
+    if (evaluateDecisionExpression(c.expression, ctx)) {
+      return {
+        matchedCaseId: c.id,
+        next: c.next,
+        clauseDigest: digestDecisionExpression(c.expression)
+      };
+    }
+  }
+  return {
+    matchedCaseId: null,
+    next: node.elseNext,
+    clauseDigest: "else"
+  };
+};
+
+// src/stateMachine/graphLanding.ts
+var resolveOsPermissionDestination = (screen, response) => {
+  const layer = findLayerById(screen, response.layerId);
+  if (!layer || layer.kind !== "button" || layer.action.kind !== "request_os_permission")
+    return null;
+  if (layer.action.permissionKey !== response.permissionKey) return null;
+  const target = layer.action.outcomes[response.outcome];
+  if (target === OS_PERMISSION_OUTCOME_END) return null;
+  if (target === OS_PERMISSION_OUTCOME_CONTINUE) return screen.next.default ?? null;
+  return target;
+};
+var resolveNextScreenId = (screen, response) => {
+  if (response.kind === "screen_commit") {
+    return resolveNextScreenId(screen, response.primary);
+  }
+  if (response.kind === "go_to_screen") return response.screenId;
+  if (response.kind === "permission_outcome") {
+    const nextId = resolveOsPermissionDestination(screen, response);
+    return nextId ?? screen.next.default ?? null;
+  }
+  if (response.kind === "app_review_outcome") {
+    const layer = findLayerById(screen, response.layerId);
+    if (!layer || layer.kind !== "button" || layer.action.kind !== "request_app_review") {
+      return screen.next.default ?? null;
+    }
+    return screen.next.default ?? null;
+  }
+  if (response.kind === "oauth_login_resolve") {
+    return screen.next.default ?? null;
+  }
+  if (response.kind === "email_password_auth_resolve") {
+    return screen.next.default ?? null;
+  }
+  const input = findInputLayer(screen);
+  if (input && (input.kind === "single_choice" || input.kind === "multiple_choice") && input.branching.enabled) {
+    if (response.kind === "choice") {
+      const m = input.branching.conditions.find((c) => c.choiceId === response.choiceId);
+      if (m) return m.goTo;
+    } else if (response.kind === "multiChoice") {
+      const m = input.branching.conditions.find((c) => response.choiceIds.includes(c.choiceId));
+      if (m) return m.goTo;
+    }
+  }
+  return screen.next.default ?? null;
+};
+var resolveThroughGraph = (manifest, cursor, responses, session, onDecisionEvaluated) => {
+  let cur = cursor;
+  const evalCtx = {
+    locale: session.locale,
+    platform: session.platform,
+    sdkAttributes: session.sdkAttributes,
+    responses
+  };
+  while (cur) {
+    const dn = findDecisionNode(manifest, cur);
+    if (!dn) break;
+    const evalResult = evaluateDecisionNode(dn, evalCtx);
+    onDecisionEvaluated?.({
+      decisionNodeId: dn.id,
+      matchedCaseId: evalResult.matchedCaseId,
+      clauseDigest: evalResult.clauseDigest
+    });
+    cur = evalResult.next;
+    if (cur == null) break;
+  }
+  if (cur == null) return { kind: "end" };
+  if (findExternalSurface(manifest, cur)) return { kind: "surface", nodeId: cur };
+  return { kind: "screen", screenId: cur };
+};
+var responseKeyFor = (screen, response) => {
+  if (response.kind === "text" || response.kind === "choice" || response.kind === "multiChoice" || response.kind === "scale" || response.kind === "checkbox") {
+    const input = findInputLayer(screen);
+    if (input) return input.fieldKey;
+  }
+  if (response.kind === "permission_outcome") return permissionCaptureFieldKey(response.permissionKey);
+  if (response.kind === "app_review_outcome") return appReviewCaptureFieldKey(response.layerId);
+  if (response.kind === "checkbox") return response.fieldKey;
+  if (response.kind === "oauth_login_resolve") return oauthLoginResponseKey(response.layerId);
+  if (response.kind === "email_password_auth_resolve") {
+    return emailPasswordAuthResponseKey(response.layerId);
+  }
+  return screen.id;
+};
+var applyGraphLanding = (base, landing, nextResponses, now) => {
+  if (landing.kind === "end") {
+    return {
+      ...base,
+      responses: nextResponses,
+      currentScreenId: null,
+      pendingExternalSurface: null,
+      status: "completed",
+      completedAt: now
+    };
+  }
+  if (landing.kind === "surface") {
+    return {
+      ...base,
+      responses: nextResponses,
+      currentScreenId: null,
+      pendingExternalSurface: { nodeId: landing.nodeId },
+      history: [...base.history, landing.nodeId]
+    };
+  }
+  return {
+    ...base,
+    responses: nextResponses,
+    currentScreenId: landing.screenId,
+    pendingExternalSurface: null,
+    history: [...base.history, landing.screenId]
+  };
+};
+var startFlow = (state, second) => {
+  const opts = typeof second === "string" ? { now: second } : second ?? {};
+  const now = opts.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const entry = state.manifest.entryScreenId;
+  if (entry == null) {
+    return {
+      ...state,
+      status: "idle",
+      currentScreenId: null,
+      pendingExternalSurface: null,
+      history: [],
+      startedAt: null,
+      completedAt: null
+    };
+  }
+  const landing = resolveThroughGraph(
+    state.manifest,
+    entry,
+    {},
+    {
+      ...state.session
+    },
+    opts.onDecisionEvaluated
+  );
+  if (landing.kind === "end") {
+    return {
+      ...state,
+      status: "completed",
+      currentScreenId: null,
+      pendingExternalSurface: null,
+      history: [entry],
+      startedAt: now,
+      completedAt: now
+    };
+  }
+  if (landing.kind === "surface") {
+    return {
+      ...state,
+      status: "running",
+      currentScreenId: null,
+      pendingExternalSurface: { nodeId: landing.nodeId },
+      history: [landing.nodeId],
+      startedAt: now
+    };
+  }
+  return {
+    ...state,
+    status: "running",
+    currentScreenId: landing.screenId,
+    pendingExternalSurface: null,
+    history: [landing.screenId],
+    startedAt: now
+  };
+};
+var submitResponse = (state, response, third) => {
+  const opts = typeof third === "string" ? { now: third } : third ?? {};
+  const now = opts.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  if (state.status !== "running") return state;
+  if (response.kind === "external_surface_outcome") {
+    const pending = state.pendingExternalSurface;
+    if (!pending || pending.nodeId !== response.nodeId) return state;
+    const surface = findExternalSurface(state.manifest, pending.nodeId);
+    if (!surface) return state;
+    const nextSession = response.sdkKeyPatch ? {
+      ...state.session,
+      sdkAttributes: { ...state.session.sdkAttributes, ...response.sdkKeyPatch }
+    } : state.session;
+    const target = surface.outcomes[response.outcome] ?? surface.fallback;
+    const nextResponses2 = {
+      ...state.responses,
+      [externalSurfaceResponseKey(pending.nodeId)]: response
+    };
+    if (target === EXTERNAL_SURFACE_NO_NEXT) {
+      return {
+        ...state,
+        session: nextSession,
+        responses: nextResponses2,
+        pendingExternalSurface: null,
+        currentScreenId: null,
+        status: "completed",
+        completedAt: now
+      };
+    }
+    const landing2 = resolveThroughGraph(
+      state.manifest,
+      target,
+      nextResponses2,
+      nextSession,
+      opts.onDecisionEvaluated
+    );
+    return applyGraphLanding(
+      { ...state, session: nextSession },
+      landing2,
+      nextResponses2,
+      now
+    );
+  }
+  if (!state.currentScreenId) return state;
+  const screen = findScreen(state.manifest, state.currentScreenId);
+  if (!screen) return state;
+  if (response.kind === "screen_commit") {
+    const mergedResponses = { ...state.responses };
+    for (const [fk, value] of Object.entries(response.checkboxValues)) {
+      mergedResponses[fk] = { kind: "checkbox", fieldKey: fk, value };
+    }
+    if (response.capturedDraft) {
+      mergedResponses[responseKeyFor(screen, response.capturedDraft)] = response.capturedDraft;
+    }
+    return submitResponse({ ...state, responses: mergedResponses }, response.primary, opts);
+  }
+  if (response.kind === "go_back") {
+    const fallback = response.fallbackScreenId;
+    if (state.history.length > 1) {
+      const nextHistory = state.history.slice(0, -1);
+      const prevId = nextHistory[nextHistory.length - 1];
+      if (!prevId) return state;
+      return {
+        ...state,
+        currentScreenId: prevId,
+        history: nextHistory
+      };
+    }
+    if (fallback && findScreen(state.manifest, fallback)) {
+      return {
+        ...state,
+        currentScreenId: fallback,
+        history: [fallback]
+      };
+    }
+    return state;
+  }
+  if (response.kind === "oauth_login_resolve" && !response.success) {
+    const key2 = oauthLoginResponseKey(response.layerId);
+    return {
+      ...state,
+      responses: { ...state.responses, [key2]: response }
+    };
+  }
+  if (response.kind === "email_password_auth_resolve" && !response.success) {
+    const key2 = emailPasswordAuthResponseKey(response.layerId);
+    return {
+      ...state,
+      responses: { ...state.responses, [key2]: response }
+    };
+  }
+  if (response.kind === "end_flow") {
+    const nextResponses2 = { ...state.responses };
+    if (response.consumedDraft) {
+      nextResponses2[responseKeyFor(screen, response.consumedDraft)] = response.consumedDraft;
+    }
+    nextResponses2[responseKeyFor(screen, { kind: "end_flow" })] = { kind: "end_flow" };
+    return {
+      ...state,
+      responses: nextResponses2,
+      currentScreenId: null,
+      status: "completed",
+      completedAt: now
+    };
+  }
+  if (response.kind === "skip") {
+    const nextResponses2 = { ...state.responses };
+    const manualInput = findManualSubmitInputLayer(screen);
+    if (manualInput) {
+      nextResponses2[manualInput.fieldKey] = { kind: "bypass_input", via: "skip" };
+    }
+    nextResponses2[responseKeyFor(screen, { kind: "skip" })] = { kind: "skip" };
+    const nextRaw2 = resolveNextScreenId(screen, { kind: "skip" });
+    const landing2 = resolveThroughGraph(
+      state.manifest,
+      nextRaw2,
+      nextResponses2,
+      state.session,
+      opts.onDecisionEvaluated
+    );
+    return applyGraphLanding(state, landing2, nextResponses2, now);
+  }
+  const key = responseKeyFor(screen, response);
+  const nextResponses = { ...state.responses, [key]: response };
+  if (response.kind === "go_to_screen") {
+    const manualInput = findManualSubmitInputLayer(screen);
+    if (manualInput) {
+      nextResponses[manualInput.fieldKey] = { kind: "bypass_input", via: "go_to_screen" };
+    }
+  }
+  const nextRaw = resolveNextScreenId(screen, response);
+  const landing = resolveThroughGraph(
+    state.manifest,
+    nextRaw,
+    nextResponses,
+    state.session,
+    opts.onDecisionEvaluated
+  );
+  return applyGraphLanding(state, landing, nextResponses, now);
+};
+
+// src/stateMachine/flowTerminal.ts
+var TERMINAL_EXPORT_AUTH_RESPONSE_KEY_PREFIXES = ["oauth:", "email_pw:"];
+var isAuthTerminalExportResponseKey = (key) => TERMINAL_EXPORT_AUTH_RESPONSE_KEY_PREFIXES.some((prefix) => key.startsWith(prefix));
+var stripAuthResponsesForTerminalExport = (responses) => {
+  const out = {};
+  for (const [k, v] of Object.entries(responses)) {
+    if (isAuthTerminalExportResponseKey(k)) continue;
+    out[k] = v;
+  }
+  return out;
+};
+var stepResponseToCompletionValue = (r) => {
+  if (r.kind === "screen_commit") return void 0;
+  switch (r.kind) {
+    case "choice":
+      return r.choiceId;
+    case "multiChoice":
+      return r.choiceIds;
+    case "text":
+      return { value: r.value, classification: r.classification };
+    case "scale":
+      return r.value;
+    case "checkbox":
+      return r.value;
+    case "cta":
+      return r.action;
+    case "carousel":
+      return "carousel";
+    case "end_flow":
+      return "end_flow";
+    case "skip":
+      return "skip";
+    case "permission_outcome":
+      return r.outcome;
+    case "app_review_outcome":
+      return r.outcome;
+    case "oauth_login_resolve":
+      return {
+        success: r.success,
+        customerExternalId: r.customerExternalId,
+        provider: r.provider
+      };
+    case "email_password_auth_resolve":
+      return {
+        success: r.success,
+        mode: r.mode,
+        email: r.email
+      };
+    case "bypass_input":
+      return { bypassed: true, via: r.via };
+    case "external_surface_outcome":
+      return { outcome: r.outcome };
+    case "go_to_screen":
+      return { goToScreen: r.screenId };
+    case "go_back":
+      return void 0;
+    default: {
+      const _never = r;
+      return _never;
+    }
+  }
+};
+var buildCompletionResponses = (state) => {
+  const out = {};
+  for (const [key, r] of Object.entries(state.responses)) {
+    const v = stepResponseToCompletionValue(r);
+    if (v !== void 0) out[key] = v;
+  }
+  return out;
+};
+var abandonFlow = (state, now = (/* @__PURE__ */ new Date()).toISOString()) => ({
+  ...state,
+  status: "abandoned",
+  completedAt: now
+});
+var validateManifest = (data) => {
+  const migrated = migrateLegacyManifest(data);
+  const result = FlowManifestSchema.safeParse(migrated);
+  if (result.success) return { ok: true, manifest: result.data };
+  return {
+    ok: false,
+    issues: result.error.issues.map((i) => {
+      const screenIdx = i.path[1];
+      const screenId = typeof screenIdx === "number" && Array.isArray(data?.screens) ? data.screens[screenIdx]?.id : void 0;
+      return {
+        stepId: screenId ?? null,
+        path: [...i.path],
+        message: i.message,
+        code: i.code
+      };
+    })
+  };
+};
+var validatePublishable = (manifest) => {
+  const issues = [];
+  const warnings = [];
+  if (manifest.screens.length === 0) {
+    issues.push({
+      path: ["screens"],
+      message: "flow must have at least one screen",
+      code: "flow.no_screens"
+    });
+  }
+  if (manifest.entryScreenId == null && manifest.screens.length > 0) {
+    issues.push({
+      path: ["entryScreenId"],
+      message: "flow entry is not connected \u2014 connect the entry node on the canvas to a screen, decision, or integration step before publishing",
+      code: "flow.no_entry"
+    });
+  }
+  const screenMap = new Map(
+    manifest.screens.map((s) => [s.id, s])
+  );
+  const decisionMap = new Map((manifest.decisionNodes ?? []).map((d) => [d.id, d]));
+  const surfaceMap = new Map((manifest.externalSurfaceNodes ?? []).map((s) => [s.id, s]));
+  const enqueueGraphNode = (t) => {
+    if (t === null || t === void 0) return;
+    if (screenMap.has(t) || decisionMap.has(t) || surfaceMap.has(t)) {
+      queue.push(t);
+    }
+  };
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = [];
+  if (manifest.entryScreenId != null) {
+    queue.push(manifest.entryScreenId);
+  }
+  let canTerminate = false;
+  while (queue.length) {
+    const id = queue.shift();
+    if (reachable.has(id)) continue;
+    reachable.add(id);
+    const decision = decisionMap.get(id);
+    if (decision) {
+      for (const c of decision.cases) {
+        if (c.next != null) enqueueGraphNode(c.next);
+      }
+      if (decision.elseNext != null) enqueueGraphNode(decision.elseNext);
+      continue;
+    }
+    const surface = surfaceMap.get(id);
+    if (surface) {
+      const outcomeTargets = Object.values(surface.outcomes);
+      if (outcomeTargets.some((t) => t === EXTERNAL_SURFACE_NO_NEXT) || surface.fallback === EXTERNAL_SURFACE_NO_NEXT) {
+        canTerminate = true;
+      }
+      if (surface.fallback != null && surface.fallback !== EXTERNAL_SURFACE_NO_NEXT) {
+        enqueueGraphNode(surface.fallback);
+      }
+      for (const t of outcomeTargets) {
+        if (t != null && t !== EXTERNAL_SURFACE_NO_NEXT) enqueueGraphNode(t);
+      }
+      continue;
+    }
+    const screen = screenMap.get(id);
+    if (!screen) continue;
+    const targets = [];
+    targets.push(screen.next.default);
+    const input = findInputLayer(screen);
+    if (input && (input.kind === "single_choice" || input.kind === "multiple_choice") && input.branching.enabled) {
+      for (const c of input.branching.conditions) targets.push(c.goTo);
+    }
+    walkScreen(screen, (l) => {
+      if (l.kind === "button" && l.action.kind === "go_to_step") {
+        targets.push(l.action.screenId);
+      }
+      if (l.kind === "button" && l.action.kind === "end_flow") {
+        targets.push(null);
+      }
+      if (l.kind === "button" && l.action.kind === "request_app_review") {
+        targets.push(screen.next.default);
+      }
+      if (l.kind === "button" && l.action.kind === "request_os_permission") {
+        const o = l.action.outcomes;
+        for (const t of [o.granted, o.denied, o.blocked]) {
+          if (t === OS_PERMISSION_OUTCOME_END) {
+            targets.push(null);
+          } else if (t === OS_PERMISSION_OUTCOME_CONTINUE) {
+            targets.push(screen.next.default);
+          } else {
+            targets.push(t);
+          }
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "go_back_one_screen" && l.action.fallbackScreenId) {
+        targets.push(l.action.fallbackScreenId);
+      }
+      if (l.kind === "back_button" && l.fallbackScreenId) {
+        targets.push(l.fallbackScreenId);
+      }
+    });
+    if (targets.every((t) => t === null || t === void 0)) {
+      canTerminate = true;
+    }
+    for (const t of targets) {
+      if (t === null || t === void 0) {
+        canTerminate = true;
+      } else {
+        enqueueGraphNode(t);
+      }
+    }
+  }
+  if (manifest.entryScreenId != null && !canTerminate) {
+    issues.push({
+      path: ["screens"],
+      message: "no path from entry screen reaches completion",
+      code: "flow.no_completion_path"
+    });
+  }
+  for (const screen of manifest.screens) {
+    if (manifest.entryScreenId != null && !reachable.has(screen.id)) {
+      warnings.push({
+        stepId: screen.id,
+        path: ["screens", screen.id],
+        message: `screen "${screen.id}" is not reachable from entry`,
+        code: "screen.unreachable"
+      });
+    }
+  }
+  for (const sn of manifest.externalSurfaceNodes ?? []) {
+    if (manifest.entryScreenId != null && !reachable.has(sn.id)) {
+      warnings.push({
+        stepId: null,
+        path: ["externalSurfaceNodes", sn.id],
+        message: `external surface "${sn.name ?? sn.id}" is not reachable from entry`,
+        code: "external_surface.unreachable"
+      });
+    }
+  }
+  for (const dn of manifest.decisionNodes ?? []) {
+    if (manifest.entryScreenId != null && !reachable.has(dn.id)) {
+      warnings.push({
+        stepId: null,
+        path: ["decisionNodes", dn.id],
+        message: `decision "${dn.id}" is not reachable from entry`,
+        code: "decision.unreachable"
+      });
+    }
+    for (const c of dn.cases) {
+      if (c.next == null) {
+        issues.push({
+          stepId: null,
+          path: ["decisionNodes", dn.id, "cases", c.id],
+          message: `decision "${dn.id}" segment "${c.name ?? c.id}" must have a next step before publishing`,
+          code: "decision.incomplete_branches"
+        });
+      }
+    }
+    if (dn.elseNext == null) {
+      issues.push({
+        stepId: null,
+        path: ["decisionNodes", dn.id, "elseNext"],
+        message: `decision "${dn.id}" needs an "everyone else" branch connected before publishing`,
+        code: "decision.incomplete_branches"
+      });
+    }
+  }
+  return { ok: issues.length === 0, issues, warnings };
+};
+var BUILDER_RULES_AGENT_BULLETS = [
+  "Connect flow entry on the canvas before publishing (entryScreenId must exist when screens are present).",
+  "Every text and icon layer needs explicit style.color (including nested button label text \u2014 native does not inherit colors).",
+  'Screens with text_input, multiple_choice, or scale_input need a button with action.kind "continue".',
+  "At most one input layer per screen (single_choice, multiple_choice, text_input, scale_input).",
+  "Do not combine oauth_login or email_password_auth with other input layers on the same screen.",
+  "Only one oauth_login and one email_password_auth per screen; never both on the same screen.",
+  "fieldKey values must be unique snake_case across the flow.",
+  "Choice branch goTo and go_to_step screenId must reference existing screen ids.",
+  "request_app_review buttons require screen.next.default wired to a valid target.",
+  'request_os_permission outcomes must target existing screens, "continue", or "end".',
+  'Lottie/video with autoPlay false needs a button with action.kind "play_media" targeting that layer (or screen background video id).',
+  "play_media targetLayerIds must reference Lottie/video layers on the same screen or the screen background video playback id."
+];
+var FIELD_KEY_RE = /^[a-z][a-z0-9_]*$/;
+var styleBucketHasColor = (s) => s !== void 0 && s.color !== void 0;
+var textLayerHasAuthoringColor = (l) => {
+  if (styleBucketHasColor(l.style)) return true;
+  const bp = l.styleBreakpoints;
+  if (!bp) return false;
+  return styleBucketHasColor(bp.sm) || styleBucketHasColor(bp.md) || styleBucketHasColor(bp.lg) || styleBucketHasColor(bp.xl) || styleBucketHasColor(bp["2xl"]);
+};
+var iconLayerHasAuthoringColor = (l) => {
+  if (styleBucketHasColor(l.style)) return true;
+  const bp = l.styleBreakpoints;
+  if (!bp) return false;
+  return styleBucketHasColor(bp.sm) || styleBucketHasColor(bp.md) || styleBucketHasColor(bp.lg) || styleBucketHasColor(bp.xl) || styleBucketHasColor(bp["2xl"]);
+};
+var collectFlowBuilderIssues = (manifest) => {
+  const issues = [];
+  const fieldKeyOwners = /* @__PURE__ */ new Map();
+  const screenIds = new Set(manifest.screens.map((s) => s.id));
+  const jumpTargetIds = /* @__PURE__ */ new Set([
+    ...screenIds,
+    ...manifest.decisionNodes.map((d) => d.id),
+    ...(manifest.externalSurfaceNodes ?? []).map((n) => n.id)
+  ]);
+  if (manifest.entryScreenId == null) {
+    if (manifest.screens.length > 0) {
+      issues.push(
+        "Connect the flow entry node on the canvas to where the flow starts (a screen, decision, or integration step)."
+      );
+    }
+  } else if (!jumpTargetIds.has(manifest.entryScreenId)) {
+    issues.push(`Flow entry target "${manifest.entryScreenId}" does not exist.`);
+  }
+  for (const screen of manifest.screens) {
+    let inputCount = 0;
+    let oauthLoginLayerCount = 0;
+    let emailPasswordAuthLayerCount = 0;
+    let needsManualSubmit = false;
+    let hasContinueButton = false;
+    const screenLabel = screen.name || screen.id;
+    const mediaLayerIds = /* @__PURE__ */ new Set();
+    const buttonLayerIds = /* @__PURE__ */ new Set();
+    const shellPlaybackId = screenBackgroundPlaybackId(screen.id);
+    const shellFill = screen.containerStyle?.backgroundFill;
+    const shellVideoFill = shellFill?.kind === "video" ? shellFill : void 0;
+    walkScreen(screen, (l) => {
+      if (l.kind === "button") buttonLayerIds.add(l.id);
+    });
+    if (shellFill?.kind === "image" || shellFill?.kind === "video") {
+      if (!shellFill.media?.mediaAssetId) {
+        issues.push(
+          `Screen "${screenLabel}" ${shellFill.kind} background needs a media asset.`
+        );
+      }
+    }
+    if (shellVideoFill) {
+      if (shellVideoFill.autoPlay === false) {
+        const triggerId = shellVideoFill.triggerLayerId?.trim();
+        if (!triggerId) {
+          issues.push(
+            `Screen "${screenLabel}" background video needs a trigger button when auto-play is off.`
+          );
+        } else if (!buttonLayerIds.has(triggerId)) {
+          issues.push(
+            `Screen "${screenLabel}" background video references a missing trigger button "${triggerId}".`
+          );
+        } else {
+          const btn = findLayerById(screen, triggerId);
+          if (!btn || btn.kind !== "button") {
+            issues.push(
+              `Screen "${screenLabel}" background video trigger must be a button layer.`
+            );
+          } else if (btn.action.kind !== "play_media") {
+            issues.push(
+              `Screen "${screenLabel}" background video trigger button must use On Tap \u2192 Play media.`
+            );
+          } else if (!btn.action.targetLayerIds.includes(shellPlaybackId)) {
+            issues.push(
+              `Screen "${screenLabel}" background video is not listed on trigger button "${triggerId}".`
+            );
+          }
+        }
+      } else if (shellVideoFill.triggerLayerId) {
+        const btn = findLayerById(screen, shellVideoFill.triggerLayerId);
+        if (btn?.kind === "button" && btn.action.kind === "play_media" && !btn.action.targetLayerIds.includes(shellPlaybackId)) {
+          issues.push(
+            `Screen "${screenLabel}" background video trigger button does not target the screen background.`
+          );
+        }
+      }
+    }
+    walkScreen(screen, (l) => {
+      if (l.kind === "lottie" || l.kind === "video") mediaLayerIds.add(l.id);
+      if (l.kind === "oauth_login") {
+        oauthLoginLayerCount += 1;
+      }
+      if (l.kind === "email_password_auth") {
+        emailPasswordAuthLayerCount += 1;
+      }
+      if (l.kind === "button" && l.action.kind === "continue") {
+        hasContinueButton = true;
+      }
+      if (isInputLayer(l)) {
+        inputCount += 1;
+        if (l.kind === "multiple_choice" || l.kind === "text_input" || l.kind === "scale_input") {
+          needsManualSubmit = true;
+        }
+        const key = l.fieldKey;
+        const label = screen.name || screen.id;
+        if (!key || key.length === 0) {
+          issues.push(`Screen "${label}" is missing a variable name (fieldKey).`);
+        } else if (!FIELD_KEY_RE.test(key)) {
+          issues.push(
+            `Screen "${label}" has an invalid variable name "${key}" \u2014 use snake_case (a\u2013z, 0\u20139, _).`
+          );
+        } else {
+          const owners = fieldKeyOwners.get(key) ?? [];
+          owners.push(label);
+          fieldKeyOwners.set(key, owners);
+        }
+        if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+          for (const cond of l.branching.conditions) {
+            if (!screenIds.has(cond.goTo)) {
+              issues.push(
+                `Screen "${label}" branches choice "${cond.choiceId}" to a missing screen "${cond.goTo}".`
+              );
+            }
+          }
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "go_to_step") {
+        if (!screenIds.has(l.action.screenId)) {
+          issues.push(
+            `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" targets a missing screen "${l.action.screenId}".`
+          );
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "request_app_review") {
+        const def = screen.next?.default;
+        if (def == null) {
+          issues.push(
+            `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" requests app review but the screen has no default next step.`
+          );
+        } else if (!screenIds.has(def) && !manifest.decisionNodes?.some((d) => d.id === def)) {
+          issues.push(
+            `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" requests app review but default next "${def}" is missing.`
+          );
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "request_os_permission") {
+        const o = l.action.outcomes;
+        for (const slot of ["granted", "denied", "blocked"]) {
+          const sid = o[slot];
+          if (sid === OS_PERMISSION_OUTCOME_END) {
+            continue;
+          }
+          if (sid === OS_PERMISSION_OUTCOME_CONTINUE) {
+            const def = screen.next?.default;
+            if (def == null) {
+              continue;
+            }
+            if (!screenIds.has(def) && !manifest.decisionNodes?.some((d) => d.id === def)) {
+              issues.push(
+                `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" (${slot}) continues to missing target "${def}".`
+              );
+            }
+            continue;
+          }
+          if (!screenIds.has(sid)) {
+            issues.push(
+              `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" (${slot}) targets a missing screen "${sid}".`
+            );
+          }
+        }
+      }
+      if (l.kind === "back_button" && l.fallbackScreenId && !screenIds.has(l.fallbackScreenId)) {
+        issues.push(
+          `Back button "${l.name || l.id}" on screen "${screen.name || screen.id}" uses a missing fallback screen "${l.fallbackScreenId}".`
+        );
+      }
+      if (l.kind === "button" && l.action.kind === "go_back_one_screen" && l.action.fallbackScreenId) {
+        if (!screenIds.has(l.action.fallbackScreenId)) {
+          issues.push(
+            `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" uses a missing fallback screen "${l.action.fallbackScreenId}".`
+          );
+        }
+      }
+      if (l.kind === "lottie" || l.kind === "video") {
+        const media = l;
+        if (media.autoPlay === false) {
+          const triggerId = media.triggerLayerId?.trim();
+          if (!triggerId) {
+            issues.push(
+              `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" needs a trigger button when auto-play is off.`
+            );
+          } else if (!buttonLayerIds.has(triggerId)) {
+            issues.push(
+              `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" references a missing trigger button "${triggerId}".`
+            );
+          } else {
+            const btn = findLayerById(screen, triggerId);
+            if (!btn || btn.kind !== "button") {
+              issues.push(
+                `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" trigger must be a button layer.`
+              );
+            } else if (btn.action.kind !== "play_media") {
+              issues.push(
+                `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" trigger button must use On Tap \u2192 Play media (or pick the trigger again from this screen).`
+              );
+            } else if (!btn.action.targetLayerIds.includes(media.id)) {
+              issues.push(
+                `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" is not listed on trigger button "${triggerId}".`
+              );
+            }
+          }
+        } else if (media.triggerLayerId) {
+          const btn = findLayerById(screen, media.triggerLayerId);
+          if (btn?.kind === "button" && btn.action.kind === "play_media" && !btn.action.targetLayerIds.includes(media.id)) {
+            issues.push(
+              `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" trigger button does not target this layer.`
+            );
+          }
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "play_media") {
+        for (const targetId of l.action.targetLayerIds) {
+          if (targetId === shellPlaybackId) {
+            if (!shellVideoFill) {
+              issues.push(
+                `Button "${l.name || l.id}" on screen "${screenLabel}" targets screen background video, but this screen has no video background.`
+              );
+            }
+            continue;
+          }
+          if (isScreenBackgroundPlaybackId(targetId)) {
+            issues.push(
+              `Button "${l.name || l.id}" on screen "${screenLabel}" play-media target "${targetId}" is not valid for this screen.`
+            );
+            continue;
+          }
+          if (!mediaLayerIds.has(targetId)) {
+            issues.push(
+              `Button "${l.name || l.id}" on screen "${screenLabel}" play-media target "${targetId}" must be a Lottie or video layer on this screen, or screen background video.`
+            );
+          }
+        }
+      }
+    });
+    if (oauthLoginLayerCount > 0 && inputCount > 0) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" cannot combine OAuth Login with input layers (${inputCount}). Split them onto separate screens.`
+      );
+    }
+    if (emailPasswordAuthLayerCount > 0 && inputCount > 0) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" cannot combine Email / password login with input layers (${inputCount}). Split them onto separate screens.`
+      );
+    }
+    if (oauthLoginLayerCount > 0 && emailPasswordAuthLayerCount > 0) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" cannot combine OAuth Login with Email / password login. Use one login block per screen.`
+      );
+    }
+    if (emailPasswordAuthLayerCount > 1) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" has ${emailPasswordAuthLayerCount} Email / password login layers; only one is allowed per screen.`
+      );
+    }
+    if (oauthLoginLayerCount > 1) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" has ${oauthLoginLayerCount} OAuth Login layers; only one is allowed per screen.`
+      );
+    }
+    if (inputCount > 1) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" has ${inputCount} input layers; only one is allowed.`
+      );
+    }
+    if (needsManualSubmit && !hasContinueButton) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" has a multiple_choice, text_input, or scale_input but no Button with action "continue". Add a Continue button so users can submit.`
+      );
+    }
+  }
+  for (const [key, owners] of fieldKeyOwners) {
+    if (owners.length > 1) {
+      issues.push(`Variable name "${key}" is used by multiple screens: ${owners.join(", ")}.`);
+    }
+  }
+  for (const screen of manifest.screens) {
+    walkScreen(screen, (l) => {
+      const screenLabel = screen.name || screen.id;
+      if (l.kind === "text" && !textLayerHasAuthoringColor(l)) {
+        issues.push(
+          `Screen "${screenLabel}": text layer "${l.id}" must set style.color for light and dark (CSS inheritance does not apply on native).`
+        );
+      }
+      if (l.kind === "icon" && !iconLayerHasAuthoringColor(l)) {
+        issues.push(
+          `Screen "${screenLabel}": icon layer "${l.id}" must set style.color for light and dark.`
+        );
+      }
+    });
+  }
+  return issues;
+};
+
+// src/assignment.ts
+var fnv1a = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash >>> 0;
+};
+var assignVariant = (experimentId, appUserId, variants) => {
+  if (variants.length === 0) return null;
+  const totalWeight = variants.reduce((sum, v) => sum + v.weight, 0);
+  if (totalWeight <= 0) return variants[0] ?? null;
+  const bucket = fnv1a(`${experimentId}:${appUserId}`) % totalWeight;
+  let acc = 0;
+  for (const v of variants) {
+    acc += v.weight;
+    if (bucket < acc) return v;
+  }
+  return variants[variants.length - 1] ?? null;
+};
+
+// src/brandGradientManifestIssues.ts
+var BP_KEYS = ["sm", "md", "lg", "xl", "2xl"];
+var themedStrings = (tc) => {
+  if (tc === void 0) return [];
+  if (typeof tc === "string") return [tc];
+  const out = [];
+  if (tc.light !== void 0) out.push(tc.light);
+  if (tc.dark !== void 0) out.push(tc.dark);
+  return out;
+};
+var pushIssue = (issues, stepId, layerId, field, message, code) => {
+  issues.push({
+    stepId,
+    path: ["screens", stepId, layerId, field],
+    message,
+    code
+  });
+};
+var checkThemed = (issues, stepId, layerId, field, tc, allowGradient, branding) => {
+  for (const s of themedStrings(tc)) {
+    if (isBrandGradientToken(s)) {
+      if (!allowGradient) {
+        pushIssue(
+          issues,
+          stepId,
+          layerId,
+          field,
+          `Brand gradient presets can only be used on background fills (not ${field}).`,
+          "brand_gradient.disallowed_field"
+        );
+        return;
+      }
+      if (branding !== void 0 && resolveBrandGradientToken(branding, s) === void 0) {
+        pushIssue(
+          issues,
+          stepId,
+          layerId,
+          field,
+          `Brand gradient preset not found: ${s}`,
+          "brand_gradient.unknown_preset"
+        );
+      }
+      continue;
+    }
+    if (isStoredLinearGradientCss(s)) {
+      if (!allowGradient) {
+        pushIssue(
+          issues,
+          stepId,
+          layerId,
+          field,
+          `CSS linear gradients can only be used on background fills in v1 (not ${field}).`,
+          "brand_gradient.linear_css_disallowed_field"
+        );
+        return;
+      }
+    }
+  }
+};
+var checkCommon = (issues, stepId, layerId, fieldPrefix, s, branding) => {
+  if (!s) return;
+  checkThemed(issues, stepId, layerId, `${fieldPrefix}background`, s.background, true, branding);
+  checkThemed(issues, stepId, layerId, `${fieldPrefix}border.color`, s.border?.color, false, branding);
+  checkThemed(issues, stepId, layerId, `${fieldPrefix}shadow.color`, s.shadow?.color, false, branding);
+};
+var checkTextLike = (issues, stepId, layerId, fieldPrefix, s, branding) => {
+  if (!s) return;
+  checkCommon(issues, stepId, layerId, fieldPrefix, s, branding);
+  checkThemed(issues, stepId, layerId, `${fieldPrefix}color`, s.color, false, branding);
+};
+var walkCommonBreakpoints = (issues, stepId, layerId, base, breakpoints, branding) => {
+  checkCommon(issues, stepId, layerId, "style.", base, branding);
+  if (!breakpoints) return;
+  for (const k of BP_KEYS) {
+    const patch = breakpoints[k];
+    if (patch) checkCommon(issues, stepId, layerId, `styleBreakpoints.${k}.`, patch, branding);
+  }
+};
+var walkTextBreakpoints = (issues, stepId, layerId, base, breakpoints, branding) => {
+  checkTextLike(issues, stepId, layerId, "style.", base, branding);
+  if (!breakpoints) return;
+  for (const k of BP_KEYS) {
+    const patch = breakpoints[k];
+    if (patch) checkTextLike(issues, stepId, layerId, `styleBreakpoints.${k}.`, patch, branding);
+  }
+};
+var checkCheckboxGlyph = (issues, stepId, layerId, suffix, g, branding) => {
+  if (!g) return;
+  const p = suffix ? `${suffix}.` : "";
+  checkThemed(issues, stepId, layerId, `${p}background`, g.background, true, branding);
+  checkThemed(issues, stepId, layerId, `${p}border.color`, g.border?.color, false, branding);
+  checkThemed(issues, stepId, layerId, `${p}shadow.color`, g.shadow?.color, false, branding);
+  checkThemed(issues, stepId, layerId, `${p}checkColor`, g.checkColor, false, branding);
+};
+var checkCarouselPageControl = (issues, stepId, layerId, pc, branding) => {
+  if (!pc) return;
+  const ind = pc.indicators;
+  if (ind) {
+    checkThemed(issues, stepId, layerId, "pageControl.indicators.defaultColor", ind.defaultColor, false, branding);
+    checkThemed(issues, stepId, layerId, "pageControl.indicators.activeColor", ind.activeColor, false, branding);
+    checkThemed(issues, stepId, layerId, "pageControl.indicators.border.color", ind.border?.color, false, branding);
+    checkThemed(
+      issues,
+      stepId,
+      layerId,
+      "pageControl.indicators.activeBorder.color",
+      ind.activeBorder?.color,
+      false,
+      branding
+    );
+  }
+  checkThemed(issues, stepId, layerId, "pageControl.border.color", pc.border?.color, false, branding);
+  checkThemed(issues, stepId, layerId, "pageControl.shadow.color", pc.shadow?.color, false, branding);
+};
+var scanLayer = (issues, screen, layer, branding) => {
+  const stepId = screen.id;
+  const id = layer.id;
+  switch (layer.kind) {
+    case "stack":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      checkCommon(issues, stepId, id, "selectedStyle.", layer.selectedStyle, branding);
+      return;
+    case "text":
+      walkTextBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      return;
+    case "image":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      return;
+    case "lottie":
+    case "video":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      return;
+    case "icon": {
+      const base = layer.style;
+      checkCommon(issues, stepId, id, "style.", base, branding);
+      checkThemed(issues, stepId, id, "style.color", base?.color, false, branding);
+      const bp = layer.styleBreakpoints;
+      if (bp) {
+        for (const k of BP_KEYS) {
+          const patch = bp[k];
+          if (!patch) continue;
+          checkCommon(issues, stepId, id, `styleBreakpoints.${k}.`, patch, branding);
+          checkThemed(issues, stepId, id, `styleBreakpoints.${k}.color`, patch.color, false, branding);
+        }
+      }
+      return;
+    }
+    case "button":
+    case "back_button": {
+      const base = layer.style;
+      checkTextLike(issues, stepId, id, "style.", base, branding);
+      const bp = layer.styleBreakpoints;
+      if (bp) {
+        for (const k of BP_KEYS) {
+          const patch = bp[k];
+          if (patch) checkTextLike(issues, stepId, id, `styleBreakpoints.${k}.`, patch, branding);
+        }
+      }
+      return;
+    }
+    case "hyperlink":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      return;
+    case "progress":
+      checkCommon(issues, stepId, id, "style.", layer.style, branding);
+      checkThemed(issues, stepId, id, "trackColor", layer.trackColor, false, branding);
+      checkThemed(issues, stepId, id, "fillColor", layer.fillColor, false, branding);
+      return;
+    case "loader":
+      checkCommon(issues, stepId, id, "style.", layer.style, branding);
+      checkThemed(issues, stepId, id, "trackColor", layer.trackColor, false, branding);
+      checkThemed(issues, stepId, id, "fillColor", layer.fillColor, false, branding);
+      return;
+    case "counter":
+      walkTextBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      return;
+    case "checkbox":
+      checkCheckboxGlyph(issues, stepId, id, "uncheckedStyle", layer.uncheckedStyle, branding);
+      checkCheckboxGlyph(issues, stepId, id, "checkedStyle", layer.checkedStyle, branding);
+      return;
+    case "carousel":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, void 0, branding);
+      checkCarouselPageControl(issues, stepId, id, layer.pageControl, branding);
+      return;
+    case "single_choice":
+    case "multiple_choice":
+      return;
+    case "text_input":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, void 0, branding);
+      return;
+    case "scale_input":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, void 0, branding);
+      checkThemed(issues, stepId, id, "labelStyle.color", layer.labelStyle?.color, false, branding);
+      checkThemed(issues, stepId, id, "valueStyle.color", layer.valueStyle?.color, false, branding);
+      checkThemed(issues, stepId, id, "trackColor", layer.trackColor, false, branding);
+      checkThemed(issues, stepId, id, "fillColor", layer.fillColor, false, branding);
+      checkThemed(issues, stepId, id, "thumbColor", layer.thumbColor, false, branding);
+      return;
+    case "oauth_login":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      return;
+    case "oauth_provider":
+      if (layer.variant === "preset") {
+        walkCommonBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      } else {
+        const base = layer.style;
+        checkTextLike(issues, stepId, id, "style.", base, branding);
+        const bp = layer.styleBreakpoints;
+        if (bp) {
+          for (const k of BP_KEYS) {
+            const patch = bp[k];
+            if (patch) checkTextLike(issues, stepId, id, `styleBreakpoints.${k}.`, patch, branding);
+          }
+        }
+      }
+      return;
+    case "email_password_auth":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      return;
+    case "email_password_field":
+      walkCommonBreakpoints(issues, stepId, id, layer.style, layer.styleBreakpoints, branding);
+      return;
+    case "email_password_submit": {
+      const base = layer.style;
+      checkTextLike(issues, stepId, id, "style.", base, branding);
+      const bp = layer.styleBreakpoints;
+      if (bp) {
+        for (const k of BP_KEYS) {
+          const patch = bp[k];
+          if (patch) checkTextLike(issues, stepId, id, `styleBreakpoints.${k}.`, patch, branding);
+        }
+      }
+      return;
+    }
+    default:
+      return;
+  }
+};
+var collectBrandGradientManifestIssues = (manifest, branding) => {
+  const issues = [];
+  for (const screen of manifest.screens) {
+    walkScreen(screen, (layer) => scanLayer(issues, screen, layer, branding));
+  }
+  return issues;
+};
+
+// src/colorAlpha.ts
+var multiplyColorAlpha = (color, factor) => {
+  if (color === void 0) return void 0;
+  if (factor === void 0 || factor >= 1 - 1e-6) return color;
+  if (factor <= 1e-6) return "rgba(0,0,0,0)";
+  const hex8 = /^#([0-9a-fA-F]{8})$/;
+  const hex6 = /^#([0-9a-fA-F]{6})$/;
+  const hex3 = /^#([0-9a-fA-F]{3})$/;
+  const rgba = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/;
+  let r;
+  let g;
+  let b;
+  let a = 1;
+  const m8 = color.match(hex8);
+  const m6 = color.match(hex6);
+  const m3 = color.match(hex3);
+  const mr = color.match(rgba);
+  if (m8) {
+    const h = m8[1];
+    r = parseInt(h.slice(0, 2), 16);
+    g = parseInt(h.slice(2, 4), 16);
+    b = parseInt(h.slice(4, 6), 16);
+    a = parseInt(h.slice(6, 8), 16) / 255;
+  } else if (m6) {
+    const h = m6[1];
+    r = parseInt(h.slice(0, 2), 16);
+    g = parseInt(h.slice(2, 4), 16);
+    b = parseInt(h.slice(4, 6), 16);
+  } else if (m3) {
+    const h = m3[1];
+    r = parseInt(h[0] + h[0], 16);
+    g = parseInt(h[1] + h[1], 16);
+    b = parseInt(h[2] + h[2], 16);
+  } else if (mr) {
+    r = Number(mr[1]);
+    g = Number(mr[2]);
+    b = Number(mr[3]);
+    if (mr[4] !== void 0) a = Number(mr[4]);
+  } else {
+    return color;
+  }
+  const outA = Math.min(1, Math.max(0, a * factor));
+  return `rgba(${r},${g},${b},${outA})`;
+};
+
+// src/animations.ts
+var EASING_BEZIERS = {
+  linear: [0, 0, 1, 1],
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1],
+  // Material-style "standard" / "emphasized" curves — useful defaults
+  // for product animations without inviting per-platform divergence.
+  standard: [0.2, 0, 0, 1],
+  emphasized: [0.3, 0, 0, 1]
+};
+var sampleBezier = (t, [x1, y1, x2, y2]) => {
+  if (x1 === y1 && x2 === y2) return t;
+  const ax = 3 * x1 - 3 * x2 + 1;
+  const bx = 3 * x2 - 6 * x1;
+  const cx = 3 * x1;
+  const ay = 3 * y1 - 3 * y2 + 1;
+  const by = 3 * y2 - 6 * y1;
+  const cy = 3 * y1;
+  const xAt = (s2) => ((ax * s2 + bx) * s2 + cx) * s2;
+  const yAt = (s2) => ((ay * s2 + by) * s2 + cy) * s2;
+  const dxAt = (s2) => (3 * ax * s2 + 2 * bx) * s2 + cx;
+  let s = t;
+  for (let i = 0; i < 8; i++) {
+    const x = xAt(s) - t;
+    const dx = dxAt(s);
+    if (Math.abs(x) < 1e-6) return yAt(s);
+    if (Math.abs(dx) < 1e-6) break;
+    s -= x / dx;
+  }
+  let lo = 0;
+  let hi = 1;
+  s = t;
+  for (let i = 0; i < 24; i++) {
+    const x = xAt(s);
+    if (Math.abs(x - t) < 1e-6) return yAt(s);
+    if (x < t) lo = s;
+    else hi = s;
+    s = (lo + hi) / 2;
+  }
+  return yAt(s);
+};
+var sampleTrack = (track, tNorm) => {
+  const ks = track.keyframes;
+  if (tNorm <= ks[0].t) return ks[0].value;
+  if (tNorm >= ks[ks.length - 1].t) return ks[ks.length - 1].value;
+  let prev = ks[0];
+  let next = ks[ks.length - 1];
+  for (let i = 0; i < ks.length - 1; i++) {
+    if (ks[i].t <= tNorm && ks[i + 1].t >= tNorm) {
+      prev = ks[i];
+      next = ks[i + 1];
+      break;
+    }
+  }
+  const span = next.t - prev.t;
+  const localT = span === 0 ? 0 : (tNorm - prev.t) / span;
+  const eased = sampleBezier(localT, EASING_BEZIERS[prev.easing ?? "linear"]);
+  return prev.value + (next.value - prev.value) * eased;
+};
+var effectiveDelayMs = (clip, screen) => {
+  const base = clip.delayMs ?? 0;
+  if (clip.trigger === "stagger" && clip.staggerIndex !== void 0) {
+    const step = screen.stagger?.stepMs ?? 60;
+    return base + clip.staggerIndex * step;
+  }
+  return base;
+};
+var sampleClipAt = (clip, screen, tMs) => {
+  const delay = effectiveDelayMs(clip, screen);
+  const local = clip.durationMs > 0 ? (tMs - delay) / clip.durationMs : 1;
+  const tNorm = Math.min(1, Math.max(0, local));
+  const out = {};
+  for (const track of clip.tracks) {
+    out[track.property] = sampleTrack(track, tNorm);
+  }
+  return out;
+};
+var mergeSampledClips = (base, overlay) => {
+  const out = { ...base };
+  for (const k of Object.keys(overlay)) {
+    const v = overlay[k];
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+};
+var sampleLayerAnimAt = (screen, layerId, tMs) => {
+  const list = clipsByLayerId(screen).get(layerId) ?? [];
+  if (list.length === 0) return {};
+  const sorted = [...list].sort((a, b) => {
+    const da = effectiveDelayMs(a, screen);
+    const db = effectiveDelayMs(b, screen);
+    if (da !== db) return da - db;
+    return a.id.localeCompare(b.id);
+  });
+  let state = {};
+  for (let i = 0; i < sorted.length; i++) {
+    const clip = sorted[i];
+    const d = effectiveDelayMs(clip, screen);
+    const end = d + clip.durationMs;
+    if (tMs < d) {
+      if (clip.trigger === "unmount") continue;
+      if (clip.trigger !== "mount" && clip.trigger !== "stagger") continue;
+      const earlierAnimating = sorted.slice(0, i).some((earlier) => {
+        const dE = effectiveDelayMs(earlier, screen);
+        const endE = dE + earlier.durationMs;
+        return tMs >= dE && tMs < endE;
+      });
+      if (earlierAnimating) continue;
+      const pending = sampleClipAt(clip, screen, d);
+      state = mergeSampledClips(state, pending);
+      continue;
+    }
+    const at = tMs <= end ? tMs : end;
+    state = mergeSampledClips(state, sampleClipAt(clip, screen, at));
+  }
+  return state;
+};
+var layerHasAnimationClips = (screen, layerId) => (screen?.animations ?? []).some((c) => c.targetLayerId === layerId);
+var screenAnimationsDurationMs = (screen) => {
+  if (!screen.animations || screen.animations.length === 0) return 0;
+  let max = 0;
+  for (const clip of screen.animations) {
+    const total = effectiveDelayMs(clip, screen) + clip.durationMs;
+    if (total > max) max = total;
+  }
+  return max;
+};
+var loaderLayerFillTimelineEndMs = (layer) => (layer.fillDelayMs ?? 0) + (layer.durationMs ?? 2e3);
+var screenLoaderTimelineExtentMs = (screen) => {
+  let max = 0;
+  walkScreen(screen, (l) => {
+    if (l.kind !== "loader") return;
+    const end = loaderLayerFillTimelineEndMs(l);
+    if (end > max) max = end;
+  });
+  return max;
+};
+var loaderFillProgressAtGlobalMs = (tMs, fillDelayMs, durationMs) => {
+  if (durationMs <= 0) return tMs >= fillDelayMs ? 1 : 0;
+  return Math.min(1, Math.max(0, (tMs - fillDelayMs) / durationMs));
+};
+var DEFAULT_LOTTIE_PLAY_DURATION_MS = 2e3;
+var lottieJsonDurationMs = (animationData) => {
+  const j = animationData;
+  const fr = typeof j.fr === "number" && j.fr > 0 ? j.fr : 60;
+  const ip = typeof j.ip === "number" ? j.ip : 0;
+  const op = typeof j.op === "number" ? j.op : 60;
+  const frames = Math.max(0, op - ip);
+  return Math.max(1, Math.round(frames / fr * 1e3));
+};
+var MIN_ANIMATION_TIMELINE_AUTHORING_SPAN_MS = 1e4;
+var animationTimelineAuthoringEndMs = (screen) => screenAnimationsDurationMs(screen);
+var migrateStaggerClipsToMount = (screen) => {
+  const staggerClipPresent = screen.animations?.some((c) => c.trigger === "stagger");
+  const staggerFieldPresent = screen.stagger !== void 0;
+  if (!staggerClipPresent && !staggerFieldPresent) return screen;
+  const step = screen.stagger?.stepMs ?? 60;
+  const { stagger: _st, ...rest } = screen;
+  if (!staggerClipPresent) {
+    return { ...rest };
+  }
+  const nextAnimations = (screen.animations ?? []).map((c) => {
+    if (c.trigger !== "stagger") return c;
+    const base = c.delayMs ?? 0;
+    const extra = (c.staggerIndex ?? 0) * step;
+    return {
+      ...c,
+      trigger: "mount",
+      delayMs: base + extra,
+      staggerIndex: void 0
+    };
+  });
+  return { ...rest, animations: nextAnimations };
+};
+var hasStaggerClip = (screen, layerId) => (screen.animations ?? []).some((c) => c.targetLayerId === layerId && c.trigger === "stagger");
+var applyStaggerIndicesFromTreeOrder = (screen) => {
+  if (!screen.animations?.some((c) => c.trigger === "stagger")) return screen;
+  const staggerIndexByLayerId = /* @__PURE__ */ new Map();
+  const visitStackChildren = (stack) => {
+    let idx = 0;
+    for (const ch of stack.children) {
+      if (hasStaggerClip(screen, ch.id)) {
+        staggerIndexByLayerId.set(ch.id, idx);
+        idx += 1;
+      }
+      visit(ch);
+    }
+  };
+  const visit = (l) => {
+    if (l.kind === "stack") {
+      visitStackChildren(l);
+      return;
+    }
+    if (l.kind === "carousel") {
+      for (const s of l.slides) visit(s);
+      return;
+    }
+    if (l.kind === "button" || l.kind === "back_button") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "hyperlink") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "text_input" || l.kind === "scale_input") {
+      l.children?.forEach(visit);
+      return;
+    }
+    if (l.kind === "oauth_login") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "oauth_provider" && l.variant === "custom") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "email_password_auth") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "email_password_field") {
+      l.children?.forEach(visit);
+      return;
+    }
+    if (l.kind === "email_password_submit") {
+      l.children.forEach(visit);
+      return;
+    }
+  };
+  if (screen.regions.header) visit(screen.regions.header);
+  visit(screen.regions.body);
+  if (screen.regions.footer) visit(screen.regions.footer);
+  const nextAnimations = screen.animations.map((c) => {
+    if (c.trigger !== "stagger") return c;
+    const nextIdx = staggerIndexByLayerId.get(c.targetLayerId);
+    if (nextIdx === void 0) return c;
+    if (c.staggerIndex === nextIdx) return c;
+    return { ...c, staggerIndex: nextIdx };
+  });
+  if (nextAnimations.every((c, i) => c === screen.animations[i])) return screen;
+  return { ...screen, animations: nextAnimations };
+};
+var clipsByLayerId = (screen) => {
+  const map = /* @__PURE__ */ new Map();
+  if (!screen.animations) return map;
+  for (const clip of screen.animations) {
+    const list = map.get(clip.targetLayerId) ?? [];
+    list.push(clip);
+    map.set(clip.targetLayerId, list);
+  }
+  return map;
+};
+var applyReducedMotion = (clip, policy) => {
+  if (policy === "play") return clip;
+  return {
+    ...clip,
+    durationMs: 0,
+    delayMs: 0,
+    tracks: clip.tracks.map((t) => ({
+      ...t,
+      keyframes: t.keyframes.map((k) => ({ ...k, t: k.t === 0 ? 0 : 1 }))
+    }))
+  };
+};
+var listAnimatablePropsForLayerKind = (_kind) => ["opacity", "translateX", "translateY", "scale"];
+var isPropertyAllowedOnLayer = (layer, property) => listAnimatablePropsForLayerKind(layer.kind).includes(property);
+
+// src/restingMotion/restingMotionEntries.ts
+var RESTING_MOTION_DEFAULT_DURATION_MS = {
+  translate: 2400,
+  bounce: 2e3,
+  scale: 2200,
+  pulse: 1800,
+  rotate: 3200
+};
+var RESTING_MOTION_SEGMENT_DURATION_MS_MIN = 200;
+var RESTING_MOTION_SEGMENT_DURATION_MS_MAX = 2e4;
+var clampRestingMotionSegmentDurationMs = (ms) => Math.min(
+  RESTING_MOTION_SEGMENT_DURATION_MS_MAX,
+  Math.max(RESTING_MOTION_SEGMENT_DURATION_MS_MIN, Math.round(ms))
+);
+var LEGACY_RESTING_MOTION_ID = "__legacy";
+var layerRestingMotionEntries = (layer) => {
+  const list = layer.restingMotions;
+  if (list && list.length > 0) return list;
+  if (layer.restingMotion) {
+    return [{ ...layer.restingMotion, id: LEGACY_RESTING_MOTION_ID }];
+  }
+  return [];
+};
+var layerWithRestingMotionEntries = (layer, entries) => {
+  if (entries.length === 0) {
+    const next = { ...layer };
+    delete next.restingMotion;
+    delete next.restingMotions;
+    return next;
+  }
+  return {
+    ...layer,
+    restingMotions: entries.map((e) => ({ ...e })),
+    restingMotion: void 0
+  };
+};
+var restingMotionSyncScaleNonLoopClipAndPattern = (r, ms) => {
+  const v = clampRestingMotionSegmentDurationMs(ms);
+  return { ...r, durationMs: v, scalePatternDurationMs: v };
+};
+var restingMotionNormalizeScaleNonLoopClip = (r) => {
+  if (r.preset !== "scale" || r.loop === true) return r;
+  const ms = clampRestingMotionSegmentDurationMs(
+    r.durationMs ?? r.scalePatternDurationMs ?? RESTING_MOTION_DEFAULT_DURATION_MS.scale
+  );
+  return { ...r, durationMs: ms, scalePatternDurationMs: ms };
+};
+var restingMotionEffectiveDurationMs = (r) => r.durationMs ?? RESTING_MOTION_DEFAULT_DURATION_MS[r.preset];
+var restingMotionCycleDurationMs = (r) => r.cycleDurationMs ?? RESTING_MOTION_DEFAULT_DURATION_MS[r.preset];
+var restingMotionMotionSpeedSliderMs = (r) => r.loop === true ? restingMotionCycleDurationMs(r) : restingMotionEffectiveDurationMs(r);
+var restingMotionIntensity = (r) => {
+  "worklet";
+  return r.intensity ?? 1;
+};
+var restingMotionDelayAfterMountEndMs = (r) => r.delayMsAfterMountEnd ?? 0;
+
+// src/restingMotion/restingMotionTimeline.ts
+var layerMountClipsEndMs = (screen, layerId) => {
+  const clips = screen.animations?.filter(
+    (c) => c.targetLayerId === layerId && (c.trigger === "mount" || c.trigger === "stagger")
+  ) ?? [];
+  let maxEnd = 0;
+  for (const c of clips) {
+    maxEnd = Math.max(maxEnd, effectiveDelayMs(c, screen) + c.durationMs);
+  }
+  return maxEnd;
+};
+var layerRestingMotionStartMs = (screen, layerId, cfg) => cfg.timelineStartMs !== void 0 ? cfg.timelineStartMs : layerMountClipsEndMs(screen, layerId) + restingMotionDelayAfterMountEndMs(cfg);
+var screenRestingTimelineExtentMs = (screen) => {
+  let max = 0;
+  walkScreen(screen, (l) => {
+    for (const r of layerRestingMotionEntries(l)) {
+      const start = layerRestingMotionStartMs(screen, l.id, r);
+      max = Math.max(max, start + restingMotionEffectiveDurationMs(r));
+    }
+  });
+  return max;
+};
+var motionTimelineScrubClampMs = (screen) => Math.max(
+  screenAnimationsDurationMs(screen),
+  screenRestingTimelineExtentMs(screen),
+  screenLoaderTimelineExtentMs(screen)
+);
+var DEFAULT_WORKBENCH_TIMELINE_MS = 1e4;
+var workbenchTimelineTotalMs = (screen) => {
+  const extent = motionTimelineScrubClampMs(screen);
+  return extent > 0 ? extent : DEFAULT_WORKBENCH_TIMELINE_MS;
+};
+var layerRestingMotionEndMs = (screen, layerId, cfg) => layerRestingMotionStartMs(screen, layerId, cfg) + restingMotionEffectiveDurationMs(cfg);
+var restingMotionAllowedAtTime = (screen, layerId, tMs, cfg) => {
+  const start = layerRestingMotionStartMs(screen, layerId, cfg);
+  const end = start + restingMotionEffectiveDurationMs(cfg);
+  return tMs >= start && tMs < end;
+};
+var restingMotionLocalElapsedMs = (screen, layerId, cfg, tMs) => {
+  if (!restingMotionAllowedAtTime(screen, layerId, tMs, cfg)) return null;
+  return tMs - layerRestingMotionStartMs(screen, layerId, cfg);
+};
+
+// src/restingMotion/restingMotionEffects.ts
+var RESTING_MOTION_BOUNCE_BASE_PX = 14;
+var restingMotionBounceAmplitudePx = (r) => r.bounceAmplitudePx ?? RESTING_MOTION_BOUNCE_BASE_PX * restingMotionIntensity(r);
+var bouncePhaseToTranslateY = (ph, amplitudePx) => -amplitudePx * Math.sin(Math.PI * ph);
+var RESTING_MOTION_DEFAULT_SCALE_UP_PERCENT = 8;
+var RESTING_MOTION_DEFAULT_SCALE_DOWN_PERCENT = 0;
+var RESTING_MOTION_DEFAULT_SCALE_PERCENT = RESTING_MOTION_DEFAULT_SCALE_UP_PERCENT;
+var RESTING_MOTION_DEFAULT_TRANSLATE_PEAK_Y_PERCENT = 6;
+var RESTING_MOTION_DEFAULT_TRANSLATE_PEAK_Y_PX = 6;
+var RESTING_MOTION_DEFAULT_TRANSLATE_RANGE_PX = RESTING_MOTION_DEFAULT_TRANSLATE_PEAK_Y_PX;
+var RESTING_MOTION_DEFAULT_ROTATE_DEG = 5;
+var RESTING_MOTION_PULSE_DIP_BASE = 0.38;
+var restingMotionScalePatternDurationMs = (r) => {
+  const def = RESTING_MOTION_DEFAULT_DURATION_MS.scale;
+  if (r.preset !== "scale") return def;
+  if (r.loop !== true) {
+    return r.durationMs ?? r.scalePatternDurationMs ?? r.cycleDurationMs ?? def;
+  }
+  return r.scalePatternDurationMs ?? r.cycleDurationMs ?? def;
+};
+var restingMotionPhase01 = (cfg, localMs) => {
+  const segment = restingMotionEffectiveDurationMs(cfg);
+  const cycle = restingMotionCycleDurationMs(cfg);
+  if (segment <= 0) return 0;
+  if (cfg.preset === "scale") {
+    const pattern = restingMotionScalePatternDurationMs(cfg);
+    if (pattern <= 0) return 0;
+    if (cfg.loop === true) {
+      const u = (localMs % pattern + pattern) % pattern;
+      return u / pattern;
+    }
+    return Math.min(1, Math.max(0, localMs / pattern));
+  }
+  if (cfg.loop === true && cycle > 0) {
+    const u = (localMs % cycle + cycle) % cycle;
+    return u / cycle;
+  }
+  return Math.min(1, Math.max(0, localMs / segment));
+};
+var restingMotionScaleDirection = (r) => {
+  "worklet";
+  if (r.scaleDirection === "down") return "down";
+  if (r.scaleDirection === "up") return "up";
+  const down = r.scaleDownPercent ?? 0;
+  const up = r.scaleUpPercent ?? 0;
+  if (down > 0 && up === 0) return "down";
+  return "up";
+};
+var restingMotionScalePercentResolved = (r) => {
+  "worklet";
+  if (r.scalePercent !== void 0) return r.scalePercent;
+  if (restingMotionScaleDirection(r) === "down") {
+    return r.scaleDownPercent !== void 0 ? r.scaleDownPercent : r.scaleUpPercent ?? RESTING_MOTION_DEFAULT_SCALE_DOWN_PERCENT;
+  }
+  return r.scaleUpPercent ?? RESTING_MOTION_DEFAULT_SCALE_UP_PERCENT;
+};
+var restingMotionScaleAmountFraction = (r) => {
+  "worklet";
+  return restingMotionScalePercentResolved(r) / 100 * restingMotionIntensity(r);
+};
+var restingMotionScaleSpringBack = (r) => {
+  "worklet";
+  return r.scaleSpringBack !== false;
+};
+var restingMotionScaleUpFraction = (r) => restingMotionScaleDirection(r) === "up" ? restingMotionScaleAmountFraction(r) : 0;
+var restingMotionScaleDownFraction = (r) => restingMotionScaleDirection(r) === "down" ? restingMotionScaleAmountFraction(r) : 0;
+var restingMotionScalePeakMultiplier = (cfg) => {
+  "worklet";
+  const amt = restingMotionScaleAmountFraction(cfg);
+  const dir = restingMotionScaleDirection(cfg);
+  return dir === "up" ? 1 + amt : 1 - amt;
+};
+var restingMotionScaleAtPhase = (cfg, ph) => {
+  "worklet";
+  const peak = restingMotionScalePeakMultiplier(cfg);
+  const p = Math.min(1, Math.max(0, ph));
+  if (!restingMotionScaleSpringBack(cfg)) {
+    return 1 + (peak - 1) * p;
+  }
+  if (p < 0.5) {
+    const t2 = p * 2;
+    return 1 + (peak - 1) * t2;
+  }
+  const t = (p - 0.5) * 2;
+  return peak + (1 - peak) * t;
+};
+var legacyTranslatePxToDisplayPercent = (px) => Math.max(-200, Math.min(200, Math.round(px / 80 * 200)));
+var restingMotionTranslateBasePeak = (r) => {
+  "worklet";
+  const hasPercent = r.translatePeakXPercent !== void 0 || r.translatePeakYPercent !== void 0;
+  const hasPx = r.translatePeakXPx !== void 0 || r.translatePeakYPx !== void 0;
+  const hasLegacyRange = r.translateRangePx !== void 0;
+  if (hasPercent) {
+    return {
+      unit: "percent",
+      x: r.translatePeakXPercent ?? 0,
+      y: r.translatePeakYPercent ?? 0
+    };
+  }
+  if (hasPx || hasLegacyRange) {
+    if (hasPx) {
+      return {
+        unit: "px",
+        x: r.translatePeakXPx ?? 0,
+        y: r.translatePeakYPx ?? 0
+      };
+    }
+    return { unit: "px", x: 0, y: r.translateRangePx ?? 0 };
+  }
+  return { unit: "percent", x: 0, y: RESTING_MOTION_DEFAULT_TRANSLATE_PEAK_Y_PERCENT };
+};
+var restingMotionTranslateAuthoringPeakPercent = (r) => {
+  const base = restingMotionTranslateBasePeak(r);
+  if (base.unit === "percent") return { x: base.x, y: base.y };
+  return {
+    x: legacyTranslatePxToDisplayPercent(base.x),
+    y: legacyTranslatePxToDisplayPercent(base.y)
+  };
+};
+var restingMotionTranslateAuthoringPeakPx = (r) => {
+  const base = restingMotionTranslateBasePeak(r);
+  if (base.unit === "px") return { x: base.x, y: base.y };
+  return { x: 0, y: 0 };
+};
+var restingMotionTranslatePeakResolved = (r) => {
+  "worklet";
+  const base = restingMotionTranslateBasePeak(r);
+  const i = restingMotionIntensity(r);
+  if (base.unit === "percent") {
+    let x2 = base.x * i;
+    let y2 = base.y * i;
+    x2 = Math.max(-200, Math.min(200, x2));
+    y2 = Math.max(-200, Math.min(200, y2));
+    return { unit: "percent", x: x2, y: y2 };
+  }
+  let x = base.x * i;
+  let y = base.y * i;
+  x = Math.max(-200, Math.min(200, x));
+  y = Math.max(-200, Math.min(200, y));
+  return { unit: "px", x, y };
+};
+var restingMotionTranslatePeakPx = (r) => {
+  const r2 = restingMotionTranslatePeakResolved(r);
+  return { x: r2.x, y: r2.y };
+};
+var restingMotionTranslateSpringBack = (r) => {
+  "worklet";
+  return r.translateSpringBack !== false;
+};
+var restingMotionRotateMaxDeg = (r) => {
+  "worklet";
+  const raw = (r.rotateMaxDeg ?? RESTING_MOTION_DEFAULT_ROTATE_DEG) * restingMotionIntensity(r);
+  return Math.max(0, Math.min(360, raw));
+};
+var restingMotionRotateSpringBack = (r) => {
+  "worklet";
+  return r.rotateSpringBack !== false;
+};
+var restingMotionRotateDirection = (r) => {
+  "worklet";
+  return r.rotateDirection === "counterclockwise" ? "counterclockwise" : "clockwise";
+};
+var restingMotionRotateSign = (r) => {
+  "worklet";
+  return restingMotionRotateDirection(r) === "counterclockwise" ? -1 : 1;
+};
+var restingMotionPulseMinOpacity = (r) => {
+  "worklet";
+  if (r.pulseMinOpacity !== void 0) {
+    return Math.max(0, Math.min(1, r.pulseMinOpacity));
+  }
+  return Math.max(
+    0,
+    Math.min(1, 1 - RESTING_MOTION_PULSE_DIP_BASE * restingMotionIntensity(r))
+  );
+};
+var restingMotionSampleStyle = (cfg, ph) => {
+  switch (cfg.preset) {
+    case "translate": {
+      const peak = restingMotionTranslatePeakResolved(cfg);
+      const env = restingMotionTranslateSpringBack(cfg) ? Math.sin(ph * Math.PI) : ph;
+      let tx = env * peak.x;
+      let ty = env * peak.y;
+      if (Math.abs(tx) < 1e-6) tx = 0;
+      if (Math.abs(ty) < 1e-6) ty = 0;
+      if (peak.unit === "percent") {
+        return { transform: `translate(${tx}%, ${ty}%)`, willChange: "transform" };
+      }
+      return { transform: `translate(${tx}px, ${ty}px)`, willChange: "transform" };
+    }
+    case "bounce": {
+      const y = bouncePhaseToTranslateY(ph, restingMotionBounceAmplitudePx(cfg));
+      return { transform: `translateY(${y}px)`, willChange: "transform" };
+    }
+    case "scale": {
+      const sc = restingMotionScaleAtPhase(cfg, ph);
+      return { transform: `scale(${sc})`, willChange: "transform" };
+    }
+    case "pulse": {
+      const omin = restingMotionPulseMinOpacity(cfg);
+      const dip = 1 - omin;
+      const op = ph <= 0.5 ? 1 - ph * 2 * dip : 1 - (1 - ph) * 2 * dip;
+      return { opacity: op, willChange: "opacity" };
+    }
+    case "rotate": {
+      const peakDeg = restingMotionRotateMaxDeg(cfg);
+      let deg = restingMotionRotateSign(cfg) * (restingMotionRotateSpringBack(cfg) ? Math.sin(ph * Math.PI) * peakDeg : ph * peakDeg);
+      if (Math.abs(deg) < 1e-6) deg = 0;
+      return { transform: `rotate(${deg}deg)`, willChange: "transform" };
+    }
+    default:
+      return {};
+  }
+};
+var restingMotionStyleAtTime = (screen, layerId, cfg, tMs) => {
+  const local = restingMotionLocalElapsedMs(screen, layerId, cfg, tMs);
+  if (local === null) return null;
+  const ph = restingMotionPhase01(cfg, local);
+  return restingMotionSampleStyle(cfg, ph);
+};
+var RESTING_MOTION_KEYFRAMES_CSS = `
+@keyframes ob-rm-translate {
+  0%, 100% { transform: translate(0, 0); }
+  50% {
+    transform: translate(var(--ob-rm-translate-peak-x, 0%), var(--ob-rm-translate-peak-y, 6%));
+  }
+}
+@keyframes ob-rm-translate-ramp {
+  0% { transform: translate(0, 0); }
+  100% {
+    transform: translate(var(--ob-rm-translate-peak-x, 0%), var(--ob-rm-translate-peak-y, 6%));
+  }
+}
+@keyframes ob-rm-bounce {
+  0%, 100% { transform: translateY(0); }
+  50% { transform: translateY(calc(-1 * var(--ob-rm-bounce-px, 14px))); }
+}
+@keyframes ob-rm-scale {
+  0%, 100% { transform: scale(1); }
+  50% { transform: scale(var(--ob-rm-scale-peak, 1.08)); }
+}
+@keyframes ob-rm-scale-ramp {
+  0% { transform: scale(1); }
+  100% { transform: scale(var(--ob-rm-scale-peak, 1.08)); }
+}
+@keyframes ob-rm-pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: var(--ob-rm-pulse-min, 0.62); }
+}
+@keyframes ob-rm-rotate {
+  0%, 100% { transform: rotate(0deg); }
+  50% { transform: rotate(var(--ob-rm-rotate-peak, 5deg)); }
+}
+@keyframes ob-rm-rotate-ramp {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(var(--ob-rm-rotate-peak, 5deg)); }
+}
+`.trim();
+var restingMotionWebAnimationName = (config) => {
+  if (config.preset === "rotate" && !restingMotionRotateSpringBack(config)) {
+    return "ob-rm-rotate-ramp";
+  }
+  if (config.preset === "translate" && !restingMotionTranslateSpringBack(config)) {
+    return "ob-rm-translate-ramp";
+  }
+  if (config.preset === "scale" && !restingMotionScaleSpringBack(config)) {
+    return "ob-rm-scale-ramp";
+  }
+  return `ob-rm-${config.preset}`;
+};
+var restingMotionWebStyle = (config) => {
+  const duration = restingMotionEffectiveDurationMs(config);
+  const intensity = restingMotionIntensity(config);
+  const name = restingMotionWebAnimationName(config);
+  const oneCycleMs = config.preset === "scale" ? restingMotionScalePatternDurationMs(config) : config.loop === true ? restingMotionCycleDurationMs(config) : duration;
+  const iter = config.loop === true ? "infinite" : "1 forwards";
+  const base = {
+    ["--ob-rm-i"]: String(intensity),
+    animation: `${name} ${oneCycleMs}ms ease-in-out ${iter}`,
+    willChange: config.preset === "pulse" ? "opacity" : "transform"
+  };
+  if (config.preset === "bounce") {
+    return {
+      ...base,
+      ["--ob-rm-bounce-px"]: `${restingMotionBounceAmplitudePx(config)}px`
+    };
+  }
+  if (config.preset === "scale") {
+    return {
+      ...base,
+      ["--ob-rm-scale-peak"]: String(restingMotionScalePeakMultiplier(config))
+    };
+  }
+  if (config.preset === "translate") {
+    const peak = restingMotionTranslatePeakResolved(config);
+    const sx = peak.unit === "percent" ? `${peak.x}%` : `${peak.x}px`;
+    const sy = peak.unit === "percent" ? `${peak.y}%` : `${peak.y}px`;
+    return {
+      ...base,
+      ["--ob-rm-translate-peak-x"]: sx,
+      ["--ob-rm-translate-peak-y"]: sy
+    };
+  }
+  if (config.preset === "rotate") {
+    const signedPeak = restingMotionRotateSign(config) * restingMotionRotateMaxDeg(config);
+    return {
+      ...base,
+      ["--ob-rm-rotate-peak"]: `${signedPeak}deg`
+    };
+  }
+  if (config.preset === "pulse") {
+    return {
+      ...base,
+      ["--ob-rm-pulse-min"]: String(restingMotionPulseMinOpacity(config))
+    };
+  }
+  return base;
+};
+
+// src/dropShadow.ts
+var clamp01 = (n) => Math.max(0, Math.min(1, n));
+var hexToRgba = (hex, alpha) => {
+  const raw = hex.trim().replace(/^#/, "");
+  if (!/^([0-9a-f]{3}|[0-9a-f]{6})$/i.test(raw)) return `rgba(0,0,0,${clamp01(alpha)})`;
+  const full = raw.length === 3 ? raw.split("").map((c) => c + c).join("") : raw;
+  const r = parseInt(full.slice(0, 2), 16);
+  const g = parseInt(full.slice(2, 4), 16);
+  const b = parseInt(full.slice(4, 6), 16);
+  return `rgba(${r},${g},${b},${clamp01(alpha)})`;
+};
+var colorWithOpacity = (resolved, opacity) => {
+  const o = clamp01(opacity);
+  if (!resolved) return `rgba(0,0,0,${o})`;
+  const t = resolved.trim();
+  if (t.startsWith("#")) return hexToRgba(t, o);
+  const m = t.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i);
+  if (m) return `rgba(${m[1]},${m[2]},${m[3]},${o})`;
+  return t;
+};
+var shadowHasAnyField = (sh) => sh !== void 0 && Object.values(sh).some((v) => v !== void 0);
+var dropShadowToBoxShadow = (sh, theme, palette) => {
+  if (!shadowHasAnyField(sh)) return void 0;
+  const ox = sh.offsetX ?? 0;
+  const oy = sh.offsetY ?? 2;
+  const blur = sh.blur ?? 8;
+  const spread = sh.spread ?? 0;
+  const opacity = sh.opacity ?? 0.25;
+  const base = resolveThemedColor(theme, palette, sh.color);
+  const color = colorWithOpacity(base, opacity);
+  return `${ox}px ${oy}px ${blur}px ${spread}px ${color}`;
+};
+var dropShadowToWebStyle = (sh, theme, palette) => {
+  const boxShadow = dropShadowToBoxShadow(sh, theme, palette);
+  return boxShadow ? { boxShadow } : {};
+};
+var dropShadowToNativeStyle = (sh, theme, palette) => {
+  if (!shadowHasAnyField(sh)) return {};
+  const ox = sh.offsetX ?? 0;
+  const oy = sh.offsetY ?? 2;
+  const blur = sh.blur ?? 8;
+  const opacity = sh.opacity ?? 0.25;
+  const base = resolveThemedColor(theme, palette, sh.color);
+  const color = colorWithOpacity(base, opacity);
+  return {
+    shadowOffset: { width: ox, height: oy },
+    shadowOpacity: 1,
+    shadowRadius: blur,
+    shadowColor: color,
+    elevation: Math.min(24, Math.max(0, Math.round(blur / 2 + Math.abs(oy))))
+  };
+};
+
+// src/scaleValidation.ts
+var scaleStep = (layer) => layer.step ?? 1;
+var snapScaleValue = (layer, raw) => {
+  const step = scaleStep(layer);
+  const { min, max } = layer;
+  const n = Math.round((raw - min) / step);
+  const v = min + n * step;
+  if (v < min) return min;
+  if (v > max) return max;
+  return v;
+};
+var scaleValueIsOnStep = (layer, value) => {
+  const step = scaleStep(layer);
+  const n = (value - layer.min) / step;
+  return Number.isFinite(n) && Math.abs(n - Math.round(n)) < 1e-6;
+};
+var scaleValueInRange = (layer, value) => value >= layer.min && value <= layer.max;
+
+// src/textInputValidation.ts
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+var PHONE_RE = /^[\d\s+().-]{3,32}$/u;
+var isProbablyUrl = (s) => {
+  try {
+    const withProto = /^[a-z]+:/iu.test(s) ? s : `https://${s}`;
+    const u = new URL(withProto);
+    return u.hostname.length > 0;
+  } catch {
+    return false;
+  }
+};
+var effectiveInputType = (layer) => layer.inputType ?? "plain";
+var effectiveRequired = (layer) => layer.required !== false;
+var validateTextInputValue = (layer, raw) => {
+  const trimmed = raw.trim();
+  const required = effectiveRequired(layer);
+  if (trimmed.length === 0) {
+    if (!required) return { ok: true };
+    return { ok: false, reason: "Text is empty" };
+  }
+  if (layer.minLength !== void 0 && trimmed.length < layer.minLength) {
+    return { ok: false, reason: `Enter at least ${layer.minLength} characters` };
+  }
+  if (layer.maxLength !== void 0 && trimmed.length > layer.maxLength) {
+    return { ok: false, reason: `Exceeds max length of ${layer.maxLength}` };
+  }
+  const mode = effectiveInputType(layer);
+  switch (mode) {
+    case "plain":
+    case "multiline":
+      return { ok: true };
+    case "email":
+      return EMAIL_RE.test(trimmed) ? { ok: true } : { ok: false, reason: "Enter a valid email address" };
+    case "phone":
+      return PHONE_RE.test(trimmed) ? { ok: true } : { ok: false, reason: "Enter a valid phone number (digits and common symbols only)" };
+    case "url":
+      return isProbablyUrl(trimmed) ? { ok: true } : { ok: false, reason: "Enter a valid URL" };
+    default:
+      return { ok: true };
+  }
+};
+
+// src/emailPasswordAuthValidation.ts
+var EMAIL_RE2 = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var validateEmailPasswordAuthFields = (args) => {
+  const email = args.email.trim();
+  if (!email) return { ok: false, message: "Email is required" };
+  if (!EMAIL_RE2.test(email)) return { ok: false, message: "Enter a valid email" };
+  if (!args.password) return { ok: false, message: "Password is required" };
+  if (args.password.length < args.minPasswordLength) {
+    return {
+      ok: false,
+      message: `Password must be at least ${args.minPasswordLength} characters`
+    };
+  }
+  if (args.mode === "sign_up") {
+    if (!args.confirmPassword) return { ok: false, message: "Confirm your password" };
+    if (args.password !== args.confirmPassword) {
+      return { ok: false, message: "Passwords do not match" };
+    }
+  }
+  return { ok: true };
+};
+var extractLiquidTemplateBodies = (s) => {
+  const out = [];
+  let i = 0;
+  while (i < s.length) {
+    const open = s.indexOf("{{", i);
+    if (open === -1) break;
+    const close = s.indexOf("}}", open + 2);
+    if (close === -1) break;
+    out.push(s.slice(open + 2, close));
+    i = close + 2;
+  }
+  return out;
+};
+var FIELD_KEY_SOURCE = FIELD_KEY_RE$1.source.replace(/^\^|\$$/g, "");
+var parseDefaultFilter = (inner) => {
+  const m = inner.match(/\s*\|\s*default\s*:/i);
+  if (!m || m.index === void 0) return { exprPart: inner.trim() };
+  const exprPart = inner.slice(0, m.index).trim();
+  let tail = inner.slice(m.index + m[0].length).trim();
+  if (tail.startsWith('"')) {
+    const end = tail.indexOf('"', 1);
+    if (end > 0) tail = tail.slice(1, end);
+    else tail = tail.slice(1);
+  }
+  return { exprPart, defaultValue: tail };
+};
+var parseExpression = (exprRaw) => {
+  const expr = exprRaw.trim();
+  const customM = expr.match(new RegExp(`^custom\\.(${FIELD_KEY_SOURCE})$`));
+  if (customM) return { kind: "custom", key: customM[1] };
+  const idM = expr.match(new RegExp(`^(${FIELD_KEY_SOURCE})\\.id$`));
+  if (idM) return { kind: "field", fieldKey: idM[1], mode: "id" };
+  const plainM = expr.match(new RegExp(`^(${FIELD_KEY_SOURCE})$`));
+  if (plainM) return { kind: "field", fieldKey: plainM[1], mode: "label" };
+  return { kind: "invalid" };
+};
+var analyzeLiquidTemplateInner = (inner) => {
+  const { exprPart, defaultValue } = parseDefaultFilter(inner);
+  const p = parseExpression(exprPart);
+  if (p.kind === "invalid") return { expr: { kind: "invalid" }, defaultValue };
+  if (p.kind === "custom") return { expr: { kind: "custom", key: p.key }, defaultValue };
+  return { expr: { kind: "field", fieldKey: p.fieldKey, mode: p.mode }, defaultValue };
+};
+var findInputOwner = (manifest, fieldKey) => {
+  for (const screen of manifest.screens) {
+    const input = findInputLayer(screen);
+    if (input && input.fieldKey === fieldKey) return { screen, input };
+  }
+  return null;
+};
+var choiceLabelFor = (manifest, fieldKey, choiceId, locale) => {
+  const owner = findInputOwner(manifest, fieldKey);
+  if (!owner) return "";
+  const { input } = owner;
+  if (input.kind !== "single_choice" && input.kind !== "multiple_choice") return "";
+  return choiceOptionLabel(input, choiceId, locale);
+};
+var responseToDisplayString = (manifest, fieldKey, response, mode, locale) => {
+  if (!response) return "";
+  switch (response.kind) {
+    case "text":
+      return mode === "id" ? "" : response.value;
+    case "scale":
+      return mode === "id" ? "" : String(response.value);
+    case "choice":
+      if (mode === "id") return response.choiceId;
+      return choiceLabelFor(manifest, fieldKey, response.choiceId, locale);
+    case "multiChoice":
+      if (mode === "id") return response.choiceIds.join(", ");
+      return response.choiceIds.map((id) => choiceLabelFor(manifest, fieldKey, id, locale)).filter(Boolean).join(", ");
+    case "checkbox":
+      return mode === "id" ? "" : response.value ? "true" : "false";
+    case "bypass_input":
+      return "";
+    default:
+      return "";
+  }
+};
+var evalParsed = (parsed, ctx) => {
+  if (parsed.kind === "invalid") return "";
+  if (parsed.kind === "custom") {
+    const v = ctx.customProperties?.[parsed.key];
+    return v === void 0 || v === "" ? "" : String(v);
+  }
+  const owner = findInputOwner(ctx.manifest, parsed.fieldKey);
+  const r = ctx.responses[parsed.fieldKey];
+  if (parsed.mode === "id" && owner && owner.input.kind !== "single_choice" && owner.input.kind !== "multiple_choice") {
+    return "";
+  }
+  return responseToDisplayString(ctx.manifest, parsed.fieldKey, r, parsed.mode, ctx.locale);
+};
+var interpolateTemplateString = (template, ctx) => {
+  let i = 0;
+  let out = "";
+  while (i < template.length) {
+    const open = template.indexOf("{{", i);
+    if (open === -1) {
+      out += template.slice(i);
+      break;
+    }
+    out += template.slice(i, open);
+    const close = template.indexOf("}}", open + 2);
+    if (close === -1) {
+      out += template.slice(open);
+      break;
+    }
+    const inner = template.slice(open + 2, close);
+    const { exprPart, defaultValue } = parseDefaultFilter(inner);
+    const parsed = parseExpression(exprPart);
+    let value = evalParsed(parsed, ctx);
+    if ((value === "" || value === void 0) && defaultValue !== void 0) {
+      value = defaultValue;
+    }
+    out += value;
+    i = close + 2;
+  }
+  return out;
+};
+var resolveAndInterpolateLocalizedText = (text, ctx) => {
+  const localized = resolveLocalizedText(text, ctx.locale);
+  return interpolateTemplateString(localized, ctx);
+};
+var localizedStrings = (t) => {
+  const out = [t.default];
+  if (t.translations) {
+    for (const loc of Object.keys(t.translations)) {
+      if (/^[a-z]{2}(-[A-Z]{2})?$/.test(loc)) {
+        const v = t.translations[loc];
+        if (v) out.push(v);
+      }
+    }
+  }
+  return out;
+};
+var collectOutgoingTargets = (screen) => {
+  const out = [];
+  if (screen.next.default) out.push(screen.next.default);
+  walkScreen(screen, (l) => {
+    if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+      if (l.branching.enabled) {
+        for (const c of l.branching.conditions) out.push(c.goTo);
+      }
+    }
+    if (l.kind === "button" && l.action.kind === "go_to_step") out.push(l.action.screenId);
+    if (l.kind === "button" && l.action.kind === "request_os_permission") {
+      const o = l.action.outcomes;
+      for (const t of [o.granted, o.denied, o.blocked]) {
+        if (t === OS_PERMISSION_OUTCOME_END) ; else if (t === OS_PERMISSION_OUTCOME_CONTINUE) {
+          if (screen.next.default) out.push(screen.next.default);
+        } else {
+          out.push(t);
+        }
+      }
+    }
+    if (l.kind === "button" && l.action.kind === "go_back_one_screen" && l.action.fallbackScreenId) {
+      out.push(l.action.fallbackScreenId);
+    }
+    if (l.kind === "back_button" && l.fallbackScreenId) out.push(l.fallbackScreenId);
+  });
+  return out;
+};
+var buildForwardAdjacency = (manifest) => {
+  const m = /* @__PURE__ */ new Map();
+  for (const s of manifest.screens) {
+    m.set(s.id, collectOutgoingTargets(s));
+  }
+  for (const d of manifest.decisionNodes ?? []) {
+    const outs = [
+      ...d.cases.map((c) => c.next).filter((x) => x != null),
+      d.elseNext
+    ].filter((x) => x != null);
+    m.set(d.id, outs);
+  }
+  return m;
+};
+var reverseAdjacency = (forward) => {
+  const rev = /* @__PURE__ */ new Map();
+  for (const [u, vs] of forward) {
+    for (const v of vs) {
+      const arr = rev.get(v) ?? [];
+      arr.push(u);
+      rev.set(v, arr);
+    }
+  }
+  return rev;
+};
+var bfsForward = (entry, forward) => {
+  if (entry == null) return /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set([entry]);
+  const q = [entry];
+  while (q.length) {
+    const u = q.shift();
+    for (const v of forward.get(u) ?? []) {
+      if (!seen.has(v)) {
+        seen.add(v);
+        q.push(v);
+      }
+    }
+  }
+  return seen;
+};
+var reverseReachable = (targetId, rev, allowed) => {
+  const seen = /* @__PURE__ */ new Set([targetId]);
+  const q = [targetId];
+  while (q.length) {
+    const u = q.shift();
+    for (const v of rev.get(u) ?? []) {
+      if (!allowed.has(v)) continue;
+      if (!seen.has(v)) {
+        seen.add(v);
+        q.push(v);
+      }
+    }
+  }
+  return seen;
+};
+var upstreamScreenIdsForPicker = (manifest, screenId) => {
+  const forward = buildForwardAdjacency(manifest);
+  const rev = reverseAdjacency(forward);
+  const entry = manifest.entryScreenId;
+  if (entry == null) return [];
+  const reachFromEntry = bfsForward(entry, forward);
+  const ancestors = reverseReachable(screenId, rev, reachFromEntry);
+  const screenSet = new Set(manifest.screens.map((s) => s.id));
+  return [...ancestors].filter((id) => id !== screenId && screenSet.has(id));
+};
+var computeDominators = (manifest) => {
+  const forward = buildForwardAdjacency(manifest);
+  const entry = manifest.entryScreenId;
+  if (entry == null) return /* @__PURE__ */ new Map();
+  const reachable = bfsForward(entry, forward);
+  const nodes = [...reachable];
+  const pred = /* @__PURE__ */ new Map();
+  for (const [u, vs] of forward) {
+    for (const v of vs) {
+      if (!reachable.has(v)) continue;
+      const arr = pred.get(v) ?? [];
+      arr.push(u);
+      pred.set(v, arr);
+    }
+  }
+  const all = new Set(nodes);
+  const dom = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n === entry) dom.set(n, /* @__PURE__ */ new Set([entry]));
+    else dom.set(n, new Set(all));
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const n of nodes) {
+      if (n === entry) continue;
+      const ps = (pred.get(n) ?? []).filter((p) => reachable.has(p));
+      let nextDom;
+      if (ps.length === 0) {
+        nextDom = /* @__PURE__ */ new Set([n]);
+      } else {
+        nextDom = /* @__PURE__ */ new Set([n]);
+        const first = dom.get(ps[0]) ?? new Set(all);
+        let inter = new Set(first);
+        for (let i = 1; i < ps.length; i++) {
+          const d = dom.get(ps[i]) ?? new Set(all);
+          inter = new Set([...inter].filter((x) => d.has(x)));
+        }
+        for (const x of inter) nextDom.add(x);
+      }
+      const cur = dom.get(n);
+      if (cur.size !== nextDom.size || [...nextDom].some((x) => !cur.has(x))) {
+        dom.set(n, nextDom);
+        changed = true;
+      }
+    }
+  }
+  return dom;
+};
+var fieldKeyOwnerScreenId = (manifest, fieldKey) => {
+  for (const e of collectFieldKeys(manifest)) {
+    if (e.fieldKey === fieldKey) return e.screenId;
+  }
+  return null;
+};
+var scanLocalizedForWarnings = (manifest, hostScreenId, text, layerId, dom, seen, out) => {
+  const screenLabel = manifest.screens.find((s) => s.id === hostScreenId)?.name ?? hostScreenId;
+  for (const str of localizedStrings(text)) {
+    for (const inner of extractLiquidTemplateBodies(str)) {
+      const { expr } = analyzeLiquidTemplateInner(inner);
+      if (expr.kind === "invalid") {
+        const key = `invalid:${hostScreenId}:${layerId}:${inner}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push(
+          `Warning: Screen "${screenLabel}" text layer "${layerId}" has an invalid template token "{{${inner}}}".`
+        );
+        continue;
+      }
+      if (expr.kind === "custom") {
+        const key = `custom:${hostScreenId}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          out.push(
+            `Warning: Screen "${screenLabel}" uses \`custom.*\` template variables \u2014 values are supplied by the host SDK at runtime.`
+          );
+        }
+        continue;
+      }
+      const ownerId = fieldKeyOwnerScreenId(manifest, expr.fieldKey);
+      if (!ownerId) {
+        const key = `unknown:${hostScreenId}:${layerId}:${expr.fieldKey}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push(
+          `Warning: Screen "${screenLabel}" references unknown variable "{{${expr.fieldKey}}}" (no matching input fieldKey).`
+        );
+        continue;
+      }
+      if (expr.mode === "id") {
+        const ownerScreen = findScreen(manifest, ownerId);
+        const input = ownerScreen ? findInputLayer(ownerScreen) : null;
+        if (input?.kind !== "single_choice" && input?.kind !== "multiple_choice") {
+          const key = `id:${hostScreenId}:${layerId}:${expr.fieldKey}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          out.push(
+            `Warning: Screen "${screenLabel}" uses "{{${expr.fieldKey}.id}}" but "${expr.fieldKey}" is not a choice input \u2014 \`.id\` only applies to single or multiple choice.`
+          );
+        }
+      }
+      if (ownerId === hostScreenId) {
+        const key = `same:${hostScreenId}:${layerId}:${expr.fieldKey}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push(
+          `Warning: Screen "${screenLabel}" references "{{${expr.fieldKey}}}" which is collected on the same screen \u2014 it will be empty until after the user submits.`
+        );
+        continue;
+      }
+      const dset = dom.get(hostScreenId);
+      if (dset && !dset.has(ownerId)) {
+        const key = `path:${hostScreenId}:${layerId}:${expr.fieldKey}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push(
+          `Warning: Screen "${screenLabel}" references "{{${expr.fieldKey}}}" which may be empty on some paths (not collected before this screen on every route).`
+        );
+      }
+    }
+  }
+};
+var collectInterpolationWarnings = (manifest) => {
+  const dom = computeDominators(manifest);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const screen of manifest.screens) {
+    walkScreen(screen, (l) => {
+      if (l.kind !== "text") return;
+      scanLocalizedForWarnings(manifest, screen.id, l.text, l.id, dom, seen, out);
+    });
+  }
+  return out;
+};
+var collectDecisionWarnings = (manifest) => {
+  const dom = computeDominators(manifest);
+  const out = [];
+  for (const dn of manifest.decisionNodes ?? []) {
+    const label = dn.name ?? dn.id;
+    const dset = dom.get(dn.id);
+    for (const fk of collectDecisionFieldKeysFromNode(dn)) {
+      const ownerId = fieldKeyOwnerScreenId(manifest, fk);
+      if (!ownerId) {
+        out.push(`Warning: Decision "${label}" references unknown fieldKey "${fk}".`);
+        continue;
+      }
+      if (dset && !dset.has(ownerId)) {
+        out.push(
+          `Warning: Decision "${label}" references "${fk}" which may be empty on some paths (not collected before this decision on every route).`
+        );
+      }
+    }
+  }
+  return out;
+};
+var upstreamFieldKeysForPicker = (manifest, screenId) => {
+  const upstream = new Set(upstreamScreenIdsForPicker(manifest, screenId));
+  const keys = collectFieldKeys(manifest).filter((e) => upstream.has(e.screenId)).map((e) => e.fieldKey);
+  return [...new Set(keys)].sort();
+};
+
+// src/buildFlowPreview.ts
+var buildFlowPreview = (manifest) => {
+  const screens = Array.isArray(manifest?.screens) ? manifest.screens : [];
+  const stored = manifest?.builderMeta?.layout?.nodes ?? [];
+  const positions = new Map(stored.map((n) => [n.id, { x: n.x, y: n.y }]));
+  const nodes = screens.map((screen, idx) => {
+    const pos = positions.get(screen.id) ?? { x: 80 + idx * 360, y: 120 };
+    return {
+      id: screen.id,
+      x: pos.x,
+      y: pos.y,
+      isEntry: manifest?.entryScreenId === screen.id
+    };
+  });
+  const edges = [];
+  for (const screen of screens) {
+    const input = findInputLayer(screen);
+    const branchingOn = input && (input.kind === "single_choice" || input.kind === "multiple_choice") && input.branching.enabled;
+    const nextDefault = screen.next?.default;
+    if (branchingOn) {
+      for (const cond of input.branching.conditions) {
+        if (cond.goTo) {
+          edges.push({ source: screen.id, target: cond.goTo, branching: true });
+        }
+      }
+      if (nextDefault) {
+        edges.push({ source: screen.id, target: nextDefault, branching: true });
+      }
+    } else if (nextDefault) {
+      edges.push({ source: screen.id, target: nextDefault });
+    }
+  }
+  return { nodes, edges };
+};
+
+// src/counterLayer.ts
+var formatCounterLayerValue = (n, decimalPlaces = 0) => {
+  if (!Number.isFinite(n)) return "";
+  const p = Math.max(0, Math.min(20, Math.trunc(decimalPlaces)));
+  const s = n.toFixed(p);
+  if (p === 0) return s;
+  const trimmed = s.replace(/\.?0+$/, "");
+  return trimmed === "" || trimmed === "-" ? "0" : trimmed;
+};
+var pad2 = (n) => String(n).padStart(2, "0");
+var formatCounterAsTime = (totalSeconds, format) => {
+  if (!Number.isFinite(totalSeconds)) return "";
+  const whole = Math.max(0, Math.floor(totalSeconds));
+  switch (format) {
+    case "mm_ss": {
+      const minutes = Math.floor(whole / 60);
+      const seconds = whole % 60;
+      return `${minutes}:${pad2(seconds)}`;
+    }
+    case "hh_mm_ss": {
+      const hours = Math.floor(whole / 3600);
+      const minutes = Math.floor(whole % 3600 / 60);
+      const seconds = whole % 60;
+      return `${hours}:${pad2(minutes)}:${pad2(seconds)}`;
+    }
+    case "dd_hh_mm_ss": {
+      const days = Math.floor(whole / 86400);
+      const hours = Math.floor(whole % 86400 / 3600);
+      const minutes = Math.floor(whole % 3600 / 60);
+      const seconds = whole % 60;
+      return `${days}:${pad2(hours)}:${pad2(minutes)}:${pad2(seconds)}`;
+    }
+    default:
+      return "";
+  }
+};
+var formatCounterLayerDisplay = (n, opts) => {
+  const kind = opts.displayKind ?? "number";
+  if (kind === "time") {
+    const tf = opts.timeFormat ?? "mm_ss";
+    return formatCounterAsTime(n, tf);
+  }
+  return formatCounterLayerValue(n, opts.decimalPlaces ?? 0);
+};
+var splitSecondsForTimeFormat = (totalSeconds, format) => {
+  const whole = Math.max(0, Math.floor(Number.isFinite(totalSeconds) ? totalSeconds : 0));
+  switch (format) {
+    case "mm_ss":
+      return {
+        days: 0,
+        hours: 0,
+        minutes: Math.floor(whole / 60),
+        seconds: whole % 60
+      };
+    case "hh_mm_ss": {
+      const hours = Math.floor(whole / 3600);
+      const minutes = Math.floor(whole % 3600 / 60);
+      const seconds = whole % 60;
+      return { days: 0, hours, minutes, seconds };
+    }
+    case "dd_hh_mm_ss": {
+      const days = Math.floor(whole / 86400);
+      const hours = Math.floor(whole % 86400 / 3600);
+      const minutes = Math.floor(whole % 3600 / 60);
+      const seconds = whole % 60;
+      return { days, hours, minutes, seconds };
+    }
+    default:
+      return { days: 0, hours: 0, minutes: 0, seconds: 0 };
+  }
+};
+var clamp59 = (n) => Math.max(0, Math.min(59, Math.trunc(Number.isFinite(n) ? n : 0)));
+var clampHour23 = (n) => Math.max(0, Math.min(23, Math.trunc(Number.isFinite(n) ? n : 0)));
+var mergePartsForTimeFormat = (parts, format) => {
+  switch (format) {
+    case "mm_ss":
+      return Math.max(0, Math.trunc(Number.isFinite(parts.minutes) ? parts.minutes : 0)) * 60 + clamp59(parts.seconds);
+    case "hh_mm_ss":
+      return Math.max(0, Math.trunc(Number.isFinite(parts.hours) ? parts.hours : 0)) * 3600 + clamp59(parts.minutes) * 60 + clamp59(parts.seconds);
+    case "dd_hh_mm_ss":
+      return Math.max(0, Math.trunc(Number.isFinite(parts.days) ? parts.days : 0)) * 86400 + clampHour23(parts.hours) * 3600 + clamp59(parts.minutes) * 60 + clamp59(parts.seconds);
+    default:
+      return 0;
+  }
+};
+var resolveCounterAnimationDurationMs = (opts) => {
+  if ((opts.displayKind ?? "number") === "time") {
+    return Math.max(0, Math.round(Math.abs(opts.endValue - opts.startValue) * 1e3));
+  }
+  return opts.durationMs ?? 3e3;
+};
+
+// src/translationPlaceholders.ts
+var sortedJson = (tokens) => JSON.stringify([...tokens].sort());
+var stripLiquidRegions = (s) => {
+  let out = "";
+  let i = 0;
+  while (i < s.length) {
+    const open = s.indexOf("{{", i);
+    if (open === -1) return out + s.slice(i);
+    out += s.slice(i, open);
+    const close = s.indexOf("}}", open + 2);
+    if (close === -1) return out + s.slice(open);
+    i = close + 2;
+  }
+  return out;
+};
+var extractTranslationPlaceholders = (s) => {
+  const liquids = extractLiquidTemplateBodies(s).map((inner) => `{{${inner.trim()}}}`);
+  const stripped = stripLiquidRegions(s);
+  const singles = [];
+  const re = /\{([a-zA-Z_]\w*)\}/g;
+  for (const m of stripped.matchAll(re)) {
+    singles.push(`{${m[1]}}`);
+  }
+  return [...liquids, ...singles];
+};
+var translationPlaceholdersMatch = (source, translated) => sortedJson(extractTranslationPlaceholders(source)) === sortedJson(extractTranslationPlaceholders(translated));
+
+// src/aiFlowGenerationMerge.ts
+var AI_FLOW_PLACEHOLDER_SCREEN_ID = "scr_blank";
+var bodyStackChildrenLen = (screen) => {
+  const body = screen.regions.body;
+  if (body.kind !== "stack") return -1;
+  return body.children.length;
+};
+var isAiFlowPlaceholderManifest = (manifest) => manifest.screens.length === 1 && manifest.screens[0]?.id === AI_FLOW_PLACEHOLDER_SCREEN_ID && bodyStackChildrenLen(manifest.screens[0]) === 0;
+var findDefaultPathTailScreen = (manifest) => {
+  const map = new Map(manifest.screens.map((s) => [s.id, s]));
+  const startId = manifest.entryScreenId ?? manifest.screens[0]?.id;
+  let cur = startId ? map.get(startId) : void 0;
+  const seen = /* @__PURE__ */ new Set();
+  let last;
+  while (cur && !seen.has(cur.id)) {
+    seen.add(cur.id);
+    last = cur;
+    const n = cur.next.default;
+    if (!n) break;
+    cur = map.get(n);
+  }
+  return last;
+};
+var ensureLayoutNodes = (manifest) => {
+  const existing = new Map(
+    (manifest.builderMeta?.layout?.nodes ?? []).map((n) => [n.id, n])
+  );
+  const nodes = manifest.screens.map((s, idx) => {
+    const hit = existing.get(s.id);
+    if (hit) return { ...hit };
+    return { id: s.id, x: 80 + idx * 360, y: 120 };
+  });
+  return {
+    ...manifest,
+    builderMeta: {
+      ...manifest.builderMeta ?? {},
+      layout: {
+        ...manifest.builderMeta?.layout ?? {},
+        nodes
+      }
+    }
+  };
+};
+var mergeAiGeneratedScreenIntoManifest = (manifest, screen) => {
+  if (isAiFlowPlaceholderManifest(manifest)) {
+    const screens2 = [{ ...screen, next: { default: null } }];
+    let builderMeta = manifest.builderMeta;
+    const oldEntry = manifest.entryScreenId;
+    if (builderMeta?.layout?.nodes?.length) {
+      builderMeta = {
+        ...builderMeta,
+        layout: {
+          ...builderMeta.layout,
+          nodes: builderMeta.layout.nodes.map(
+            (n) => n.id === oldEntry ? { ...n, id: screen.id } : { ...n }
+          )
+        }
+      };
+    }
+    const merged2 = {
+      ...manifest,
+      screens: screens2,
+      entryScreenId: screen.id,
+      builderMeta
+    };
+    return ensureLayoutNodes(merged2);
+  }
+  const tail = findDefaultPathTailScreen(manifest);
+  if (!tail) {
+    throw new Error("mergeAiGeneratedScreenIntoManifest: no tail on default path");
+  }
+  if (tail.next.default !== null) {
+    throw new Error("mergeAiGeneratedScreenIntoManifest: tail must end the default path (next is null)");
+  }
+  const screens = manifest.screens.map(
+    (s) => s.id === tail.id ? { ...s, next: { default: screen.id } } : s
+  );
+  screens.push({ ...screen, next: { default: null } });
+  const merged = { ...manifest, screens };
+  return ensureLayoutNodes(merged);
+};
+var appendGeneratedScreenToManifest = (manifest, newScreen) => {
+  const wiredNew = {
+    ...newScreen,
+    next: { default: null }
+  };
+  const merged = {
+    ...manifest,
+    screens: [...manifest.screens, wiredNew]
+  };
+  return ensureLayoutNodes(merged);
+};
+var insertScreenAfterAnchorInManifest = (manifest, anchorScreenId, newScreen) => {
+  const anchor = manifest.screens.find((s) => s.id === anchorScreenId);
+  if (!anchor) {
+    throw new Error("insertScreenAfterAnchorInManifest: anchor screen not found");
+  }
+  const forwarded = anchor.next.default;
+  const wiredNew = {
+    ...newScreen,
+    next: { default: forwarded ?? null }
+  };
+  const screens = manifest.screens.map(
+    (s) => s.id === anchorScreenId ? { ...s, next: { default: wiredNew.id } } : s
+  );
+  screens.push(wiredNew);
+  const merged = { ...manifest, screens };
+  return ensureLayoutNodes(merged);
+};
+var mergeSlimManifestPreservingBuilderMeta = (draft, slim) => {
+  const merged = {
+    ...slim,
+    builderMeta: draft.builderMeta
+  };
+  return ensureLayoutNodes(merged);
+};
+
+// src/rheoAgentManifestMerge.ts
+var upsertById = (existing, incoming) => {
+  const incomingById = new Map(incoming.map((item) => [item.id, item]));
+  const merged = existing.map((item) => incomingById.get(item.id) ?? item);
+  const existingIds = new Set(existing.map((item) => item.id));
+  for (const item of incoming) {
+    if (!existingIds.has(item.id)) merged.push(item);
+  }
+  return merged;
+};
+var mergeRheoAgentPatchIntoDraft = (draft, patch) => {
+  const removeIds = new Set(patch.removeScreenIds ?? []);
+  let screens = patch.screens ? upsertById(draft.screens, patch.screens) : draft.screens;
+  if (removeIds.size > 0) {
+    screens = screens.filter((screen) => !removeIds.has(screen.id));
+  }
+  const decisionNodes = patch.decisionNodes ? upsertById(draft.decisionNodes ?? [], patch.decisionNodes) : draft.decisionNodes;
+  const externalSurfaceNodes = patch.externalSurfaceNodes ? upsertById(draft.externalSurfaceNodes ?? [], patch.externalSurfaceNodes) : draft.externalSurfaceNodes;
+  const merged = {
+    ...draft,
+    screens,
+    decisionNodes,
+    externalSurfaceNodes,
+    ...patch.entryScreenId !== void 0 ? { entryScreenId: patch.entryScreenId } : {},
+    ...patch.sdkAttributeKeys !== void 0 ? { sdkAttributeKeys: patch.sdkAttributeKeys } : {},
+    builderMeta: draft.builderMeta
+  };
+  return ensureLayoutNodes(merged);
+};
+var randomHex = (byteLength) => {
+  const bytes = new Uint8Array(byteLength);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < byteLength; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+var collectManifestLayerIds = (manifest) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const s of manifest.screens) {
+    walkScreenLayers(s, (l) => {
+      ids.add(l.id);
+    });
+  }
+  return ids;
+};
+var remapScreenIdsForManifestIngest = (manifest, screen) => {
+  const screenIds = new Set(manifest.screens.map((s) => s.id));
+  let newScreenId = `scr_ai_${randomHex(4)}`;
+  let sn = 0;
+  while (screenIds.has(newScreenId)) {
+    newScreenId = `scr_ai_${randomHex(4)}_${sn++}`.slice(0, 64);
+  }
+  const usedLayers = collectManifestLayerIds(manifest);
+  const token = randomHex(3);
+  const map = /* @__PURE__ */ new Map();
+  walkScreenLayers(screen, (l) => {
+    if (map.has(l.id)) return;
+    const tail = l.id.replace(/^lyr_/i, "").replace(/[^a-z0-9_]/gi, "_") || "layer";
+    let nid = `lyr_ai_${token}_${tail}`;
+    let i = 0;
+    for (; ; ) {
+      const taken = usedLayers.has(nid) || [...map.values()].some((v) => v === nid);
+      if (!taken) break;
+      i += 1;
+      nid = `lyr_ai_${token}_${tail}_${i}`.slice(0, 64);
+    }
+    map.set(l.id, nid);
+    usedLayers.add(nid);
+  });
+  let json = JSON.stringify({ ...screen, id: newScreenId });
+  const pairs = [...map.entries()].sort((a, b) => b[0].length - a[0].length);
+  for (const [oldId, newId] of pairs) {
+    json = json.split(oldId).join(newId);
+  }
+  return JSON.parse(json);
+};
+var remapReplacedScreenLayerCollisionsInManifest = (manifest, targetScreenId, screen) => {
+  const forbidden = /* @__PURE__ */ new Set();
+  for (const s of manifest.screens) {
+    if (s.id === targetScreenId) continue;
+    walkScreenLayers(s, (l) => forbidden.add(l.id));
+  }
+  const next = JSON.parse(JSON.stringify(screen));
+  const seen = /* @__PURE__ */ new Set();
+  const used = new Set(forbidden);
+  const alloc = () => {
+    let i = 0;
+    for (; ; ) {
+      const nid = `lyr_ai_${randomHex(4)}_${i++}`.slice(0, 64);
+      if (!used.has(nid)) {
+        used.add(nid);
+        return nid;
+      }
+    }
+  };
+  const fix = (layer) => {
+    if (forbidden.has(layer.id) || seen.has(layer.id)) {
+      layer.id = alloc();
+    }
+    seen.add(layer.id);
+    if (layer.kind === "stack") layer.children.forEach(fix);
+    else if (layer.kind === "carousel") layer.slides.forEach(fix);
+    else if (layer.kind === "button" || layer.kind === "back_button") layer.children.forEach(fix);
+    else if (layer.kind === "hyperlink") layer.children.forEach(fix);
+    else if (layer.kind === "single_choice" || layer.kind === "multiple_choice") {
+      layer.children.forEach(fix);
+    } else if (layer.kind === "text_input" || layer.kind === "scale_input") {
+      layer.children?.forEach(fix);
+    } else if (layer.kind === "oauth_login") layer.children.forEach(fix);
+    else if (layer.kind === "oauth_provider" && layer.variant === "custom") layer.children.forEach(fix);
+    else if (layer.kind === "email_password_auth") layer.children.forEach(fix);
+    else if (layer.kind === "email_password_field") layer.children?.forEach(fix);
+    else if (layer.kind === "email_password_submit") layer.children.forEach(fix);
+  };
+  if (next.regions.header) fix(next.regions.header);
+  fix(next.regions.body);
+  if (next.regions.footer) fix(next.regions.footer);
+  return next;
+};
+var FG_LIGHT = "#0a0a0a";
+var FG_DARK = "#fafafa";
+var buttonVariantChromeForTheme = (variant, theme) => {
+  const dark = theme === "dark";
+  switch (variant) {
+    case "primary":
+      return dark ? { bg: FG_DARK, color: FG_LIGHT, border: "transparent" } : { bg: FG_LIGHT, color: FG_DARK, border: "transparent" };
+    case "secondary":
+      return dark ? { bg: "transparent", color: FG_DARK, border: "#27272a" } : { bg: "transparent", color: FG_LIGHT, border: "#e4e4e7" };
+    case "ghost":
+      return dark ? { bg: "transparent", color: FG_DARK, border: "transparent" } : { bg: "transparent", color: FG_LIGHT, border: "transparent" };
+    case "destructive":
+      return dark ? { bg: "#ef4444", color: FG_DARK, border: "transparent" } : { bg: "#dc2626", color: FG_DARK, border: "transparent" };
+  }
+};
+var pairThemedColor = (light, dark) => light === dark ? light : { light, dark };
+var buttonVariantAuthoringStyleDefaults = (variant) => {
+  const l = buttonVariantChromeForTheme(variant, "light");
+  const d = buttonVariantChromeForTheme(variant, "dark");
+  return {
+    /** Matches web sim `buttonBaseStyle` (radius, type scale, width). */
+    radius: 10,
+    fontSize: 13,
+    fontWeight: 600,
+    width: "full",
+    height: "auto",
+    background: pairThemedColor(l.bg, d.bg),
+    color: pairThemedColor(l.color, d.color),
+    border: {
+      width: 1,
+      color: pairThemedColor(l.border, d.border)
+    }
+  };
+};
+var mergeAuthoringButtonStyleWithLayer = (variant, style) => deepMergeStyle(
+  buttonVariantAuthoringStyleDefaults(variant),
+  style ?? {}
+);
+var buttonPaletteBorderFallback = (variant, theme, authoredStyle, resolvedBackground) => {
+  const authoredWidth = authoredStyle?.border?.width;
+  if (authoredWidth !== void 0) {
+    return { borderWidth: authoredWidth, borderColor: void 0 };
+  }
+  if (resolvedBackground === "transparent") {
+    return { borderWidth: 0, borderColor: void 0 };
+  }
+  const chrome = buttonVariantChromeForTheme(variant, theme);
+  return {
+    borderWidth: chrome.border === "transparent" ? 0 : 1,
+    borderColor: chrome.border === "transparent" ? void 0 : chrome.border
+  };
+};
+
+// src/manifestBillingSlice.ts
+var cloneManifestForBillingSlice = (m) => structuredClone(m);
+var stripRestingMotionFromLayer = (layer) => {
+  const l = layer;
+  delete l.restingMotion;
+  delete l.restingMotions;
+};
+var stripManifestAnimations = (manifest) => {
+  const next = cloneManifestForBillingSlice(manifest);
+  for (const screen of next.screens) {
+    const s = screen;
+    delete s.animations;
+    delete s.stagger;
+  }
+  return next;
+};
+var stripManifestMotion = (manifest) => {
+  const next = stripManifestAnimations(manifest);
+  for (const screen of next.screens) {
+    walkScreen(screen, stripRestingMotionFromLayer);
+  }
+  return next;
+};
+var collapseLocalizedObjects = (node) => {
+  if (node === null || node === void 0) return;
+  if (Array.isArray(node)) {
+    for (const x of node) collapseLocalizedObjects(x);
+    return;
+  }
+  if (typeof node !== "object") return;
+  const o = node;
+  if (typeof o.default === "string" && Object.prototype.hasOwnProperty.call(o, "translations")) {
+    delete o.translations;
+  }
+  for (const v of Object.values(o)) collapseLocalizedObjects(v);
+};
+var collapseManifestToDefaultLocaleOnly = (manifest) => {
+  const next = cloneManifestForBillingSlice(manifest);
+  collapseLocalizedObjects(next);
+  next.locales = [next.defaultLocale];
+  return next;
+};
+var manifestHasScreenAnimations = (manifest) => manifest.screens.some((s) => {
+  const anim = s.animations;
+  return Array.isArray(anim) && anim.length > 0;
+});
+var recordHasNonEmptyTranslations = (node) => {
+  if (node === null || node === void 0) return false;
+  if (Array.isArray(node)) return node.some(recordHasNonEmptyTranslations);
+  if (typeof node !== "object") return false;
+  const o = node;
+  const tr = o.translations;
+  if (tr && typeof tr === "object" && Object.keys(tr).length > 0) return true;
+  return Object.values(o).some(recordHasNonEmptyTranslations);
+};
+var manifestUsesTranslationsBeyondDefault = (manifest) => {
+  if (manifest.locales.length > 1) return true;
+  return recordHasNonEmptyTranslations(manifest);
+};
+var manifestUsesExternalIntegrations = (manifest) => (manifest.externalSurfaceNodes ?? []).some(
+  (n) => n.config?.provider != null && n.config.provider !== "unspecified"
+);
+var resolveHyperlinkPreviewLabel = (roots, args) => {
+  const { manifest, locale, interpolationContext } = args;
+  let found = "";
+  const visit = (l) => {
+    if (found) return;
+    if (l.kind === "text") {
+      found = interpolationContext ? resolveAndInterpolateLocalizedText(l.text, {
+        manifest,
+        locale,
+        responses: interpolationContext.responses,
+        customProperties: interpolationContext.customProperties
+      }) : resolveLocalizedText(l.text, locale);
+      return;
+    }
+    if (l.kind === "stack") {
+      for (const c of l.children) visit(c);
+      return;
+    }
+    if (l.kind === "carousel") {
+      for (const s of l.slides) visit(s);
+      return;
+    }
+    if (l.kind === "button" || l.kind === "back_button") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "hyperlink") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "text_input" || l.kind === "scale_input") {
+      l.children?.forEach(visit);
+      return;
+    }
+    if (l.kind === "oauth_login") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "oauth_provider" && l.variant === "custom") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "email_password_auth") {
+      l.children.forEach(visit);
+      return;
+    }
+    if (l.kind === "email_password_field") {
+      l.children?.forEach(visit);
+      return;
+    }
+    if (l.kind === "email_password_submit") {
+      l.children.forEach(visit);
+      return;
+    }
+  };
+  for (const r of roots) visit(r);
+  return found;
+};
+
+// src/layerTypography.ts
+var TEXT_FONT_FAMILY_SYSTEM_UI = "__rheo_system_ui__";
+var WEB_DOCUMENT_FONT_STACK = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif';
+var quoteCssFamilyName = (name) => {
+  const t = name.trim();
+  if (!t) return "";
+  const safe = /^[-_a-zA-Z0-9]+$/.test(t);
+  return safe ? t : JSON.stringify(t);
+};
+var fontStackWithPrimary = (primary) => primary ? `${primary}, ${WEB_DOCUMENT_FONT_STACK}` : WEB_DOCUMENT_FONT_STACK;
+var resolveWebRootFontFamilyCss = (theme) => {
+  const raw = theme?.fontFamily?.trim();
+  if (!raw) return void 0;
+  if (raw.includes(",")) return raw;
+  return fontStackWithPrimary(quoteCssFamilyName(raw));
+};
+var resolveWebTextFontFamilyCss = (layerFont) => {
+  if (layerFont === TEXT_FONT_FAMILY_SYSTEM_UI) return WEB_DOCUMENT_FONT_STACK;
+  const raw = layerFont?.trim();
+  if (!raw) return void 0;
+  if (raw.includes(",")) return raw;
+  return fontStackWithPrimary(quoteCssFamilyName(raw));
+};
+var brandingWebFontFacesCss = (branding) => {
+  if (!branding?.fontFamilies?.length) return "";
+  const blocks = [];
+  for (const fam of branding.fontFamilies) {
+    const famCss = quoteCssFamilyName(fam.name);
+    for (const st of fam.styles) {
+      if (!st.url?.trim()) continue;
+      const url = JSON.stringify(st.url);
+      blocks.push(
+        `@font-face{font-family:${famCss};src:url(${url});font-weight:${st.weight};font-style:${st.italic ? "italic" : "normal"};font-display:swap;}`
+      );
+    }
+  }
+  return blocks.join("");
+};
+var nativeFontRegistrationNameForStyle = (styleId) => `RheoFont__${styleId}`;
+var buildBrandingFontLoadMap = (branding) => {
+  const map = {};
+  if (!branding?.fontFamilies?.length) return map;
+  for (const fam of branding.fontFamilies) {
+    for (const st of fam.styles) {
+      const u = st.url?.trim();
+      if (!u) continue;
+      map[nativeFontRegistrationNameForStyle(st.id)] = u;
+    }
+  }
+  return map;
+};
+var resolveNativeTextFontFamilyName = (branding, logicalFamily, fontWeight) => {
+  if (!logicalFamily?.trim()) return void 0;
+  if (logicalFamily === TEXT_FONT_FAMILY_SYSTEM_UI) return void 0;
+  const fam = branding?.fontFamilies.find((f) => f.name === logicalFamily);
+  if (!fam) return logicalFamily;
+  const w = fontWeight ?? 400;
+  const withUrl = fam.styles.filter((s) => !!s.url?.trim());
+  if (withUrl.length === 0) return logicalFamily;
+  const exact = withUrl.find((s) => s.weight === w && !s.italic);
+  const st = exact ?? withUrl.find((s) => s.weight === w) ?? withUrl[0];
+  if (!st) return logicalFamily;
+  return nativeFontRegistrationNameForStyle(st.id);
+};
+
+// src/layerRotate.ts
+var LAYER_ROTATE_DEG_MIN = -360;
+var LAYER_ROTATE_DEG_MAX = 360;
+var layerRotateCssTransform = (deg) => deg === void 0 ? void 0 : `rotate(${deg}deg)`;
+var layerRotateNativeTransform = (deg) => deg === void 0 ? void 0 : [{ rotate: `${deg}deg` }];
+
+// src/checkboxGlyphStyle.ts
+var DEFAULT_UNCHECKED = {
+  size: 18,
+  radius: 4,
+  border: { width: 2, color: { light: "#71717a", dark: "#a1a1aa" } },
+  background: "transparent",
+  opacity: 1
+};
+var DEFAULT_CHECKED_OVERLAY = {
+  background: { light: "#18181b", dark: "#e4e4e7" },
+  checkColor: { light: "#ffffff", dark: "#18181b" }
+};
+var mergeBorder = (a, b) => {
+  if (!a && !b) return void 0;
+  return { ...a, ...b };
+};
+var mergeGlyph = (a, b) => {
+  if (!b) return { ...a };
+  const out = { ...a };
+  Object.keys(b).forEach((k) => {
+    const v = b[k];
+    if (v === void 0) return;
+    if (k === "border") {
+      const merged = mergeBorder(out.border, v);
+      if (merged && Object.values(merged).some((x) => x !== void 0)) out.border = merged;
+      else delete out.border;
+      return;
+    }
+    if (k === "shadow") {
+      out.shadow = v;
+      return;
+    }
+    out[k] = v;
+  });
+  return out;
+};
+var mergeCheckboxGlyphStyle = (prev, patch) => {
+  const out = { ...prev ?? {} };
+  for (const key of Object.keys(patch)) {
+    const v = patch[key];
+    if (key === "border") {
+      if (v === void 0) delete out.border;
+      else out.border = mergeBorder(out.border, v);
+      if (out.border && !Object.values(out.border).some((x) => x !== void 0)) delete out.border;
+      continue;
+    }
+    if (key === "shadow") {
+      if (v === void 0) delete out.shadow;
+      else out.shadow = v;
+      continue;
+    }
+    if (v === void 0) delete out[key];
+    else out[key] = v;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var resolveCheckboxGlyphForRender = (theme, palette, unchecked, checkedOverlay, isChecked, branding) => {
+  const base = mergeGlyph(DEFAULT_UNCHECKED, unchecked);
+  const merged = isChecked ? mergeGlyph(mergeGlyph(base, DEFAULT_CHECKED_OVERLAY), checkedOverlay) : base;
+  const sizePx = merged.size ?? 18;
+  const radiusPx = merged.radius ?? 4;
+  const borderWidth = merged.border?.width;
+  const borderColor = resolveThemedColor(theme, palette, merged.border?.color);
+  const background = resolveThemedBackground(theme, branding, palette, merged.background);
+  const nb = nativeBrandBackgroundFromThemedColor(theme, branding, palette, merged.background);
+  const opacity = merged.opacity ?? 1;
+  const checkColor = isChecked ? resolveThemedColor(theme, palette, merged.checkColor) : void 0;
+  return {
+    sizePx,
+    radiusPx,
+    background,
+    nativeBackgroundColor: nb.solid,
+    nativeLinearGradient: nb.linear ?? null,
+    borderWidth,
+    borderColor,
+    opacity,
+    checkColor,
+    shadow: merged.shadow
+  };
+};
+
+// src/scaleInputStyle.ts
+var defaultTrackColor = (palette) => palette === "dark" ? "#3f3f46" : "#e4e4e7";
+var defaultFillColor = (theme, palette) => {
+  const fromTheme = theme?.primary ? resolveThemedColor(theme, palette, theme.primary) : void 0;
+  return fromTheme ?? (palette === "dark" ? "#fafafa" : "#0a0a0a");
+};
+var defaultLabelColor = (palette) => palette === "dark" ? "#a1a1aa" : "#52525b";
+var defaultValueColor = (palette) => palette === "dark" ? "#fafafa" : "#0a0a0a";
+var mergeScaleInputLabelStyle = (prev, patch) => {
+  const out = { ...prev ?? {} };
+  for (const key of Object.keys(patch)) {
+    const v = patch[key];
+    if (v === void 0) delete out[key];
+    else out[key] = v;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var mergeScaleInputValueStyle = mergeScaleInputLabelStyle;
+var resolveColor = (theme, palette, color, fallback) => resolveThemedColor(theme, palette, color) ?? fallback;
+var resolveTextStyle = (style, theme, palette, defaults) => ({
+  fontFamily: style?.fontFamily,
+  fontSizePx: style?.fontSize ?? defaults.fontSizePx,
+  fontWeight: style?.fontWeight ?? defaults.fontWeight,
+  color: resolveColor(theme, palette, style?.color, defaults.color),
+  textAlign: style?.align ?? defaults.textAlign,
+  lineHeight: style?.lineHeight,
+  opacity: style?.opacity ?? defaults.opacity
+});
+var resolveScaleInputSliderForRender = (layer, theme, palette) => {
+  const trackFallback = defaultTrackColor(palette);
+  const fillFallback = defaultFillColor(theme, palette);
+  return {
+    showLabels: layer.showLabels !== false,
+    showValue: layer.showValue !== false,
+    trackHeightPx: layer.trackHeight ?? 4,
+    trackColor: resolveColor(theme, palette, layer.trackColor, trackFallback),
+    fillColor: resolveColor(theme, palette, layer.fillColor, fillFallback),
+    thumbSizePx: layer.thumbSize ?? 16,
+    thumbColor: resolveColor(theme, palette, layer.thumbColor, fillFallback),
+    label: resolveTextStyle(layer.labelStyle, theme, palette, {
+      fontSizePx: 11,
+      color: defaultLabelColor(palette),
+      opacity: 0.75
+    }),
+    value: resolveTextStyle(layer.valueStyle, theme, palette, {
+      fontSizePx: 14,
+      fontWeight: 600,
+      color: defaultValueColor(palette),
+      opacity: 1,
+      textAlign: "center"
+    })
+  };
+};
+
+// src/layout/scalarLayoutDefaults.ts
+var DEFAULT_PROGRESS_LINEAR_HEIGHT_PX = 6;
+var DEFAULT_LOADER_LINEAR_HEIGHT_PX = 6;
+var DEFAULT_LOADER_CIRCULAR_SIZE_PX = 48;
+var DEFAULT_LOADER_STROKE_WIDTH_PX = 4;
+var GAP_BY_KIND = {
+  stack: 12,
+  single_choice: 8,
+  multiple_choice: 8,
+  oauth_login: 8,
+  email_password_auth: 8,
+  email_password_submit: 8,
+  button: 8,
+  back_button: 8,
+  oauth_provider: 8,
+  hyperlink: 0
+};
+var defaultGapForLayerKind = (kind) => GAP_BY_KIND[kind] ?? null;
+var defaultFeedbackStyleScalars = (kind, variant) => {
+  if (kind === "progress") {
+    return { height: DEFAULT_PROGRESS_LINEAR_HEIGHT_PX };
+  }
+  if (variant === "circular") {
+    return {
+      width: DEFAULT_LOADER_CIRCULAR_SIZE_PX,
+      height: DEFAULT_LOADER_CIRCULAR_SIZE_PX,
+      strokeWidth: DEFAULT_LOADER_STROKE_WIDTH_PX
+    };
+  }
+  return { height: DEFAULT_LOADER_LINEAR_HEIGHT_PX };
+};
+
+// src/responsive/breakpoints.ts
+var TAILWIND_DEFAULT_BREAKPOINTS = {
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  "2xl": 1536
+};
+var STYLE_BREAKPOINT_MERGE_ORDER = ["sm", "md", "lg", "xl", "2xl"];
+var SCREEN_SIZE_BUCKET_ORDER = [
+  "default",
+  "sm",
+  "md",
+  "lg",
+  "xl",
+  "2xl"
+];
+var BUILDER_INSPECTOR_BUCKET_ORDER = [
+  "default",
+  "sm",
+  "md",
+  "lg"
+];
+var SCREEN_SIZE_BUCKET_LABEL = {
+  default: "Default (< 640px)",
+  sm: "sm (640\u2013767px)",
+  md: "md (768\u20131023px)",
+  lg: "lg (1024\u20131279px)",
+  xl: "xl (1280\u20131535px)",
+  "2xl": "2xl (1536px+)"
+};
+var DEFAULT_PREVIEW_VIEWPORT_WIDTH_PX = 390;
+var getScreenSizeBucketForWidth = (width) => {
+  const { sm, md, lg, xl, "2xl": xxl } = TAILWIND_DEFAULT_BREAKPOINTS;
+  if (width < sm) return "default";
+  if (width < md) return "sm";
+  if (width < lg) return "md";
+  if (width < xl) return "lg";
+  if (width < xxl) return "xl";
+  return "2xl";
+};
+var getActiveStyleBreakpointChain = (widthPx) => {
+  const bucket = getScreenSizeBucketForWidth(widthPx);
+  if (bucket === "default") return [];
+  const idx = STYLE_BREAKPOINT_MERGE_ORDER.indexOf(bucket);
+  if (idx < 0) return [];
+  return STYLE_BREAKPOINT_MERGE_ORDER.slice(0, idx + 1);
+};
+
+// src/responsive/merge.ts
+var isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var deepMergeStyle2 = (base, ...overrides) => {
+  let acc = base ? { ...base } : void 0;
+  for (const o of overrides) {
+    if (!o) continue;
+    acc = acc ?? {};
+    for (const [k, v] of Object.entries(o)) {
+      if (v === void 0) continue;
+      const prev = acc[k];
+      if (isPlainObject(v) && isPlainObject(prev)) {
+        const merged = deepMergeStyle2(prev, v);
+        if (merged !== void 0) acc[k] = merged;
+      } else {
+        acc[k] = v;
+      }
+    }
+  }
+  return acc;
+};
+var mergeResponsivePartial = (base, breakpoints, widthPx) => {
+  const chain = getActiveStyleBreakpointChain(widthPx);
+  if (chain.length === 0) return base ? { ...base } : void 0;
+  let acc = base ? { ...base } : void 0;
+  for (const key of chain) {
+    const patch = breakpoints?.[key];
+    if (!patch) continue;
+    acc = deepMergeStyle2(acc, patch);
+  }
+  return acc;
+};
+var mergeResponsivePartialUpToBucket = (base, breakpoints, bucket) => {
+  if (bucket === "default") return base ? { ...base } : void 0;
+  const end = STYLE_BREAKPOINT_MERGE_ORDER.indexOf(bucket);
+  if (end < 0) return base ? { ...base } : void 0;
+  let acc = base ? { ...base } : void 0;
+  for (let i = 0; i <= end; i++) {
+    const key = STYLE_BREAKPOINT_MERGE_ORDER[i];
+    const patch = breakpoints?.[key];
+    if (!patch) continue;
+    acc = deepMergeStyle2(acc, patch);
+  }
+  return acc;
+};
+
+// src/responsive/layerResolve.ts
+var resolveLayerGap = (kind, gap) => gap ?? defaultGapForLayerKind(kind) ?? 0;
+var resolveProgressLinearHeightPx = (height) => typeof height === "number" ? height : DEFAULT_PROGRESS_LINEAR_HEIGHT_PX;
+var resolveLoaderLinearHeightPx = (height) => typeof height === "number" ? height : DEFAULT_LOADER_LINEAR_HEIGHT_PX;
+var resolveLoaderCircularSizePx = (width) => typeof width === "number" ? width : DEFAULT_LOADER_CIRCULAR_SIZE_PX;
+var resolveLoaderStrokeWidthPx = (strokeWidth) => strokeWidth ?? DEFAULT_LOADER_STROKE_WIDTH_PX;
+var resolveCommonStyleAtWidth = (base, breakpoints, widthPx) => mergeResponsivePartial(
+  base,
+  breakpoints,
+  widthPx
+);
+var resolveTextStyleAtWidth = (base, breakpoints, widthPx) => mergeResponsivePartial(
+  base,
+  breakpoints,
+  widthPx
+);
+var resolveImageStyleAtWidth = (base, breakpoints, widthPx) => mergeResponsivePartial(
+  base,
+  breakpoints,
+  widthPx
+);
+var resolveIconStyleAtWidth = (base, breakpoints, widthPx) => mergeResponsivePartial(
+  base,
+  breakpoints,
+  widthPx
+);
+var resolveButtonStyleAtWidth = (base, breakpoints, widthPx) => mergeResponsivePartial(
+  base,
+  breakpoints,
+  widthPx
+);
+var mergeLayoutScalars = (base, breakpoints, widthPx) => {
+  const chain = getActiveStyleBreakpointChain(widthPx);
+  let acc = { ...base };
+  for (const key of chain) {
+    const p = breakpoints?.[key];
+    if (!p) continue;
+    acc = { ...acc, ...p };
+  }
+  return acc;
+};
+var resolveStackLayoutAtWidth = (layer, widthPx) => {
+  const base = {
+    gap: layer.gap,
+    direction: layer.direction
+  };
+  const merged = mergeLayoutScalars(
+    base,
+    layer.stackLayoutBreakpoints,
+    widthPx
+  );
+  return {
+    gap: merged.gap,
+    direction: merged.direction ?? layer.direction
+  };
+};
+var resolveButtonLayoutAtWidth = (layer, widthPx) => {
+  const merged = mergeLayoutScalars(
+    { gap: layer.gap, direction: layer.direction },
+    layer.buttonLayoutBreakpoints,
+    widthPx
+  );
+  return { gap: merged.gap, direction: merged.direction };
+};
+var resolveTextStyleForEditBucket = (base, breakpoints, bucket) => mergeResponsivePartialUpToBucket(
+  base,
+  breakpoints,
+  bucket
+);
+var resolveCommonStyleForEditBucket = (base, breakpoints, bucket) => mergeResponsivePartialUpToBucket(
+  base,
+  breakpoints,
+  bucket
+);
+
+// src/choiceOptionSelection.ts
+var CHOICE_OPTION_SELECTED_ICON_SUFFIX = "_sel";
+var CHOICE_OPTION_UNSELECTED_ICON_SUFFIX = "_unsel";
+var stackWithSelectedStyle = (stack, isSelected, widthPx) => {
+  if (!isSelected || !stack.selectedStyle) return stack;
+  const resolved = resolveCommonStyleAtWidth(stack.style, stack.styleBreakpoints, widthPx);
+  return {
+    ...stack,
+    style: { ...resolved ?? {}, ...stack.selectedStyle },
+    styleBreakpoints: void 0
+  };
+};
+var iconVisibilityForChoiceOption = (layer, isSelected) => {
+  const baseOpacity = layer.style?.opacity ?? 1;
+  if (layer.id.endsWith(CHOICE_OPTION_SELECTED_ICON_SUFFIX)) {
+    return {
+      ...layer,
+      style: { ...layer.style, opacity: isSelected ? baseOpacity : 0 }
+    };
+  }
+  if (layer.id.endsWith(CHOICE_OPTION_UNSELECTED_ICON_SUFFIX)) {
+    return {
+      ...layer,
+      style: { ...layer.style, opacity: isSelected ? 0 : baseOpacity }
+    };
+  }
+  return layer;
+};
+var mapChoiceOptionChildForSelection = (child, isSelected, widthPx) => {
+  if (child.kind === "stack") {
+    const stack = child;
+    const nestedSelected = isSelected && !!stack.selectedStyle;
+    const styled = stackWithSelectedStyle(stack, nestedSelected, widthPx);
+    const children = styled.children?.map(
+      (c) => mapChoiceOptionChildForSelection(c, isSelected, widthPx)
+    );
+    return children ? { ...styled, children } : styled;
+  }
+  if (child.kind === "icon") {
+    return iconVisibilityForChoiceOption(child, isSelected);
+  }
+  return child;
+};
+var applyChoiceOptionSelectionToStack = (stack, isSelected, widthPx) => {
+  const styled = stackWithSelectedStyle(stack, isSelected, widthPx);
+  if (!styled.children) return styled;
+  return {
+    ...styled,
+    children: styled.children.map((c) => mapChoiceOptionChildForSelection(c, isSelected, widthPx))
+  };
+};
+
+// src/layout/authoringLayoutDefaults.ts
+var LAYOUT_FULL_HUG = { width: "full", height: "auto" };
+var LAYOUT_FULL_FILL = { width: "full", height: "fill" };
+var LAYOUT_HUG_HUG = { width: "auto", height: "auto" };
+var LAYOUT_FULL_FIXED_H160 = { width: "full", height: 160 };
+var LAYOUT_PROGRESS = {
+  width: "full",
+  height: DEFAULT_PROGRESS_LINEAR_HEIGHT_PX
+};
+var LAYOUT_LOADER_LINEAR = {
+  width: "full",
+  height: DEFAULT_LOADER_LINEAR_HEIGHT_PX
+};
+var defaultLayoutStyleForKind = (kind) => {
+  switch (kind) {
+    case "stack":
+      return LAYOUT_FULL_FILL;
+    case "text":
+    case "counter":
+      return LAYOUT_HUG_HUG;
+    case "hyperlink":
+      return LAYOUT_HUG_HUG;
+    case "image":
+    case "lottie":
+    case "video":
+      return LAYOUT_FULL_FIXED_H160;
+    case "icon":
+      return LAYOUT_HUG_HUG;
+    case "button":
+    case "back_button":
+    case "oauth_provider":
+    case "email_password_submit":
+      return LAYOUT_FULL_HUG;
+    case "text_input":
+    case "scale_input":
+    case "email_password_auth":
+    case "email_password_field":
+    case "oauth_login":
+      return LAYOUT_FULL_FILL;
+    case "progress":
+      return LAYOUT_PROGRESS;
+    case "loader":
+      return LAYOUT_LOADER_LINEAR;
+    case "checkbox":
+    case "single_choice":
+    case "multiple_choice":
+      return LAYOUT_FULL_HUG;
+    case "carousel":
+      return null;
+    default:
+      return null;
+  }
+};
+var mergeLayoutDefaultsIntoStyle = (kind, style) => {
+  const defaults = defaultLayoutStyleForKind(kind);
+  if (!defaults) return style ?? {};
+  return { ...defaults, ...style };
+};
+
+// src/layout/normalizeLayerLayout.ts
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var applyAxisDefaultsInPlace = (layer, kind) => {
+  const current = isObj(layer.style) ? layer.style : void 0;
+  if (kind === "loader" && layer.variant === "circular") {
+    const feedback = defaultFeedbackStyleScalars("loader", "circular");
+    layer.style = { ...feedback, ...current ?? {} };
+    return;
+  }
+  if (!defaultLayoutStyleForKind(kind)) return;
+  layer.style = mergeLayoutDefaultsIntoStyle(kind, current);
+};
+var applyGapDefaultInPlace = (layer, kind) => {
+  const gapDefault = defaultGapForLayerKind(kind);
+  if (gapDefault === null) return;
+  if (kind === "oauth_provider" && layer.variant !== "custom") return;
+  if (layer.gap === void 0) layer.gap = gapDefault;
+};
+var applyLayoutDefaultsToLayerInPlace = (layer) => {
+  if (typeof layer.kind !== "string") return;
+  const kind = layer.kind;
+  applyAxisDefaultsInPlace(layer, kind);
+  applyGapDefaultInPlace(layer, kind);
+};
+var recurseChildren = (parent, key) => {
+  const kids = parent[key];
+  if (!Array.isArray(kids)) return;
+  for (const child of kids) {
+    if (isObj(child)) normalizeLayerLayoutInPlace(child);
+  }
+};
+var normalizeLayerLayoutInPlace = (layer) => {
+  applyLayoutDefaultsToLayerInPlace(layer);
+  const kind = layer.kind;
+  if (kind === "carousel") {
+    recurseChildren(layer, "slides");
+    return;
+  }
+  recurseChildren(layer, "children");
+};
+var normalizeManifestLayoutInPlace = (manifest) => {
+  const screens = manifest.screens;
+  if (!Array.isArray(screens)) return;
+  for (const screen of screens) {
+    if (!isObj(screen)) continue;
+    const regions = screen.regions;
+    if (!isObj(regions)) continue;
+    for (const key of ["header", "body", "footer"]) {
+      const region = regions[key];
+      if (isObj(region)) normalizeLayerLayoutInPlace(region);
+    }
+  }
+};
+
+// src/layout/stackFlexGrow.ts
+var stackMainAxisFillHeight = (height) => height === "fill" || height === "full";
+
+// src/responsive/screenContainerResolve.ts
+var mergeBackgroundFillPatch = (fill, patch) => {
+  if (fill.kind === "color") {
+    return {
+      ...fill,
+      kind: "color",
+      ...patch.color !== void 0 ? { color: patch.color } : {},
+      ...patch.opacity !== void 0 ? { opacity: patch.opacity } : {}
+    };
+  }
+  const scrim = patch.scrim !== void 0 ? deepMergeStyle2(fill.scrim, patch.scrim) : fill.scrim;
+  const shared = {
+    ...fill,
+    ...patch.fit !== void 0 ? { fit: patch.fit } : {},
+    ...patch.opacity !== void 0 ? { opacity: patch.opacity } : {},
+    ...scrim !== void 0 ? { scrim } : {}
+  };
+  if (fill.kind === "image") {
+    return shared;
+  }
+  return {
+    ...shared,
+    ...patch.loop !== void 0 ? { loop: patch.loop } : {},
+    ...patch.autoPlay !== void 0 ? { autoPlay: patch.autoPlay } : {},
+    ...patch.triggerLayerId !== void 0 ? { triggerLayerId: patch.triggerLayerId } : {},
+    ...patch.onComplete !== void 0 ? { onComplete: patch.onComplete } : {},
+    ...patch.audioEnabled !== void 0 ? { audioEnabled: patch.audioEnabled } : {}
+  };
+};
+var resolveScreenContainerStyleAtWidth = (base, breakpoints, widthPx) => {
+  const chain = getActiveStyleBreakpointChain(widthPx);
+  let acc = base ? { ...base } : void 0;
+  for (const key of chain) {
+    const patch = breakpoints?.[key];
+    if (!patch) continue;
+    acc = acc ?? {};
+    if (patch.padding !== void 0) acc = { ...acc, padding: patch.padding };
+    if (patch.margin !== void 0) acc = { ...acc, margin: patch.margin };
+    if (patch.insetSafeArea !== void 0) acc = { ...acc, insetSafeArea: patch.insetSafeArea };
+    if (patch.backgroundFillPatch && acc.backgroundFill) {
+      acc = {
+        ...acc,
+        backgroundFill: mergeBackgroundFillPatch(acc.backgroundFill, patch.backgroundFillPatch)
+      };
+    }
+  }
+  return acc;
+};
+var screenBackgroundFillUsesMedia = (fill) => fill?.kind === "image" || fill?.kind === "video";
+var resolveScreenContainerForEditBucket = (base, breakpoints, bucket) => {
+  if (bucket === "default") return base ? { ...base } : void 0;
+  const end = STYLE_BREAKPOINT_MERGE_ORDER.indexOf(bucket);
+  if (end < 0) return base ? { ...base } : void 0;
+  let acc = base ? { ...base } : {};
+  for (let i = 0; i <= end; i++) {
+    const patch = breakpoints?.[STYLE_BREAKPOINT_MERGE_ORDER[i]];
+    if (!patch) continue;
+    acc = acc ?? {};
+    if (patch.padding !== void 0) acc = { ...acc, padding: patch.padding };
+    if (patch.margin !== void 0) acc = { ...acc, margin: patch.margin };
+    if (patch.insetSafeArea !== void 0) acc = { ...acc, insetSafeArea: patch.insetSafeArea };
+    if (patch.backgroundFillPatch && acc.backgroundFill) {
+      acc = {
+        ...acc,
+        backgroundFill: mergeBackgroundFillPatch(acc.backgroundFill, patch.backgroundFillPatch)
+      };
+    }
+  }
+  const hasKeys = acc && (acc.padding !== void 0 || acc.margin !== void 0 || acc.insetSafeArea !== void 0 || acc.backgroundFill !== void 0);
+  return hasKeys ? acc : void 0;
+};
+
+// src/responsive/previewSafeAreaInsets.ts
+var previewPhoneSafeAreaInsetTopPx = (width) => {
+  const statusChromePadY = Math.max(6, Math.round(width * 0.016));
+  const chromePadBottom = Math.max(4, Math.round(width * 0.01));
+  const padY = Math.max(5, Math.round(width * 0.012));
+  const statusH = Math.max(23, Math.round(width * 0.058));
+  return statusChromePadY + statusH + 2 * padY + chromePadBottom;
+};
+var previewPhoneSafeAreaInsetBottomPx = (width, systemUi = "ios") => {
+  const pad = systemUi === "ios" ? 8 : 10;
+  const pill = systemUi === "ios" ? 5 : 4;
+  return pad + pill + Math.max(6, Math.round(width * 0.014));
+};
+var previewPhoneSafeAreaInsetHorizontalPx = (_width) => 0;
+var previewPhoneSafeAreaPadding = (widthPx, systemUi = "ios") => ({
+  t: previewPhoneSafeAreaInsetTopPx(widthPx),
+  r: previewPhoneSafeAreaInsetHorizontalPx(),
+  b: previewPhoneSafeAreaInsetBottomPx(widthPx, systemUi),
+  l: previewPhoneSafeAreaInsetHorizontalPx()
+});
+
+// src/responsive/screenShellInsets.ts
+var edge = (a, b) => {
+  const sum = (a ?? 0) + (b ?? 0);
+  return sum === 0 ? void 0 : sum;
+};
+var addPadding = (a, b) => {
+  if (!a && !b) return void 0;
+  const out = {
+    t: edge(a?.t, b?.t),
+    r: edge(a?.r, b?.r),
+    b: edge(a?.b, b?.b),
+    l: edge(a?.l, b?.l)
+  };
+  const cleaned = Object.fromEntries(
+    Object.entries(out).filter(([, v]) => v !== void 0)
+  );
+  return Object.keys(cleaned).length === 0 ? void 0 : cleaned;
+};
+var resolveEffectiveScreenShellPadding = (opts) => {
+  if (!opts.insetSafeArea) return opts.manual;
+  return addPadding(opts.manual, opts.safeAreaInsets);
+};
+
+export { AI_FLOW_PLACEHOLDER_SCREEN_ID, BRAND_GRADIENT_PREFIX, BUILDER_INSPECTOR_BUCKET_ORDER, BUILDER_RULES_AGENT_BULLETS, CHOICE_OPTION_SELECTED_ICON_SUFFIX, CHOICE_OPTION_UNSELECTED_ICON_SUFFIX, DEFAULT_LOADER_CIRCULAR_SIZE_PX, DEFAULT_LOADER_LINEAR_HEIGHT_PX, DEFAULT_LOADER_STROKE_WIDTH_PX, DEFAULT_LOTTIE_PLAY_DURATION_MS, DEFAULT_PREVIEW_VIEWPORT_WIDTH_PX, DEFAULT_PROGRESS_LINEAR_HEIGHT_PX, DEFAULT_WORKBENCH_TIMELINE_MS, EASING_BEZIERS, LAYER_ROTATE_DEG_MAX, LAYER_ROTATE_DEG_MIN, LEGACY_RESTING_MOTION_ID, MIN_ANIMATION_TIMELINE_AUTHORING_SPAN_MS, RESTING_MOTION_BOUNCE_BASE_PX, RESTING_MOTION_DEFAULT_DURATION_MS, RESTING_MOTION_DEFAULT_ROTATE_DEG, RESTING_MOTION_DEFAULT_SCALE_DOWN_PERCENT, RESTING_MOTION_DEFAULT_SCALE_PERCENT, RESTING_MOTION_DEFAULT_SCALE_UP_PERCENT, RESTING_MOTION_DEFAULT_TRANSLATE_PEAK_Y_PERCENT, RESTING_MOTION_DEFAULT_TRANSLATE_PEAK_Y_PX, RESTING_MOTION_DEFAULT_TRANSLATE_RANGE_PX, RESTING_MOTION_KEYFRAMES_CSS, RESTING_MOTION_PULSE_DIP_BASE, RESTING_MOTION_SEGMENT_DURATION_MS_MAX, RESTING_MOTION_SEGMENT_DURATION_MS_MIN, SCREEN_SIZE_BUCKET_LABEL, SCREEN_SIZE_BUCKET_ORDER, STYLE_BREAKPOINT_MERGE_ORDER, TAILWIND_DEFAULT_BREAKPOINTS, TEXT_FONT_FAMILY_SYSTEM_UI, WEB_DOCUMENT_FONT_STACK, abandonFlow, addPadding, analyzeLiquidTemplateInner, animationTimelineAuthoringEndMs, appendGeneratedScreenToManifest, applyChoiceOptionSelectionToStack, applyGraphLanding, applyLayoutDefaultsToLayerInPlace, applyReducedMotion, applyStaggerIndicesFromTreeOrder, assignVariant, bouncePhaseToTranslateY, brandGradientFromThemedColor, brandGradientNativeLinear, brandGradientSolidFallback, brandGradientToCss, brandingWebFontFacesCss, buildBrandingFontLoadMap, buildCompletionResponses, buildFlowPreview, buildLinearGradientCss, buildTwoStopLinearGradientCss, buttonPaletteBorderFallback, buttonVariantAuthoringStyleDefaults, buttonVariantChromeForTheme, choiceOptionLabel, clampRestingMotionSegmentDurationMs, clipsByLayerId, cloneManifestForBillingSlice, collapseManifestToDefaultLocaleOnly, collectBrandGradientManifestIssues, collectDecisionWarnings, collectFieldKeys, collectFlowBuilderIssues, collectInterpolationWarnings, collectManifestLayerIds, computeDominators, decisionTargetIds, deepMergeStyle2 as deepMergeStyle, defaultFeedbackStyleScalars, defaultGapForLayerKind, defaultLayoutStyleForKind, digestDecisionExpression, dropShadowToBoxShadow, dropShadowToNativeStyle, dropShadowToWebStyle, effectiveDelayMs, ensureLayoutNodes, evaluateDecisionExpression, evaluateDecisionNode, externalSurfaceResponseKey, extractLiquidTemplateBodies, extractTranslationPlaceholders, findDecisionNode, findDefaultPathTailScreen, findExternalSurface, findInputLayer, findLayerById, findManualSubmitInputLayer, findOptionStackForChoice, findScreen, fnv1a, formatCounterAsTime, formatCounterLayerDisplay, formatCounterLayerValue, getActiveStyleBreakpointChain, getScreenSizeBucketForWidth, iconLayerHasAuthoringColor, initFlowState, insertScreenAfterAnchorInManifest, interpolateTemplateString, isAiFlowPlaceholderManifest, isAuthTerminalExportResponseKey, isBrandGradientToken, isEligibleConsumedDraft, isPropertyAllowedOnLayer, isStoredLinearGradientCss, layerHasAnimationClips, layerMountClipsEndMs, layerRestingMotionEndMs, layerRestingMotionEntries, layerRestingMotionStartMs, layerRotateCssTransform, layerRotateNativeTransform, layerWithRestingMotionEntries, listAnimatablePropsForLayerKind, loaderFillProgressAtGlobalMs, loaderLayerFillTimelineEndMs, lottieJsonDurationMs, manifestHasScreenAnimations, manifestUsesExternalIntegrations, manifestUsesTranslationsBeyondDefault, mergeAiGeneratedScreenIntoManifest, mergeAuthoringButtonStyleWithLayer, mergeCheckboxGlyphStyle, mergeLayoutDefaultsIntoStyle, mergePartsForTimeFormat, mergeResponsivePartial, mergeResponsivePartialUpToBucket, mergeRheoAgentPatchIntoDraft, mergeSampledClips, mergeScaleInputLabelStyle, mergeScaleInputValueStyle, mergeSlimManifestPreservingBuilderMeta, migrateStaggerClipsToMount, motionTimelineScrubClampMs, multiplyColorAlpha, nativeBrandBackgroundFromThemedColor, nativeFontRegistrationNameForStyle, nativeLinearFromAngleAndStops, nativeLinearFromAngleAndTwoColors, nextUniqueFieldKey, normalizeHexForGradient, normalizeLayerLayoutInPlace, normalizeManifestLayoutInPlace, parseLinearGradientCss, parseTwoStopLinearGradientCss, previewPhoneSafeAreaInsetBottomPx, previewPhoneSafeAreaInsetHorizontalPx, previewPhoneSafeAreaInsetTopPx, previewPhoneSafeAreaPadding, remapReplacedScreenLayerCollisionsInManifest, remapScreenIdsForManifestIngest, resolveAndInterpolateLocalizedText, resolveBrandGradientToken, resolveButtonLayoutAtWidth, resolveButtonStyleAtWidth, resolveCheckboxGlyphForRender, resolveCommonStyleAtWidth, resolveCommonStyleForEditBucket, resolveCounterAnimationDurationMs, resolveEffectiveScreenShellPadding, resolveHyperlinkPreviewLabel, resolveIconStyleAtWidth, resolveImageStyleAtWidth, resolveLayerGap, resolveLoaderCircularSizePx, resolveLoaderLinearHeightPx, resolveLoaderStrokeWidthPx, resolveNativeTextFontFamilyName, resolveNextScreenId, resolveProgressLinearHeightPx, resolveScaleInputSliderForRender, resolveScreenContainerForEditBucket, resolveScreenContainerStyleAtWidth, resolveStackLayoutAtWidth, resolveTextStyleAtWidth, resolveTextStyleForEditBucket, resolveThemedBackground, resolveThemedColor, resolveThroughGraph, resolveTokens, resolveWebRootFontFamilyCss, resolveWebTextFontFamilyCss, responseKeyFor, restingMotionAllowedAtTime, restingMotionBounceAmplitudePx, restingMotionCycleDurationMs, restingMotionDelayAfterMountEndMs, restingMotionEffectiveDurationMs, restingMotionIntensity, restingMotionLocalElapsedMs, restingMotionMotionSpeedSliderMs, restingMotionNormalizeScaleNonLoopClip, restingMotionPhase01, restingMotionPulseMinOpacity, restingMotionRotateDirection, restingMotionRotateMaxDeg, restingMotionRotateSign, restingMotionRotateSpringBack, restingMotionSampleStyle, restingMotionScaleAmountFraction, restingMotionScaleAtPhase, restingMotionScaleDirection, restingMotionScaleDownFraction, restingMotionScalePatternDurationMs, restingMotionScalePeakMultiplier, restingMotionScalePercentResolved, restingMotionScaleSpringBack, restingMotionScaleUpFraction, restingMotionStyleAtTime, restingMotionSyncScaleNonLoopClipAndPattern, restingMotionTranslateAuthoringPeakPercent, restingMotionTranslateAuthoringPeakPx, restingMotionTranslatePeakPx, restingMotionTranslatePeakResolved, restingMotionTranslateSpringBack, restingMotionWebStyle, sampleClipAt, sampleLayerAnimAt, sampleTrack, scaleStep, scaleValueInRange, scaleValueIsOnStep, screenAnimationsDurationMs, screenBackgroundFillUsesMedia, screenHasContinueButton, screenLoaderTimelineExtentMs, screenRestingTimelineExtentMs, snapScaleValue, splitSecondsForTimeFormat, stackMainAxisFillHeight, stackWithSelectedStyle, startFlow, stepResponseToCompletionValue, stripAuthResponsesForTerminalExport, stripManifestAnimations, stripManifestMotion, submitResponse, textLayerHasAuthoringColor, translationPlaceholdersMatch, upstreamFieldKeysForPicker, upstreamScreenIdsForPicker, validateEmailPasswordAuthFields, validateManifest, validatePublishable, validateTextInputValue, walkLayers, walkScreen, workbenchTimelineTotalMs };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map