From f8d2fb8eb71fdc9e50ef46daf6946cf7e0961b0f Mon Sep 17 00:00:00 2001
From: Daniel Arantes Loverde <daniel@loverde.com.br>
Date: Thu, 16 Apr 2026 14:46:38 -0300
Subject: [PATCH 1/3] feat(feature-control): add standalone BFF with bootstrap,
 exposure telemetry and tests

---
 feature-control-bff/README.md          |  89 +++++++
 feature-control-bff/core.mjs           | 333 +++++++++++++++++++++++++
 feature-control-bff/package.json       |  10 +
 feature-control-bff/server.mjs         |  34 +++
 feature-control-bff/tests/bff.test.mjs | 275 ++++++++++++++++++++
 5 files changed, 741 insertions(+)
 create mode 100644 feature-control-bff/README.md
 create mode 100644 feature-control-bff/core.mjs
 create mode 100644 feature-control-bff/package.json
 create mode 100644 feature-control-bff/server.mjs
 create mode 100644 feature-control-bff/tests/bff.test.mjs

diff --git a/feature-control-bff/README.md b/feature-control-bff/README.md
new file mode 100644
index 0000000..ac6f863
--- /dev/null
+++ b/feature-control-bff/README.md
@@ -0,0 +1,89 @@
+# Feature Control BFF
+
+BFF mínimo para expor flags ao app sem expor `Atomenta-Token` no cliente.
+
+## Endpoint
+
+- `POST /feature-control/bootstrap`
+- `POST /feature-control/telemetry/exposure`
+- `GET /health`
+
+## Variáveis de ambiente
+
+- `PORT` (default: `8787`)
+- `ATOMENTA_ORIGIN` (default: `https://atomenta.com.br`)
+- `FEATURE_CONTROL_MODULE_TOKEN` (ou `ATOMENTA_FEATURE_CONTROL_MODULE_ID`) **obrigatório**
+- `FEATURE_CONTROL_ENVIRONMENT` (default: `production`)
+- `FEATURE_CONTROL_CACHE_TTL_MS` (default: `60000`)
+- `FEATURE_CONTROL_TIMEOUT_MS` (default: `2000`)
+- `FEATURE_CONTROL_DEFAULTS_JSON` (opcional, JSON com defaults de fallback)
+
+Exemplo de `FEATURE_CONTROL_DEFAULTS_JSON`:
+
+```json
+{
+  "fc.checkout_v2": { "enabled": false, "variant": "off" },
+  "fc.search_ranking_v3": { "enabled": true, "variant": "on", "payload": { "model": "v3" } }
+}
+```
+
+## Request (App -> BFF)
+
+```json
+{
+  "environment": "production",
+  "keys": ["fc.checkout_v2", "fc.search_ranking_v3"],
+  "context": {
+    "subjectType": "customer",
+    "subjectId": "cust_123",
+    "storeId": "store_001",
+    "platform": "ios",
+    "appVersion": "2.3.1",
+    "attributes": {
+      "city": "Belo Horizonte",
+      "tier": "gold"
+    }
+  }
+}
+```
+
+Se o app enviar `Authorization: Bearer <JWT>`, o BFF tenta extrair `subjectId` do JWT (`sub`/`customerId`/`id`) quando `context.subjectId` não vier.
+
+## Response (BFF -> App)
+
+```json
+{
+  "ok": true,
+  "source": "live",
+  "configVersion": 7,
+  "evaluatedAt": "2026-04-16T12:00:00.000Z",
+  "flags": {
+    "checkoutV2": true,
+    "searchRankingV3": "off"
+  },
+  "raw": {
+    "fc.checkout_v2": {
+      "enabled": true,
+      "variant": "on",
+      "payload": null,
+      "reason": "rollout"
+    }
+  }
+}
+```
+
+Quando o upstream falha (ex.: `429`, `500`, timeout), o BFF devolve `fallback` com defaults estáticos.
+
+## Execução local
+
+```bash
+cd feature-control-bff
+FEATURE_CONTROL_MODULE_TOKEN="550e8400-e29b-41d4-a716-44665544000b" npm start
+```
+
+## Testes
+
+```bash
+cd feature-control-bff
+npm test
+```
diff --git a/feature-control-bff/core.mjs b/feature-control-bff/core.mjs
new file mode 100644
index 0000000..d5e3a22
--- /dev/null
+++ b/feature-control-bff/core.mjs
@@ -0,0 +1,333 @@
+import crypto from "node:crypto";
+
+export function loadConfig(env = process.env) {
+  return {
+    atomentaOrigin: (env.ATOMENTA_ORIGIN || "https://atomenta.com.br").replace(/\/+$/, ""),
+    moduleToken: env.FEATURE_CONTROL_MODULE_TOKEN || env.ATOMENTA_FEATURE_CONTROL_MODULE_ID || "",
+    defaultEnvironment: env.FEATURE_CONTROL_ENVIRONMENT || "production",
+    cacheTtlMs: Number(env.FEATURE_CONTROL_CACHE_TTL_MS || 60_000),
+    requestTimeoutMs: Number(env.FEATURE_CONTROL_TIMEOUT_MS || 2_000),
+    staticDefaults: parseDefaults(env.FEATURE_CONTROL_DEFAULTS_JSON)
+  };
+}
+
+export function createRuntime(config) {
+  return { cache: new Map(), inFlight: new Map(), config };
+}
+
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+export function writeJson(res, status, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(body),
+    "Cache-Control": "no-store"
+  });
+  res.end(body);
+}
+
+const MAX_BODY_BYTES = 128 * 1024;
+const MAX_KEYS = 100;
+const MAX_ATTRIBUTES_BYTES = 16 * 1024;
+const MAX_EXPOSURE_EVENTS = 100;
+
+function parseDefaults(raw) {
+  if (!raw) return {};
+  const parsed = safeParseJson(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  return parsed;
+}
+
+function safeParseJson(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function getSubjectFromAuthHeader(authHeader) {
+  if (!authHeader || !authHeader.toLowerCase().startsWith("bearer ")) return null;
+  const token = authHeader.slice(7).trim();
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+
+  try {
+    const payloadBase64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = payloadBase64 + "=".repeat((4 - (payloadBase64.length % 4)) % 4);
+    const payload = JSON.parse(Buffer.from(padded, "base64").toString("utf-8"));
+    const subjectId = normalizeString(payload.sub) || normalizeString(payload.customerId) || normalizeString(payload.id);
+    if (!subjectId) return null;
+    return { subjectType: "customer", subjectId };
+  } catch {
+    return null;
+  }
+}
+
+function buildCacheKey(input) {
+  const stable = JSON.stringify({
+    env: input.environment,
+    keys: input.keys,
+    context: {
+      subjectType: input.context.subjectType,
+      subjectId: input.context.subjectId,
+      storeId: input.context.storeId || "",
+      platform: input.context.platform || "",
+      appVersion: input.context.appVersion || "",
+      attributes: input.context.attributes || {}
+    }
+  });
+  return crypto.createHash("sha256").update(stable).digest("hex");
+}
+
+async function readBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_BODY_BYTES) {
+      throw Object.assign(new Error("Payload muito grande"), { status: 413, code: "PAYLOAD_TOO_LARGE" });
+    }
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+function validateBootstrapRequest(body, authHeader, config) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw Object.assign(new Error("Body inválido"), { status: 400, code: "INVALID_BODY" });
+  }
+
+  const keys = Array.isArray(body.keys) ? body.keys.map(normalizeString).filter(Boolean) : [];
+  if (!keys.length) throw Object.assign(new Error("`keys` é obrigatório"), { status: 400, code: "FEATURE_CONTROL_KEYS_REQUIRED" });
+  if (keys.length > MAX_KEYS) {
+    throw Object.assign(new Error(`Máximo de ${MAX_KEYS} chaves por request`), { status: 400, code: "FEATURE_CONTROL_TOO_MANY_KEYS" });
+  }
+
+  const environment = normalizeString(body.environment) || config.defaultEnvironment;
+  const contextInput = body.context && typeof body.context === "object" ? body.context : {};
+  const fromJwt = getSubjectFromAuthHeader(authHeader);
+  const subjectType = normalizeString(contextInput.subjectType) || fromJwt?.subjectType || "customer";
+  const subjectId = normalizeString(contextInput.subjectId) || fromJwt?.subjectId || "";
+  if (!subjectId) {
+    throw Object.assign(new Error("`context.subjectId` é obrigatório"), { status: 400, code: "FEATURE_CONTROL_SUBJECT_ID_REQUIRED" });
+  }
+
+  const allowed = new Set(["user", "customer", "store", "anonymous"]);
+  if (!allowed.has(subjectType)) {
+    throw Object.assign(new Error("`context.subjectType` inválido"), { status: 400, code: "FEATURE_CONTROL_SUBJECT_TYPE_INVALID" });
+  }
+
+  const attributes = contextInput.attributes && typeof contextInput.attributes === "object" && !Array.isArray(contextInput.attributes)
+    ? contextInput.attributes
+    : {};
+
+  if (Buffer.byteLength(JSON.stringify(attributes), "utf-8") > MAX_ATTRIBUTES_BYTES) {
+    throw Object.assign(new Error("`context.attributes` excede limite"), { status: 400, code: "FEATURE_CONTROL_ATTRIBUTES_TOO_LARGE" });
+  }
+
+  return {
+    environment,
+    keys: [...new Set(keys)].sort(),
+    context: {
+      subjectType,
+      subjectId,
+      storeId: normalizeString(contextInput.storeId) || undefined,
+      platform: normalizeString(contextInput.platform) || undefined,
+      appVersion: normalizeString(contextInput.appVersion) || undefined,
+      attributes
+    }
+  };
+}
+
+function validateExposureRequest(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw Object.assign(new Error("Body inválido"), { status: 400, code: "INVALID_BODY" });
+  }
+  if (!Array.isArray(body.events) || body.events.length === 0) {
+    throw Object.assign(new Error("`events` é obrigatório"), { status: 400, code: "FEATURE_CONTROL_EVENTS_REQUIRED" });
+  }
+  if (body.events.length > MAX_EXPOSURE_EVENTS) {
+    throw Object.assign(new Error(`Máximo de ${MAX_EXPOSURE_EVENTS} eventos por request`), {
+      status: 400,
+      code: "FEATURE_CONTROL_EXPOSURE_TOO_MANY_EVENTS"
+    });
+  }
+
+  const events = body.events.map((event) => ({
+    featureKey: normalizeString(event?.featureKey),
+    variant: normalizeString(event?.variant) || "off",
+    subjectType: normalizeString(event?.subjectType) || "customer",
+    storeId: normalizeString(event?.storeId) || undefined
+  }));
+
+  for (const event of events) {
+    if (!event.featureKey) {
+      throw Object.assign(new Error("`featureKey` é obrigatório"), { status: 400, code: "FEATURE_CONTROL_EXPOSURE_FEATURE_KEY_REQUIRED" });
+    }
+  }
+  return { events };
+}
+
+function buildFallbackFlags(keys, config) {
+  const raw = {};
+  const simplified = {};
+
+  for (const key of keys) {
+    const fromEnv = config.staticDefaults[key];
+    const enabled = Boolean(fromEnv?.enabled);
+    const variant = typeof fromEnv?.variant === "string" ? fromEnv.variant : enabled ? "on" : "off";
+    raw[key] = { enabled, variant, payload: fromEnv?.payload ?? null, reason: "fallback_default" };
+  }
+
+  for (const [key, value] of Object.entries(raw)) {
+    const simplifiedKey = key.replace(/^fc\./, "").replace(/[_-]([a-z])/g, (_, c) => c.toUpperCase()).replace(/\./g, "");
+    if (!simplified[simplifiedKey]) {
+      simplified[simplifiedKey] = value.variant === "on" || value.enabled === true ? true : value.variant;
+    }
+  }
+
+  return { raw, simplified };
+}
+
+function mapUpstreamError(error) {
+  return {
+    status: Number(error?.status || 500),
+    code: normalizeString(error?.code) || "FEATURE_CONTROL_BFF_ERROR",
+    message: normalizeString(error?.message) || "Erro ao avaliar flags"
+  };
+}
+
+async function callAtomenta(path, requestPayload, config) {
+  if (!config.moduleToken) {
+    throw Object.assign(new Error("Token de módulo não configurado"), { status: 500, code: "FEATURE_CONTROL_MODULE_TOKEN_MISSING" });
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), config.requestTimeoutMs);
+
+  try {
+    const response = await fetch(`${config.atomentaOrigin}${path}`, {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "Atomenta-Token": config.moduleToken
+      },
+      body: JSON.stringify(requestPayload)
+    });
+
+    const text = await response.text();
+    const parsed = safeParseJson(text) || {};
+    if (!response.ok) {
+      const upstreamCode = parsed.code || "FEATURE_CONTROL_UPSTREAM_ERROR";
+      const upstreamMessage = parsed.message || `Erro upstream (${response.status})`;
+      throw Object.assign(new Error(upstreamMessage), { status: response.status, code: upstreamCode });
+    }
+    return parsed;
+  } catch (error) {
+    if (error.name === "AbortError") {
+      throw Object.assign(new Error("Timeout no upstream"), { status: 504, code: "FEATURE_CONTROL_UPSTREAM_TIMEOUT" });
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function formatBffResponse(evaluated, requestPayload, source = "live") {
+  const result = evaluated?.result || {};
+  const flags = result.flags && typeof result.flags === "object" ? result.flags : {};
+  const simplified = {};
+  for (const key of requestPayload.keys) {
+    const value = flags[key];
+    if (!value || typeof value !== "object") continue;
+    const simplifiedKey = key.replace(/^fc\./, "").replace(/[_-]([a-z])/g, (_, c) => c.toUpperCase()).replace(/\./g, "");
+    if (!simplified[simplifiedKey]) simplified[simplifiedKey] = value.variant === "on" || value.enabled === true ? true : value.variant || "off";
+  }
+  return {
+    ok: true,
+    source,
+    configVersion: Number(result.configVersion || 0),
+    evaluatedAt: result.evaluatedAt || nowIso(),
+    flags: simplified,
+    raw: flags
+  };
+}
+
+async function evaluateWithCache(requestPayload, runtime) {
+  const cacheKey = buildCacheKey(requestPayload);
+  const current = runtime.cache.get(cacheKey);
+  if (current && current.expiresAt > Date.now()) return current.payload;
+
+  const inflight = runtime.inFlight.get(cacheKey);
+  if (inflight) return inflight;
+
+  const work = (async () => {
+    const evaluated = await callAtomenta("/api/feature-control/evaluate", requestPayload, runtime.config);
+    const payload = formatBffResponse(evaluated, requestPayload, "live");
+    runtime.cache.set(cacheKey, { payload, expiresAt: Date.now() + runtime.config.cacheTtlMs });
+    return payload;
+  })();
+  runtime.inFlight.set(cacheKey, work);
+
+  try {
+    return await work;
+  } finally {
+    runtime.inFlight.delete(cacheKey);
+  }
+}
+
+export async function handleBootstrap(req, res, runtime) {
+  try {
+    const body = safeParseJson(await readBody(req));
+    if (!body) return writeJson(res, 400, { ok: false, code: "INVALID_JSON", message: "JSON inválido" });
+    const requestPayload = validateBootstrapRequest(body, req.headers.authorization, runtime.config);
+    try {
+      const payload = await evaluateWithCache(requestPayload, runtime);
+      return writeJson(res, 200, payload);
+    } catch (error) {
+      const mapped = mapUpstreamError(error);
+      const fallback = buildFallbackFlags(requestPayload.keys, runtime.config);
+      return writeJson(res, mapped.status === 400 ? 400 : 200, {
+        ok: mapped.status === 400 ? false : true,
+        source: "fallback",
+        configVersion: 0,
+        evaluatedAt: nowIso(),
+        flags: fallback.simplified,
+        raw: fallback.raw,
+        upstreamError: mapped
+      });
+    }
+  } catch (error) {
+    return writeJson(res, Number(error?.status || 500), {
+      ok: false,
+      code: normalizeString(error?.code) || "FEATURE_CONTROL_BFF_ERROR",
+      message: normalizeString(error?.message) || "Erro interno"
+    });
+  }
+}
+
+export async function handleExposure(req, res, runtime) {
+  try {
+    const body = safeParseJson(await readBody(req));
+    if (!body) return writeJson(res, 400, { ok: false, code: "INVALID_JSON", message: "JSON inválido" });
+    const requestPayload = validateExposureRequest(body);
+    const response = await callAtomenta("/api/feature-control/telemetry/exposure", requestPayload, runtime.config);
+    return writeJson(res, 200, { ok: true, code: "FEATURE_CONTROL_EXPOSURE_ACCEPTED", result: response?.result ?? null });
+  } catch (error) {
+    return writeJson(res, Number(error?.status || 500), {
+      ok: false,
+      code: normalizeString(error?.code) || "FEATURE_CONTROL_EXPOSURE_ERROR",
+      message: normalizeString(error?.message) || "Falha ao enviar exposição"
+    });
+  }
+}
diff --git a/feature-control-bff/package.json b/feature-control-bff/package.json
new file mode 100644
index 0000000..6e8d9f9
--- /dev/null
+++ b/feature-control-bff/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "feature-control-bff",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "node server.mjs",
+    "test": "node --test tests/*.test.mjs"
+  }
+}
diff --git a/feature-control-bff/server.mjs b/feature-control-bff/server.mjs
new file mode 100644
index 0000000..e8188cc
--- /dev/null
+++ b/feature-control-bff/server.mjs
@@ -0,0 +1,34 @@
+import http from "node:http";
+import { createRuntime, handleBootstrap, handleExposure, loadConfig, nowIso, writeJson } from "./core.mjs";
+
+const PORT = Number(process.env.PORT || 8787);
+const runtime = createRuntime(loadConfig(process.env));
+
+const server = http.createServer(async (req, res) => {
+  const method = req.method || "GET";
+  const url = req.url || "/";
+
+  if (method === "GET" && url === "/health") {
+    return writeJson(res, 200, {
+      ok: true,
+      service: "feature-control-bff",
+      time: nowIso(),
+      cacheEntries: runtime.cache.size,
+      inFlight: runtime.inFlight.size
+    });
+  }
+
+  if (method === "POST" && url === "/feature-control/bootstrap") {
+    return handleBootstrap(req, res, runtime);
+  }
+
+  if (method === "POST" && url === "/feature-control/telemetry/exposure") {
+    return handleExposure(req, res, runtime);
+  }
+
+  return writeJson(res, 404, { ok: false, code: "NOT_FOUND", message: "Rota não encontrada" });
+});
+
+server.listen(PORT, () => {
+  console.log(`[feature-control-bff] listening on :${PORT}`);
+});
diff --git a/feature-control-bff/tests/bff.test.mjs b/feature-control-bff/tests/bff.test.mjs
new file mode 100644
index 0000000..98ba28d
--- /dev/null
+++ b/feature-control-bff/tests/bff.test.mjs
@@ -0,0 +1,275 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import http from "node:http";
+import { spawn } from "node:child_process";
+
+function listen(server) {
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      resolve(address.port);
+    });
+  });
+}
+
+function closeServer(server) {
+  return new Promise((resolve) => server.close(() => resolve()));
+}
+
+async function waitForHealth(url, timeoutMs = 5000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const response = await fetch(`${url}/health`);
+      if (response.ok) return;
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error("BFF health timeout");
+}
+
+async function startBff(env) {
+  const child = spawn("node", ["server.mjs"], {
+    cwd: new URL("..", import.meta.url),
+    env: { ...process.env, ...env },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+
+  const logs = [];
+  child.stdout.on("data", (chunk) => logs.push(chunk.toString("utf-8")));
+  child.stderr.on("data", (chunk) => logs.push(chunk.toString("utf-8")));
+
+  const port = Number(env.PORT);
+  const baseUrl = `http://127.0.0.1:${port}`;
+  await waitForHealth(baseUrl);
+
+  return {
+    baseUrl,
+    logs,
+    stop: async () => {
+      child.kill("SIGTERM");
+      await new Promise((resolve) => child.on("exit", () => resolve()));
+    }
+  };
+}
+
+function createUpstreamStub(options = {}) {
+  const state = {
+    evaluateMode: options.evaluateMode || "success",
+    evaluatePayload: null,
+    exposurePayload: null
+  };
+
+  const server = http.createServer(async (req, res) => {
+    if (req.method === "POST" && req.url === "/api/feature-control/evaluate") {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      state.evaluatePayload = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+
+      if (state.evaluateMode === "429") {
+        res.writeHead(429, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ code: "FEATURE_CONTROL_RATE_LIMIT", message: "rate" }));
+        return;
+      }
+
+      if (state.evaluateMode === "500") {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ code: "FEATURE_CONTROL_ERROR", message: "boom" }));
+        return;
+      }
+
+      if (state.evaluateMode === "timeout") {
+        await new Promise((resolve) => setTimeout(resolve, 600));
+      }
+
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: false,
+          code: "FEATURE_CONTROL_EVALUATED",
+          result: {
+            evaluatedAt: "2026-04-16T12:00:00.000Z",
+            configVersion: 7,
+            flags: {
+              "fc.checkout_v2": { enabled: true, variant: "on", payload: null, reason: "rollout" },
+              "fc.search_ranking_v3": { enabled: false, variant: "off", payload: null, reason: "default" }
+            }
+          }
+        })
+      );
+      return;
+    }
+
+    if (req.method === "POST" && req.url === "/api/feature-control/telemetry/exposure") {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      state.exposurePayload = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: false, code: "FEATURE_CONTROL_EXPOSURE_TRACKED", result: { accepted: true } }));
+      return;
+    }
+
+    res.writeHead(404).end();
+  });
+
+  return { server, state };
+}
+
+function bootstrapBody() {
+  return {
+    environment: "production",
+    keys: ["fc.checkout_v2", "fc.search_ranking_v3"],
+    context: {
+      subjectType: "customer",
+      subjectId: "cust_123",
+      storeId: "store_001",
+      platform: "ios",
+      appVersion: "2.3.1",
+      attributes: { city: "Campinas" }
+    }
+  };
+}
+
+test("bootstrap sucesso retorna flags simplificadas e raw", async () => {
+  const upstream = createUpstreamStub({ evaluateMode: "success" });
+  const upstreamPort = await listen(upstream.server);
+  const bffPort = upstreamPort + 1000;
+  const bff = await startBff({
+    PORT: String(bffPort),
+    ATOMENTA_ORIGIN: `http://127.0.0.1:${upstreamPort}`,
+    FEATURE_CONTROL_MODULE_TOKEN: "token",
+    FEATURE_CONTROL_TIMEOUT_MS: "300"
+  });
+
+  try {
+    const response = await fetch(`${bff.baseUrl}/feature-control/bootstrap`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(bootstrapBody())
+    });
+    assert.equal(response.status, 200);
+    const json = await response.json();
+    assert.equal(json.ok, true);
+    assert.equal(json.configVersion, 7);
+    assert.equal(json.flags.checkoutV2, true);
+    assert.equal(json.flags.searchRankingV3, "off");
+    assert.ok(json.raw["fc.checkout_v2"]);
+    assert.equal(upstream.state.evaluatePayload.context.subjectId, "cust_123");
+  } finally {
+    await bff.stop();
+    await closeServer(upstream.server);
+  }
+});
+
+test("bootstrap com 429 devolve fallback sem quebrar cliente", async () => {
+  const upstream = createUpstreamStub({ evaluateMode: "429" });
+  const upstreamPort = await listen(upstream.server);
+  const bffPort = upstreamPort + 1000;
+  const bff = await startBff({
+    PORT: String(bffPort),
+    ATOMENTA_ORIGIN: `http://127.0.0.1:${upstreamPort}`,
+    FEATURE_CONTROL_MODULE_TOKEN: "token",
+    FEATURE_CONTROL_DEFAULTS_JSON: JSON.stringify({
+      "fc.checkout_v2": { enabled: false, variant: "off" }
+    })
+  });
+
+  try {
+    const response = await fetch(`${bff.baseUrl}/feature-control/bootstrap`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(bootstrapBody())
+    });
+    assert.equal(response.status, 200);
+    const json = await response.json();
+    assert.equal(json.source, "fallback");
+    assert.equal(json.upstreamError.status, 429);
+    assert.equal(json.flags.checkoutV2, "off");
+  } finally {
+    await bff.stop();
+    await closeServer(upstream.server);
+  }
+});
+
+test("bootstrap com timeout devolve fallback", async () => {
+  const upstream = createUpstreamStub({ evaluateMode: "timeout" });
+  const upstreamPort = await listen(upstream.server);
+  const bffPort = upstreamPort + 1000;
+  const bff = await startBff({
+    PORT: String(bffPort),
+    ATOMENTA_ORIGIN: `http://127.0.0.1:${upstreamPort}`,
+    FEATURE_CONTROL_MODULE_TOKEN: "token",
+    FEATURE_CONTROL_TIMEOUT_MS: "100"
+  });
+
+  try {
+    const response = await fetch(`${bff.baseUrl}/feature-control/bootstrap`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(bootstrapBody())
+    });
+    assert.equal(response.status, 200);
+    const json = await response.json();
+    assert.equal(json.source, "fallback");
+    assert.equal(json.upstreamError.code, "FEATURE_CONTROL_UPSTREAM_TIMEOUT");
+  } finally {
+    await bff.stop();
+    await closeServer(upstream.server);
+  }
+});
+
+test("telemetria de exposure encaminha lote para upstream", async () => {
+  const upstream = createUpstreamStub({ evaluateMode: "success" });
+  const upstreamPort = await listen(upstream.server);
+  const bffPort = upstreamPort + 1000;
+  const bff = await startBff({
+    PORT: String(bffPort),
+    ATOMENTA_ORIGIN: `http://127.0.0.1:${upstreamPort}`,
+    FEATURE_CONTROL_MODULE_TOKEN: "token"
+  });
+
+  try {
+    const response = await fetch(`${bff.baseUrl}/feature-control/telemetry/exposure`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        events: [
+          { featureKey: "fc.checkout_v2", variant: "on", subjectType: "customer", storeId: "store_1" }
+        ]
+      })
+    });
+    assert.equal(response.status, 200);
+    const json = await response.json();
+    assert.equal(json.ok, true);
+    assert.equal(upstream.state.exposurePayload.events[0].featureKey, "fc.checkout_v2");
+  } finally {
+    await bff.stop();
+    await closeServer(upstream.server);
+  }
+});
+
+test("telemetria rejeita payload sem eventos", async () => {
+  const upstream = createUpstreamStub({ evaluateMode: "success" });
+  const upstreamPort = await listen(upstream.server);
+  const bffPort = upstreamPort + 1000;
+  const bff = await startBff({
+    PORT: String(bffPort),
+    ATOMENTA_ORIGIN: `http://127.0.0.1:${upstreamPort}`,
+    FEATURE_CONTROL_MODULE_TOKEN: "token"
+  });
+
+  try {
+    const response = await fetch(`${bff.baseUrl}/feature-control/telemetry/exposure`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ events: [] })
+    });
+    assert.equal(response.status, 400);
+    const json = await response.json();
+    assert.equal(json.ok, false);
+    assert.equal(json.code, "FEATURE_CONTROL_EVENTS_REQUIRED");
+  } finally {
+    await bff.stop();
+    await closeServer(upstream.server);
+  }
+});

From 7f7d414e6cb74ef43ce6e105c6f25d4bc9f70301 Mon Sep 17 00:00:00 2001
From: Daniel Arantes Loverde <daniel@loverde.com.br>
Date: Thu, 16 Apr 2026 14:48:39 -0300
Subject: [PATCH 2/3] feat(app): integrate Atomenta Feature Control bootstrap,
 cache and resume refresh

---
 .../Sources/PediFoods/ContentView.swift       |  80 ++++-
 .../Sources/PediFoods/PediFoodsApp.swift      |   1 +
 .../PediFoods/Services/ApiConfig.swift        |  11 +
 .../Services/FeatureControlService.swift      | 287 ++++++++++++++++++
 .../PediFoods/Services/SessionEvents.swift    |   1 +
 .../Sources/PediFoods/State/AppState.swift    |  54 ++++
 6 files changed, 433 insertions(+), 1 deletion(-)
 create mode 100644 pedi-foods/Sources/PediFoods/Services/FeatureControlService.swift

diff --git a/pedi-foods/Sources/PediFoods/ContentView.swift b/pedi-foods/Sources/PediFoods/ContentView.swift
index fe2173c..5beb618 100644
--- a/pedi-foods/Sources/PediFoods/ContentView.swift
+++ b/pedi-foods/Sources/PediFoods/ContentView.swift
@@ -1,3 +1,4 @@
+import Foundation
 import SwiftUI
 
 struct ContentView: View {
@@ -15,6 +16,7 @@ struct ContentView: View {
     @State private var sessionExpiredObserver: NSObjectProtocol?
     #endif
     @State var cartResetObserver: Any?
+    @State var appResumeObserver: Any?
 #if os(Android)
     @State var snackbarCenter = SnackbarCenter.shared
 #else
@@ -80,14 +82,26 @@ struct ContentView: View {
                 }
             }
         }
+        .onChange(of: appState.profile.id) { _, _ in
+            Task { @MainActor in
+                await refreshFeatureFlags(forceRefresh: true)
+            }
+        }
+        .onChange(of: appState.cart.storeId) { _, _ in
+            Task { @MainActor in
+                await refreshFeatureFlags(forceRefresh: true)
+            }
+        }
         .onAppear {
             attachCartResetObserverIfNeeded()
+            attachAppResumeObserverIfNeeded()
             #if os(iOS)
             attachSessionExpiredObserverIfNeeded()
             #endif
         }
         .onDisappear {
             detachCartResetObserver()
+            detachAppResumeObserver()
             #if os(iOS)
             detachSessionExpiredObserver()
             #endif
@@ -179,6 +193,7 @@ struct ContentView: View {
             // Keep local state when backend refresh fails transiently.
         }
 
+        await refreshFeatureFlags(forceRefresh: false)
         isBootstrappingSession = false
     }
 
@@ -189,7 +204,9 @@ struct ContentView: View {
             object: nil,
             queue: nil
         ) { _ in
-            appState.cart = CartState()
+            Task { @MainActor in
+                appState.cart = CartState()
+            }
         }
     }
 
@@ -199,6 +216,26 @@ struct ContentView: View {
         self.cartResetObserver = nil
     }
 
+    private func attachAppResumeObserverIfNeeded() {
+        guard appResumeObserver == nil else { return }
+        appResumeObserver = NotificationCenter.default.addObserver(
+            forName: .appDidResume,
+            object: nil,
+            queue: nil
+        ) { _ in
+            Task { @MainActor in
+                guard root == .main else { return }
+                await refreshFeatureFlags(forceRefresh: true)
+            }
+        }
+    }
+
+    private func detachAppResumeObserver() {
+        guard let appResumeObserver else { return }
+        NotificationCenter.default.removeObserver(appResumeObserver)
+        self.appResumeObserver = nil
+    }
+
     @MainActor
     private func hydrateAppState(with customer: CustomerProfile) {
         appState.profile.id = customer.id
@@ -206,6 +243,7 @@ struct ContentView: View {
         appState.profile.email = customer.email
         appState.profile.phone = customer.phoneNumber ?? ""
         appState.profile.profilePicture = customer.profilePicture ?? ""
+        appState.favorites.storeIds = Set(customer.favorites ?? [])
         SessionStateStore.setActiveUserKey(
             SessionStateStore.makeUserKey(profileId: customer.id, email: customer.email)
         )
@@ -299,6 +337,46 @@ struct ContentView: View {
         scheduleDisableAuthEntryPreparation()
     }
 
+    @MainActor
+    private func refreshFeatureFlags(forceRefresh: Bool) async {
+        guard root == .main else { return }
+
+        let subjectType: String
+        let subjectId: String
+        if let profileId = appState.profile.id?.trimmingCharacters(in: .whitespacesAndNewlines), profileId.isEmpty == false {
+            subjectType = "customer"
+            subjectId = profileId
+        } else {
+            subjectType = "anonymous"
+            subjectId = "anonymous-device"
+        }
+
+        var attrs: [String: String] = [:]
+        let addressLabel = appState.address.display.trimmingCharacters(in: .whitespacesAndNewlines)
+        if addressLabel.isEmpty == false, addressLabel.lowercased() != "defina seu endereco" {
+            attrs["addressLabel"] = addressLabel
+        }
+
+        let context = FeatureControlEvaluationContext(
+            subjectType: subjectType,
+            subjectId: subjectId,
+            storeId: appState.cart.storeId,
+            attributes: attrs
+        )
+
+        let snapshot = await FeatureControlService.shared.evaluate(
+            context: context,
+            jwt: appState.session.jwt,
+            forceRefresh: forceRefresh
+        )
+        appState.featureFlags = snapshot
+        await FeatureControlService.shared.sendExposureEvents(
+            snapshot: snapshot,
+            context: context,
+            jwt: appState.session.jwt
+        )
+    }
+
     private func scheduleDisableAuthEntryPreparation() {
         Task { @MainActor in
             try? await Task.sleep(nanoseconds: 900_000_000)
diff --git a/pedi-foods/Sources/PediFoods/PediFoodsApp.swift b/pedi-foods/Sources/PediFoods/PediFoodsApp.swift
index 1d672a5..309fc70 100644
--- a/pedi-foods/Sources/PediFoods/PediFoodsApp.swift
+++ b/pedi-foods/Sources/PediFoods/PediFoodsApp.swift
@@ -39,6 +39,7 @@ let logger: Logger = Logger(subsystem: "com.br.pedifoods.app", category: "PediFo
 
     /* SKIP @bridge */public func onResume() {
         logger.debug("onResume")
+        NotificationCenter.default.post(name: .appDidResume, object: nil)
     }
 
     /* SKIP @bridge */public func onPause() {
diff --git a/pedi-foods/Sources/PediFoods/Services/ApiConfig.swift b/pedi-foods/Sources/PediFoods/Services/ApiConfig.swift
index 1fc39db..2c67a63 100644
--- a/pedi-foods/Sources/PediFoods/Services/ApiConfig.swift
+++ b/pedi-foods/Sources/PediFoods/Services/ApiConfig.swift
@@ -14,6 +14,17 @@ enum ApiConfig {
         return URL(string: raw) ?? URL(string: "https://atomenta.com.br")!
     }
 
+    static var featureControlBffURL: URL {
+        let raw = ProcessInfo.processInfo.environment["FEATURE_CONTROL_BFF_URL"] ?? "http://localhost:8787"
+        return URL(string: raw) ?? URL(string: "http://localhost:8787")!
+    }
+
+    static var featureControlEnvironment: String {
+        let raw = ProcessInfo.processInfo.environment["FEATURE_CONTROL_ENVIRONMENT"] ?? "production"
+        let clean = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        return clean.isEmpty ? "production" : clean
+    }
+
     // Tokens provided by backend modules
     static let storeToken = "550e8400-e29b-41d4-a716-446655440008"
     static let customerToken = "550e8400-e29b-41d4-a716-44665544000a"
diff --git a/pedi-foods/Sources/PediFoods/Services/FeatureControlService.swift b/pedi-foods/Sources/PediFoods/Services/FeatureControlService.swift
new file mode 100644
index 0000000..312a157
--- /dev/null
+++ b/pedi-foods/Sources/PediFoods/Services/FeatureControlService.swift
@@ -0,0 +1,287 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+struct FeatureControlRawFlag: Codable, Equatable {
+    let enabled: Bool
+    let variant: String
+    let payload: FeatureControlJSONValue?
+    let reason: String?
+}
+
+enum FeatureControlJSONValue: Codable, Equatable {
+    case string(String)
+    case number(Double)
+    case bool(Bool)
+    case object([String: FeatureControlJSONValue])
+    case array([FeatureControlJSONValue])
+    case null
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if container.decodeNil() {
+            self = .null
+        } else if let value = try? container.decode(Bool.self) {
+            self = .bool(value)
+        } else if let value = try? container.decode(Double.self) {
+            self = .number(value)
+        } else if let value = try? container.decode(String.self) {
+            self = .string(value)
+        } else if let value = try? container.decode([String: FeatureControlJSONValue].self) {
+            self = .object(value)
+        } else if let value = try? container.decode([FeatureControlJSONValue].self) {
+            self = .array(value)
+        } else {
+            self = .null
+        }
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case .string(let value): try container.encode(value)
+        case .number(let value): try container.encode(value)
+        case .bool(let value): try container.encode(value)
+        case .object(let value): try container.encode(value)
+        case .array(let value): try container.encode(value)
+        case .null: try container.encodeNil()
+        }
+    }
+}
+
+private struct FeatureControlBootstrapRequest: Codable {
+    struct Context: Codable {
+        let subjectType: String
+        let subjectId: String
+        let storeId: String?
+        let platform: String
+        let appVersion: String
+        let attributes: [String: String]
+    }
+
+    let environment: String
+    let keys: [String]
+    let context: Context
+}
+
+private struct FeatureControlBootstrapResponse: Codable {
+    let ok: Bool
+    let source: String?
+    let configVersion: Int
+    let evaluatedAt: String?
+    let flags: [String: FeatureFlagValue]
+    let raw: [String: FeatureControlRawFlag]
+}
+
+private struct FeatureControlExposureRequest: Codable {
+    struct Event: Codable {
+        let featureKey: String
+        let variant: String
+        let subjectType: String
+        let storeId: String?
+    }
+
+    let events: [Event]
+}
+
+private struct FeatureControlCacheEntry: Codable {
+    let expiresAtUnixMs: Int64
+    let snapshot: FeatureFlagsState
+}
+
+struct FeatureControlEvaluationContext {
+    let subjectType: String
+    let subjectId: String
+    let storeId: String?
+    let attributes: [String: String]
+}
+
+@MainActor
+final class FeatureControlService {
+    static let shared = FeatureControlService()
+
+    private let session: URLSession
+    private let cacheTTL: TimeInterval
+    private let decoder = JSONDecoder()
+    private let encoder = JSONEncoder()
+    private let userDefaults: UserDefaults
+    private let defaultsPrefix = "feature-control.cache.v1."
+
+    init(
+        session: URLSession = .shared,
+        cacheTTL: TimeInterval = 60,
+        userDefaults: UserDefaults = .standard
+    ) {
+        self.session = session
+        self.cacheTTL = cacheTTL
+        self.userDefaults = userDefaults
+    }
+
+    func evaluate(
+        context: FeatureControlEvaluationContext,
+        jwt: String?,
+        forceRefresh: Bool = false
+    ) async -> FeatureFlagsState {
+        let key = storageKey(for: context)
+        if forceRefresh == false, let cached = loadFromCache(storageKey: key) {
+            return cached
+        }
+
+        let requestBody = FeatureControlBootstrapRequest(
+            environment: ApiConfig.featureControlEnvironment,
+            keys: featureKeys(),
+            context: .init(
+                subjectType: context.subjectType,
+                subjectId: context.subjectId,
+                storeId: context.storeId,
+                platform: platformName(),
+                appVersion: appVersion(),
+                attributes: context.attributes
+            )
+        )
+
+        do {
+            let response = try await performBootstrapRequest(body: requestBody, jwt: jwt)
+            let snapshot = FeatureFlagsState(
+                configVersion: response.configVersion,
+                evaluatedAt: response.evaluatedAt,
+                source: response.source ?? "live",
+                values: response.flags,
+                raw: response.raw
+            )
+            saveToCache(snapshot: snapshot, storageKey: key)
+            return snapshot
+        } catch {
+            if let cached = loadFromCache(storageKey: key) {
+                return FeatureFlagsState(
+                    configVersion: cached.configVersion,
+                    evaluatedAt: cached.evaluatedAt,
+                    source: "cache_fallback",
+                    values: cached.values,
+                    raw: cached.raw
+                )
+            }
+            return FeatureFlagsState(source: "defaults")
+        }
+    }
+
+    func sendExposureEvents(snapshot: FeatureFlagsState, context: FeatureControlEvaluationContext, jwt: String?) async {
+        guard snapshot.raw.isEmpty == false else { return }
+
+        let events = snapshot.raw.compactMap { entry -> FeatureControlExposureRequest.Event? in
+            let key = entry.key
+            let value = entry.value
+            guard value.enabled || value.variant.lowercased() != "off" else { return nil }
+            return .init(
+                featureKey: key,
+                variant: value.variant,
+                subjectType: context.subjectType,
+                storeId: context.storeId
+            )
+        }
+
+        guard events.isEmpty == false else { return }
+
+        let batched = Array(events.prefix(100))
+        let payload = FeatureControlExposureRequest(events: batched)
+        guard let body = try? encoder.encode(payload) else { return }
+
+        var request = URLRequest(url: ApiConfig.featureControlBffURL.appendingPathComponent("/feature-control/telemetry/exposure"))
+        request.httpMethod = "POST"
+        request.httpBody = body
+        request.timeoutInterval = 3
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        if let jwt, jwt.isEmpty == false {
+            request.setValue("Bearer \(jwt)", forHTTPHeaderField: "Authorization")
+        }
+
+        _ = try? await session.data(for: request)
+    }
+
+    private func performBootstrapRequest(body: FeatureControlBootstrapRequest, jwt: String?) async throws -> FeatureControlBootstrapResponse {
+        var request = URLRequest(url: ApiConfig.featureControlBffURL.appendingPathComponent("/feature-control/bootstrap"))
+        request.httpMethod = "POST"
+        request.httpBody = try encoder.encode(body)
+        request.timeoutInterval = 3
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        if let jwt, jwt.isEmpty == false {
+            request.setValue("Bearer \(jwt)", forHTTPHeaderField: "Authorization")
+        }
+
+        let (data, response) = try await session.data(for: request)
+        guard let http = response as? HTTPURLResponse, (200...299).contains(http.statusCode) else {
+            throw NetworkError.invalidResponse
+        }
+
+        return try decoder.decode(FeatureControlBootstrapResponse.self, from: data)
+    }
+
+    private func storageKey(for context: FeatureControlEvaluationContext) -> String {
+        let tokens = [
+            ApiConfig.featureControlEnvironment,
+            context.subjectType,
+            context.subjectId,
+            context.storeId ?? "none",
+            platformName(),
+            appVersion(),
+            featureKeys().joined(separator: "|")
+        ]
+        let base = tokens.joined(separator: "::")
+            .lowercased()
+            .replacingOccurrences(of: " ", with: "_")
+        return defaultsPrefix + base
+    }
+
+    private func saveToCache(snapshot: FeatureFlagsState, storageKey: String) {
+        let expiresAt = Int64((Date().timeIntervalSince1970 + cacheTTL) * 1000)
+        let entry = FeatureControlCacheEntry(expiresAtUnixMs: expiresAt, snapshot: snapshot)
+        guard let data = try? encoder.encode(entry) else { return }
+        userDefaults.set(data, forKey: storageKey)
+    }
+
+    private func loadFromCache(storageKey: String) -> FeatureFlagsState? {
+        guard let data = userDefaults.data(forKey: storageKey),
+              let entry = try? decoder.decode(FeatureControlCacheEntry.self, from: data) else {
+            return nil
+        }
+
+        let now = Int64(Date().timeIntervalSince1970 * 1000)
+        guard entry.expiresAtUnixMs > now else {
+            userDefaults.removeObject(forKey: storageKey)
+            return nil
+        }
+
+        return entry.snapshot
+    }
+
+    private func featureKeys() -> [String] {
+        let raw = ProcessInfo.processInfo.environment["FEATURE_CONTROL_KEYS"] ?? "fc.checkout_v2,fc.search_ranking_v3"
+        let items = raw
+            .split(separator: ",")
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { $0.isEmpty == false }
+        return items.isEmpty ? ["fc.checkout_v2"] : items
+    }
+
+    private func platformName() -> String {
+        #if os(Android)
+        return "android"
+        #else
+        return "ios"
+        #endif
+    }
+
+    private func appVersion() -> String {
+        #if canImport(UIKit) || canImport(AppKit)
+        let version = (Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        if let version, version.isEmpty == false {
+            return version
+        }
+        #endif
+        return "0.0.0"
+    }
+}
diff --git a/pedi-foods/Sources/PediFoods/Services/SessionEvents.swift b/pedi-foods/Sources/PediFoods/Services/SessionEvents.swift
index 4746314..a25cc72 100644
--- a/pedi-foods/Sources/PediFoods/Services/SessionEvents.swift
+++ b/pedi-foods/Sources/PediFoods/Services/SessionEvents.swift
@@ -4,4 +4,5 @@ extension Notification.Name {
     static let sessionExpired = Notification.Name("SessionExpiredNotification")
     static let cartDidReset = Notification.Name("CartDidResetNotification")
     static let orderReviewDidSave = Notification.Name("OrderReviewDidSaveNotification")
+    static let appDidResume = Notification.Name("AppDidResumeNotification")
 }
diff --git a/pedi-foods/Sources/PediFoods/State/AppState.swift b/pedi-foods/Sources/PediFoods/State/AppState.swift
index b48f28b..6788b70 100644
--- a/pedi-foods/Sources/PediFoods/State/AppState.swift
+++ b/pedi-foods/Sources/PediFoods/State/AppState.swift
@@ -6,10 +6,64 @@ struct AppState {
     var cart = CartState()
     var address = AddressState()
     var favorites = FavoritesState()
+    var featureFlags = FeatureFlagsState()
     var homeFilters = HomeFiltersState()
     var activeModal: AppModal? = nil
 }
 
+enum FeatureFlagValue: Codable, Equatable {
+    case boolean(Bool)
+    case text(String)
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let boolValue = try? container.decode(Bool.self) {
+            self = .boolean(boolValue)
+            return
+        }
+        if let stringValue = try? container.decode(String.self) {
+            self = .text(stringValue)
+            return
+        }
+        if let intValue = try? container.decode(Int.self) {
+            self = .text(String(intValue))
+            return
+        }
+        if let doubleValue = try? container.decode(Double.self) {
+            self = .text(String(doubleValue))
+            return
+        }
+        self = .text("off")
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case .boolean(let value):
+            try container.encode(value)
+        case .text(let value):
+            try container.encode(value)
+        }
+    }
+
+    var boolValue: Bool {
+        switch self {
+        case .boolean(let value):
+            return value
+        case .text(let value):
+            return value.lowercased() == "on" || value.lowercased() == "true"
+        }
+    }
+}
+
+struct FeatureFlagsState: Codable, Equatable {
+    var configVersion: Int = 0
+    var evaluatedAt: String? = nil
+    var source: String = "default"
+    var values: [String: FeatureFlagValue] = [:]
+    var raw: [String: FeatureControlRawFlag] = [:]
+}
+
 enum AppModal: String, Identifiable {
     case addressPicker
     case filters

From 0ebb8542135c919ea216df3423be8d049c72a9df Mon Sep 17 00:00:00 2001
From: Daniel Arantes Loverde <daniel@loverde.com.br>
Date: Thu, 16 Apr 2026 14:50:07 -0300
Subject: [PATCH 3/3] updates

---
 API_Mobile_App.md                             | 172 ++++++++++-
 pedi-foods/Android/app/build.gradle.kts       |   4 -
 .../PediFoods.xcodeproj/project.pbxproj       |   2 +-
 pedi-foods/Package.swift                      |   4 +-
 .../PediFoods/Components/StoreCard.swift      |   7 +-
 .../PediFoods/Resources/Localizable.xcstrings |   6 +
 .../Services/ApiFavoriteModels.swift          |   6 +
 .../PediFoods/Services/ApiModels.swift        |   2 +
 .../PediFoods/Services/ApiService.swift       |  51 +++-
 .../Services/StoreCatalogNormalizer.swift     | 280 ++++++++++++++++++
 .../PediFoods/Views/Auth/OtpView.swift        |   2 +
 .../Views/Main/HomeScrollOffsetObserver.swift |  87 ++----
 .../Views/Main/HomeView+Favorites.swift       |  42 +++
 .../PediFoods/Views/Main/HomeView.swift       |  22 +-
 .../Views/Main/StoreDetailSupport.swift       | 141 ++-------
 .../Views/Main/StoreDetailView+Logic.swift    |  79 ++++-
 .../Views/Main/StoreDetailView.swift          |  14 +-
 .../FavoritesDecodingTests.swift              |  49 +++
 .../StoreCatalogNormalizerTests.swift         | 117 ++++++++
 sim-home.png                                  | Bin 0 -> 137541 bytes
 20 files changed, 871 insertions(+), 216 deletions(-)
 create mode 100644 pedi-foods/Sources/PediFoods/Services/ApiFavoriteModels.swift
 create mode 100644 pedi-foods/Sources/PediFoods/Services/StoreCatalogNormalizer.swift
 create mode 100644 pedi-foods/Sources/PediFoods/Views/Main/HomeView+Favorites.swift
 create mode 100644 pedi-foods/Tests/PediFoodsTests/FavoritesDecodingTests.swift
 create mode 100644 pedi-foods/Tests/PediFoodsTests/StoreCatalogNormalizerTests.swift
 create mode 100644 sim-home.png

diff --git a/API_Mobile_App.md b/API_Mobile_App.md
index 3150af2..007a3e5 100644
--- a/API_Mobile_App.md
+++ b/API_Mobile_App.md
@@ -167,6 +167,106 @@ Used when interacting with a specific store (Catalog, Checkout).
 - Se a distância entre `lat_long` enviado e o ponto do CEP for maior que `1.5 km`, a API substitui `lat_long` pelo ponto do CEP cacheado.
 - Objetivo: evitar discrepâncias grandes entre endereço e coordenada salva no perfil.
 
+### 5. List Favorite Stores
+**GET** `/api/customer/favorites`
+
+**Headers:**
+
+- `Authorization: Bearer <JWT_Token>`
+- `Atomenta-Token: 550e8400-e29b-41d4-a716-44665544000a`
+
+**Notes:**
+
+- Retorna as lojas favoritas do customer autenticado.
+- Apenas lojas públicas/visíveis são retornadas.
+- A ordem segue a ordem salva em `favorites`.
+
+**Response:**
+
+```json
+{
+  "error": false,
+  "code": "CUSTOMER_FAVORITES_RETRIEVED",
+  "result": [
+    {
+      "id": "store_1775510226293_yn5ys",
+      "name": "CPS Drinks",
+      "logo": null,
+      "cover": null,
+      "category": "Doces & Bolos",
+      "rating": 4.8,
+      "totalReviews": 12,
+      "isOpen": true,
+      "statusLabel": "Aberto",
+      "nextOpenLabel": null
+    }
+  ]
+}
+```
+
+### 6. Add Store to Favorites
+**POST** `/api/customer/favorites/:storeId`
+
+**Headers:**
+
+- `Authorization: Bearer <JWT_Token>`
+- `Atomenta-Token: 550e8400-e29b-41d4-a716-44665544000a`
+
+**Notes:**
+
+- Salva a loja nos favoritos do customer autenticado.
+- Se a loja já estiver favoritada, a operação continua idempotente.
+- A loja precisa existir e estar publicamente visível.
+
+**Response:**
+
+```json
+{
+  "error": false,
+  "code": "CUSTOMER_FAVORITE_SAVED",
+  "result": {
+    "favorites": ["store_1775510226293_yn5ys"],
+    "store": {
+      "id": "store_1775510226293_yn5ys",
+      "name": "CPS Drinks",
+      "logo": null,
+      "cover": null,
+      "category": "Doces & Bolos",
+      "rating": 4.8,
+      "totalReviews": 12,
+      "isOpen": true,
+      "statusLabel": "Aberto",
+      "nextOpenLabel": null
+    }
+  }
+}
+```
+
+### 7. Remove Store from Favorites
+**DELETE** `/api/customer/favorites/:storeId`
+
+**Headers:**
+
+- `Authorization: Bearer <JWT_Token>`
+- `Atomenta-Token: 550e8400-e29b-41d4-a716-44665544000a`
+
+**Notes:**
+
+- Remove a loja dos favoritos do customer autenticado.
+- A operação é idempotente: se a loja não estiver favoritada, o array volta sem ela.
+
+**Response:**
+
+```json
+{
+  "error": false,
+  "code": "CUSTOMER_FAVORITE_REMOVED",
+  "result": {
+    "favorites": []
+  }
+}
+```
+
 ---
 
 ## 🏠 App Home Screen
@@ -538,19 +638,29 @@ Use este canal para acompanhar mudança de status do pedido em tempo real (sem d
 ```
 
 **Eventos recebidos pelo app:**
-- `order_update`: enviado quando o pedido muda (pagamento aprovado, aceito pela loja, saiu para entrega, concluído, cancelado).
+- `order_update`: alteração geral de status do pedido.
+- `order_cancelled`: cancelamento confirmado, com motivo e metadados de estorno.
+- `delivery_order_cancelled`: evento dedicado para telas de OTP/entrega interromperem o fluxo imediatamente.
 
-**Payload típico de `order_update`:**
+**Payload típico de `order_cancelled`:**
 
 ```json
 {
-  "id": "ord_987...",
-  "shortId": "1234",
-  "storeId": "store_123...",
-  "userId": "cust_uuid...",
-  "status": "CONFIRMED",
-  "paymentStatus": "CONFIRMED",
-  "updatedAt": "2026-02-15T20:10:00.000Z"
+  "event": "order_cancelled",
+  "emittedAt": "2026-03-05T18:00:00.000Z",
+  "orderId": "ffdc47b4-6a55-4713-aea9-45169e4cf0d7",
+  "shortId": "3778",
+  "storeId": "store_1772117366848_wmqw4",
+  "userId": "cust_uuid_001",
+  "status": "CANCELED",
+  "cancelledBy": "store",
+  "cancelledAt": "2026-03-05T18:00:00.000Z",
+  "cancelReasonCode": "STORE_UNAVAILABLE",
+  "cancelReasonDetail": "Falta de insumo crítico para finalizar o pedido",
+  "refundStatus": "failed",
+  "refundIdempotencyKey": "refund:ffdc47b4-...",
+  "refundProviderRef": null,
+  "refundError": "Falha ao solicitar estorno automático"
 }
 ```
 
@@ -566,9 +676,45 @@ Se o socket cair, o app deve continuar consultando o status até estado final.
 - depois: a cada `10s`
 - parar em status final (`COMPLETED`, `CANCELED`, `REFUNDED`) ou ao sair da tela.
 
-### 8. Catálogo Oficial de Tags de Review
+### 8. Cancelamento de Pedido (Loja/Customer)
 
-### 8.1 Matriz Completa de Endpoints (Reviews + Tags)
+**Cancelamento pela loja (Store API):**
+- `POST /api/store/:storeId/orders/:orderId/cancel`
+
+**Cancelamento pelo customer:**
+- `POST /api/customer/orders/:orderId/cancel`
+
+**Request body (ambos):**
+```json
+{
+  "reasonCode": "CUSTOMER_REQUEST",
+  "reasonDetail": "Cliente solicitou cancelamento antes da entrega"
+}
+```
+
+**Motivos aceitos (`reasonCode`):**
+- `STORE_UNAVAILABLE`
+- `CUSTOMER_REQUEST`
+- `DELIVERY_ISSUE`
+
+**Regras atuais de cancelamento:**
+- Permitido em: `PAYMENT_PENDING`, `PENDING`, `ACCEPTED`, `PREPARING`, `READY`, `DELIVERING`.
+- Bloqueado em: `COMPLETED` e `CANCELED`.
+- Motoboy não cancela pedido.
+- Ao cancelar, o backend invalida `otp`, `confirmOtp` e `customerOtp`.
+
+**Concorrência e idempotência (ponta a ponta):**
+- Cancelamento é serializado por `orderId` (lock por pedido).
+- Estorno automático usa lock + chave idempotente de estorno para evitar duplicidade.
+- Em segunda tentativa após cancelamento efetivado, a API retorna `409 ORDER_ALREADY_CANCELED`.
+
+**Campos relevantes no retorno:**
+- `cancelledBy`, `cancelledAt`, `cancelReasonCode`, `cancelReasonDetail`
+- `refundStatus`, `refundIdempotencyKey`, `refundProviderRef`
+
+### 9. Catálogo Oficial de Tags de Review
+
+### 9.1 Matriz Completa de Endpoints (Reviews + Tags)
 
 **Público/App (Customer):**
 - `GET /api/public/reviews/tags` → catálogo oficial de tags e regras de validação.
@@ -630,7 +776,7 @@ O app deve buscar este endpoint para renderizar as tags válidas e enviar soment
 - Não hardcodear tags no app; usar o catálogo do backend.
 - Enviar no POST de review apenas os `id` retornados em cada bloco.
 
-### 9. Enviar Avaliação do Pedido
+### 10. Enviar Avaliação do Pedido
 Permite o customer enviar review da loja a partir de um pedido finalizado.
 
 **Endpoint:**
@@ -749,7 +895,7 @@ Exemplo inválido (entrega positiva com tags negativas):
 
 Retorno esperado: `400 INVALID_DELIVERY_SENTIMENT_TAGS`.
 
-### 10. Analytics de Reviews (Store/API)
+### 11. Analytics de Reviews (Store/API)
 Para dashboard da loja e análise de produto, usar:
 
 - `GET /api/store/:storeId/reviews`
diff --git a/pedi-foods/Android/app/build.gradle.kts b/pedi-foods/Android/app/build.gradle.kts
index 4752bf9..8a591a5 100644
--- a/pedi-foods/Android/app/build.gradle.kts
+++ b/pedi-foods/Android/app/build.gradle.kts
@@ -41,10 +41,6 @@ android {
         // versionName = MARKETING_VERSION
     }
 
-    buildFeatures {
-        buildConfig = true
-    }
-
     lint {
         disable.add("Instantiatable")
         disable.add("MissingPermission")
diff --git a/pedi-foods/Darwin/PediFoods.xcodeproj/project.pbxproj b/pedi-foods/Darwin/PediFoods.xcodeproj/project.pbxproj
index 3edd5e9..57006fe 100644
--- a/pedi-foods/Darwin/PediFoods.xcodeproj/project.pbxproj
+++ b/pedi-foods/Darwin/PediFoods.xcodeproj/project.pbxproj
@@ -300,7 +300,7 @@
 			repositoryURL = "https://git.loverde.com.br/Loverde-Company-LTDA/LCEssentials.git";
 			requirement = {
 				kind = upToNextMajorVersion;
-				minimumVersion = 1.0.5;
+				minimumVersion = 1.0.7;
 			};
 		};
 /* End XCRemoteSwiftPackageReference section */
diff --git a/pedi-foods/Package.swift b/pedi-foods/Package.swift
index 3d1ebe1..888bcd1 100644
--- a/pedi-foods/Package.swift
+++ b/pedi-foods/Package.swift
@@ -10,8 +10,8 @@ let package = Package(
         .library(name: "PediFoods", type: .dynamic, targets: ["PediFoods"]),
     ],
     dependencies: [
-        .package(url: "https://source.skip.tools/skip.git", from: "1.7.0"),
-        .package(url: "https://source.skip.tools/skip-fuse-ui.git", from: "1.0.0"),
+        .package(url: "https://source.skip.tools/skip.git", from: "1.8.4"),
+        .package(path: "Vendor/skip-fuse-ui"),
         .package(url: "https://git.loverde.com.br/Loverde-Company-LTDA/LCEssentials.git", from: "1.0.5")
     ],
     targets: [
diff --git a/pedi-foods/Sources/PediFoods/Components/StoreCard.swift b/pedi-foods/Sources/PediFoods/Components/StoreCard.swift
index 9f7c7ad..26de91f 100644
--- a/pedi-foods/Sources/PediFoods/Components/StoreCard.swift
+++ b/pedi-foods/Sources/PediFoods/Components/StoreCard.swift
@@ -2,6 +2,7 @@ import SwiftUI
 
 struct FeaturedStoreCard: View {
     let store: FeaturedStoreCardModel
+    var onFavoriteToggle: (() -> Void)? = nil
 
     var body: some View {
         VStack(alignment: .leading, spacing: 12) {
@@ -21,7 +22,9 @@ struct FeaturedStoreCard: View {
 
                 HStack {
                     Spacer()
-                    Button(action: {}) {
+                    Button {
+                        onFavoriteToggle?()
+                    } label: {
                         Image(systemName: store.isFavorite ? "heart.fill" : "heart")
                             .foregroundStyle(store.isFavorite ? Color.red : AppColors.textMuted)
                             .padding(8)
@@ -29,6 +32,8 @@ struct FeaturedStoreCard: View {
                             .clipShape(Circle())
                             .shadow(color: AppShadow.soft.color, radius: AppShadow.soft.radius, y: AppShadow.soft.y)
                     }
+                    .buttonStyle(.borderless)
+                    .accessibilityLabel(store.isFavorite ? "Remover loja dos favoritos" : "Adicionar loja aos favoritos")
                     .padding(10)
                 }
             }
diff --git a/pedi-foods/Sources/PediFoods/Resources/Localizable.xcstrings b/pedi-foods/Sources/PediFoods/Resources/Localizable.xcstrings
index 2a72535..b6d87f9 100644
--- a/pedi-foods/Sources/PediFoods/Resources/Localizable.xcstrings
+++ b/pedi-foods/Sources/PediFoods/Resources/Localizable.xcstrings
@@ -153,6 +153,9 @@
     "Adicionar fotos" : {
       "comment" : "A label for adding photos in the order review section.",
       "isCommentAutoGenerated" : true
+    },
+    "Adicionar loja aos favoritos" : {
+
     },
     "Adicionar novo endereço" : {
       "comment" : "A button label that translates to \"Add new address\" in English.",
@@ -932,6 +935,9 @@
     "Remover" : {
       "comment" : "A button that deletes the user's profile picture.",
       "isCommentAutoGenerated" : true
+    },
+    "Remover loja dos favoritos" : {
+
     },
     "Resposta da loja" : {
       "comment" : "A heading for the reply from the store in an order review.",
diff --git a/pedi-foods/Sources/PediFoods/Services/ApiFavoriteModels.swift b/pedi-foods/Sources/PediFoods/Services/ApiFavoriteModels.swift
new file mode 100644
index 0000000..317be1d
--- /dev/null
+++ b/pedi-foods/Sources/PediFoods/Services/ApiFavoriteModels.swift
@@ -0,0 +1,6 @@
+import Foundation
+
+struct CustomerFavoritesMutationResult: Decodable {
+    let favorites: [String]
+    let store: StoreSummary?
+}
diff --git a/pedi-foods/Sources/PediFoods/Services/ApiModels.swift b/pedi-foods/Sources/PediFoods/Services/ApiModels.swift
index 8b54b96..4e207c3 100644
--- a/pedi-foods/Sources/PediFoods/Services/ApiModels.swift
+++ b/pedi-foods/Sources/PediFoods/Services/ApiModels.swift
@@ -21,6 +21,7 @@ struct CustomerProfile: Decodable {
     let email: String
     let phoneNumber: String?
     let profilePicture: String?
+    let favorites: [String]?
     let addressBook: [CustomerAddress]?
 
     enum CodingKeys: String, CodingKey {
@@ -29,6 +30,7 @@ struct CustomerProfile: Decodable {
         case email
         case phoneNumber
         case profilePicture
+        case favorites
         case addressBook = "address_book"
     }
 }
diff --git a/pedi-foods/Sources/PediFoods/Services/ApiService.swift b/pedi-foods/Sources/PediFoods/Services/ApiService.swift
index da0e965..ee295f4 100644
--- a/pedi-foods/Sources/PediFoods/Services/ApiService.swift
+++ b/pedi-foods/Sources/PediFoods/Services/ApiService.swift
@@ -23,6 +23,7 @@ final class ApiService {
     private var tokenStore: TokenStore
     private let profileCachePrefix = "api:profile:"
     private let ordersCachePrefix = "api:orders:"
+    private let favoritesCachePrefix = "api:favorites:"
     private let publicCategoriesCacheKey = "api:public-categories"
 
     init(client: ApiClient = ApiClient(), tokenStore: TokenStore = DefaultTokenStore()) {
@@ -68,10 +69,16 @@ final class ApiService {
         tokenStore.clear()
         AppContentCache.shared.invalidate(prefix: profileCachePrefix)
         AppContentCache.shared.invalidate(prefix: ordersCachePrefix)
+        AppContentCache.shared.invalidate(prefix: favoritesCachePrefix)
         AppContentCache.shared.invalidate(prefix: publicCategoriesCacheKey)
         NotificationCenter.default.post(name: .sessionExpired, object: message)
     }
 
+    private func invalidateFavoritesCache() {
+        AppContentCache.shared.invalidate(prefix: profileCachePrefix)
+        AppContentCache.shared.invalidate(prefix: favoritesCachePrefix)
+    }
+
     private func scopedCacheSuffix() -> String {
         let jwt = tokenStore.jwt ?? "anonymous"
         if jwt.count <= 16 { return jwt }
@@ -168,7 +175,7 @@ final class ApiService {
         if envelope.error == false, envelope.result != nil {
             AppContentCache.shared.set(envelope, for: scopedProfileKey, ttl: AppCacheTTL.twoHours)
         } else {
-            AppContentCache.shared.invalidate(prefix: profileCachePrefix)
+            invalidateFavoritesCache()
         }
         return envelope
     }
@@ -241,11 +248,51 @@ final class ApiService {
         if envelope.error == false, envelope.result != nil {
             AppContentCache.shared.set(envelope, for: scopedProfileKey, ttl: AppCacheTTL.twoHours)
         } else {
-            AppContentCache.shared.invalidate(prefix: profileCachePrefix)
+            invalidateFavoritesCache()
         }
         return envelope
     }
 
+    func listFavoriteStores(forceRefresh: Bool = false) async throws -> ApiEnvelope<[StoreSummary]> {
+        let cacheKey = "\(favoritesCachePrefix)\(scopedCacheSuffix())"
+        if forceRefresh == false,
+           let cached: ApiEnvelope<[StoreSummary]> = AppContentCache.shared.value(for: cacheKey, as: ApiEnvelope<[StoreSummary]>.self) {
+            return cached
+        }
+
+        let req = ApiRequest(path: "/api/customer/favorites", method: "GET", module: .customer, requiresAuth: true)
+        let envelope: ApiEnvelope<[StoreSummary]> = try await sendEnvelope(req)
+        if envelope.error == false, envelope.result != nil {
+            AppContentCache.shared.set(envelope, for: cacheKey, ttl: AppCacheTTL.twoHours)
+        }
+        return envelope
+    }
+
+    func addStoreToFavorites(storeId: String) async throws -> ApiEnvelope<CustomerFavoritesMutationResult> {
+        let req = ApiRequest(path: "/api/customer/favorites/\(storeId)", method: "POST", module: .customer, requiresAuth: true)
+        let envelope: ApiEnvelope<CustomerFavoritesMutationResult> = try await sendEnvelope(req)
+        if envelope.error == false {
+            invalidateFavoritesCache()
+        }
+        return envelope
+    }
+
+    func removeStoreFromFavorites(storeId: String) async throws -> ApiEnvelope<CustomerFavoritesMutationResult> {
+        let req = ApiRequest(path: "/api/customer/favorites/\(storeId)", method: "DELETE", module: .customer, requiresAuth: true)
+        let envelope: ApiEnvelope<CustomerFavoritesMutationResult> = try await sendEnvelope(req)
+        if envelope.error == false {
+            invalidateFavoritesCache()
+        }
+        return envelope
+    }
+
+    func setStoreFavorite(storeId: String, isFavorite: Bool) async throws -> ApiEnvelope<CustomerFavoritesMutationResult> {
+        if isFavorite {
+            return try await addStoreToFavorites(storeId: storeId)
+        }
+        return try await removeStoreFromFavorites(storeId: storeId)
+    }
+
     private func matchesAddress(_ lhs: CustomerAddress, _ rhs: CustomerAddress) -> Bool {
         lhs.label == rhs.label &&
         lhs.address == rhs.address &&
diff --git a/pedi-foods/Sources/PediFoods/Services/StoreCatalogNormalizer.swift b/pedi-foods/Sources/PediFoods/Services/StoreCatalogNormalizer.swift
new file mode 100644
index 0000000..563ee6e
--- /dev/null
+++ b/pedi-foods/Sources/PediFoods/Services/StoreCatalogNormalizer.swift
@@ -0,0 +1,280 @@
+import Foundation
+
+enum StoreCatalogNormalizer {
+    static func sanitize(categories: [StoreCatalogCategory], storeId: String) -> [StoreCatalogCategory] {
+        var seenCategoryIds: Set<String> = []
+
+        return categories.enumerated().map { categoryIndex, category in
+            let categoryId = makeUniqueId(
+                rawValue: category.id,
+                fallback: "\(storeId)-category-\(categoryIndex)",
+                seenIds: &seenCategoryIds
+            )
+
+            let normalizedPizzaConfig = sanitize(
+                pizzaConfig: category.pizzaConfig,
+                categoryId: categoryId
+            )
+
+            var seenProductIds: Set<String> = []
+            let normalizedProducts = category.products.enumerated().map { productIndex, product in
+                sanitize(
+                    product: product,
+                    categoryId: categoryId,
+                    productIndex: productIndex,
+                    seenProductIds: &seenProductIds
+                )
+            }
+
+            return StoreCatalogCategory(
+                id: categoryId,
+                name: category.name,
+                isPizzaCategory: category.isPizzaCategory,
+                pizzaConfig: normalizedPizzaConfig,
+                products: normalizedProducts
+            )
+        }
+    }
+
+    static func preferredCategoryId(
+        from categories: [StoreCatalogCategory],
+        preferredId: String?
+    ) -> String? {
+        guard let preferredId, preferredId.isEmpty == false else {
+            return categories.first?.id
+        }
+
+        if categories.contains(where: { $0.id == preferredId }) {
+            return preferredId
+        }
+
+        return categories.first?.id
+    }
+
+    private static func sanitize(
+        pizzaConfig: StorePizzaConfig?,
+        categoryId: String
+    ) -> StorePizzaConfig? {
+        guard let pizzaConfig else { return nil }
+
+        var seenSizeIds: Set<String> = []
+        let normalizedSizes = pizzaConfig.sizes.enumerated().map { index, size in
+            StorePizzaSize(
+                id: makeUniqueId(
+                    rawValue: size.id,
+                    fallback: "\(categoryId)-size-\(index)",
+                    seenIds: &seenSizeIds
+                ),
+                name: size.name,
+                slices: size.slices,
+                maxFlavors: size.maxFlavors
+            )
+        }
+
+        var seenDoughIds: Set<String> = []
+        let normalizedDoughs = pizzaConfig.doughs.enumerated().map { index, dough in
+            StorePizzaDough(
+                id: makeUniqueId(
+                    rawValue: dough.id,
+                    fallback: "\(categoryId)-dough-\(index)",
+                    seenIds: &seenDoughIds
+                ),
+                name: dough.name,
+                active: dough.active
+            )
+        }
+
+        var seenCrustIds: Set<String> = []
+        let normalizedCrusts = pizzaConfig.crusts.enumerated().map { index, crust in
+            StorePizzaCrust(
+                id: makeUniqueId(
+                    rawValue: crust.id,
+                    fallback: "\(categoryId)-crust-\(index)",
+                    seenIds: &seenCrustIds
+                ),
+                name: crust.name,
+                active: crust.active,
+                priceModifier: crust.priceModifier
+            )
+        }
+
+        return StorePizzaConfig(
+            sizes: normalizedSizes,
+            doughs: normalizedDoughs,
+            crusts: normalizedCrusts
+        )
+    }
+
+    private static func sanitize(
+        product: StoreCatalogProduct,
+        categoryId: String,
+        productIndex: Int,
+        seenProductIds: inout Set<String>
+    ) -> StoreCatalogProduct {
+        let productId = makeUniqueId(
+            rawValue: product.id,
+            fallback: "\(categoryId)-product-\(productIndex)",
+            seenIds: &seenProductIds
+        )
+
+        var seenGroupIds: Set<String> = []
+        var seenAddonItemIds: Set<String> = []
+        let normalizedAddonGroups = product.addonGroups.enumerated().map { groupIndex, group in
+            let groupId = makeUniqueId(
+                rawValue: group.id,
+                fallback: "\(productId)-group-\(groupIndex)",
+                seenIds: &seenGroupIds
+            )
+
+            let normalizedItems = group.items.enumerated().map { itemIndex, item in
+                StoreAddonItem(
+                    id: makeUniqueId(
+                        rawValue: item.id,
+                        fallback: "\(groupId)-item-\(itemIndex)",
+                        seenIds: &seenAddonItemIds
+                    ),
+                    name: item.name,
+                    price: item.price
+                )
+            }
+
+            return StoreAddonGroup(
+                id: groupId,
+                name: group.name,
+                minSelectors: group.minSelectors,
+                maxSelectors: group.maxSelectors,
+                items: normalizedItems
+            )
+        }
+
+        return StoreCatalogProduct(
+            id: productId,
+            type: product.type,
+            name: product.name,
+            description: product.description,
+            image: product.image,
+            price: product.price,
+            originalPrice: product.originalPrice,
+            pizzaPrices: product.pizzaPrices,
+            addonGroups: normalizedAddonGroups
+        )
+    }
+
+    private static func makeUniqueId(
+        rawValue: String,
+        fallback: String,
+        seenIds: inout Set<String>
+    ) -> String {
+        let trimmedRawValue = rawValue.trimmingCharacters(in: .whitespacesAndNewlines)
+        let baseId = trimmedRawValue.isEmpty ? fallback : trimmedRawValue
+
+        if seenIds.contains(baseId) == false {
+            seenIds.insert(baseId)
+            return baseId
+        }
+
+        var suffix = 1
+        while true {
+            let candidate = "\(baseId)-\(suffix)"
+            if seenIds.contains(candidate) == false {
+                seenIds.insert(candidate)
+                return candidate
+            }
+            suffix += 1
+        }
+    }
+}
+
+extension StoreCatalogCategory {
+    init(
+        id: String,
+        name: String,
+        isPizzaCategory: Bool,
+        pizzaConfig: StorePizzaConfig?,
+        products: [StoreCatalogProduct]
+    ) {
+        self.id = id
+        self.name = name
+        self.isPizzaCategory = isPizzaCategory
+        self.pizzaConfig = pizzaConfig
+        self.products = products
+    }
+}
+
+extension StoreCatalogProduct {
+    init(
+        id: String,
+        type: String?,
+        name: String,
+        description: String?,
+        image: String?,
+        price: Double?,
+        originalPrice: Double?,
+        pizzaPrices: [String: Double],
+        addonGroups: [StoreAddonGroup]
+    ) {
+        self.id = id
+        self.type = type
+        self.name = name
+        self.description = description
+        self.image = image
+        self.price = price
+        self.originalPrice = originalPrice
+        self.pizzaPrices = pizzaPrices
+        self.addonGroups = addonGroups
+    }
+}
+
+extension StoreAddonGroup {
+    init(
+        id: String,
+        name: String,
+        minSelectors: Int?,
+        maxSelectors: Int?,
+        items: [StoreAddonItem]
+    ) {
+        self.id = id
+        self.name = name
+        self.minSelectors = minSelectors
+        self.maxSelectors = maxSelectors
+        self.items = items
+    }
+}
+
+extension StoreAddonItem {
+    init(
+        id: String,
+        name: String,
+        price: Double?
+    ) {
+        self.id = id
+        self.name = name
+        self.price = price
+    }
+}
+
+extension StorePizzaConfig {
+    init(
+        sizes: [StorePizzaSize],
+        doughs: [StorePizzaDough],
+        crusts: [StorePizzaCrust]
+    ) {
+        self.sizes = sizes
+        self.doughs = doughs
+        self.crusts = crusts
+    }
+}
+
+extension StorePizzaCrust {
+    init(
+        id: String,
+        name: String?,
+        active: Bool?,
+        priceModifier: Double?
+    ) {
+        self.id = id
+        self.name = name
+        self.active = active
+        self.priceModifier = priceModifier
+    }
+}
diff --git a/pedi-foods/Sources/PediFoods/Views/Auth/OtpView.swift b/pedi-foods/Sources/PediFoods/Views/Auth/OtpView.swift
index 93c4a93..25c8e6c 100644
--- a/pedi-foods/Sources/PediFoods/Views/Auth/OtpView.swift
+++ b/pedi-foods/Sources/PediFoods/Views/Auth/OtpView.swift
@@ -285,6 +285,7 @@ struct OtpView: View {
             appState.profile.email = customer.email
             appState.profile.phone = customer.phoneNumber ?? ""
             appState.profile.profilePicture = customer.profilePicture ?? ""
+            appState.favorites.storeIds = Set(customer.favorites ?? [])
             SessionStateStore.setActiveUserKey(
                 SessionStateStore.makeUserKey(profileId: customer.id, email: customer.email)
             )
@@ -315,6 +316,7 @@ struct OtpView: View {
         }
 
         appState.profile.email = email
+        appState.favorites = FavoritesState()
         SessionStateStore.setActiveUserKey(
             SessionStateStore.makeUserKey(profileId: nil, email: email)
         )
diff --git a/pedi-foods/Sources/PediFoods/Views/Main/HomeScrollOffsetObserver.swift b/pedi-foods/Sources/PediFoods/Views/Main/HomeScrollOffsetObserver.swift
index 4489f2b..c5eef3d 100644
--- a/pedi-foods/Sources/PediFoods/Views/Main/HomeScrollOffsetObserver.swift
+++ b/pedi-foods/Sources/PediFoods/Views/Main/HomeScrollOffsetObserver.swift
@@ -1,76 +1,35 @@
 import SwiftUI
-#if canImport(UIKit)
-import UIKit
-#endif
+
+enum HomeScrollCoordinateSpace {
+    static let name = "home-scroll"
+}
 
 #if os(iOS)
-@MainActor
-struct ScrollOffsetObserver: UIViewRepresentable {
-    let onOffsetChange: (CGFloat) -> Void
+struct HomeScrollOffsetPreferenceKey: PreferenceKey {
+    static let defaultValue: CGFloat = 0
 
-    func makeUIView(context: Context) -> ScrollOffsetProbeView {
-        let view = ScrollOffsetProbeView()
-        view.onOffsetChange = onOffsetChange
-        return view
-    }
-
-    func updateUIView(_ uiView: ScrollOffsetProbeView, context: Context) {
-        uiView.onOffsetChange = onOffsetChange
-        uiView.attachIfNeeded()
+    static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
+        value = nextValue()
     }
 }
 
-@MainActor
-final class ScrollOffsetProbeView: UIView {
-    var onOffsetChange: (CGFloat) -> Void = { _ in }
+struct ScrollOffsetObserver: View {
+    let onOffsetChange: (CGFloat) -> Void
 
-    private weak var observedScrollView: UIScrollView?
-    private var observation: NSKeyValueObservation?
-
-    override init(frame: CGRect) {
-        super.init(frame: frame)
-        backgroundColor = .clear
-        isUserInteractionEnabled = false
-    }
-
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-    }
-
-    deinit {
-        observation?.invalidate()
-    }
-
-    override func didMoveToSuperview() {
-        super.didMoveToSuperview()
-        attachIfNeeded()
-    }
-
-    override func didMoveToWindow() {
-        super.didMoveToWindow()
-        attachIfNeeded()
-    }
-
-    func attachIfNeeded() {
-        guard let scrollView = findEnclosingScrollView() else { return }
-        guard scrollView !== observedScrollView else { return }
-
-        observation?.invalidate()
-        observedScrollView = scrollView
-        observation = scrollView.observe(\.contentOffset, options: [.initial, .new]) { [weak self] sv, _ in
-            self?.onOffsetChange(sv.contentOffset.y)
-        }
-    }
-
-    private func findEnclosingScrollView() -> UIScrollView? {
-        var view: UIView? = self
-        while let current = view {
-            if let scrollView = current as? UIScrollView {
-                return scrollView
+    var body: some View {
+        Color.clear
+            .frame(height: 0)
+            .background(
+                GeometryReader { geometry in
+                    Color.clear.preference(
+                        key: HomeScrollOffsetPreferenceKey.self,
+                        value: geometry.frame(in: .named(HomeScrollCoordinateSpace.name)).minY
+                    )
+                }
+            )
+            .onPreferenceChange(HomeScrollOffsetPreferenceKey.self) { minY in
+                onOffsetChange(-minY)
             }
-            view = current.superview
-        }
-        return nil
     }
 }
 #endif
diff --git a/pedi-foods/Sources/PediFoods/Views/Main/HomeView+Favorites.swift b/pedi-foods/Sources/PediFoods/Views/Main/HomeView+Favorites.swift
new file mode 100644
index 0000000..b5fcc40
--- /dev/null
+++ b/pedi-foods/Sources/PediFoods/Views/Main/HomeView+Favorites.swift
@@ -0,0 +1,42 @@
+import Foundation
+
+extension HomeView {
+    @MainActor
+    func toggleFavoriteStore(storeId: String, storeName: String) async {
+        guard favoriteRequestStoreIds.contains(storeId) == false else { return }
+        guard appState.session.isAuthenticated else {
+            SnackbarCenter.shared.show(title: "Faça login para favoritar lojas.", style: .warning, icon: "person.crop.circle.badge.exclamationmark", duration: 2.5)
+            return
+        }
+
+        let isFavorite = appState.favorites.storeIds.contains(storeId)
+        favoriteRequestStoreIds.insert(storeId)
+        defer { favoriteRequestStoreIds.remove(storeId) }
+
+        do {
+            let response = try await ApiService().setStoreFavorite(storeId: storeId, isFavorite: isFavorite == false)
+            guard response.error == false, let result = response.result else {
+                let message = response.message ?? "Não foi possível atualizar seus favoritos."
+                SnackbarCenter.shared.show(title: message, style: .error, icon: "xmark.octagon.fill", duration: 3.5)
+                return
+            }
+
+            appState.favorites.storeIds = Set(result.favorites)
+            let successTitle = isFavorite
+                ? "\(storeName) removida dos favoritos."
+                : "\(storeName) adicionada aos favoritos."
+            let successIcon = isFavorite ? "heart.slash.fill" : "heart.fill"
+            SnackbarCenter.shared.show(title: successTitle, style: .success, icon: successIcon, duration: 2.2)
+        } catch {
+            let message: String
+            if let networkError = error as? NetworkError {
+                message = networkError.errorDescription ?? "Não foi possível atualizar seus favoritos."
+            } else if let serviceError = error as? ApiServiceError {
+                message = serviceError.errorDescription ?? "Não foi possível atualizar seus favoritos."
+            } else {
+                message = "Não foi possível atualizar seus favoritos."
+            }
+            SnackbarCenter.shared.show(title: message, style: .error, icon: "xmark.octagon.fill", duration: 3.5)
+        }
+    }
+}
diff --git a/pedi-foods/Sources/PediFoods/Views/Main/HomeView.swift b/pedi-foods/Sources/PediFoods/Views/Main/HomeView.swift
index f2d28fd..2474a1d 100644
--- a/pedi-foods/Sources/PediFoods/Views/Main/HomeView.swift
+++ b/pedi-foods/Sources/PediFoods/Views/Main/HomeView.swift
@@ -19,6 +19,7 @@ struct HomeView: View {
     @State var stores: [StoreSummary] = []
     @State var productSearchIndexByStoreId: [String: [String]] = [:]
     @State var searchDebounceToken = 0
+    @State var favoriteRequestStoreIds: Set<String> = []
 
     private let specials: [SpecialOfferCardModel] = [
 //        .init(id: "ddddd", title: "Get 50% OFF", subtitle: "For your first order", colors: [Color(hex: "#1E6B43"), Color(hex: "#58A56C")]),
@@ -47,7 +48,7 @@ struct HomeView: View {
                     refreshCategories: true
                 )
             }
-            .background(scrollOffsetObserver)
+            .coordinateSpace(name: HomeScrollCoordinateSpace.name)
 
             header(collapseProgress: collapseProgress, height: headerHeight)
                 .frame(maxWidth: .infinity, alignment: .top)
@@ -84,6 +85,7 @@ struct HomeView: View {
 
     private var contentStack: some View {
         VStack(spacing: 24) {
+            scrollOffsetObserver
             categoriesSection
 
             section(title: "Featured") {
@@ -102,7 +104,14 @@ struct HomeView: View {
                                     appState: $appState
                                 )
                             } label: {
-                                FeaturedStoreCard(store: store)
+                                FeaturedStoreCard(
+                                    store: store,
+                                    onFavoriteToggle: {
+                                        Task {
+                                            await toggleFavoriteStore(storeId: store.id, storeName: store.name)
+                                        }
+                                    }
+                                )
                                     .frame(width: 190)
                             }
                             .buttonStyle(.plain)
@@ -171,7 +180,14 @@ struct HomeView: View {
                                     appState: $appState
                                 )
                             } label: {
-                                FeaturedStoreCard(store: store)
+                                FeaturedStoreCard(
+                                    store: store,
+                                    onFavoriteToggle: {
+                                        Task {
+                                            await toggleFavoriteStore(storeId: store.id, storeName: store.name)
+                                        }
+                                    }
+                                )
                             }
                             .buttonStyle(.plain)
                         }
diff --git a/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailSupport.swift b/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailSupport.swift
index ba3b30c..1ba5e28 100644
--- a/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailSupport.swift
+++ b/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailSupport.swift
@@ -1,7 +1,4 @@
 import SwiftUI
-#if canImport(UIKit)
-import UIKit
-#endif
 
 struct CategoryHeaderOffsetPreferenceKey: PreferenceKey {
     static let defaultValue: [String: CGFloat] = [:]
@@ -11,125 +8,41 @@ struct CategoryHeaderOffsetPreferenceKey: PreferenceKey {
     }
 }
 
+enum StoreDetailScrollCoordinateSpace {
+    static let name = "store-detail-scroll"
+}
+
+struct ScrollOffsetPreferenceKey: PreferenceKey {
+    static let defaultValue: CGFloat = 0
+
+    static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
+        value = nextValue()
+    }
+}
+
 struct ScrollOffsetReader: View {
     @Binding var offsetY: CGFloat
 
     var body: some View {
-#if canImport(UIKit)
-        ScrollOffsetReaderRepresentable(offsetY: $offsetY)
-#else
         Color.clear
-#endif
+            .frame(height: 0)
+            .background(
+                GeometryReader { geometry in
+                    Color.clear.preference(
+                        key: ScrollOffsetPreferenceKey.self,
+                        value: geometry.frame(in: .named(StoreDetailScrollCoordinateSpace.name)).minY
+                    )
+                }
+            )
+            .onPreferenceChange(ScrollOffsetPreferenceKey.self) { minY in
+                let normalizedOffset = max(0, -minY)
+                if abs(offsetY - normalizedOffset) > 0.5 {
+                    offsetY = normalizedOffset
+                }
+            }
     }
 }
 
-#if canImport(UIKit)
-struct ScrollOffsetReaderRepresentable: UIViewRepresentable {
-    @Binding var offsetY: CGFloat
-
-    func makeUIView(context: Context) -> OffsetProbeView {
-        let view = OffsetProbeView()
-        view.onOffsetChanged = { value in
-            if offsetY != value {
-                offsetY = value
-            }
-        }
-        return view
-    }
-
-    func updateUIView(_ uiView: OffsetProbeView, context: Context) {
-        uiView.onOffsetChanged = { value in
-            if offsetY != value {
-                offsetY = value
-            }
-        }
-    }
-}
-
-final class OffsetProbeView: UIView {
-    var onOffsetChanged: ((CGFloat) -> Void)?
-    private var observation: NSKeyValueObservation?
-    private weak var observedScrollView: UIScrollView?
-
-    override func didMoveToWindow() {
-        super.didMoveToWindow()
-        attachIfNeeded()
-    }
-
-    override func didMoveToSuperview() {
-        super.didMoveToSuperview()
-        attachIfNeeded()
-    }
-
-    private func attachIfNeeded() {
-        guard observation == nil else { return }
-        guard observedScrollView == nil else { return }
-
-        if let scrollView = enclosingScrollView() ?? findScrollViewInWindow() {
-            observe(scrollView)
-            return
-        }
-
-        retryAttach()
-    }
-
-    private func observe(_ scrollView: UIScrollView) {
-        observedScrollView = scrollView
-        observation = scrollView.observe(\.contentOffset, options: [.new, .initial]) { [weak self, weak scrollView] _, change in
-            guard let self, let scrollView, let y = change.newValue?.y else { return }
-            let adjusted = max(0, y + scrollView.adjustedContentInset.top)
-            DispatchQueue.main.async {
-                self.onOffsetChanged?(adjusted)
-            }
-        }
-    }
-
-    private func retryAttach() {
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
-            self?.attachIfNeeded()
-        }
-    }
-
-    private func enclosingScrollView() -> UIScrollView? {
-        var current: UIView? = self
-        while let view = current {
-            if let scrollView = view as? UIScrollView {
-                return scrollView
-            }
-            current = view.superview
-        }
-        return nil
-    }
-
-    private func findScrollViewInWindow() -> UIScrollView? {
-        guard let window else { return nil }
-        let targetPoint = convert(CGPoint(x: bounds.midX, y: bounds.midY), to: window)
-        return findScrollView(in: window, containing: targetPoint)
-    }
-
-    private func findScrollView(in root: UIView, containing point: CGPoint) -> UIScrollView? {
-        for subview in root.subviews.reversed() {
-            if let match = findScrollView(in: subview, containing: point) {
-                return match
-            }
-        }
-
-        if let scrollView = root as? UIScrollView {
-            let rectInWindow = scrollView.convert(scrollView.bounds, to: window)
-            if rectInWindow.contains(point) {
-                return scrollView
-            }
-        }
-
-        return nil
-    }
-
-    deinit {
-        observation?.invalidate()
-    }
-}
-#endif
-
 struct AsyncStoreImage: View {
     let imageURL: String?
 
diff --git a/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailView+Logic.swift b/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailView+Logic.swift
index f510296..b0dba94 100644
--- a/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailView+Logic.swift
+++ b/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailView+Logic.swift
@@ -1,11 +1,15 @@
 import SwiftUI
 
 extension StoreDetailView {
-    func heroIconButton(icon: String, action: @escaping () -> Void) -> some View {
+    func heroIconButton(
+        icon: String,
+        foregroundStyle: Color = .white,
+        action: @escaping () -> Void
+    ) -> some View {
         Button(action: action) {
             Image(systemName: icon)
                 .font(.system(size: 14, weight: .semibold))
-                .foregroundStyle(Color.white)
+                .foregroundStyle(foregroundStyle)
                 .frame(width: 32, height: 32)
                 .background(Color.white.opacity(0.24))
                 .clipShape(Circle())
@@ -65,6 +69,49 @@ extension StoreDetailView {
         info?.isOpen ?? true
     }
 
+    var isFavoriteStore: Bool {
+        appState.favorites.storeIds.contains(storeId)
+    }
+
+    @MainActor
+    func toggleFavoriteStore() async {
+        guard isFavoriteRequestInFlight == false else { return }
+        guard appState.session.isAuthenticated else {
+            SnackbarCenter.shared.show(title: "Faça login para favoritar lojas.", style: .warning, icon: "person.crop.circle.badge.exclamationmark", duration: 2.5)
+            return
+        }
+
+        let isFavorite = isFavoriteStore
+        isFavoriteRequestInFlight = true
+        defer { isFavoriteRequestInFlight = false }
+
+        do {
+            let response = try await ApiService().setStoreFavorite(storeId: storeId, isFavorite: isFavorite == false)
+            guard response.error == false, let result = response.result else {
+                let message = response.message ?? "Não foi possível atualizar seus favoritos."
+                SnackbarCenter.shared.show(title: message, style: .error, icon: "xmark.octagon.fill", duration: 3.5)
+                return
+            }
+
+            appState.favorites.storeIds = Set(result.favorites)
+            let successTitle = isFavorite
+                ? "\(storeName) removida dos favoritos."
+                : "\(storeName) adicionada aos favoritos."
+            let successIcon = isFavorite ? "heart.slash.fill" : "heart.fill"
+            SnackbarCenter.shared.show(title: successTitle, style: .success, icon: successIcon, duration: 2.2)
+        } catch {
+            let message: String
+            if let networkError = error as? NetworkError {
+                message = networkError.errorDescription ?? "Não foi possível atualizar seus favoritos."
+            } else if let serviceError = error as? ApiServiceError {
+                message = serviceError.errorDescription ?? "Não foi possível atualizar seus favoritos."
+            } else {
+                message = "Não foi possível atualizar seus favoritos."
+            }
+            SnackbarCenter.shared.show(title: message, style: .error, icon: "xmark.octagon.fill", duration: 3.5)
+        }
+    }
+
     var summaryCardHeight: CGFloat {
         summaryCardBaseHeight + (isStoreOpen ? 0 : closedBannerHeight)
     }
@@ -97,9 +144,13 @@ extension StoreDetailView {
         if forceRefresh == false,
            let cachedInfo: StoreInfoResult = AppContentCache.shared.value(for: infoCacheKey, as: StoreInfoResult.self),
            let cachedCatalog: [StoreCatalogCategory] = AppContentCache.shared.value(for: catalogCacheKey, as: [StoreCatalogCategory].self) {
+            let normalizedCatalog = StoreCatalogNormalizer.sanitize(categories: cachedCatalog, storeId: storeId)
             info = cachedInfo
-            categories = cachedCatalog
-            selectedCategoryId = cachedCatalog.first?.id
+            categories = normalizedCatalog
+            selectedCategoryId = StoreCatalogNormalizer.preferredCategoryId(
+                from: normalizedCatalog,
+                preferredId: selectedCategoryId
+            )
             isLoading = false
             return
         }
@@ -110,9 +161,9 @@ extension StoreDetailView {
         }
 
         do {
-            async let infoRequest = ApiService().storeInfo(storeId: storeId)
-            async let catalogRequest = ApiService().storeCatalog(storeId: storeId)
-            let (infoResponse, catalogResponse) = try await (infoRequest, catalogRequest)
+            let apiService = ApiService()
+            let infoResponse = try await apiService.storeInfo(storeId: storeId)
+            let catalogResponse = try await apiService.storeCatalog(storeId: storeId)
 
             if infoResponse.error {
                 errorMessage = infoResponse.message ?? "Não foi possível carregar a loja."
@@ -125,13 +176,21 @@ extension StoreDetailView {
                 return
             }
 
+            let normalizedCatalog = StoreCatalogNormalizer.sanitize(
+                categories: catalogResponse.result ?? [],
+                storeId: storeId
+            )
+
             info = infoResponse.result
-            categories = catalogResponse.result ?? []
-            selectedCategoryId = categories.first?.id
+            categories = normalizedCatalog
+            selectedCategoryId = StoreCatalogNormalizer.preferredCategoryId(
+                from: normalizedCatalog,
+                preferredId: selectedCategoryId
+            )
             if let info = infoResponse.result {
                 AppContentCache.shared.set(info, for: infoCacheKey, ttl: AppCacheTTL.twoHours)
             }
-            AppContentCache.shared.set(categories, for: catalogCacheKey, ttl: AppCacheTTL.twoHours)
+            AppContentCache.shared.set(normalizedCatalog, for: catalogCacheKey, ttl: AppCacheTTL.twoHours)
             isLoading = false
         } catch {
             isLoading = false
diff --git a/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailView.swift b/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailView.swift
index 4834975..df42bbb 100644
--- a/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailView.swift
+++ b/pedi-foods/Sources/PediFoods/Views/Main/StoreDetailView.swift
@@ -34,6 +34,7 @@ struct StoreDetailView: View {
     @State var categoryHeaderOffsets: [String: CGFloat] = [:]
     @State var isProgrammaticCategoryScroll = false
     @State var scrollOffsetY: CGFloat = 0
+    @State var isFavoriteRequestInFlight = false
 
     let cardTopInset: CGFloat = 168
     let summaryCardBaseHeight: CGFloat = 170
@@ -52,6 +53,7 @@ struct StoreDetailView: View {
                     ScrollView(showsIndicators: false) {
 #if os(Android)
                         LazyVStack(spacing: 0) {
+                            ScrollOffsetReader(offsetY: $scrollOffsetY)
                             topSection
 
                             categoryTabs(proxy: proxy, safeTop: safeTop, isSticky: false)
@@ -60,6 +62,7 @@ struct StoreDetailView: View {
                         }
 #else
                         LazyVStack(spacing: 0, pinnedViews: [.sectionHeaders]) {
+                            ScrollOffsetReader(offsetY: $scrollOffsetY)
                             topSection
 
                             categoryTabs(proxy: proxy, safeTop: safeTop, isSticky: false)
@@ -71,8 +74,8 @@ struct StoreDetailView: View {
                     .refreshable {
                         await loadStoreData(forceRefresh: true)
                     }
+                    .coordinateSpace(name: StoreDetailScrollCoordinateSpace.name)
                     .ignoresSafeArea(edges: .top)
-                    .background(ScrollOffsetReader(offsetY: $scrollOffsetY))
                 }
                 .ignoresSafeArea(edges: .top)
                 .overlay(alignment: .top) {
@@ -218,7 +221,14 @@ struct StoreDetailView: View {
                     }
                     Spacer()
                     heroIconButton(icon: "magnifyingglass") {}
-                    heroIconButton(icon: "heart") {}
+                    heroIconButton(
+                        icon: isFavoriteStore ? "heart.fill" : "heart",
+                        foregroundStyle: isFavoriteStore ? Color.red : Color.white
+                    ) {
+                        Task {
+                            await toggleFavoriteStore()
+                        }
+                    }
                 }
                 .padding(.horizontal, 14)
                 .padding(.top, UIDevice.topNotch)
diff --git a/pedi-foods/Tests/PediFoodsTests/FavoritesDecodingTests.swift b/pedi-foods/Tests/PediFoodsTests/FavoritesDecodingTests.swift
new file mode 100644
index 0000000..d91e743
--- /dev/null
+++ b/pedi-foods/Tests/PediFoodsTests/FavoritesDecodingTests.swift
@@ -0,0 +1,49 @@
+import Foundation
+import Testing
+@testable import PediFoods
+
+@Test("Customer profile decodes persisted favorite store ids")
+func customerProfileDecodesFavoriteStoreIds() throws {
+    let json = """
+    {
+      "error": false,
+      "result": {
+        "id": "cust_1",
+        "name": "Daniel",
+        "email": "daniel@example.com",
+        "phoneNumber": "+5511999999999",
+        "favorites": ["store_a", "store_b"],
+        "address_book": []
+      }
+    }
+    """
+
+    let envelope = try JSONDecoder().decode(ApiEnvelope<CustomerProfile>.self, from: Data(json.utf8))
+    #expect(envelope.result?.favorites == ["store_a", "store_b"])
+}
+
+@Test("Favorite mutation decodes updated favorites array")
+func favoriteMutationDecodesUpdatedFavoritesArray() throws {
+    let json = """
+    {
+      "error": false,
+      "result": {
+        "favorites": ["store_a"],
+        "store": {
+          "id": "store_a",
+          "name": "CPS Drinks",
+          "category": "Doces & Bolos",
+          "rating": 4.8,
+          "totalReviews": 12,
+          "isOpen": true,
+          "statusLabel": "Aberto"
+        }
+      }
+    }
+    """
+
+    let envelope = try JSONDecoder().decode(ApiEnvelope<CustomerFavoritesMutationResult>.self, from: Data(json.utf8))
+    #expect(envelope.result?.favorites == ["store_a"])
+    #expect(envelope.result?.store?.id == "store_a")
+    #expect(envelope.result?.store?.name == "CPS Drinks")
+}
diff --git a/pedi-foods/Tests/PediFoodsTests/StoreCatalogNormalizerTests.swift b/pedi-foods/Tests/PediFoodsTests/StoreCatalogNormalizerTests.swift
new file mode 100644
index 0000000..cc85638
--- /dev/null
+++ b/pedi-foods/Tests/PediFoodsTests/StoreCatalogNormalizerTests.swift
@@ -0,0 +1,117 @@
+import Testing
+@testable import PediFoods
+
+@Test("Store catalog normalizer makes IDs non-empty and unique")
+func storeCatalogNormalizerMakesIdsUnique() {
+    let catalog = [
+        StoreCatalogCategory(
+            id: "",
+            name: "Pizzas",
+            isPizzaCategory: true,
+            pizzaConfig: StorePizzaConfig(
+                sizes: [
+                    StorePizzaSize(id: "", name: "Grande", slices: 8, maxFlavors: 2),
+                    StorePizzaSize(id: "", name: "Familia", slices: 12, maxFlavors: 3)
+                ],
+                doughs: [
+                    StorePizzaDough(id: "massa", name: "Tradicional", active: true),
+                    StorePizzaDough(id: "massa", name: "Fina", active: true)
+                ],
+                crusts: [
+                    StorePizzaCrust(id: "", name: "Cheddar", active: true, priceModifier: 5),
+                    StorePizzaCrust(id: "", name: "Catupiry", active: true, priceModifier: 6)
+                ]
+            ),
+            products: [
+                StoreCatalogProduct(
+                    id: "",
+                    type: "pizza",
+                    name: "Calabresa",
+                    description: nil,
+                    image: nil,
+                    price: 10,
+                    originalPrice: nil,
+                    pizzaPrices: [:],
+                    addonGroups: [
+                        StoreAddonGroup(
+                            id: "",
+                            name: "Extras",
+                            minSelectors: nil,
+                            maxSelectors: nil,
+                            items: [
+                                StoreAddonItem(id: "", name: "Bacon", price: 2),
+                                StoreAddonItem(id: "", name: "Bacon em dobro", price: 4)
+                            ]
+                        ),
+                        StoreAddonGroup(
+                            id: "",
+                            name: "Molhos",
+                            minSelectors: nil,
+                            maxSelectors: nil,
+                            items: [
+                                StoreAddonItem(id: "", name: "Alho", price: 1)
+                            ]
+                        )
+                    ]
+                ),
+                StoreCatalogProduct(
+                    id: "",
+                    type: "pizza",
+                    name: "Mussarela",
+                    description: nil,
+                    image: nil,
+                    price: 12,
+                    originalPrice: nil,
+                    pizzaPrices: [:],
+                    addonGroups: []
+                )
+            ]
+        ),
+        StoreCatalogCategory(
+            id: "",
+            name: "Bebidas",
+            isPizzaCategory: false,
+            pizzaConfig: nil,
+            products: [
+                StoreCatalogProduct(
+                    id: "",
+                    type: nil,
+                    name: "Refrigerante",
+                    description: nil,
+                    image: nil,
+                    price: 7,
+                    originalPrice: nil,
+                    pizzaPrices: [:],
+                    addonGroups: []
+                )
+            ]
+        )
+    ]
+
+    let normalized = StoreCatalogNormalizer.sanitize(categories: catalog, storeId: "store-1")
+
+    let categoryIds = normalized.map(\.id)
+    #expect(Set(categoryIds).count == categoryIds.count)
+    #expect(categoryIds.allSatisfy { $0.isEmpty == false })
+
+    let firstCategory = normalized[0]
+    let productIds = firstCategory.products.map(\.id)
+    #expect(Set(productIds).count == productIds.count)
+    #expect(productIds.allSatisfy { $0.isEmpty == false })
+
+    let addonGroupIds = firstCategory.products[0].addonGroups.map(\.id)
+    #expect(Set(addonGroupIds).count == addonGroupIds.count)
+    #expect(addonGroupIds.allSatisfy { $0.isEmpty == false })
+
+    let addonItemIds = firstCategory.products[0].addonGroups.flatMap(\.items).map(\.id)
+    #expect(Set(addonItemIds).count == addonItemIds.count)
+    #expect(addonItemIds.allSatisfy { $0.isEmpty == false })
+
+    let sizeIds = firstCategory.pizzaConfig?.sizes.map(\.id) ?? []
+    let doughIds = firstCategory.pizzaConfig?.doughs.map(\.id) ?? []
+    let crustIds = firstCategory.pizzaConfig?.crusts.map(\.id) ?? []
+
+    #expect(Set(sizeIds).count == sizeIds.count)
+    #expect(Set(doughIds).count == doughIds.count)
+    #expect(Set(crustIds).count == crustIds.count)
+}
diff --git a/sim-home.png b/sim-home.png
new file mode 100644
index 0000000000000000000000000000000000000000..742d33ff2fbb96e918f3d46b5447f6b21a4b8fd4
GIT binary patch
literal 137541
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

literal 0
HcmV?d00001