@fayz-ai/core 0.11.0 → 0.14.0

package/dist/chunk-S5FOFKR4.js

@@ -0,0 +1,1618 @@
+import { globalCache, getActiveTenantId, getSupabaseClientOptional, parseRangeFilter, matchesRange, applyRangeToQuery, isFilterObject, stableKey, DEFAULT_CACHE_TTL, createSupabaseProvider } from './chunk-KFBEKFII.js';
+import { declaredCustomFields, validateEntityRecordData } from './chunk-EWKX4VUM.js';
+import * as React from 'react';
+
+// src/data/count.ts
+var TTL_MS = 15e3;
+var cache = /* @__PURE__ */ new Map();
+function cacheKey(table, tenantId, kind, period) {
+  return `${tenantId}::${table}::${kind ?? ""}::${period}`;
+}
+function startOfMonthISO() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(now.getFullYear(), now.getMonth(), 1).toISOString();
+}
+var COUNT_TIMEOUT_MS = 5e3;
+async function countByTenant(table, options = {}) {
+  const tenantId = options.tenantId ?? getActiveTenantId();
+  if (!tenantId) return 0;
+  const period = options.period ?? "total";
+  const key = cacheKey(table, tenantId, options.kind, period);
+  if (!options.fresh) {
+    const hit = cache.get(key);
+    if (hit && hit.expires > Date.now()) return hit.value;
+  }
+  const client = getSupabaseClientOptional();
+  if (!client) return 0;
+  let query = client.from(table).select("*", { count: "exact", head: true }).eq("tenant_id", tenantId);
+  if (options.kind) {
+    query = query.eq("kind", options.kind);
+  }
+  if (period === "month") {
+    query = query.gte("created_at", startOfMonthISO());
+  }
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ count: null, error: "timeout", timedOut: true }), COUNT_TIMEOUT_MS);
+  });
+  const settled = await Promise.race([
+    query,
+    timeout
+  ]);
+  if (timer) clearTimeout(timer);
+  const { count, error } = settled;
+  const value = error ? 0 : count ?? 0;
+  if (!settled.timedOut) {
+    cache.set(key, { value, expires: Date.now() + TTL_MS });
+  }
+  return value;
+}
+function invalidateCount(tenantOrKey) {
+  if (!tenantOrKey) {
+    cache.clear();
+    return;
+  }
+  for (const key of cache.keys()) {
+    if (key.includes(tenantOrKey)) cache.delete(key);
+  }
+}
+
+// src/data/platform-api.ts
+function resolveTenantId(config) {
+  const tenantId = config?.tenantId;
+  return typeof tenantId === "function" ? tenantId() : tenantId;
+}
+async function resolveRuntimeToken(config) {
+  const runtimeToken = config?.runtimeToken;
+  return typeof runtimeToken === "function" ? runtimeToken() : runtimeToken;
+}
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function appendQuery(url, query, tenantId, tenantIdColumn = "tenant_id", searchColumns = []) {
+  const filters = normalizeFilters(query.filters);
+  if (query.search && searchColumns[0]) {
+    filters.push({ column: searchColumns[0], operator: "ilike", value: `%${query.search}%` });
+  }
+  if (query.sortBy) url.searchParams.set("sortColumn", query.sortBy);
+  if (query.sortDir) url.searchParams.set("sortDirection", query.sortDir);
+  if (query.page != null) url.searchParams.set("page", String(query.page));
+  if (query.pageSize != null) url.searchParams.set("limit", String(query.pageSize));
+  if (tenantId) filters.push({ column: tenantIdColumn, operator: "eq", value: tenantId });
+  if (filters.length > 0) url.searchParams.set("filters", JSON.stringify(filters));
+}
+async function parseResponse(response) {
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`[@fayz-ai/core] Fayz API request failed (${response.status}): ${text || response.statusText}`);
+  }
+  return response.json();
+}
+function isFilterOperator(value) {
+  return typeof value === "string" && [
+    "eq",
+    "neq",
+    "gt",
+    "lt",
+    "gte",
+    "lte",
+    "like",
+    "ilike",
+    "is_null",
+    "is_not_null"
+  ].includes(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeFilters(filters) {
+  if (!filters) return [];
+  return Object.entries(filters).flatMap(([column, raw]) => {
+    if (isRecord(raw) && isFilterOperator(raw.operator)) {
+      return [{ column, operator: raw.operator, value: raw.value }];
+    }
+    const range = parseRangeFilter(raw);
+    if (range) {
+      return ["gte", "gt", "lte", "lt"].filter((op) => range[op] !== void 0).map((op) => ({ column, operator: op, value: range[op] }));
+    }
+    return [{ column, operator: "eq", value: raw }];
+  });
+}
+function createFayzApiProvider(entityOrTable, config = {}) {
+  const fetcher = config.fetcher ?? fetch;
+  const baseUrl = trimTrailingSlash(config.baseUrl ?? "");
+  const projectId = config.projectId;
+  const table = config.table ?? entityOrTable;
+  const idColumn = config.idColumn ?? "id";
+  async function headers(runtimeToken) {
+    return {
+      "Content-Type": "application/json",
+      ...config.headers ? await config.headers() : {},
+      ...runtimeToken ? { Authorization: `Bearer ${runtimeToken}` } : {}
+    };
+  }
+  function tableRowsUrl(runtime = false) {
+    const prefix = baseUrl || (typeof window !== "undefined" ? window.location.origin : "http://localhost");
+    const encodedProjectId = encodeURIComponent(projectId ?? "current");
+    const encodedTable = encodeURIComponent(table);
+    const route = runtime ? `/api/v1/runtime/projects/${encodedProjectId}/database/tables/${encodedTable}/rows` : `/api/projects/${encodedProjectId}/database/tables/${encodedTable}/rows`;
+    const url = new URL(route, prefix);
+    if (config.schema) url.searchParams.set("schema", config.schema);
+    return url;
+  }
+  function withTenant(data, runtime = false) {
+    if (runtime) return data;
+    const tenantId = resolveTenantId(config);
+    if (!tenantId || config.tenantIdColumn === false) return data;
+    return { ...data, [config.tenantIdColumn ?? "tenant_id"]: tenantId };
+  }
+  function primaryKeys(id) {
+    return { [idColumn]: id };
+  }
+  async function listRows(query) {
+    const runtimeToken = await resolveRuntimeToken(config);
+    const runtime = Boolean(runtimeToken);
+    const url = tableRowsUrl(runtime);
+    appendQuery(
+      url,
+      query,
+      runtime || config.tenantIdColumn === false ? void 0 : resolveTenantId(config),
+      config.tenantIdColumn || void 0,
+      config.searchColumns
+    );
+    const result = await parseResponse(await fetcher(url, { headers: await headers(runtimeToken) }));
+    return { data: result.rows, total: result.total };
+  }
+  async function assertTenantScopedRowExists(id, runtime = false) {
+    if (runtime) return;
+    const tenantId = config.tenantIdColumn === false ? void 0 : resolveTenantId(config);
+    if (!tenantId) return;
+    const result = await listRows({ filters: { [idColumn]: id }, page: 1, pageSize: 1 });
+    if (result.data.length === 0) {
+      throw new Error(`[@fayz-ai/core] Row "${id}" was not found for the active tenant.`);
+    }
+  }
+  return {
+    async list(query) {
+      return listRows(query);
+    },
+    async create(data) {
+      const runtimeToken = await resolveRuntimeToken(config);
+      const runtime = Boolean(runtimeToken);
+      return parseResponse(await fetcher(tableRowsUrl(runtime), {
+        method: "POST",
+        headers: await headers(runtimeToken),
+        body: JSON.stringify(withTenant(data, runtime))
+      }));
+    },
+    async update(id, data) {
+      const runtimeToken = await resolveRuntimeToken(config);
+      const runtime = Boolean(runtimeToken);
+      await assertTenantScopedRowExists(id, runtime);
+      return parseResponse(await fetcher(tableRowsUrl(runtime), {
+        method: "PATCH",
+        headers: await headers(runtimeToken),
+        body: JSON.stringify({ primaryKeys: primaryKeys(id), data })
+      }));
+    },
+    async remove(id) {
+      const runtimeToken = await resolveRuntimeToken(config);
+      const runtime = Boolean(runtimeToken);
+      await assertTenantScopedRowExists(id, runtime);
+      await parseResponse(await fetcher(tableRowsUrl(runtime), {
+        method: "DELETE",
+        headers: await headers(runtimeToken),
+        body: JSON.stringify({ rows: [primaryKeys(id)] })
+      }));
+    },
+    async removeMany(ids) {
+      if (!ids.length) return;
+      const runtimeToken = await resolveRuntimeToken(config);
+      const runtime = Boolean(runtimeToken);
+      for (const id of ids) await assertTenantScopedRowExists(id, runtime);
+      await parseResponse(await fetcher(tableRowsUrl(runtime), {
+        method: "DELETE",
+        headers: await headers(runtimeToken),
+        body: JSON.stringify({ rows: ids.map((id) => primaryKeys(id)) })
+      }));
+    }
+  };
+}
+
+// src/data/mock.ts
+function createMockProvider(entityDefOrSearchKeys, initialData = []) {
+  let items = [...initialData];
+  const searchableKeys = Array.isArray(entityDefOrSearchKeys) ? entityDefOrSearchKeys : entityDefOrSearchKeys.fields.filter((f) => f.searchable).map((f) => f.key);
+  const defaultSort = Array.isArray(entityDefOrSearchKeys) ? void 0 : entityDefOrSearchKeys.defaultSort;
+  const defaultSortDir = Array.isArray(entityDefOrSearchKeys) ? "asc" : entityDefOrSearchKeys.defaultSortDir ?? "asc";
+  return {
+    async list(query) {
+      let filtered = [...items];
+      if (query.search && searchableKeys.length > 0) {
+        const term = query.search.toLowerCase();
+        filtered = filtered.filter(
+          (item) => searchableKeys.some((key) => {
+            const val = item[key];
+            return typeof val === "string" && val.toLowerCase().includes(term);
+          })
+        );
+      }
+      if (query.filters) {
+        for (const [key, val] of Object.entries(query.filters)) {
+          if (val == null || val === "") continue;
+          const range = parseRangeFilter(val);
+          filtered = range ? filtered.filter((item) => matchesRange(item[key], range)) : filtered.filter((item) => item[key] === val);
+        }
+      }
+      const sortBy = query.sortBy ?? defaultSort;
+      const sortDir = query.sortDir ?? defaultSortDir;
+      if (sortBy) {
+        filtered.sort((a, b) => {
+          const av = a[sortBy] ?? "";
+          const bv = b[sortBy] ?? "";
+          const cmp = typeof av === "number" && typeof bv === "number" ? av - bv : String(av).localeCompare(String(bv));
+          return sortDir === "desc" ? -cmp : cmp;
+        });
+      }
+      const total = filtered.length;
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      const start = (page - 1) * pageSize;
+      const data = filtered.slice(start, start + pageSize);
+      return { data, total };
+    },
+    async create(data) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const item = {
+        ...data,
+        id: crypto.randomUUID(),
+        tenantId: "mock-tenant",
+        createdAt: now,
+        updatedAt: now
+      };
+      items.unshift(item);
+      return item;
+    },
+    async update(id, data) {
+      const idx = items.findIndex((i) => i.id === id);
+      if (idx === -1) throw new Error(`[@fayz-ai/core] Mock provider: item not found: ${id}`);
+      items[idx] = { ...items[idx], ...data, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      return items[idx];
+    },
+    async remove(id) {
+      items = items.filter((i) => i.id !== id);
+    },
+    async removeMany(ids) {
+      const drop = new Set(ids);
+      items = items.filter((i) => !drop.has(i.id));
+    }
+  };
+}
+
+// src/data/archetype.ts
+var HAS_KIND = /* @__PURE__ */ new Set(["person", "category", "order", "transaction", "schedule", "location"]);
+var ARCHETYPE_CONFIG = {
+  person: { table: "people", fkColumn: "person_id" },
+  category: { table: "categories", fkColumn: "category_id" },
+  product: { table: "products", fkColumn: "product_id" },
+  service: { table: "services", fkColumn: "service_id" },
+  location: { table: "locations", fkColumn: "location_id" },
+  order: { table: "orders", fkColumn: "order_id" },
+  transaction: { table: "transactions", fkColumn: "transaction_id" },
+  schedule: { table: "schedules", fkColumn: "schedule_id" }
+};
+var CUSTOM_FIELDS_COLUMN = "custom_fields";
+var CUSTOM_FIELD_FILTER_PREFIX = "custom.";
+var ARCHETYPE_COLUMNS = {
+  person: /* @__PURE__ */ new Set(["name", "email", "phone", "document_number", "avatar_url", "date_of_birth", "address", "city", "state", "country", "postal_code", "tags", "is_active", "notes", "metadata", CUSTOM_FIELDS_COLUMN]),
+  category: /* @__PURE__ */ new Set(["name", "slug", "parent_id", "icon", "color", "sort_order", "is_active", "metadata", CUSTOM_FIELDS_COLUMN]),
+  product: /* @__PURE__ */ new Set(["name", "description", "sku", "price", "cost", "currency", "unit", "image_url", "stock", "min_stock", "status", "is_active", "tags", "metadata", "category_id", CUSTOM_FIELDS_COLUMN]),
+  service: /* @__PURE__ */ new Set(["name", "description", "price", "cost", "currency", "duration_minutes", "image_url", "status", "is_active", "tags", "metadata", "category_id", CUSTOM_FIELDS_COLUMN]),
+  location: /* @__PURE__ */ new Set(["name", "email", "phone", "address", "city", "state", "country", "postal_code", "is_headquarters", "is_active", "tags", "notes", "metadata", CUSTOM_FIELDS_COLUMN]),
+  order: /* @__PURE__ */ new Set(["reference_number", "status", "party_id", "assignee_id", "location_id", "subtotal", "discount", "tax", "total", "currency", "due_at", "completed_at", "notes", "tags", "metadata", CUSTOM_FIELDS_COLUMN]),
+  transaction: /* @__PURE__ */ new Set(["order_id", "party_id", "amount", "currency", "payment_method", "reference", "status", "transacted_at", "notes", "metadata", CUSTOM_FIELDS_COLUMN]),
+  schedule: /* @__PURE__ */ new Set(["assignee_id", "location_id", "day_of_week", "specific_date", "starts_at", "ends_at", "is_active", "metadata", CUSTOM_FIELDS_COLUMN])
+};
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function mapRow(row) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    result[snakeToCamel(key)] = value;
+  }
+  return result;
+}
+function createArchetypeProvider(config) {
+  const ac = ARCHETYPE_CONFIG[config.archetype];
+  const archetypeColumns = ARCHETYPE_COLUMNS[config.archetype];
+  const { fkColumn } = ac;
+  function getClient2() {
+    const supabase = getSupabaseClientOptional();
+    if (!supabase) throw new Error("Supabase client not available");
+    return supabase;
+  }
+  function coreClient() {
+    return getClient2();
+  }
+  function splitFields(data) {
+    const archetypeData = {};
+    const projectData = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (["id", "createdAt", "updatedAt", "createdBy", "tenantId", fkColumn].includes(key)) continue;
+      const snakeKey = camelToSnake(key);
+      if (archetypeColumns.has(snakeKey)) {
+        archetypeData[snakeKey] = value;
+      } else {
+        projectData[snakeKey] = value;
+      }
+    }
+    return { archetypeData, projectData };
+  }
+  const VIEW_MAP = {
+    clients: "v_clients",
+    staff_members: "v_staff"
+  };
+  const viewName = VIEW_MAP[config.projectTable] ?? `v_${config.projectTable}`;
+  const isPure = config.projectTable === ac.table;
+  return {
+    async list(query) {
+      const tenantId = config.tenantId();
+      if (!tenantId) return { data: [], total: 0 };
+      const countOpts = query.countMode === "none" ? void 0 : { count: "exact" };
+      let q = isPure ? coreClient().from(ac.table).select("*", countOpts).eq("tenant_id", tenantId) : getClient2().from(viewName).select("*", countOpts).eq("tenant_id", tenantId);
+      if (isPure && HAS_KIND.has(config.archetype)) {
+        q = q.eq("kind", config.archetypeKind);
+      }
+      if (query.filters) {
+        for (const [key, val] of Object.entries(query.filters)) {
+          if (val == null || val === "") continue;
+          const col = key.startsWith(CUSTOM_FIELD_FILTER_PREFIX) ? `${CUSTOM_FIELDS_COLUMN}->>${key.slice(CUSTOM_FIELD_FILTER_PREFIX.length)}` : camelToSnake(key);
+          const range = parseRangeFilter(val);
+          if (range) {
+            q = applyRangeToQuery(q, col, range);
+            continue;
+          }
+          if (isFilterObject(val)) {
+            throw new Error(
+              `[@fayz-ai/core] Filter "${key}" is an object with no recognised bound. Use {from,to} / {gte,lte,gt,lt} for ranges, or a plain value for equality.`
+            );
+          }
+          q = q.eq(col, val);
+        }
+      }
+      if (query.search && config.searchColumns && config.searchColumns.length > 0) {
+        const term = `%${query.search}%`;
+        const orClauses = config.searchColumns.map((col) => camelToSnake(col)).map((col) => `${col}.ilike.${term}`);
+        if (orClauses.length > 0) {
+          q = q.or(orClauses.join(","));
+        }
+      }
+      if (query.sortBy) {
+        q = q.order(camelToSnake(query.sortBy), { ascending: query.sortDir !== "desc" });
+      } else {
+        q = q.order("created_at", { ascending: false });
+      }
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      const from = (page - 1) * pageSize;
+      q = q.range(from, from + pageSize - 1);
+      const { data, error, count } = await q;
+      if (error) throw error;
+      const rows = (data ?? []).map((row) => mapRow(row));
+      return { data: rows, total: count ?? 0 };
+    },
+    async create(data) {
+      const tenantId = config.tenantId();
+      if (!tenantId) throw new Error("No tenant selected");
+      const { archetypeData, projectData } = splitFields(data);
+      archetypeData.tenant_id = tenantId;
+      if (HAS_KIND.has(config.archetype)) {
+        archetypeData.kind = config.archetypeKind;
+      }
+      const { data: archetypeRow, error: archetypeError } = await coreClient().from(ac.table).insert(archetypeData).select().single();
+      if (archetypeError) throw archetypeError;
+      const archetypeId = archetypeRow.id;
+      if (!isPure) {
+        projectData[fkColumn] = archetypeId;
+        projectData.tenant_id = tenantId;
+        const { error: projectError } = await getClient2().from(config.projectTable).insert(projectData);
+        if (projectError) {
+          await coreClient().from(ac.table).delete().eq("id", archetypeId);
+          throw projectError;
+        }
+      }
+      return { id: archetypeId, ...archetypeRow, ...isPure ? {} : projectData };
+    },
+    async update(id, data) {
+      const { archetypeData, projectData } = splitFields(data);
+      if (Object.keys(archetypeData).length > 0) {
+        const { error } = await coreClient().from(ac.table).update(archetypeData).eq("id", id);
+        if (error) throw error;
+      }
+      if (!isPure && Object.keys(projectData).length > 0) {
+        const { error } = await getClient2().from(config.projectTable).update(projectData).eq(fkColumn, id);
+        if (error) throw error;
+      }
+      const { data: archetypeRow } = await coreClient().from(ac.table).select("*").eq("id", id).single();
+      if (isPure) {
+        return mapRow({ ...archetypeRow, id });
+      }
+      const { data: projectRow } = await getClient2().from(config.projectTable).select("*").eq(fkColumn, id).single();
+      const flat = { ...archetypeRow, ...projectRow, id };
+      if (archetypeRow && CUSTOM_FIELDS_COLUMN in archetypeRow) {
+        flat[CUSTOM_FIELDS_COLUMN] = archetypeRow[CUSTOM_FIELDS_COLUMN];
+      }
+      delete flat[fkColumn];
+      return mapRow(flat);
+    },
+    async remove(id) {
+      const { error } = await coreClient().from(ac.table).delete().eq("id", id);
+      if (error) throw error;
+    },
+    async removeMany(ids) {
+      if (!ids.length) return;
+      const { error } = await coreClient().from(ac.table).delete().in("id", ids);
+      if (error) throw error;
+    }
+  };
+}
+
+// src/data/cached.ts
+function cachePrefixFor(tenantId, table) {
+  return `${tenantId ?? "_"}:${table}`;
+}
+function cacheKeyFor(tenantId, table, query) {
+  return `${cachePrefixFor(tenantId, table)}:${stableKey(query)}`;
+}
+function withCache(provider, options) {
+  function prefix() {
+    return cachePrefixFor(options.tenantId(), options.table);
+  }
+  return {
+    async list(query) {
+      const key = cacheKeyFor(options.tenantId(), options.table, query);
+      const cached = globalCache.get(key);
+      if (cached) return { ...cached, cached: true };
+      const result = await provider.list(query);
+      globalCache.set(key, result, options.ttl);
+      return result;
+    },
+    async create(data) {
+      const result = await provider.create(data);
+      globalCache.invalidate(prefix());
+      return result;
+    },
+    // Forwarded, not dropped: an optional method that disappears behind the
+    // wrapper silently downgrades every bulk write to a loop of single writes,
+    // and nothing upstream can tell — `createMany` was doing exactly that.
+    ...provider.createMany && {
+      async createMany(rows, options2) {
+        const result = await provider.createMany(rows, options2);
+        globalCache.invalidate(prefix());
+        return result;
+      }
+    },
+    async update(id, data) {
+      const result = await provider.update(id, data);
+      globalCache.invalidate(prefix());
+      return result;
+    },
+    async remove(id) {
+      await provider.remove(id);
+      globalCache.invalidate(prefix());
+    },
+    ...provider.removeMany && {
+      async removeMany(ids) {
+        await provider.removeMany(ids);
+        globalCache.invalidate(prefix());
+      }
+    }
+  };
+}
+
+// src/data/errors.ts
+var RETRYABLE_KINDS = ["offline", "server"];
+var DataError = class extends Error {
+  constructor(kind, message, options = {}) {
+    super(message);
+    this.name = "DataError";
+    this.kind = kind;
+    this.retryable = RETRYABLE_KINDS.includes(kind);
+    this.cause = options.cause;
+    this.status = options.status;
+    this.code = options.code;
+    this.details = options.details;
+    this.hint = options.hint;
+  }
+};
+var CODE_KINDS = {
+  // PostgREST
+  PGRST100: "invalid",
+  // parse error in the query string
+  PGRST106: "missing-object",
+  // schema not exposed
+  PGRST116: "not-found",
+  // zero rows where exactly one was requested
+  PGRST202: "missing-object",
+  // function not found in schema cache
+  PGRST204: "missing-object",
+  // column not found in schema cache
+  PGRST205: "missing-object",
+  // table not found in schema cache
+  PGRST301: "unauthorized",
+  // JWT invalid or expired
+  PGRST302: "unauthorized",
+  // anonymous access disabled
+  // Postgres
+  "22007": "invalid",
+  // invalid datetime format
+  "22P02": "invalid",
+  // invalid input syntax
+  "23502": "invalid",
+  // not-null violation
+  "23505": "conflict",
+  // unique violation
+  "23514": "invalid",
+  // check violation
+  "42501": "forbidden",
+  // insufficient privilege / permission denied
+  "42883": "missing-object",
+  // undefined function
+  "42P01": "missing-object",
+  // undefined table
+  "53300": "server",
+  // too many connections
+  "57014": "server"
+  // statement timeout, server side
+};
+var OFFLINE_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ECONNRESET", "ENOTFOUND", "ETIMEDOUT", "EAI_AGAIN"]);
+var OFFLINE_TEXT = /failed to fetch|fetch failed|network ?error|networkrequestfailed|load failed|connection (refused|reset|closed)|err_internet_disconnected|aborted|signal is aborted|the operation was aborted|timed out|timeout/i;
+function statusKind(status) {
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404 || status === 406) return "not-found";
+  if (status === 408) return "offline";
+  if (status === 409) return "conflict";
+  if (status === 400 || status === 422) return "invalid";
+  if (status >= 500) return "server";
+  return "server";
+}
+function textKind(message) {
+  const m = message.toLowerCase();
+  if (/permission denied|row-level security|row level security|insufficient privilege/.test(m)) return "forbidden";
+  if (/does not exist|undefined table|undefined function|schema cache|could not find the (table|function)/.test(m)) return "missing-object";
+  if (/jwt|not authenticated|invalid token|unauthorized|no api key/.test(m)) return "unauthorized";
+  if (/duplicate key|already exists|conflict/.test(m)) return "conflict";
+  if (/invalid input (syntax|value)|violates (not-null|check) constraint|invalid request/.test(m)) return "invalid";
+  if (/no rows|not found/.test(m)) return "not-found";
+  return void 0;
+}
+function pick(source, key) {
+  const value = source[key];
+  return value === null ? void 0 : value;
+}
+function readStatus(source) {
+  for (const key of ["status", "statusCode", "httpStatus"]) {
+    const value = pick(source, key);
+    if (typeof value === "number") return value;
+    if (typeof value === "string" && /^\d{3}$/.test(value)) return Number(value);
+  }
+  const response = pick(source, "response");
+  if (response && typeof response === "object") {
+    const status = response.status;
+    if (typeof status === "number") return status;
+  }
+  return void 0;
+}
+function isOffline(name, message, code, status) {
+  if (name === "AbortError" || name === "TimeoutError") return true;
+  if (code && OFFLINE_CODES.has(code)) return true;
+  if (status !== void 0) return false;
+  const nav = globalThis.navigator;
+  if (nav && nav.onLine === false) return true;
+  return OFFLINE_TEXT.test(message);
+}
+function toDataError(err) {
+  if (err instanceof DataError) return err;
+  const source = err && typeof err === "object" ? err : {};
+  const name = typeof source.name === "string" ? source.name : "";
+  const rawMessage = typeof source.message === "string" ? source.message : "";
+  const message = rawMessage || (typeof err === "string" ? err : "") || "data request failed";
+  const codeValue = pick(source, "code");
+  const code = typeof codeValue === "string" ? codeValue : typeof codeValue === "number" ? String(codeValue) : void 0;
+  const status = readStatus(source);
+  const details = typeof source.details === "string" ? source.details : void 0;
+  const hint = typeof source.hint === "string" ? source.hint : void 0;
+  let kind = code ? CODE_KINDS[code] : void 0;
+  if (!kind && isOffline(name, message, code, status)) kind = "offline";
+  if (!kind && status !== void 0) kind = statusKind(status);
+  if (!kind) kind = textKind(message);
+  return new DataError(kind ?? "server", message, { cause: err, status, code, details, hint });
+}
+
+// src/events/bus.ts
+function createEventBus() {
+  const handlers = /* @__PURE__ */ new Map();
+  const bus = {
+    emit(event, payload) {
+      const set = handlers.get(event);
+      if (!set) return;
+      for (const handler of Array.from(set)) {
+        try {
+          handler(payload);
+        } catch (err) {
+          console.error(`[fayz] event handler for "${event}" threw:`, err);
+        }
+      }
+    },
+    on(event, handler) {
+      let set = handlers.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        handlers.set(event, set);
+      }
+      set.add(handler);
+      return () => bus.off(event, handler);
+    },
+    once(event, handler) {
+      const wrapped = (payload) => {
+        bus.off(event, wrapped);
+        handler(payload);
+      };
+      return bus.on(event, wrapped);
+    },
+    off(event, handler) {
+      handlers.get(event)?.delete(handler);
+    },
+    clear(event) {
+      if (event) handlers.delete(event);
+      else handlers.clear();
+    }
+  };
+  return bus;
+}
+var eventBus = createEventBus();
+var DATA_CHANGED_EVENT = "data:changed";
+function matchesDataChange(match, payload) {
+  const attributed = payload.table ?? payload.entityKey ?? payload.archetype;
+  if (!attributed) return true;
+  if (match.table && payload.table && match.table === payload.table) return true;
+  if (match.entityKey && payload.entityKey && match.entityKey === payload.entityKey) return true;
+  if (match.archetype && payload.archetype && match.archetype === payload.archetype) return true;
+  return !match.table && !match.entityKey && !match.archetype;
+}
+var pending = [];
+var flushTimer = null;
+function flush() {
+  const batch = pending;
+  pending = [];
+  flushTimer = null;
+  for (const payload of batch) eventBus.emit(DATA_CHANGED_EVENT, payload);
+}
+function emitDataChanged(payload = {}) {
+  if (payload.table) {
+    const tenant = getActiveTenantId() ?? "_";
+    const sibling = payload.table.startsWith("v_") ? payload.table.slice(2) : `v_${payload.table}`;
+    globalCache.invalidate(`${tenant}:${payload.table}`);
+    globalCache.invalidate(`${tenant}:${sibling}`);
+  } else {
+    globalCache.clear();
+  }
+  pending.push({ op: "unknown", source: "agent", ...payload });
+  if (flushTimer) return;
+  flushTimer = setTimeout(flush, 120);
+}
+function useDataChanged(match, handler, deps = []) {
+  const handlerRef = React.useRef(handler);
+  handlerRef.current = handler;
+  const { table, entityKey, archetype } = match;
+  React.useEffect(
+    () => eventBus.on(DATA_CHANGED_EVENT, (payload) => {
+      if (matchesDataChange({ table, entityKey, archetype }, payload)) handlerRef.current(payload);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [table, entityKey, archetype, ...deps]
+  );
+}
+
+// src/lib/cache-idb.ts
+var DB_VERSION = 1;
+var STORE_ENTRIES = "entries";
+var STORE_REPLICAS = "replicas";
+function idbAvailable() {
+  return typeof indexedDB !== "undefined" && typeof IDBKeyRange !== "undefined";
+}
+var NOOP_CACHE = {
+  available: false,
+  hydrate: async () => 0,
+  getStale: async () => void 0,
+  put: () => {
+  },
+  expire: () => {
+  },
+  purge: () => {
+  },
+  putReplica: () => {
+  },
+  getReplica: async () => void 0,
+  dropReplica: () => {
+  },
+  flush: async () => {
+  },
+  detach: () => {
+  }
+};
+var attached = null;
+function getPersistentCache() {
+  return attached;
+}
+function attachPersistentCache(store = globalCache, options = {}) {
+  attached?.detach();
+  if (!idbAvailable()) {
+    attached = NOOP_CACHE;
+    return NOOP_CACHE;
+  }
+  const dbName = options.dbName ?? "core-cache";
+  const maxAgeMs = options.maxAgeMs ?? 24 * 60 * 60 * 1e3;
+  const flushDelayMs = options.flushDelayMs ?? 50;
+  const defaultTTL = options.defaultTTL ?? DEFAULT_CACHE_TTL;
+  let dbPromise = null;
+  function openDb() {
+    if (dbPromise) return dbPromise;
+    dbPromise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(dbName, DB_VERSION);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(STORE_ENTRIES)) db.createObjectStore(STORE_ENTRIES);
+        if (!db.objectStoreNames.contains(STORE_REPLICAS)) db.createObjectStore(STORE_REPLICAS);
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("cache database failed to open"));
+      request.onblocked = () => reject(new Error("cache database blocked by another tab"));
+    });
+    return dbPromise;
+  }
+  function promisify(request) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("cache request failed"));
+    });
+  }
+  async function transact(names, mode, run) {
+    const db = await openDb();
+    const tx = db.transaction(names, mode);
+    const done = new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error ?? new Error("cache transaction failed"));
+      tx.onabort = () => reject(tx.error ?? new Error("cache transaction aborted"));
+    });
+    const value = await run(tx);
+    await done;
+    return value;
+  }
+  let queue = [];
+  let timer = null;
+  let running = Promise.resolve();
+  let detached = false;
+  function enqueue(op) {
+    if (detached) return;
+    if (op.op === "put") {
+      let barrier = -1;
+      for (let i = queue.length - 1; i >= 0; i--) {
+        if (queue[i].op !== "put") {
+          barrier = i;
+          break;
+        }
+      }
+      const at = queue.findIndex(
+        (q, i) => i > barrier && q.op === "put" && q.store === op.store && q.key === op.key
+      );
+      if (at >= 0) queue[at] = op;
+      else queue.push(op);
+    } else if (op.op === "purge") {
+      queue = queue.filter((q) => !(q.op !== "expire" && q.store === op.store && "key" in q && q.key.startsWith(op.prefix)));
+      queue.push(op);
+    } else {
+      queue.push(op);
+    }
+    schedule();
+  }
+  function schedule() {
+    if (timer || detached) return;
+    timer = setTimeout(() => {
+      timer = null;
+      running = running.then(drain);
+    }, flushDelayMs);
+  }
+  async function drain() {
+    const batch = queue;
+    queue = [];
+    if (batch.length === 0) return;
+    try {
+      let segment = [];
+      for (const op of batch) {
+        if (op.op === "expire") {
+          if (segment.length) await commit(segment);
+          segment = [];
+          await applyExpiry(op.prefix);
+        } else {
+          segment.push(op);
+        }
+      }
+      if (segment.length) await commit(segment);
+    } catch {
+    }
+  }
+  async function commit(batch) {
+    await transact([STORE_ENTRIES, STORE_REPLICAS], "readwrite", async (tx) => {
+      for (const op of batch) {
+        if (op.op === "expire") continue;
+        const objectStore = tx.objectStore(op.store);
+        try {
+          if (op.op === "put") objectStore.put(op.value, op.key);
+          else if (op.op === "delete") objectStore.delete(op.key);
+          else objectStore.delete(rangeFor(op.prefix));
+        } catch {
+        }
+      }
+    });
+  }
+  async function applyExpiry(prefix) {
+    await transact([STORE_ENTRIES], "readwrite", async (tx) => {
+      const objectStore = tx.objectStore(STORE_ENTRIES);
+      const keysPromise = promisify(objectStore.getAllKeys());
+      const valuesPromise = promisify(objectStore.getAll());
+      const keys = await keysPromise;
+      const values = await valuesPromise;
+      for (let i = 0; i < keys.length; i++) {
+        const key = String(keys[i]);
+        const value = values[i];
+        if (!value || prefix && !key.startsWith(prefix)) continue;
+        if (value.expiresAt === 0) continue;
+        objectStore.put({ ...value, expiresAt: 0 }, key);
+      }
+    });
+  }
+  async function flush2() {
+    for (let round = 0; round < 8; round++) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      running = running.then(drain);
+      await running;
+      if (queue.length === 0 && !timer) return;
+    }
+  }
+  function rangeFor(prefix) {
+    return IDBKeyRange.bound(prefix, `${prefix}\uFFFF`);
+  }
+  function queuedPut(storeName, key) {
+    for (let i = queue.length - 1; i >= 0; i--) {
+      const op = queue[i];
+      if (op.op === "put" && op.store === storeName && op.key === key) return op.value;
+    }
+    return void 0;
+  }
+  const originalSet = store.set.bind(store);
+  const originalInvalidate = store.invalidate.bind(store);
+  const originalClear = store.clear.bind(store);
+  store.set = (key, data, ttl) => {
+    originalSet(key, data, ttl);
+    enqueue({
+      op: "put",
+      store: STORE_ENTRIES,
+      key,
+      value: { data, expiresAt: Date.now() + (ttl ?? defaultTTL), storedAt: Date.now() }
+    });
+  };
+  store.invalidate = (prefix) => {
+    originalInvalidate(prefix);
+    enqueue({ op: "expire", prefix });
+  };
+  store.clear = () => {
+    originalClear();
+    enqueue({ op: "expire", prefix: "" });
+  };
+  const handle = {
+    available: true,
+    async hydrate() {
+      if (detached) return 0;
+      const now = Date.now();
+      try {
+        const { keys, values } = await transact([STORE_ENTRIES], "readonly", async (tx) => {
+          const objectStore = tx.objectStore(STORE_ENTRIES);
+          const keysPromise = promisify(objectStore.getAllKeys());
+          const valuesPromise = promisify(objectStore.getAll());
+          return {
+            keys: await keysPromise,
+            values: await valuesPromise
+          };
+        });
+        let loaded = 0;
+        for (let i = 0; i < keys.length; i++) {
+          const key = String(keys[i]);
+          const entry = values[i];
+          if (!entry) continue;
+          if (now - entry.storedAt > maxAgeMs) {
+            enqueue({ op: "delete", store: STORE_ENTRIES, key });
+            continue;
+          }
+          if (entry.expiresAt > now) {
+            originalSet(key, entry.data, entry.expiresAt - now);
+            loaded++;
+          }
+        }
+        return loaded;
+      } catch {
+        return 0;
+      }
+    },
+    async getStale(key) {
+      if (detached) return void 0;
+      const queued = queuedPut(STORE_ENTRIES, key);
+      if (queued) return queued;
+      try {
+        const entry = await transact(
+          [STORE_ENTRIES],
+          "readonly",
+          (tx) => promisify(tx.objectStore(STORE_ENTRIES).get(key))
+        );
+        if (!entry) return void 0;
+        if (Date.now() - entry.storedAt > maxAgeMs) return void 0;
+        return entry;
+      } catch {
+        return void 0;
+      }
+    },
+    put(key, data, expiresAt) {
+      enqueue({ op: "put", store: STORE_ENTRIES, key, value: { data, expiresAt, storedAt: Date.now() } });
+    },
+    expire(prefix) {
+      enqueue({ op: "expire", prefix });
+    },
+    purge(prefix = "") {
+      enqueue({ op: "purge", store: STORE_ENTRIES, prefix });
+      enqueue({ op: "purge", store: STORE_REPLICAS, prefix });
+    },
+    putReplica(key, rows) {
+      enqueue({ op: "put", store: STORE_REPLICAS, key, value: { rows, syncedAt: Date.now() } });
+    },
+    async getReplica(key) {
+      if (detached) return void 0;
+      const queued = queuedPut(STORE_REPLICAS, key);
+      if (queued) return queued;
+      try {
+        return await transact(
+          [STORE_REPLICAS],
+          "readonly",
+          (tx) => promisify(tx.objectStore(STORE_REPLICAS).get(key))
+        );
+      } catch {
+        return void 0;
+      }
+    },
+    dropReplica(key) {
+      enqueue({ op: "delete", store: STORE_REPLICAS, key });
+    },
+    flush: flush2,
+    detach() {
+      if (detached) return;
+      detached = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      store.set = originalSet;
+      store.invalidate = originalInvalidate;
+      store.clear = originalClear;
+      if (attached === handle) attached = null;
+      void dbPromise?.then((db) => db.close()).catch(() => {
+      });
+      dbPromise = null;
+    }
+  };
+  if (options.requestPersistence !== false) void requestPersistence();
+  attached = handle;
+  return handle;
+}
+async function requestPersistence() {
+  try {
+    const storage = globalThis.navigator?.storage;
+    await storage?.persist?.();
+  } catch {
+  }
+}
+
+// src/data/offline.ts
+var REPLICA_PAGE_SIZE = 500;
+var REPLICA_MAX_ROWS = 5e3;
+var REPLICA_FIRST_DELAY_MS = 1500;
+var REPLICA_REFRESH_DELAY_MS = 3e3;
+var REPLICA_MIN_INTERVAL_MS = 6e4;
+function replicaKeyFor(tenantId, table) {
+  return `replica:${cachePrefixFor(tenantId, table)}`;
+}
+function withOffline(provider, options) {
+  if (options.policy === "online") return provider;
+  const ttl = options.ttl ?? DEFAULT_CACHE_TTL;
+  if (options.policy === "replica") ensureReplicaSync(provider, options);
+  async function fromPersisted(query) {
+    const l2 = getPersistentCache();
+    if (!l2?.available) return void 0;
+    const entry = await l2.getStale(cacheKeyFor(options.tenantId(), options.table, query));
+    if (!entry) return void 0;
+    return { ...entry.data, stale: true, staleAt: entry.storedAt };
+  }
+  async function fromReplica(query) {
+    const l2 = getPersistentCache();
+    if (!l2?.available) return void 0;
+    const snapshot = await l2.getReplica(replicaKeyFor(options.tenantId(), options.table));
+    if (!snapshot) return void 0;
+    const result = await localList(snapshot.rows, query, options.entityDef);
+    return { ...result, stale: true, staleAt: snapshot.syncedAt };
+  }
+  return {
+    async list(query) {
+      try {
+        const result = await provider.list(query);
+        const l2 = getPersistentCache();
+        if (options.policy === "cache" && l2?.available) {
+          l2.put(cacheKeyFor(options.tenantId(), options.table, query), result, Date.now() + ttl);
+        }
+        return result;
+      } catch (err) {
+        const error = toDataError(err);
+        if (error.kind !== "offline") throw error;
+        const fallback = (options.policy === "replica" ? await fromReplica(query) : void 0) ?? await fromPersisted(query);
+        if (!fallback) throw error;
+        return fallback;
+      }
+    },
+    async create(data) {
+      const result = await provider.create(data);
+      if (options.policy === "replica") scheduleReplicaSync(options, REPLICA_REFRESH_DELAY_MS);
+      return result;
+    },
+    ...provider.createMany && {
+      async createMany(rows, bulkOptions) {
+        const result = await provider.createMany(rows, bulkOptions);
+        if (options.policy === "replica") scheduleReplicaSync(options, REPLICA_REFRESH_DELAY_MS);
+        return result;
+      }
+    },
+    async update(id, data) {
+      const result = await provider.update(id, data);
+      if (options.policy === "replica") scheduleReplicaSync(options, REPLICA_REFRESH_DELAY_MS);
+      return result;
+    },
+    async remove(id) {
+      await provider.remove(id);
+      if (options.policy === "replica") scheduleReplicaSync(options, REPLICA_REFRESH_DELAY_MS);
+    },
+    ...provider.removeMany && {
+      async removeMany(ids) {
+        await provider.removeMany(ids);
+        if (options.policy === "replica") scheduleReplicaSync(options, REPLICA_REFRESH_DELAY_MS);
+      }
+    }
+  };
+}
+async function localList(rows, query, entityDef) {
+  const shape = entityDef ?? [];
+  return createMockProvider(shape, rows).list(query);
+}
+async function syncReplica(provider, options) {
+  const l2 = getPersistentCache();
+  if (!l2?.available) return 0;
+  const pageSize = options.pageSize ?? REPLICA_PAGE_SIZE;
+  const maxRows = options.maxRows ?? REPLICA_MAX_ROWS;
+  const rows = [];
+  for (let page = 1; rows.length < maxRows; page++) {
+    const result = await provider.list({ page, pageSize, countMode: "none" });
+    rows.push(...result.data);
+    if (result.data.length < pageSize) break;
+  }
+  const snapshot = rows.slice(0, maxRows);
+  l2.putReplica(replicaKeyFor(options.tenantId, options.table), snapshot);
+  await l2.flush();
+  return snapshot.length;
+}
+var replicaSyncs = /* @__PURE__ */ new Map();
+function ensureReplicaSync(provider, options) {
+  const key = replicaKeyFor(options.tenantId(), options.table);
+  if (replicaSyncs.has(key)) return;
+  const state = {
+    // Tenant read at sync time, not at registration: the first provider is often
+    // built before the session settles on one.
+    run: () => syncReplica(provider, {
+      table: options.table,
+      tenantId: options.tenantId(),
+      pageSize: options.replicaPageSize,
+      maxRows: options.replicaMaxRows
+    }),
+    timer: null,
+    lastSyncAt: 0,
+    running: false
+  };
+  replicaSyncs.set(key, state);
+  const table = options.table.split("#")[0];
+  const sibling = table.startsWith("v_") ? table.slice(2) : `v_${table}`;
+  eventBus.on(DATA_CHANGED_EVENT, (payload) => {
+    if (payload.table && payload.table !== table && payload.table !== sibling) return;
+    scheduleReplicaSync(options, REPLICA_REFRESH_DELAY_MS);
+  });
+  scheduleReplicaSync(options, REPLICA_FIRST_DELAY_MS);
+}
+function scheduleReplicaSync(options, delayMs) {
+  const state = replicaSyncs.get(replicaKeyFor(options.tenantId(), options.table));
+  if (!state || state.timer) return;
+  state.timer = setTimeout(() => {
+    state.timer = null;
+    if (state.running || Date.now() - state.lastSyncAt < REPLICA_MIN_INTERVAL_MS) return;
+    state.running = true;
+    void state.run().then(() => {
+      state.lastSyncAt = Date.now();
+    }).catch(() => {
+    }).finally(() => {
+      state.running = false;
+    });
+  }, delayMs);
+  state.timer.unref?.();
+}
+
+// src/fields/store.ts
+var FIELDS_TABLE = "plg_entity_fields";
+var CustomFieldsError = class extends Error {
+  constructor(reference, issues) {
+    super(`${reference} custom fields: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "CustomFieldsError";
+    this.issues = issues;
+  }
+};
+function readOptions(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const options = raw.map((entry) => {
+    if (typeof entry === "string") return { value: entry };
+    const record = entry;
+    return typeof record?.value === "string" ? { value: record.value, label: typeof record.label === "string" ? record.label : void 0 } : null;
+  }).filter((option) => option !== null);
+  return options.length ? options : void 0;
+}
+function rowToField(row) {
+  const field = { type: row.type };
+  if (row.label) field.label = row.label;
+  if (row.help) field.help = row.help;
+  if (row.required) field.required = true;
+  if (row.default_value !== null && row.default_value !== void 0) field.default = row.default_value;
+  const options = readOptions(row.options);
+  if (options) field.options = options;
+  if (row.validation && Object.keys(row.validation).length) {
+    field.validation = row.validation;
+  }
+  return field;
+}
+var EMPTY = { reference: "", fields: {}, order: [] };
+var cache2 = /* @__PURE__ */ new Map();
+function clearCustomFieldsCache() {
+  cache2.clear();
+}
+async function load(reference, tenantId) {
+  const declared = declaredCustomFields(reference);
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) return { reference, fields: { ...declared }, order: Object.keys(declared) };
+  const { data, error } = await supabase.from(FIELDS_TABLE).select("reference,key,type,label,help,required,default_value,validation,options,position,origin").eq("reference", reference).is("archived_at", null).order("position", { ascending: true });
+  if (error) return { reference, fields: { ...declared }, order: Object.keys(declared) };
+  const fields = {};
+  const order = [];
+  for (const row of data ?? []) {
+    if (fields[row.key]) continue;
+    fields[row.key] = rowToField(row);
+    order.push(row.key);
+  }
+  for (const [key, field] of Object.entries(declared)) {
+    if (!fields[key]) order.push(key);
+    fields[key] = field;
+  }
+  return { reference, fields, order };
+}
+function resolveCustomFields(reference, tenantId) {
+  const tenant = tenantId ?? getActiveTenantId();
+  if (!tenant) return Promise.resolve({ ...EMPTY, reference, fields: { ...declaredCustomFields(reference) } });
+  const cacheKey2 = `${tenant}:${reference}`;
+  let pending2 = cache2.get(cacheKey2);
+  if (!pending2) {
+    pending2 = load(reference).catch((err) => {
+      cache2.delete(cacheKey2);
+      throw err;
+    });
+    cache2.set(cacheKey2, pending2);
+  }
+  return pending2;
+}
+async function validateCustomFields(reference, values, tenantId) {
+  const { fields } = await resolveCustomFields(reference, tenantId);
+  const issues = validateEntityRecordData({ fields }, values);
+  if (issues.length) throw new CustomFieldsError(reference, issues);
+}
+function mergeCustomFields(current, patch) {
+  const merged = { ...current ?? {} };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === null) delete merged[key];
+    else merged[key] = value;
+  }
+  return merged;
+}
+
+// src/data/custom-fields.ts
+var KEY = "customFields";
+function patchOf(data) {
+  const value = data?.[KEY];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function withCustomFields(provider, reference) {
+  return {
+    ...provider,
+    async create(data) {
+      const patch = patchOf(data);
+      if (!patch) return provider.create(data);
+      await validateCustomFields(reference, patch);
+      return provider.create(data);
+    },
+    async update(id, data) {
+      const patch = patchOf(data);
+      if (!patch) return provider.update(id, data);
+      await validateCustomFields(reference, patch);
+      const { data: rows } = await provider.list({
+        filters: { id },
+        pageSize: 1,
+        countMode: "none"
+      });
+      const current = rows[0]?.[KEY];
+      const merged = mergeCustomFields(current, patch);
+      return provider.update(id, { ...data, [KEY]: merged });
+    }
+  };
+}
+
+// src/data/resolve.ts
+function resolveDataProvider(entityDef, mockData, options = {}) {
+  const backend = options.backend;
+  if (backend?.provider === "mock") {
+    return createMockProvider(entityDef, mockData);
+  }
+  if (backend?.provider === "fayz-api") {
+    const table = entityDef.data?.table ?? entityDef.name;
+    return createFayzApiProvider(table, {
+      ...options.fayzApi,
+      baseUrl: options.fayzApi?.baseUrl ?? backend.url,
+      projectId: options.fayzApi?.projectId ?? backend.projectRef,
+      entityKey: entityDef.name ?? table,
+      table,
+      schema: options.fayzApi?.schema ?? entityDef.data?.schema,
+      idColumn: options.fayzApi?.idColumn ?? entityDef.data?.columnMap?.id,
+      searchColumns: options.fayzApi?.searchColumns ?? entityDef.data?.searchColumns ?? entityDef.fields.filter((field) => field.searchable).map((field) => field.key),
+      tenantIdColumn: entityDef.data?.tenantScoped === false ? false : options.fayzApi?.tenantIdColumn ?? entityDef.data?.tenantIdColumn,
+      tenantId: options.fayzApi?.tenantId ?? (() => getActiveTenantId())
+    });
+  }
+  if (backend?.provider === "custom") {
+    const adapterId = backend.adapterId;
+    const factory = adapterId ? options.customProviders?.[adapterId] : void 0;
+    if (!adapterId || !factory) {
+      throw new Error(`[@fayz-ai/core] Custom data provider "${adapterId ?? "unknown"}" is not registered.`);
+    }
+    return factory(entityDef, mockData);
+  }
+  const client = getSupabaseClientOptional();
+  if (client && entityDef.data?.table) {
+    const tenantId = () => getActiveTenantId();
+    const cacheOptions = {
+      table: entityDef.data.archetypeKind ? `${entityDef.data.table}#${entityDef.data.archetypeKind}` : entityDef.data.table,
+      tenantId,
+      ttl: entityDef.data.cacheTTL
+    };
+    const offlinePolicy = entityDef.data.offline ?? "online";
+    const cached = (p) => {
+      const withL1 = options.cache === false ? p : withCache(p, cacheOptions);
+      return withOffline(withL1, { ...cacheOptions, policy: offlinePolicy, entityDef });
+    };
+    if (entityDef.data.archetype && entityDef.data.archetypeKind && !entityDef.data.schema) {
+      return cached(withCustomFields(createArchetypeProvider({
+        archetype: entityDef.data.archetype,
+        archetypeKind: entityDef.data.archetypeKind,
+        projectTable: entityDef.data.table,
+        tenantId,
+        searchColumns: entityDef.data.searchColumns ?? entityDef.fields.filter((field) => field.searchable).map((field) => field.key)
+      }), entityDef.data.archetype));
+    }
+    return cached(createSupabaseProvider(entityDef.data.table, {
+      schema: entityDef.data.schema,
+      tenantId: entityDef.data.tenantScoped === false ? void 0 : tenantId,
+      tenantIdColumn: entityDef.data.tenantIdColumn,
+      searchColumns: entityDef.data.searchColumns ?? entityDef.fields.filter((field) => field.searchable).map((field) => field.key),
+      selectColumns: entityDef.data.selectColumns,
+      columnMap: entityDef.data.columnMap,
+      filters: entityDef.data.filters,
+      defaults: entityDef.data.defaults
+    }));
+  }
+  if (entityDef.data?.table) {
+    console.warn(
+      `[fayz/core] resolveDataProvider: falling back to mock for "${entityDef.name}" (table: ${entityDef.data.table}). Supabase client ${client ? "available" : "NOT initialized"}.`
+    );
+  }
+  return createMockProvider(entityDef, mockData);
+}
+
+// src/data/query.ts
+var DEFAULT_TIMEOUT_MS = 15e3;
+var DEFAULT_RETRY_DELAY_MS = 150;
+var telemetryHook = null;
+function registerDataTelemetry(fn) {
+  const previous = telemetryHook;
+  telemetryHook = fn;
+  return () => {
+    telemetryHook = previous;
+  };
+}
+function report(event) {
+  if (!telemetryHook) return;
+  try {
+    telemetryHook(event);
+  } catch {
+  }
+}
+function getClient(schema) {
+  const client = getSupabaseClientOptional();
+  if (!client) throw new DataError("invalid", "supabase client not initialized");
+  if (!schema || schema === "public") return client;
+  if (typeof client.schema !== "function") {
+    throw new DataError("invalid", `supabase client cannot reach schema "${schema}"`);
+  }
+  return client.schema(schema);
+}
+function resolveTenant(options, target) {
+  if (options.tenant === "none") return null;
+  const id = getActiveTenantId();
+  if (!id) {
+    throw new DataError(
+      "invalid",
+      `no active tenant for "${target}" \u2014 set one with setActiveTenantId, or pass tenant: 'none'`
+    );
+  }
+  return { column: options.tenantColumn ?? "tenant_id", arg: options.tenantArg, id };
+}
+function targetOf(from, rpc) {
+  return from ?? `rpc:${rpc?.name ?? "?"}`;
+}
+function cachePrefix(tenantId, table) {
+  return `${tenantId ?? "_"}:${table}`;
+}
+function applyFilters(builder, filters) {
+  if (!filters) return builder;
+  let q = builder;
+  for (const [column, value] of Object.entries(filters)) {
+    if (value === void 0) continue;
+    q = value === null ? q.is(column, null) : q.eq(column, value);
+  }
+  return q;
+}
+function withAbort(builder, signal) {
+  return typeof builder.abortSignal === "function" ? builder.abortSignal(signal) : builder;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runWithTimeout(build, timeoutMs) {
+  const controller = new AbortController();
+  let timer;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new DataError("offline", `request timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+  try {
+    const pending2 = Promise.resolve(build(controller.signal));
+    return await Promise.race([pending2, deadline]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function unwrap(response) {
+  if (response?.error) throw toDataError(response.error);
+  return response?.data;
+}
+async function dataQuery(options) {
+  const started = Date.now();
+  const target = targetOf(options.from, options.rpc);
+  try {
+    if (!options.from === !options.rpc) {
+      throw new DataError("invalid", "dataQuery needs exactly one of `from` or `rpc`");
+    }
+    const tenant = resolveTenant(options, target);
+    const cacheKey2 = options.key ?? `${cachePrefix(tenant?.id, target)}:${stableKey("q", {
+      select: options.select,
+      filters: options.filters,
+      rpc: options.rpc?.args,
+      order: options.order,
+      limit: options.limit,
+      page: options.page,
+      single: options.single,
+      schema: options.schema
+    })}`;
+    if (options.policy === "cache") {
+      const hit = globalCache.get(cacheKey2);
+      if (hit !== void 0) {
+        report({ op: "query", target, durationMs: Date.now() - started, cached: true });
+        return hit;
+      }
+    }
+    const attempts = 2;
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      try {
+        const rows = await executeQuery(options, tenant);
+        if (options.policy === "cache") globalCache.set(cacheKey2, rows, options.ttl);
+        report({ op: "query", target, durationMs: Date.now() - started });
+        return rows;
+      } catch (err) {
+        lastError = toDataError(err);
+        if (!lastError.retryable || attempt === attempts) throw lastError;
+        await delay(options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS);
+      }
+    }
+    throw lastError ?? new DataError("server", `query on "${target}" produced no result`);
+  } catch (err) {
+    const error = toDataError(err);
+    report({ op: "query", target, durationMs: Date.now() - started, error });
+    throw error;
+  }
+}
+async function executeQuery(options, tenant) {
+  const client = getClient(options.schema);
+  const response = await runWithTimeout((signal) => {
+    let q;
+    if (options.rpc) {
+      const args = { ...options.rpc.args };
+      if (tenant?.arg && args[tenant.arg] === void 0) args[tenant.arg] = tenant.id;
+      q = client.rpc(options.rpc.name, args);
+      if (options.select) q = q.select(options.select);
+    } else {
+      q = client.from(options.from).select(options.select ?? "*");
+      if (tenant) q = q.eq(tenant.column, tenant.id);
+    }
+    q = applyFilters(q, options.filters);
+    if (options.apply) q = options.apply(q);
+    if (options.order) q = q.order(options.order.column, { ascending: options.order.ascending !== false });
+    if (options.limit !== void 0) {
+      const page = Math.max(1, options.page ?? 1);
+      const from = (page - 1) * options.limit;
+      q = page > 1 ? q.range(from, from + options.limit - 1) : q.limit(options.limit);
+    }
+    if (options.single) q = q.single();
+    return withAbort(q, signal);
+  }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const data = unwrap(response);
+  if (options.single) return data;
+  return data ?? [];
+}
+async function dataCall(options) {
+  const started = Date.now();
+  const target = targetOf(options.from, options.rpc);
+  try {
+    if (!options.from === !options.rpc) {
+      throw new DataError("invalid", "dataCall needs exactly one of `from` or `rpc`");
+    }
+    if (options.from && !options.action) {
+      throw new DataError("invalid", `dataCall on "${options.from}" needs an action`);
+    }
+    const tenant = resolveTenant(options, target);
+    const client = getClient(options.schema);
+    const isDelete = options.action === "delete";
+    const returning = options.returning ?? !isDelete;
+    const single = options.single ?? (returning && !Array.isArray(options.values));
+    const response = await runWithTimeout((signal) => {
+      let q;
+      if (options.rpc) {
+        const args = { ...options.rpc.args };
+        if (tenant?.arg && args[tenant.arg] === void 0) args[tenant.arg] = tenant.id;
+        q = client.rpc(options.rpc.name, args);
+      } else {
+        const table = client.from(options.from);
+        const values = withTenantValues(options.values, tenant, options.action);
+        const match = { ...options.match };
+        if (tenant && (options.action === "update" || options.action === "delete")) {
+          match[tenant.column] = tenant.id;
+        }
+        q = options.action === "insert" ? table.insert(values) : options.action === "upsert" ? table.upsert(values) : options.action === "update" ? table.update(values) : table.delete();
+        q = applyFilters(q, match);
+        if (returning) q = q.select(options.select ?? "*");
+        if (single) q = q.single();
+      }
+      return withAbort(q, signal);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const data = unwrap(response);
+    if (options.from) {
+      globalCache.invalidate(cachePrefix(tenant?.id ?? getActiveTenantId(), options.from));
+      emitDataChanged({ table: options.from, op: changeOp(options.action), source: "ui" });
+    }
+    for (const table of options.invalidates ?? []) {
+      globalCache.invalidate(cachePrefix(tenant?.id ?? getActiveTenantId(), table));
+      emitDataChanged({ table, op: "unknown", source: "ui" });
+    }
+    report({ op: "call", target, durationMs: Date.now() - started });
+    return data;
+  } catch (err) {
+    const error = toDataError(err);
+    report({ op: "call", target, durationMs: Date.now() - started, error });
+    throw error;
+  }
+}
+function changeOp(action) {
+  if (action === "insert") return "create";
+  if (action === "delete") return "delete";
+  return "update";
+}
+function withTenantValues(values, tenant, action) {
+  if (values === void 0) return void 0;
+  if (!tenant || action === "update") return values;
+  const stamp = (row) => row[tenant.column] === void 0 ? { ...row, [tenant.column]: tenant.id } : row;
+  return Array.isArray(values) ? values.map(stamp) : stamp(values);
+}
+
+// src/data/bulk.ts
+async function bulkCreate(provider, rows, options) {
+  if (!rows.length) return { created: 0, failed: [] };
+  if (provider.createMany) return provider.createMany(rows, options);
+  let created = 0;
+  const failed = [];
+  for (let i = 0; i < rows.length; i++) {
+    try {
+      await provider.create(rows[i]);
+      created += 1;
+    } catch (error) {
+      failed.push({ index: i, message: error instanceof Error ? error.message : String(error) });
+    }
+    options?.onProgress?.(i + 1, rows.length);
+  }
+  return { created, failed };
+}
+async function bulkRemove(provider, ids, options) {
+  if (!ids.length) return { removed: 0, failed: [] };
+  const failed = [];
+  const message = (error) => error instanceof Error ? error.message : String(error);
+  if (provider.removeMany) {
+    const chunkSize = options?.chunkSize ?? 100;
+    let removed2 = 0;
+    for (let i = 0; i < ids.length; i += chunkSize) {
+      const chunk = ids.slice(i, i + chunkSize);
+      try {
+        await provider.removeMany(chunk);
+        removed2 += chunk.length;
+      } catch (error) {
+        for (const id of chunk) failed.push({ id, message: message(error) });
+      }
+    }
+    return { removed: removed2, failed };
+  }
+  let removed = 0;
+  for (const id of ids) {
+    try {
+      await provider.remove(id);
+      removed += 1;
+    } catch (error) {
+      failed.push({ id, message: message(error) });
+    }
+  }
+  return { removed, failed };
+}
+
+export { CustomFieldsError, DATA_CHANGED_EVENT, DataError, FIELDS_TABLE, attachPersistentCache, bulkCreate, bulkRemove, cacheKeyFor, cachePrefixFor, clearCustomFieldsCache, countByTenant, createArchetypeProvider, createEventBus, createFayzApiProvider, createMockProvider, dataCall, dataQuery, emitDataChanged, eventBus, getPersistentCache, invalidateCount, localList, matchesDataChange, mergeCustomFields, registerDataTelemetry, replicaKeyFor, resolveCustomFields, resolveDataProvider, syncReplica, toDataError, useDataChanged, validateCustomFields, withCache, withOffline };
+//# sourceMappingURL=chunk-S5FOFKR4.js.map
+//# sourceMappingURL=chunk-S5FOFKR4.js.map