@fayz-ai/admin 0.43.4 → 0.44.1

package/dist/{chunk-KP3LNCNP.js → chunk-V2IBAF4O.js}

@@ -1,14 +1,15 @@
-import { markWorkspaceSwitch, clearOrgSnapshot, useTenant, useTenantOptional, setAutoPick } from './chunk-3C5Q4OGJ.js';
-import { persistOrgId, cn, getPersistedOrgId } from './chunk-QOS6UAQ4.js';
+import { usePermissionsStore } from './chunk-UQ2NTFQC.js';
+import { persistOrgId, cn, useOrganizationStore, getPersistedOrgId } from './chunk-QOS6UAQ4.js';
 import { createClient } from '@supabase/supabase-js';
-import { EMPTY_APP_CONFIG, getActiveUnitId, getActiveTenantId, setGlobalSupabaseClient, useTranslation, getSupabaseClientOptional as getSupabaseClientOptional$1 } from '@fayz-ai/core';
+import { EMPTY_APP_CONFIG, resetActiveUnit, setUnitMode, setActiveUnitId, setScopedResources, getSupabaseClientOptional, isKnownMissing, rememberIfMissing, getActiveUnitId, getActiveTenantId, setGlobalSupabaseClient, useTranslation, isImpersonating, errorMessage, emitDomainEvent, setHouseCurrency } from '@fayz-ai/core';
 import { createDedupedFetch } from '@fayz-ai/sdk';
-import * as React2 from 'react';
+import * as React3 from 'react';
 import { useState, useEffect } from 'react';
 import { Building2, Check, ShieldCheck } from 'lucide-react';
 import { create } from 'zustand';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { cn as cn$1, Checkbox, Button } from '@fayz-ai/ui';
+import { useAuthStore, readAppHandoff } from '@fayz-ai/auth';
 
 var _client = null;
 function requestUrl(input) {
@@ -981,6 +982,61 @@ function createMockOrgAdapter(defaultProfiles) {
     }
   };
 }
+
+// src/org/choice.ts
+var AUTOPICK_KEY = "fayz:workspace-autopick";
+var SWITCHING_KEY = "fayz:workspace-switching";
+function markWorkspaceSwitch(orgId) {
+  try {
+    if (typeof sessionStorage === "undefined") return;
+    sessionStorage.setItem(SWITCHING_KEY, orgId);
+  } catch {
+  }
+}
+function takeWorkspaceSwitch() {
+  try {
+    if (typeof sessionStorage === "undefined") return null;
+    const v = sessionStorage.getItem(SWITCHING_KEY);
+    if (v) sessionStorage.removeItem(SWITCHING_KEY);
+    return v;
+  } catch {
+    return null;
+  }
+}
+function getAutoPick() {
+  try {
+    if (typeof localStorage === "undefined") return false;
+    return localStorage.getItem(AUTOPICK_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+function setAutoPick(on) {
+  try {
+    if (typeof localStorage === "undefined") return;
+    if (on) localStorage.setItem(AUTOPICK_KEY, "1");
+    else localStorage.removeItem(AUTOPICK_KEY);
+  } catch {
+  }
+}
+function decideWorkspaceChoice({
+  memberships,
+  switchingToId = null,
+  handoffId,
+  pinnedId,
+  autoPick
+}) {
+  if (memberships.length === 0) return { kind: "none" };
+  const has = (id) => id && memberships.some((m) => m.orgId === id) ? id : null;
+  const switching = has(switchingToId);
+  if (switching) return { kind: "resolved", orgId: switching };
+  const handoff = has(handoffId);
+  if (handoff) return { kind: "resolved", orgId: handoff };
+  if (memberships.length === 1) return { kind: "resolved", orgId: memberships[0].orgId };
+  const pinned = has(pinnedId);
+  if (pinned && autoPick) return { kind: "resolved", orgId: pinned };
+  return { kind: "ask", suggestedId: pinned };
+}
 var initialState = {
   config: EMPTY_APP_CONFIG,
   tenantId: null,
@@ -1023,9 +1079,9 @@ function OrgMark({ name, logoUrl, className, tone = "sidebar", current = false }
   const identity = useAppConfigStore((state) => state.config.branding?.identity);
   const pick = (key) => typeof identity?.[key] === "string" ? identity[key] : void 0;
   const src = (current ? pick("markUrl") : void 0) ?? logoUrl;
-  const [status, setStatus] = React2.useState("loading");
-  const imgRef = React2.useRef(null);
-  React2.useLayoutEffect(() => {
+  const [status, setStatus] = React3.useState("loading");
+  const imgRef = React3.useRef(null);
+  React3.useLayoutEffect(() => {
     const el = imgRef.current;
     setStatus(el?.complete ? el.naturalWidth > 0 ? "ok" : "error" : "loading");
   }, [src]);
@@ -1075,6 +1131,881 @@ function OrgMark({ name, logoUrl, className, tone = "sidebar", current = false }
     }
   );
 }
+var UNIT_BOOTSTRAP_OBJECT = "rpc:unit_bootstrap";
+var UNIT_MODE_OBJECT = "tenants.unit_scoping_enabled";
+var SCOPED_RESOURCES_OBJECT = "scoped_resources";
+var UNIT_ACCESS_CHANGED = "core.unit-access.changed";
+function emitUnitAccessChanged(userId, unitId) {
+  emitDomainEvent(
+    UNIT_ACCESS_CHANGED,
+    { user_id: userId, unit_id: unitId },
+    { tenantId: getActiveTenantId() ?? null, subject: { type: "location", id: unitId } }
+  );
+}
+function client() {
+  return getSupabaseClientOptional();
+}
+function mapUnit(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    kind: row.kind ?? "branch",
+    name: row.name,
+    email: row.email ?? void 0,
+    phone: row.phone ?? void 0,
+    address: row.address ?? void 0,
+    city: row.city ?? void 0,
+    state: row.state ?? void 0,
+    country: row.country ?? "BR",
+    postalCode: row.postal_code ?? void 0,
+    isHeadquarters: Boolean(row.is_headquarters),
+    isActive: row.is_active !== false,
+    tags: row.tags ?? [],
+    notes: row.notes ?? void 0,
+    metadata: row.metadata ?? {},
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    parentId: row.parent_id ?? null,
+    code: row.code ?? null,
+    // numeric do Postgres chega como string no PostgREST; a aritmética de
+    // distância precisa de número, e `Number(null)` é 0, que é uma coordenada
+    // real no golfo da Guiné.
+    latitude: row.latitude == null ? null : Number(row.latitude),
+    longitude: row.longitude == null ? null : Number(row.longitude)
+  };
+}
+async function fetchUnits(tenantId) {
+  const db = client();
+  if (!db) return [];
+  const { data, error } = await db.from("v_units").select("*").eq("tenant_id", tenantId).order("is_headquarters", { ascending: false }).order("name");
+  if (error) return [];
+  return (data ?? []).map(mapUnit);
+}
+async function fetchMyBindings(userId, tenantId) {
+  const db = client();
+  if (!db) return [];
+  const { data, error } = await db.from("v_unit_members").select("location_id, role").eq("user_id", userId).eq("tenant_id", tenantId);
+  if (error) return [];
+  return (data ?? []).map((r) => ({ locationId: r.location_id, role: r.role ?? null }));
+}
+async function fetchUnitBootstrap(tenantId, deviceId) {
+  const db = client();
+  if (!db) return null;
+  if (isKnownMissing(UNIT_BOOTSTRAP_OBJECT)) return null;
+  const { data, error } = await db.rpc("unit_bootstrap", {
+    p_tenant_id: tenantId,
+    p_device_id: deviceId ?? null
+  });
+  if (error) {
+    rememberIfMissing(UNIT_BOOTSTRAP_OBJECT, error);
+    return null;
+  }
+  if (!data) return null;
+  const raw = data;
+  return {
+    mode: Boolean(raw.mode),
+    units: (raw.units ?? []).map(mapUnit),
+    bindings: (raw.bindings ?? []).map((r) => ({
+      locationId: r.location_id,
+      role: r.role ?? null
+    })),
+    scoped: Object.fromEntries(
+      Object.entries(raw.scoped ?? {}).map(([table, v]) => [
+        table,
+        { unitColumn: v?.unit_column ?? "unit_id", shareable: v?.shareable !== false }
+      ])
+    ),
+    // user_unit_ids_in walks the tree with UNION over (id, depth): a branch
+    // reached directly AND through its HQ comes back twice.
+    reachable: Array.isArray(raw.reachable) ? [...new Set(raw.reachable)] : void 0,
+    devicePin: { set: Boolean(raw.device_pin_set), unitId: raw.device_pin ?? null },
+    accountPin: { set: Boolean(raw.account_pin_set), unitId: raw.account_pin ?? null }
+  };
+}
+async function saveEntryUnit(tenantId, unitId, deviceId) {
+  const db = client();
+  if (!db || !deviceId) return;
+  await db.rpc("set_entry_unit", {
+    p_tenant_id: tenantId,
+    p_unit_id: unitId ?? null,
+    p_device_id: deviceId
+  });
+}
+async function fetchUnitMembers(unitId) {
+  const db = client();
+  if (!db) return [];
+  const { data, error } = await db.from("v_unit_members").select("id, user_id, role, created_at").eq("location_id", unitId).order("created_at");
+  if (error) return [];
+  return (data ?? []).map((r) => ({
+    id: r.id,
+    userId: r.user_id,
+    role: r.role ?? null,
+    since: r.created_at ?? null
+  }));
+}
+async function fetchMemberActivity(tenantId) {
+  const db = client();
+  if (!db) return {};
+  const { data, error } = await db.rpc("tenant_member_activity", { p_tenant_id: tenantId });
+  if (error) return {};
+  const out = {};
+  for (const r of data ?? []) {
+    out[r.user_id] = {
+      lastSignInAt: r.last_sign_in_at ?? null,
+      signedUpAt: r.signed_up_at ?? null
+    };
+  }
+  return out;
+}
+async function fetchMemberUnits(userId, tenantId) {
+  const tenant = tenantId ?? getActiveTenantId();
+  if (!tenant) return [];
+  return fetchMyBindings(userId, tenant);
+}
+async function bindUserToUnit(unitId, userId, role) {
+  const db = client();
+  if (!db) throw new Error("sem conex\xE3o");
+  const { error } = await db.rpc("unit_member_set", { p_unit: unitId, p_user: userId, p_role: role });
+  if (error) throw error;
+  emitUnitAccessChanged(userId, unitId);
+}
+async function unbindUserFromUnit(unitId, userId) {
+  const db = client();
+  if (!db) throw new Error("sem conex\xE3o");
+  const { error } = await db.rpc("unit_member_remove", { p_unit: unitId, p_user: userId });
+  if (error) throw error;
+  emitUnitAccessChanged(userId, unitId);
+}
+async function fetchUserIdForPerson(personId) {
+  const db = client();
+  if (!db) return null;
+  const { data, error } = await db.from("v_team_members").select("user_id").eq("person_id", personId).maybeSingle();
+  if (error || !data) return null;
+  return data.user_id ?? null;
+}
+async function fetchScopedResources() {
+  const db = client();
+  if (!db) return {};
+  if (isKnownMissing(SCOPED_RESOURCES_OBJECT)) return {};
+  const { data, error } = await db.from("scoped_resources").select("resource_table, unit_column, shareable");
+  if (error) {
+    rememberIfMissing(SCOPED_RESOURCES_OBJECT, error);
+    return {};
+  }
+  const out = {};
+  for (const r of data ?? []) {
+    out[r.resource_table] = {
+      unitColumn: r.unit_column ?? "unit_id",
+      shareable: r.shareable !== false
+    };
+  }
+  return out;
+}
+async function fetchUnitMode(tenantId) {
+  const db = client();
+  if (!db) return { installed: false, on: false };
+  if (isKnownMissing(UNIT_MODE_OBJECT)) return { installed: false, on: false };
+  const { data, error } = await db.from("tenants").select("unit_scoping_enabled").eq("id", tenantId).maybeSingle();
+  if (error) {
+    rememberIfMissing(UNIT_MODE_OBJECT, error);
+    return { installed: false, on: false };
+  }
+  return { installed: true, on: Boolean(data?.unit_scoping_enabled) };
+}
+async function setUnitModeRemote(tenantId, on) {
+  const db = client();
+  if (!db) throw new Error("sem conex\xE3o");
+  const { error } = await db.from("tenants").update({ unit_scoping_enabled: on }).eq("id", tenantId);
+  if (error) throw error;
+}
+async function bindAllMembersTo(tenantId, unitId) {
+  const db = client();
+  if (!db) return 0;
+  const { data } = await db.from("v_team_members").select("user_id").eq("tenant_id", tenantId);
+  const userIds = (data ?? []).map((m) => m.user_id);
+  if (userIds.length === 0) return 0;
+  for (const userId of userIds) {
+    const { error } = await db.rpc("unit_member_set", { p_unit: unitId, p_user: userId, p_role: null });
+    if (error) throw error;
+  }
+  emitUnitAccessChanged(null, unitId);
+  return userIds.length;
+}
+async function countUnboundMembers(tenantId) {
+  const db = client();
+  if (!db) return 0;
+  const { data: members } = await db.from("v_team_members").select("user_id").eq("tenant_id", tenantId);
+  const { data: units } = await db.from("v_units").select("id").eq("tenant_id", tenantId);
+  const unitIds = (units ?? []).map((u) => u.id);
+  if (unitIds.length === 0) return (members ?? []).length;
+  const { data: bound } = await db.from("v_unit_members").select("user_id").in("location_id", unitIds);
+  const boundSet = new Set((bound ?? []).map((b) => b.user_id));
+  return (members ?? []).filter((m) => !boundSet.has(m.user_id)).length;
+}
+
+// src/units/cache.ts
+var STORAGE_KEY2 = "fayz:units-snapshot";
+var VERSION = 1;
+var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var MAX_BYTES = 256 * 1024;
+function storage() {
+  try {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage;
+  } catch {
+    return null;
+  }
+}
+function readUnitSnapshot() {
+  const store = storage();
+  if (!store) return null;
+  try {
+    const raw = store.getItem(STORAGE_KEY2);
+    if (!raw) return null;
+    const snapshot = JSON.parse(raw);
+    if (snapshot?.version !== VERSION || !snapshot.tenantId || !snapshot.userId) return null;
+    const age = Date.now() - snapshot.savedAt;
+    if (age < 0 || age > MAX_AGE_MS) {
+      store.removeItem(STORAGE_KEY2);
+      return null;
+    }
+    return snapshot;
+  } catch {
+    return null;
+  }
+}
+function saveUnitSnapshot(input) {
+  const store = storage();
+  if (!store) return;
+  try {
+    const raw = JSON.stringify({ ...input, version: VERSION, savedAt: Date.now() });
+    if (raw.length > MAX_BYTES) return;
+    store.setItem(STORAGE_KEY2, raw);
+  } catch {
+  }
+}
+function patchUnitSnapshotActive(activeUnitId) {
+  const store = storage();
+  const current = readUnitSnapshot();
+  if (!store || !current) return;
+  try {
+    store.setItem(STORAGE_KEY2, JSON.stringify({ ...current, activeUnitId }));
+  } catch {
+  }
+}
+function clearUnitSnapshot() {
+  try {
+    storage()?.removeItem(STORAGE_KEY2);
+  } catch {
+  }
+}
+
+// src/units/device.ts
+var STORAGE_KEY3 = "fayz:device-id";
+var cached = null;
+function randomId() {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+  } catch {
+  }
+  return `d-${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function getDeviceId() {
+  if (cached) return cached;
+  try {
+    if (typeof localStorage === "undefined") return void 0;
+    const existing = localStorage.getItem(STORAGE_KEY3);
+    if (existing) {
+      cached = existing;
+      return existing;
+    }
+    const fresh = randomId();
+    localStorage.setItem(STORAGE_KEY3, fresh);
+    cached = fresh;
+    return fresh;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lib/dedup.ts
+var inflight = /* @__PURE__ */ new Map();
+function dedup2(key, fn) {
+  const existing = inflight.get(key);
+  if (existing) return existing;
+  const promise = fn().finally(() => {
+    inflight.delete(key);
+  });
+  inflight.set(key, promise);
+  return promise;
+}
+
+// src/units/entry.ts
+function resolveEntry(reachable, pins) {
+  const canStand = (id) => id != null && reachable.includes(id);
+  const ladder = [
+    [pins.device, "device"],
+    [pins.account, "account"]
+  ];
+  for (const [pin, reason] of ladder) {
+    if (!pin?.set) continue;
+    if (pin.unitId === null) return { unitId: void 0, reason: "all", needsChoice: false };
+    if (canStand(pin.unitId)) return { unitId: pin.unitId, reason, needsChoice: false };
+  }
+  if (canStand(pins.legacy)) return { unitId: pins.legacy, reason: "device", needsChoice: false };
+  if (reachable.length === 1) return { unitId: reachable[0], reason: "only", needsChoice: false };
+  return { unitId: void 0, reason: "all", needsChoice: reachable.length > 1 };
+}
+
+// src/units/store.ts
+var LEGACY_KEY = "saas-core:current-location";
+function legacyPin() {
+  try {
+    return localStorage.getItem(LEGACY_KEY) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildTree(units) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const u of units) nodes.set(u.id, { ...u, children: [] });
+  const roots = [];
+  for (const node of nodes.values()) {
+    const parent = node.parentId ? nodes.get(node.parentId) : void 0;
+    if (parent && parent.id !== node.id) parent.children.push(node);
+    else roots.push(node);
+  }
+  return roots;
+}
+function expandDown(units, seeds) {
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const u of units) {
+    if (!u.parentId) continue;
+    const list = childrenOf.get(u.parentId) ?? [];
+    list.push(u.id);
+    childrenOf.set(u.parentId, list);
+  }
+  const out = /* @__PURE__ */ new Set();
+  const queue = [...seeds];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (out.has(id)) continue;
+    out.add(id);
+    for (const child of childrenOf.get(id) ?? []) queue.push(child);
+  }
+  return [...out];
+}
+function branchesOnly(ids, byId) {
+  return ids.filter((id) => byId[id]?.kind !== "region");
+}
+var useUnitStore = create((set, get) => ({
+  units: [],
+  byId: {},
+  tree: [],
+  myUnitIds: [],
+  myBindings: [],
+  activeUnitId: void 0,
+  entryReason: "all",
+  unitMode: false,
+  loading: false,
+  resolved: false,
+  needsChoice: false,
+  loadedFor: null,
+  // Uma chamada por conta, por mais telas que peçam.
+  //
+  // Dez componentes chamam `useUnitBootstrap` — o seletor, a linha de
+  // identidade, o rodapé do registro, a aba de unidades de uma pessoa — e todos
+  // montam no mesmo quadro. A guarda anterior era `loadedFor === tenantId &&
+  // !loading`, que deixa passar exatamente enquanto a primeira chamada está no
+  // ar: o segundo componente via a conta já marcada, via `loading` ligado, e a
+  // condição inteira dava falso. Resultado: uma requisição por tela, todas
+  // idênticas. Juntar cinco viagens numa e depois disparar essa uma cinco vezes
+  // não economiza nada.
+  //
+  // `dedup` é o mesmo utilitário que a tela de equipe já usa: quem chegar
+  // enquanto a primeira está no ar recebe a MESMA promessa em vez de abrir
+  // outra.
+  async load(tenantId, userId) {
+    if (!tenantId) return;
+    if (get().loadedFor === tenantId && !get().loading) return;
+    return dedup2(`units:${tenantId}:${userId ?? ""}`, () => loadOnce(tenantId, userId, set, get));
+  },
+  setActive(unitId, reason = "manual") {
+    setActiveUnitId(unitId);
+    set({ activeUnitId: unitId, entryReason: reason, needsChoice: false });
+    patchUnitSnapshotActive(unitId ?? null);
+    const tenantId = get().loadedFor;
+    if (tenantId) void saveEntryUnit(tenantId, unitId, getDeviceId());
+  },
+  setMode(on) {
+    setUnitMode(on);
+    set({ unitMode: on });
+    if (!on) {
+      setActiveUnitId(void 0);
+      set({ activeUnitId: void 0, entryReason: "all", needsChoice: false });
+      patchUnitSnapshotActive(null);
+    }
+  },
+  reset() {
+    clearUnitSnapshot();
+    resetActiveUnit();
+    set({
+      units: [],
+      byId: {},
+      tree: [],
+      myUnitIds: [],
+      myBindings: [],
+      activeUnitId: void 0,
+      entryReason: "all",
+      unitMode: false,
+      loading: false,
+      resolved: false,
+      needsChoice: false,
+      loadedFor: null
+    });
+  }
+}));
+async function loadOnce(tenantId, userId, set, get) {
+  set({ loading: true, loadedFor: tenantId });
+  try {
+    const deviceId = getDeviceId();
+    const boot = await fetchUnitBootstrap(tenantId, deviceId);
+    let mode;
+    let units;
+    let bindings;
+    let scoped;
+    let reachableFromServer;
+    if (boot) {
+      ;
+      [mode, units, bindings, scoped] = [boot.mode, boot.units, boot.bindings, boot.scoped];
+      reachableFromServer = boot.reachable;
+    } else {
+      const modeResult = await fetchUnitMode(tenantId);
+      mode = modeResult.on;
+      if (!modeResult.installed) {
+        units = [];
+        bindings = [];
+        scoped = {};
+      } else {
+        ;
+        [units, bindings, scoped] = await Promise.all([
+          fetchUnits(tenantId),
+          userId ? fetchMyBindings(userId, tenantId) : Promise.resolve([]),
+          mode ? fetchScopedResources() : Promise.resolve({})
+        ]);
+      }
+    }
+    setScopedResources(scoped);
+    const byId = {};
+    for (const u of units) byId[u.id] = u;
+    const reachable = reachableFromServer ? branchesOnly(reachableFromServer.filter((id) => byId[id]), byId) : branchesOnly(expandDown(units, bindings.map((b) => b.locationId)), byId);
+    const entry = resolveEntry(reachable, {
+      device: boot?.devicePin,
+      account: boot?.accountPin,
+      legacy: legacyPin()
+    });
+    setUnitMode(mode);
+    setActiveUnitId(entry.unitId);
+    set({
+      units,
+      byId,
+      tree: buildTree(units),
+      myUnitIds: reachable,
+      myBindings: bindings,
+      unitMode: mode,
+      activeUnitId: entry.unitId,
+      entryReason: entry.reason,
+      needsChoice: entry.needsChoice,
+      loading: false,
+      resolved: true
+    });
+    if (userId) {
+      saveUnitSnapshot({
+        userId,
+        tenantId,
+        mode,
+        units,
+        bindings,
+        myUnitIds: reachable,
+        activeUnitId: entry.unitId ?? null,
+        scoped
+      });
+    }
+  } finally {
+    if (get().loading) set({ loading: false });
+  }
+}
+(function hydrate() {
+  const snapshot = readUnitSnapshot();
+  if (!snapshot) return;
+  const org = readOrgSnapshot();
+  if (!org || org.org?.id !== snapshot.tenantId || org.userId !== snapshot.userId) {
+    clearUnitSnapshot();
+    return;
+  }
+  const byId = {};
+  for (const u of snapshot.units) byId[u.id] = u;
+  const active = snapshot.activeUnitId ?? void 0;
+  const standable = active && snapshot.myUnitIds.includes(active) ? active : void 0;
+  setScopedResources(snapshot.scoped);
+  setUnitMode(snapshot.mode);
+  setActiveUnitId(standable);
+  useUnitStore.setState({
+    units: snapshot.units,
+    byId,
+    tree: buildTree(snapshot.units),
+    myUnitIds: snapshot.myUnitIds,
+    myBindings: snapshot.bindings,
+    unitMode: snapshot.mode,
+    activeUnitId: standable,
+    entryReason: standable ? "device" : "all",
+    resolved: true
+  });
+})();
+
+// src/units/useHouseCurrencySync.ts
+function useHouseCurrencySync(orgId, tenantCurrency) {
+  const activeUnitId = useUnitStore((s) => s.activeUnitId);
+  React3.useEffect(() => {
+    if (!orgId) {
+      setHouseCurrency(null);
+      return;
+    }
+    setHouseCurrency(tenantCurrency ?? null);
+    if (!activeUnitId) return;
+    let alive = true;
+    void unitCurrency(orgId, activeUnitId).then((code) => {
+      if (alive && code) setHouseCurrency(code);
+    });
+    return () => {
+      alive = false;
+    };
+  }, [orgId, activeUnitId, tenantCurrency]);
+}
+var unitCurrencyCache = /* @__PURE__ */ new Map();
+function unitCurrency(orgId, unitId) {
+  const key = `${orgId}:${unitId}`;
+  let pending = unitCurrencyCache.get(key);
+  if (!pending) {
+    const client2 = getSupabaseClientOptional();
+    pending = client2 ? Promise.resolve(client2.rpc("my_unit_currency", { p_unit: unitId })).then((res) => res.error || typeof res.data !== "string" ? null : res.data).catch(() => null) : Promise.resolve(null);
+    unitCurrencyCache.set(key, pending);
+  }
+  return pending;
+}
+
+// src/org/cache.ts
+var STORAGE_KEY4 = "fayz:org-snapshot";
+var VERSION2 = 1;
+var ORG_CACHE_TTL_MS = 5 * 60 * 1e3;
+var MAX_AGE_MS2 = 24 * 60 * 60 * 1e3;
+var MAX_BYTES2 = 512 * 1024;
+function storage2() {
+  try {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage;
+  } catch {
+    return null;
+  }
+}
+function readOrgSnapshot() {
+  const store = storage2();
+  if (!store) return null;
+  try {
+    const raw = store.getItem(STORAGE_KEY4);
+    if (!raw) return null;
+    const snapshot = JSON.parse(raw);
+    if (snapshot?.version !== VERSION2 || !snapshot.org?.id || !snapshot.userId) return null;
+    if (snapshotAge(snapshot) > MAX_AGE_MS2) {
+      store.removeItem(STORAGE_KEY4);
+      return null;
+    }
+    return snapshot;
+  } catch {
+    return null;
+  }
+}
+function snapshotAge(snapshot) {
+  const age = Date.now() - snapshot.savedAt;
+  return age < 0 ? Number.POSITIVE_INFINITY : age;
+}
+function isSnapshotFresh(snapshot, ttlMs) {
+  return snapshotAge(snapshot) < ttlMs;
+}
+function saveOrgSnapshot(input) {
+  write({ ...input, version: VERSION2, savedAt: Date.now() });
+}
+function patchOrgSnapshot(input) {
+  const current = readOrgSnapshot();
+  if (!current || current.userId !== input.userId) return;
+  write({ ...input, version: VERSION2, savedAt: current.savedAt });
+}
+function clearOrgSnapshot() {
+  try {
+    storage2()?.removeItem(STORAGE_KEY4);
+  } catch {
+  }
+}
+function write(snapshot) {
+  const store = storage2();
+  if (!store) return;
+  try {
+    const raw = JSON.stringify(snapshot);
+    if (raw.length > MAX_BYTES2) return;
+    store.setItem(STORAGE_KEY4, raw);
+  } catch {
+  }
+}
+var OrgAdapterContext = React3.createContext(null);
+function useOrgAdapter() {
+  const adapter = React3.useContext(OrgAdapterContext);
+  if (!adapter) {
+    throw new Error("useOrgAdapter must be used within an <OrgProvider>");
+  }
+  return adapter;
+}
+function useOrgAdapterOptional() {
+  return React3.useContext(OrgAdapterContext);
+}
+var TenantContext = React3.createContext(null);
+function useTenant() {
+  const ctx = React3.useContext(TenantContext);
+  if (!ctx) {
+    throw new Error("useTenant must be used inside <OrgProvider>");
+  }
+  return ctx;
+}
+function useTenantOptional() {
+  return React3.useContext(TenantContext);
+}
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React3.useLayoutEffect : React3.useEffect;
+function OrgProvider({
+  adapter,
+  autoCreate = false,
+  cacheTtlMs = ORG_CACHE_TTL_MS,
+  children
+}) {
+  const { user, isLoading: authLoading } = useAuthStore();
+  const { currentOrg, userOrgs, loading, setCurrentOrg, paintCurrentOrg, setUserOrgs, setMembers, setLoading, reset } = useOrganizationStore();
+  const setProfiles = usePermissionsStore((s) => s.setProfiles);
+  const setCurrentProfile = usePermissionsStore((s) => s.setCurrentProfile);
+  const setProfileKnownFor = usePermissionsStore((s) => s.setProfileKnownFor);
+  const adapterRef = React3.useRef(adapter);
+  adapterRef.current = adapter;
+  const [snapshot] = React3.useState(
+    () => cacheTtlMs > 0 ? readOrgSnapshot() : null
+  );
+  const loadedForRef = React3.useRef(null);
+  const [settledFor, setSettledFor] = React3.useState(
+    () => snapshot?.org ? snapshot.userId : null
+  );
+  const [orgsReadFor, setOrgsReadFor] = React3.useState(
+    () => snapshot?.org ? snapshot.userId : null
+  );
+  const [loadError, setLoadError] = React3.useState(null);
+  const [retryTick, setRetryTick] = React3.useState(0);
+  const retryOrgs = React3.useCallback(() => {
+    loadedForRef.current = null;
+    setLoadError(null);
+    setRetryTick((n) => n + 1);
+  }, []);
+  const settled = user ? settledFor === user.id : !authLoading;
+  const orgsKnown = !!user && orgsReadFor === user.id;
+  useIsomorphicLayoutEffect(() => {
+    if (!snapshot) return;
+    setUserOrgs(snapshot.userOrgs);
+    paintCurrentOrg(snapshot.org);
+    setMembers(snapshot.members);
+    setProfiles(snapshot.profiles);
+    setCurrentProfile(snapshot.profiles.find((p) => p.id === snapshot.currentProfileId) ?? null);
+    setProfileKnownFor(snapshot.org.id);
+  }, []);
+  React3.useEffect(() => {
+    if (cacheTtlMs <= 0 || !user) return;
+    const uid = user.id;
+    const sync = () => {
+      const org = useOrganizationStore.getState();
+      if (!org.currentOrg) return;
+      const perms = usePermissionsStore.getState();
+      patchOrgSnapshot({
+        userId: uid,
+        org: org.currentOrg,
+        userOrgs: org.userOrgs,
+        members: org.members,
+        profiles: perms.profiles,
+        // realProfile, not currentProfile: an impersonation preview is not
+        // something to cache back as the user's own role.
+        currentProfileId: perms.realProfile?.id ?? null
+      });
+    };
+    const unsubscribeOrg = useOrganizationStore.subscribe(sync);
+    const unsubscribePerms = usePermissionsStore.subscribe(sync);
+    return () => {
+      unsubscribeOrg();
+      unsubscribePerms();
+    };
+  }, [user?.id, cacheTtlMs]);
+  const hydrateOrg = React3.useCallback(
+    async (org, memberships, uid) => {
+      try {
+        const [members, profiles] = await Promise.all([
+          adapterRef.current.listMembers(org.id),
+          adapterRef.current.listProfiles(org.id)
+        ]);
+        setMembers(members);
+        setProfiles(profiles);
+        const myMembership = uid ? members.find((m) => m.userId === uid) : void 0;
+        const profile = profiles.find((p) => p.id === myMembership?.profileId) ?? null;
+        setCurrentProfile(profile);
+        if (cacheTtlMs > 0 && uid) {
+          saveOrgSnapshot({
+            userId: uid,
+            org,
+            userOrgs: memberships,
+            members,
+            profiles,
+            currentProfileId: profile?.id ?? null
+          });
+        }
+      } catch {
+      } finally {
+        setProfileKnownFor(org.id);
+      }
+    },
+    [setMembers, setProfiles, setCurrentProfile, setProfileKnownFor, cacheTtlMs]
+  );
+  React3.useEffect(() => {
+    if (!user) {
+      if (authLoading) return;
+      loadedForRef.current = null;
+      reset();
+      clearOrgSnapshot();
+      setSettledFor(null);
+      setOrgsReadFor(null);
+      return;
+    }
+    const cached2 = snapshot?.userId === user.id ? snapshot : null;
+    if (cached2 && isSnapshotFresh(cached2, cacheTtlMs)) {
+      setSettledFor(user.id);
+      setOrgsReadFor(user.id);
+      return;
+    }
+    if (snapshot && snapshot.userId !== user.id && loadedForRef.current === null) {
+      reset();
+      clearOrgSnapshot();
+    }
+    if (loadedForRef.current === user.id) return;
+    loadedForRef.current = user.id;
+    const silent = !!cached2;
+    let cancelled = false;
+    async function loadOrgs() {
+      if (!silent) setLoading(true);
+      try {
+        let accepted = 0;
+        try {
+          if (!isImpersonating()) accepted = await adapterRef.current.acceptPendingInvites?.() ?? 0;
+        } catch {
+        }
+        if (cancelled) return;
+        let memberships = await adapterRef.current.listUserOrgs(user.id);
+        if (memberships.length === 0 && accepted > 0) {
+          memberships = await adapterRef.current.listUserOrgs(user.id);
+        }
+        for (let attempt = 0; memberships.length === 0 && attempt < 2; attempt++) {
+          await new Promise((resolve) => setTimeout(resolve, 250 * (attempt + 1)));
+          if (cancelled) return;
+          memberships = await adapterRef.current.listUserOrgs(user.id);
+        }
+        if (cancelled) return;
+        setUserOrgs(memberships);
+        setOrgsReadFor(user.id);
+        if (memberships.length === 0 && accepted === 0 && autoCreate) {
+          const newOrg = await adapterRef.current.createOrg(
+            user.fullName ? `${user.fullName}'s Organization` : "My Organization",
+            user.id
+          );
+          if (!cancelled) {
+            const ownMembership = [
+              {
+                orgId: newOrg.id,
+                orgName: newOrg.name,
+                orgSlug: newOrg.slug,
+                profileId: "owner",
+                profileName: "Owner"
+              }
+            ];
+            setUserOrgs(ownMembership);
+            setCurrentOrg(newOrg);
+            await hydrateOrg(newOrg, ownMembership, user.id);
+          }
+          return;
+        }
+        const choice = decideWorkspaceChoice({
+          memberships,
+          // Consumed here, and only here: this is the one boot the marker was
+          // written for, and leaving it behind would pin the next one too.
+          switchingToId: takeWorkspaceSwitch(),
+          handoffId: readAppHandoff()?.tenantId ?? null,
+          pinnedId: getPersistedOrgId(),
+          autoPick: getAutoPick()
+        });
+        if (choice.kind !== "resolved") return;
+        if (!cancelled) {
+          const org = await adapterRef.current.getOrg(choice.orgId);
+          if (!cancelled) {
+            setCurrentOrg(org);
+            await hydrateOrg(org, memberships, user.id);
+          }
+        }
+      } catch (err) {
+        if (!cancelled) setLoadError(errorMessage(err));
+      } finally {
+        if (!cancelled && !silent) setLoading(false);
+        if (!cancelled) setSettledFor(user.id);
+      }
+    }
+    void loadOrgs();
+    return () => {
+      cancelled = true;
+    };
+  }, [user?.id, authLoading, retryTick]);
+  async function switchOrg(orgId) {
+    setLoading(true);
+    try {
+      const org = await adapterRef.current.getOrg(orgId);
+      setCurrentOrg(org);
+      await hydrateOrg(org, useOrganizationStore.getState().userOrgs, user?.id);
+    } finally {
+      setLoading(false);
+    }
+  }
+  async function refreshOrg() {
+    if (!currentOrg) return;
+    setLoading(true);
+    try {
+      const org = await adapterRef.current.getOrg(currentOrg.id);
+      setCurrentOrg(org);
+      await hydrateOrg(org, useOrganizationStore.getState().userOrgs, user?.id);
+    } finally {
+      setLoading(false);
+    }
+  }
+  useHouseCurrencySync(currentOrg?.id, currentOrg?.settings?.currency);
+  const tenantValue = {
+    org: currentOrg,
+    userOrgs,
+    loading,
+    settled,
+    orgsKnown,
+    loadError,
+    retryOrgs,
+    switchOrg,
+    refreshOrg
+  };
+  return /* @__PURE__ */ jsx(OrgAdapterContext.Provider, { value: adapter, children: /* @__PURE__ */ jsx(TenantContext.Provider, { value: tenantValue, children }) });
+}
 
 // src/org/workspace-search.ts
 var WORKSPACE_SEARCH_THRESHOLD = 8;
@@ -1104,16 +2035,16 @@ function WorkspaceChooser({ memberships, suggestedId, onCancel }) {
     return !v || v === key ? fallback : v;
   };
   const { switchOrg } = useTenant();
-  const [selected, setSelected] = React2.useState(
+  const [selected, setSelected] = React3.useState(
     suggestedId ?? memberships[0]?.orgId ?? null
   );
-  const [remember, setRemember] = React2.useState(false);
-  const [query, setQuery] = React2.useState("");
-  const search = React2.useMemo(
+  const [remember, setRemember] = React3.useState(false);
+  const [query, setQuery] = React3.useState("");
+  const search = React3.useMemo(
     () => searchWorkspaces(memberships, query, selected, 12),
     [memberships, query, selected]
   );
-  const [entering, setEntering] = React2.useState(false);
+  const [entering, setEntering] = React3.useState(false);
   const enter = async (orgId) => {
     if (entering) return;
     setEntering(true);
@@ -1216,7 +2147,7 @@ function WorkspaceChooser({ memberships, suggestedId, onCancel }) {
     ) })
   ] }) });
 }
-var getSupabaseClientOptional = () => getSupabaseClientOptional$1();
+var getSupabaseClientOptional3 = () => getSupabaseClientOptional();
 
 // src/app/useDomainTenant.ts
 var LOCAL = /^(localhost|127\.0\.0\.1|\[::1\])$/;
@@ -1232,7 +2163,7 @@ function useDomainTenant() {
   const [resolving, setResolving] = useState(true);
   useEffect(() => {
     const host = resolveHostname();
-    const supabase = getSupabaseClientOptional();
+    const supabase = getSupabaseClientOptional3();
     if (!host || !supabase) {
       setResolving(false);
       return;
@@ -1267,8 +2198,8 @@ function WorkspaceChooserGate({ fallback, children }) {
   const tenant = useTenantOptional();
   const { tenant: byDomain, resolving: resolvingDomain } = useDomainTenant();
   const switchOrg = tenant?.switchOrg;
-  const entering = React2.useRef(false);
-  React2.useEffect(() => {
+  const entering = React3.useRef(false);
+  React3.useEffect(() => {
     if (!byDomain || !tenant?.orgsKnown || tenant.org || !switchOrg || entering.current) return;
     if (!tenant.userOrgs.some((m) => m.orgId === byDomain.tenantId)) return;
     entering.current = true;
@@ -1310,7 +2241,7 @@ function WorkspaceSwitching({ orgName, orgLogoUrl, onDone }) {
     const v = t(key);
     return !v || v === key ? fallback : v;
   };
-  const steps = React2.useMemo(
+  const steps = React3.useMemo(
     () => [
       tr("organization.switching.step1", "Alterando organiza\xE7\xE3o"),
       tr("organization.switching.step2", "Garantindo seguran\xE7a dos dados"),
@@ -1319,10 +2250,10 @@ function WorkspaceSwitching({ orgName, orgLogoUrl, onDone }) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []
   );
-  const [step, setStep] = React2.useState(0);
-  const doneRef = React2.useRef(onDone);
+  const [step, setStep] = React3.useState(0);
+  const doneRef = React3.useRef(onDone);
   doneRef.current = onDone;
-  React2.useEffect(() => {
+  React3.useEffect(() => {
     const id = window.setInterval(() => {
       setStep((s) => {
         if (s < steps.length - 1) return s + 1;
@@ -1399,6 +2330,6 @@ function WorkspaceSwitchingHost() {
   );
 }
 
-export { OrgMark, WorkspaceChooser, WorkspaceChooserGate, WorkspaceSwitching, WorkspaceSwitchingHost, activePluginIds, createFayzSupabaseClient, createMockOrgAdapter, createSupabaseOrgAdapter, getFayzSupabaseClient, getFayzSupabaseClientOptional, getSupabaseClientOptional, hasPlugin, orgInitials, resolveAppId, searchWorkspaces, useAppConfigStore, useWorkspaceSwitchingStore };
-//# sourceMappingURL=chunk-KP3LNCNP.js.map
-//# sourceMappingURL=chunk-KP3LNCNP.js.map
+export { ORG_CACHE_TTL_MS, OrgMark, OrgProvider, UNIT_ACCESS_CHANGED, WorkspaceChooser, WorkspaceChooserGate, WorkspaceSwitching, WorkspaceSwitchingHost, activePluginIds, bindAllMembersTo, bindUserToUnit, clearOrgSnapshot, countUnboundMembers, createFayzSupabaseClient, createMockOrgAdapter, createSupabaseOrgAdapter, decideWorkspaceChoice, dedup2 as dedup, fetchMemberActivity, fetchMemberUnits, fetchUnitMembers, fetchUserIdForPerson, getAutoPick, getFayzSupabaseClient, getFayzSupabaseClientOptional, getSupabaseClientOptional3 as getSupabaseClientOptional, hasPlugin, markWorkspaceSwitch, orgInitials, readOrgSnapshot, resolveAppId, searchWorkspaces, setAutoPick, setUnitModeRemote, takeWorkspaceSwitch, unbindUserFromUnit, useAppConfigStore, useOrgAdapter, useOrgAdapterOptional, useTenant, useTenantOptional, useUnitStore, useWorkspaceSwitchingStore };
+//# sourceMappingURL=chunk-V2IBAF4O.js.map
+//# sourceMappingURL=chunk-V2IBAF4O.js.map