@fayz-ai/core 0.8.1 → 0.8.3

package/dist/index.cjs

@@ -2,13 +2,13 @@
 
 var chunk56GH3WC2_cjs = require('./chunk-56GH3WC2.cjs');
 var chunkP5OJUH25_cjs = require('./chunk-P5OJUH25.cjs');
-var chunk54SRL7AJ_cjs = require('./chunk-54SRL7AJ.cjs');
-var chunk2NTHNWEH_cjs = require('./chunk-2NTHNWEH.cjs');
-var chunk5X2VX3RQ_cjs = require('./chunk-5X2VX3RQ.cjs');
-var chunkQR7U2URY_cjs = require('./chunk-QR7U2URY.cjs');
+var chunkKSI2L3E4_cjs = require('./chunk-KSI2L3E4.cjs');
+var chunkUKU4RIWM_cjs = require('./chunk-UKU4RIWM.cjs');
+var chunkZOPJB5FN_cjs = require('./chunk-ZOPJB5FN.cjs');
+var chunkCATASHPK_cjs = require('./chunk-CATASHPK.cjs');
 var chunkAXTWKF5X_cjs = require('./chunk-AXTWKF5X.cjs');
 var chunk5TKIZVVJ_cjs = require('./chunk-5TKIZVVJ.cjs');
-var React2 = require('react');
+var React3 = require('react');
 var zustand = require('zustand');
 
 function _interopNamespace(e) {
@@ -29,7 +29,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React2__namespace = /*#__PURE__*/_interopNamespace(React2);
+var React3__namespace = /*#__PURE__*/_interopNamespace(React3);
 
 // src/types/plugins.ts
 var WidgetZone = {
@@ -43,13 +43,104 @@ var WidgetZone = {
   SETTINGS_AFTER: "settings.after",
   FLOATING: "shell.floating"
 };
+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();
+function useOnEvent(event, handler, deps = []) {
+  const ref = React3__namespace.useRef(handler);
+  ref.current = handler;
+  React3__namespace.useEffect(
+    () => eventBus.on(event, (payload) => ref.current(payload)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [event, ...deps]
+  );
+}
+
+// src/data/refresh.ts
+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) {
+    chunkKSI2L3E4_cjs.globalCache.invalidate(`${chunkKSI2L3E4_cjs.getActiveTenantId() ?? "_"}:${payload.table}`);
+  } else {
+    chunkKSI2L3E4_cjs.globalCache.clear();
+  }
+  pending.push({ op: "unknown", source: "agent", ...payload });
+  if (flushTimer) return;
+  flushTimer = setTimeout(flush, 120);
+}
+function useDataChanged(match, handler, deps = []) {
+  const handlerRef = React3__namespace.useRef(handler);
+  handlerRef.current = handler;
+  const { table, entityKey, archetype } = match;
+  React3__namespace.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/plugin/createSafeDataProvider.ts
 function createSafeDataProvider(makeSupabase, makeMock) {
   let resolved = null;
   const get = () => {
     if (!resolved) {
-      resolved = chunk54SRL7AJ_cjs.getSupabaseClientOptional() ? makeSupabase() : makeMock();
+      resolved = chunkKSI2L3E4_cjs.getSupabaseClientOptional() ? makeSupabase() : makeMock();
     }
     return resolved;
   };
@@ -102,6 +193,92 @@ function maskDigitCount(mask) {
   for (const ch of mask) if (ch === "#") n++;
   return n;
 }
+
+// src/address/index.ts
+function normalizePostalCode(value) {
+  return (value || "").replace(/\D/g, "");
+}
+function formatPostalCode(value) {
+  const digits = normalizePostalCode(value).slice(0, 8);
+  return digits.length > 5 ? `${digits.slice(0, 5)}-${digits.slice(5)}` : digits;
+}
+function isValidPostalCode(value) {
+  return normalizePostalCode(value).length === 8;
+}
+var CACHE_KEY = "fayz.postal.cache.v1";
+var memoryCache = /* @__PURE__ */ new Map();
+function readCache(code) {
+  const hit = memoryCache.get(code);
+  if (hit) return hit;
+  try {
+    const raw = globalThis.localStorage?.getItem(CACHE_KEY);
+    if (!raw) return void 0;
+    const all = JSON.parse(raw);
+    const stored = all[code];
+    if (stored) memoryCache.set(code, stored);
+    return stored;
+  } catch {
+    return void 0;
+  }
+}
+function writeCache(code, address) {
+  memoryCache.set(code, address);
+  try {
+    const store = globalThis.localStorage;
+    if (!store) return;
+    const raw = store.getItem(CACHE_KEY);
+    const all = raw ? JSON.parse(raw) : {};
+    all[code] = address;
+    store.setItem(CACHE_KEY, JSON.stringify(all));
+  } catch {
+  }
+}
+function clearPostalCache() {
+  memoryCache.clear();
+  try {
+    globalThis.localStorage?.removeItem(CACHE_KEY);
+  } catch {
+  }
+}
+function createViaCepProvider(options) {
+  const fetcher = options?.fetcher ?? globalThis.fetch;
+  return {
+    async lookup(postalCode) {
+      const code = normalizePostalCode(postalCode);
+      if (code.length !== 8) return null;
+      const response = await fetcher(`https://viacep.com.br/ws/${code}/json/`);
+      if (!response.ok) throw new Error(`Consulta de CEP falhou (${response.status})`);
+      const data = await response.json();
+      if (data.erro === true || data.erro === "true" || !data.localidade) return null;
+      return {
+        postalCode: code,
+        street: data.logradouro ?? "",
+        district: data.bairro ?? "",
+        city: data.localidade,
+        state: (data.uf ?? "").toUpperCase(),
+        country: "BR",
+        cityCode: data.ibge || void 0
+      };
+    }
+  };
+}
+var _provider = null;
+function setPostalLookupProvider(provider) {
+  _provider = provider;
+}
+function getPostalLookupProvider() {
+  if (!_provider) _provider = createViaCepProvider();
+  return _provider;
+}
+async function lookupPostalCode(postalCode) {
+  const code = normalizePostalCode(postalCode);
+  if (code.length !== 8) return null;
+  const cached = readCache(code);
+  if (cached) return cached;
+  const address = await getPostalLookupProvider().lookup(code);
+  if (address) writeCache(code, address);
+  return address;
+}
 var MANAGED = "data-fayz-seo";
 function seoOrigin() {
   return typeof window !== "undefined" ? window.location.origin : "";
@@ -160,7 +337,7 @@ function applySeo(config) {
 }
 function useSeo(config) {
   const key = JSON.stringify(config);
-  React2.useEffect(() => {
+  React3.useEffect(() => {
     applySeo(config);
     return () => clearManaged();
   }, [key]);
@@ -196,7 +373,7 @@ function setDefaultCurrency(code) {
 }
 function getActiveLocale() {
   try {
-    return chunkQR7U2URY_cjs.getCurrentLocale() || "en";
+    return chunkCATASHPK_cjs.getCurrentLocale() || "en";
   } catch {
     return "en";
   }
@@ -263,58 +440,560 @@ function downloadCSV(csv, filename) {
 function exportCSV(columns, rows, filename) {
   downloadCSV(buildCSV(columns, rows), filename);
 }
-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);
-        }
+
+// src/search/text.ts
+var COMBINING_MARKS = /[\u0300-\u036f]/g;
+function foldText(value) {
+  if (typeof value !== "string" || value === "") return "";
+  return value.normalize("NFD").replace(COMBINING_MARKS, "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function foldWithMap(value) {
+  const out = [];
+  const map = [];
+  let pendingSpace = false;
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    const folded = ch.normalize("NFD").replace(COMBINING_MARKS, "").toLowerCase();
+    for (const f of folded) {
+      const alnum = f >= "a" && f <= "z" || f >= "0" && f <= "9";
+      if (!alnum) {
+        pendingSpace = out.length > 0;
+        continue;
       }
-    },
-    on(event, handler) {
-      let set = handlers.get(event);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        handlers.set(event, set);
+      if (pendingSpace) {
+        out.push(" ");
+        map.push(i);
+        pendingSpace = false;
       }
-      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();
+      out.push(f);
+      map.push(i);
     }
+  }
+  return { folded: out.join(""), map };
+}
+function digitsOf(value) {
+  return typeof value === "string" ? value.replace(/\D+/g, "") : "";
+}
+var MIN_DIGIT_QUERY = 4;
+function normalizeQuery(raw) {
+  const folded = foldText(raw);
+  const tokens = folded ? folded.split(" ").filter(Boolean) : [];
+  const digits = raw.replace(/\D+/g, "");
+  let anchor = "";
+  for (const token of tokens) if (token.length > anchor.length) anchor = token;
+  return {
+    raw,
+    folded,
+    tokens,
+    digits: digits.length >= MIN_DIGIT_QUERY ? digits : "",
+    anchor
   };
-  return bus;
 }
-var eventBus = createEventBus();
-function useOnEvent(event, handler, deps = []) {
-  const ref = React2__namespace.useRef(handler);
-  ref.current = handler;
-  React2__namespace.useEffect(
-    () => eventBus.on(event, (payload) => ref.current(payload)),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [event, ...deps]
-  );
+function bigrams(value) {
+  if (value.length < 2) return value ? [value] : [];
+  const out = [];
+  for (let i = 0; i < value.length - 1; i++) out.push(value.slice(i, i + 2));
+  return out;
+}
+function similarity(a, b) {
+  if (!a || !b) return 0;
+  if (a === b) return 1;
+  const left = bigrams(a);
+  const right = bigrams(b);
+  if (left.length === 0 || right.length === 0) return 0;
+  const pool = /* @__PURE__ */ new Map();
+  for (const g of left) pool.set(g, (pool.get(g) ?? 0) + 1);
+  let shared = 0;
+  for (const g of right) {
+    const count = pool.get(g);
+    if (count) {
+      shared++;
+      pool.set(g, count - 1);
+    }
+  }
+  return 2 * shared / (left.length + right.length);
+}
+function wordSimilarity(text, token) {
+  let best = similarity(text, token);
+  for (const word of text.split(" ")) {
+    if (!word) continue;
+    const s = similarity(word, token);
+    if (s > best) best = s;
+  }
+  return best;
+}
+var FUZZY_FLOOR = 0.62;
+function scoreCandidate(query, candidate) {
+  const { folded, tokens } = query;
+  if (!folded || tokens.length === 0) return 0;
+  const title = candidate.title;
+  const haystack = candidate.haystack || title;
+  let phrase = 0;
+  if (title === folded) phrase = 1;
+  else if (title.startsWith(folded)) phrase = 0.94;
+  else if (title.includes(" " + folded)) phrase = 0.88;
+  else if (title.includes(folded)) phrase = 0.76;
+  else if (haystack.startsWith(folded) || haystack.includes(" " + folded)) phrase = 0.7;
+  else if (haystack.includes(folded)) phrase = 0.62;
+  let tokenTotal = 0;
+  let fuzzyUsed = false;
+  for (const token of tokens) {
+    let best = 0;
+    if (title.startsWith(token)) best = 0.95;
+    else if (title.includes(" " + token)) best = 0.85;
+    else if (title.includes(token)) best = 0.7;
+    else if (haystack.startsWith(token) || haystack.includes(" " + token)) best = 0.6;
+    else if (haystack.includes(token)) best = 0.5;
+    else {
+      const sim = wordSimilarity(title, token);
+      if (sim >= FUZZY_FLOOR) {
+        best = 0.45 * sim;
+        fuzzyUsed = true;
+      }
+    }
+    if (best === 0) return phrase > 0 ? phrase : 0;
+    tokenTotal += best;
+  }
+  let tokenScore = tokenTotal / tokens.length;
+  if (fuzzyUsed) tokenScore *= 0.8;
+  let score = Math.max(phrase, tokenScore);
+  if (query.digits && candidate.digits && candidate.digits.includes(query.digits)) {
+    score = Math.max(score, 0.72 + Math.min(0.2, query.digits.length / 50));
+  }
+  if (score === 0) return 0;
+  const brevity = 1 / (1 + Math.max(0, title.length - folded.length) / 40);
+  return score * 0.97 + brevity * 0.03;
+}
+function highlightRanges(text, query) {
+  if (!text || query.tokens.length === 0) return [];
+  const { folded, map } = foldWithMap(text);
+  if (!folded) return [];
+  const spans = [];
+  const needles = query.tokens.length > 1 ? [query.folded, ...query.tokens] : [query.folded];
+  for (const needle of needles) {
+    if (!needle) continue;
+    let from = 0;
+    for (; ; ) {
+      const at = folded.indexOf(needle, from);
+      if (at === -1) break;
+      const start = map[at];
+      const endChar = map[at + needle.length - 1];
+      if (start !== void 0 && endChar !== void 0) spans.push([start, endChar + 1]);
+      from = at + needle.length;
+    }
+  }
+  if (spans.length === 0) return [];
+  spans.sort((a, b) => a[0] - b[0]);
+  const merged = [spans[0]];
+  for (const span of spans.slice(1)) {
+    const last = merged[merged.length - 1];
+    if (span[0] <= last[1]) last[1] = Math.max(last[1], span[1]);
+    else merged.push(span);
+  }
+  return merged;
+}
+
+// src/search/engine.ts
+var MIN_QUERY_LENGTH = 2;
+var DEFAULT_LIMIT = 30;
+var DEFAULT_PER_TARGET = 5;
+var SCAN_CONCURRENCY = 16;
+var TARGET_TIMEOUT_MS = 3e3;
+var CACHE_TTL_MS = 3e4;
+var CACHE_MAX_ENTRIES = 40;
+var RPC_NAME = "fayz_global_search";
+var indexAvailable = null;
+function setSearchIndexAvailable(value) {
+  indexAvailable = value;
+}
+function isSearchIndexAvailable() {
+  return indexAvailable;
+}
+function camelOf(key) {
+  return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function snakeOf(key) {
+  return key.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
+}
+function readField(row, key) {
+  if (key in row) return row[key];
+  const camel = camelOf(key);
+  if (camel in row) return row[camel];
+  const snake = snakeOf(key);
+  if (snake in row) return row[snake];
+  return void 0;
+}
+function asText(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string").join(" ");
+  return "";
+}
+function searchableKeys(entity) {
+  const declared = entity.data?.searchColumns ?? entity.fields.filter((f) => f.searchable).map((f) => f.key);
+  const keys = [...declared];
+  const display = entity.displayField ?? "name";
+  if (!keys.includes(display)) keys.unshift(display);
+  const subtitle = entity.subtitleField;
+  if (subtitle && !keys.includes(subtitle)) keys.push(subtitle);
+  return keys;
+}
+var DIGIT_FIELD_TYPES = /* @__PURE__ */ new Set(["phone", "number"]);
+function digitKeys(entity) {
+  const keys = entity.fields.filter((f) => DIGIT_FIELD_TYPES.has(f.type) || /phone|document|cpf|cnpj|zip|postal|sku|code|reference/i.test(f.key)).map((f) => f.key);
+  for (const extra of ["phone", "document_number", "sku", "reference_number", "postal_code"]) {
+    if (!keys.includes(extra)) keys.push(extra);
+  }
+  return keys;
+}
+function titleOf(entity, row) {
+  const display = entity.displayField ?? "name";
+  const primary = asText(readField(row, display));
+  if (primary) return primary;
+  for (const field of entity.fields) {
+    if (field.type === "text" || field.type === "email") {
+      const value = asText(readField(row, field.key));
+      if (value) return value;
+    }
+  }
+  return asText(row.id) || "\u2014";
+}
+function subtitleOf(entity, row, title) {
+  const distinct = (value) => {
+    if (!value || foldText(value) === foldText(title)) return void 0;
+    return value.length > 90 ? value.slice(0, 89) + "\u2026" : value;
+  };
+  const declared = entity.subtitleField;
+  if (declared) {
+    const value = distinct(asText(readField(row, declared)));
+    if (value) return value;
+  }
+  for (const key of ["email", "phone", "sku", "reference_number", "document_number", "description"]) {
+    const value = distinct(asText(readField(row, key)));
+    if (value) return value;
+  }
+  return void 0;
+}
+function hitFromRow(target, row, query) {
+  const id = asText(row.id);
+  if (!id) return null;
+  const entity = target.entity;
+  const title = titleOf(entity, row);
+  const parts = [title];
+  for (const key of searchableKeys(entity)) {
+    const value = asText(readField(row, key));
+    if (value) parts.push(value);
+  }
+  let digits = "";
+  for (const key of digitKeys(entity)) {
+    const value = readField(row, key);
+    if (typeof value === "string" || typeof value === "number") digits += digitsOf(String(value));
+  }
+  const score = scoreCandidate(query, {
+    title: foldText(title),
+    haystack: foldText(parts.join(" ")),
+    digits
+  });
+  if (score === 0) return null;
+  return {
+    uid: `${target.key}:${id}`,
+    id,
+    key: target.key,
+    group: target.label,
+    icon: target.icon ?? entity.icon,
+    title,
+    subtitle: subtitleOf(entity, row, title),
+    score: score * (target.boost ?? 1),
+    archetype: entity.data?.archetype,
+    archetypeKind: entity.data?.archetypeKind,
+    table: entity.data?.table,
+    record: row
+  };
+}
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function recordIdentity(hit) {
+  if (UUID.test(hit.id)) return hit.id;
+  return `${hit.table ?? hit.key}#${hit.id}`;
+}
+function assemble(query, hits, targets, opts) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const hit of hits.slice().sort((a, b) => b.score - a.score || a.title.localeCompare(b.title))) {
+    const identity = recordIdentity(hit);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    unique.push(hit);
+  }
+  const byKey = /* @__PURE__ */ new Map();
+  const kept = [];
+  const capped = /* @__PURE__ */ new Set();
+  for (const hit of unique) {
+    const bucket = byKey.get(hit.key) ?? [];
+    if (bucket.length >= opts.perTarget) {
+      capped.add(hit.key);
+      continue;
+    }
+    bucket.push(hit);
+    byKey.set(hit.key, bucket);
+    kept.push(hit);
+  }
+  const limited = kept.slice(0, opts.limit);
+  const order = new Map(targets.map((t, i) => [t.key, i]));
+  const groups = [];
+  for (const hit of limited) {
+    let group = groups.find((g) => g.key === hit.key);
+    if (!group) {
+      group = { key: hit.key, label: hit.group, icon: hit.icon, hits: [], hasMore: capped.has(hit.key) };
+      groups.push(group);
+    }
+    group.hits.push(hit);
+  }
+  groups.sort((a, b) => (b.hits[0]?.score ?? 0) - (a.hits[0]?.score ?? 0) || (order.get(a.key) ?? 99) - (order.get(b.key) ?? 99));
+  return {
+    query,
+    hits: limited,
+    groups,
+    via: opts.via,
+    failed: opts.failed,
+    elapsedMs: opts.elapsedMs,
+    partial: opts.partial ?? false
+  };
+}
+var cache = [];
+function scopeKey(targets) {
+  return `${chunkKSI2L3E4_cjs.getActiveTenantId() ?? "_"}|${targets.map((t) => t.key).sort().join(",")}`;
+}
+function cacheGet(scope, folded) {
+  const now = Date.now();
+  return cache.find((e) => e.scope === scope && e.folded === folded && now - e.at < CACHE_TTL_MS);
+}
+function cachePrefix(scope, folded) {
+  const now = Date.now();
+  let best;
+  for (const entry of cache) {
+    if (entry.scope !== scope || !entry.complete) continue;
+    if (now - entry.at >= CACHE_TTL_MS) continue;
+    if (!folded.startsWith(entry.folded)) continue;
+    if (!best || entry.folded.length > best.folded.length) best = entry;
+  }
+  return best;
+}
+function cacheSet(entry) {
+  const at = cache.findIndex((e) => e.scope === entry.scope && e.folded === entry.folded);
+  if (at >= 0) cache.splice(at, 1);
+  cache.unshift(entry);
+  if (cache.length > CACHE_MAX_ENTRIES) cache.length = CACHE_MAX_ENTRIES;
+}
+function clearSearchCache() {
+  cache.length = 0;
+}
+function isMissingFunction(error) {
+  if (!error) return false;
+  if (error.code === "PGRST202") return true;
+  const message = (error.message ?? "").toLowerCase();
+  return message.includes(RPC_NAME) && (message.includes("does not exist") || message.includes("not find"));
+}
+async function searchViaIndex(query, targets, perTarget, limit) {
+  const client = chunkKSI2L3E4_cjs.getSupabaseClientOptional();
+  const tenantId = chunkKSI2L3E4_cjs.getActiveTenantId();
+  if (!client || !tenantId) return { hits: [], ok: false };
+  const byKey = new Map(targets.map((t) => [t.key, t]));
+  const { data, error } = await client.rpc(RPC_NAME, {
+    p_query: query.raw,
+    p_tenant_id: tenantId,
+    p_entity_keys: targets.map((t) => t.key),
+    p_per_source: perTarget * 3,
+    p_limit: limit * 3
+  });
+  if (error) {
+    if (isMissingFunction(error)) {
+      indexAvailable = false;
+      return { hits: [], ok: false };
+    }
+    throw error;
+  }
+  indexAvailable = true;
+  const rows = Array.isArray(data) ? data : [];
+  const hits = [];
+  for (const row of rows) {
+    const target = byKey.get(row.entity_key);
+    if (!target || !row.record_id) continue;
+    const title = row.title ?? "";
+    const local = scoreCandidate(query, {
+      title: foldText(title),
+      haystack: foldText(`${title} ${row.subtitle ?? ""}`),
+      digits: digitsOf(row.subtitle ?? "") + digitsOf(title)
+    });
+    const score = local > 0 ? local : Math.min(0.55, row.score ?? 0.4);
+    hits.push({
+      uid: `${target.key}:${row.record_id}`,
+      id: row.record_id,
+      key: target.key,
+      group: target.label,
+      icon: target.icon ?? target.entity.icon,
+      title: title || "\u2014",
+      subtitle: row.subtitle ?? void 0,
+      score: score * (target.boost ?? 1),
+      archetype: target.entity.data?.archetype,
+      archetypeKind: target.entity.data?.archetypeKind,
+      table: target.entity.data?.table
+    });
+  }
+  return { hits, ok: true };
+}
+async function withTimeout(promise, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("search target timed out")), ms);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function mapLimited(items, limit, fn) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    for (; ; ) {
+      const index = cursor++;
+      if (index >= items.length) return;
+      const item = items[index];
+      try {
+        results[index] = { ok: true, value: await fn(item) };
+      } catch {
+        results[index] = { ok: false, item };
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+async function searchViaScan(query, targets, perTarget, onProgress) {
+  const multiWord = query.tokens.length > 1;
+  const phrase = query.folded;
+  const token = query.anchor.length >= MIN_QUERY_LENGTH ? query.anchor : phrase;
+  const pageSize = Math.min(perTarget * 3, 24);
+  const widePageSize = Math.min(perTarget * 6, 40);
+  const searchable = targets.filter((t) => searchableKeys(t.entity).length > 0);
+  const running = [];
+  const round = (search, size) => mapLimited(searchable, SCAN_CONCURRENCY, async (target) => {
+    const provider = chunkKSI2L3E4_cjs.resolveDataProvider(target.entity, target.mockData);
+    const result = await withTimeout(
+      provider.list({ search, pageSize: size, countMode: "none" }),
+      TARGET_TIMEOUT_MS
+    );
+    const rows = result.data;
+    const hits = rows.map((row) => hitFromRow(target, row, query)).filter((h) => h !== null);
+    if (hits.length && onProgress) {
+      running.push(...hits);
+      onProgress(running.slice());
+    }
+    return { target, hits };
+  });
+  const collect = (settled) => {
+    const hits = [];
+    const failed = [];
+    for (const outcome of settled) {
+      if (outcome.ok) hits.push(...outcome.value.hits);
+      else failed.push(outcome.item.key);
+    }
+    return { hits, failed };
+  };
+  const first = collect(await round(phrase, pageSize));
+  if (first.hits.length > 0 || !multiWord || token === phrase) return first;
+  const second = collect(await round(token, widePageSize));
+  return { hits: second.hits, failed: [.../* @__PURE__ */ new Set([...first.failed, ...second.failed])] };
+}
+async function searchEverything(rawQuery, options) {
+  const started = Date.now();
+  const query = normalizeQuery(rawQuery);
+  const targets = options.targets;
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  const perTarget = options.perTarget ?? DEFAULT_PER_TARGET;
+  const empty = (via2) => assemble(rawQuery, [], targets, { via: via2, failed: [], elapsedMs: Date.now() - started, perTarget, limit });
+  if (query.folded.length < MIN_QUERY_LENGTH || targets.length === 0) return empty("cache");
+  const scope = scopeKey(targets);
+  const exact = cacheGet(scope, query.folded);
+  if (exact) {
+    return assemble(rawQuery, exact.hits, targets, {
+      via: "cache",
+      failed: [],
+      elapsedMs: Date.now() - started,
+      perTarget,
+      limit
+    });
+  }
+  if (options.onPartial) {
+    const prefix = cachePrefix(scope, query.folded);
+    if (prefix) {
+      const rescored = prefix.hits.map((hit) => {
+        const score = scoreCandidate(query, {
+          title: foldText(hit.title),
+          haystack: foldText(`${hit.title} ${hit.subtitle ?? ""}`),
+          digits: digitsOf(hit.subtitle ?? "")
+        });
+        return score > 0 ? { ...hit, score } : null;
+      }).filter((h) => h !== null);
+      options.onPartial(assemble(rawQuery, rescored, targets, {
+        via: "cache",
+        failed: [],
+        elapsedMs: Date.now() - started,
+        perTarget,
+        limit,
+        partial: true
+      }));
+    }
+  }
+  let hits = [];
+  let failed = [];
+  let via = "scan";
+  if (!options.forceScan && indexAvailable !== false) {
+    try {
+      const indexed = await searchViaIndex(query, targets, perTarget, limit);
+      if (indexed.ok) {
+        hits = indexed.hits;
+        via = "index";
+      }
+    } catch {
+    }
+  }
+  if (via !== "index") {
+    const emit = options.onPartial;
+    const scanned = await searchViaScan(query, targets, perTarget, emit ? (running) => emit(assemble(rawQuery, running, targets, {
+      via: "scan",
+      failed: [],
+      elapsedMs: Date.now() - started,
+      perTarget,
+      limit,
+      partial: true
+    })) : void 0);
+    hits = scanned.hits;
+    failed = scanned.failed;
+  }
+  if (options.signal?.aborted) return empty(via);
+  const result = assemble(rawQuery, hits, targets, {
+    via,
+    failed,
+    elapsedMs: Date.now() - started,
+    perTarget,
+    limit
+  });
+  cacheSet({
+    scope,
+    folded: query.folded,
+    at: Date.now(),
+    // Only an uncapped answer is a sound superset for longer queries.
+    complete: failed.length === 0 && !result.groups.some((g) => g.hasMore),
+    hits
+  });
+  return result;
 }
 function UnknownBlock({ type }) {
-  return React2__namespace.createElement(
+  return React3__namespace.createElement(
     "div",
     {
       style: {
@@ -329,16 +1008,16 @@ function UnknownBlock({ type }) {
   );
 }
 function BlockRenderer({ node }) {
-  const Comp = chunk5X2VX3RQ_cjs.getBlock(node.type);
+  const Comp = chunkZOPJB5FN_cjs.getBlock(node.type);
   const childEls = node.children?.length ? node.children.map(
-    (child, i) => React2__namespace.createElement(BlockRenderer, { key: child.id ?? `${child.type}-${i}`, node: child })
+    (child, i) => React3__namespace.createElement(BlockRenderer, { key: child.id ?? `${child.type}-${i}`, node: child })
   ) : null;
-  if (!Comp) return React2__namespace.createElement(UnknownBlock, { type: node.type });
-  return React2__namespace.createElement(Comp, { ...node.props ?? {}, node }, childEls);
+  if (!Comp) return React3__namespace.createElement(UnknownBlock, { type: node.type });
+  return React3__namespace.createElement(Comp, { ...node.props ?? {}, node }, childEls);
 }
 function renderBlocks(nodes) {
   return nodes.map(
-    (node, i) => React2__namespace.createElement(BlockRenderer, { key: node.id ?? `${node.type}-${i}`, node })
+    (node, i) => React3__namespace.createElement(BlockRenderer, { key: node.id ?? `${node.type}-${i}`, node })
   );
 }
 function BlockChildren({ node }) {
@@ -347,7 +1026,7 @@ function BlockChildren({ node }) {
 }
 
 // src/manifest/index.ts
-var CURRENT_MANIFEST_VERSION = 2;
+var CURRENT_MANIFEST_VERSION = 3;
 var migrations = /* @__PURE__ */ new Map();
 var supportedBackendProviders = ["supabase", "fayz-api", "fayz-shop", "mock", "custom"];
 var supportedPageSections = /* @__PURE__ */ new Set(["main", "secondary", "settings"]);
@@ -361,7 +1040,10 @@ var allowedManifestKeys = /* @__PURE__ */ new Set([
   "permissions",
   "billing",
   "entities",
-  "surfaces"
+  "surfaces",
+  "limitDeclarations",
+  "agent",
+  "contractHash"
 ]);
 var allowedBackendKeys = /* @__PURE__ */ new Set(["provider", "projectRef", "url", "adapterId", "options"]);
 var allowedSurfaceKeys = /* @__PURE__ */ new Set(["scaffold", "options", "plugins", "pages"]);
@@ -373,6 +1055,7 @@ var manifestIdPattern = /^[a-z0-9][a-z0-9-]*$/;
 function registerManifestMigration(fromVersion, fn) {
   migrations.set(fromVersion, fn);
 }
+registerManifestMigration(2, (m) => m);
 function migrateManifest(input) {
   let m = { ...input };
   let version = typeof m.manifestVersion === "number" ? m.manifestVersion : 1;
@@ -410,6 +1093,21 @@ function validateManifest(m) {
   validateLooseObject(manifest.theme, "manifest.theme", problems);
   validateLooseObject(manifest.permissions, "manifest.permissions", problems);
   validateLooseObject(manifest.billing, "manifest.billing", problems);
+  validateLooseObject(manifest.agent, "manifest.agent", problems);
+  if (manifest.contractHash !== void 0 && !isNonEmptyString(manifest.contractHash)) {
+    problems.push("manifest.contractHash must be a non-empty string");
+  }
+  if (manifest.limitDeclarations !== void 0) {
+    if (!Array.isArray(manifest.limitDeclarations)) {
+      problems.push("manifest.limitDeclarations must be an array");
+    } else {
+      manifest.limitDeclarations.forEach((decl, index) => {
+        if (!isRecord(decl) || !isNonEmptyString(decl.key) || !isNonEmptyString(decl.table)) {
+          problems.push(`manifest.limitDeclarations[${index}] must declare key and table`);
+        }
+      });
+    }
+  }
   if (manifest.entities !== void 0) {
     if (!Array.isArray(manifest.entities)) {
       problems.push("manifest.entities must be an array");
@@ -570,7 +1268,7 @@ function validateBlockManifest(block, path, problems) {
 function addUnsupportedKeys(value, allowedKeys, path, problems) {
   for (const key of Object.keys(value)) {
     if (!allowedKeys.has(key)) {
-      problems.push(`${path}.${key} is not part of AppManifest v2`);
+      problems.push(`${path}.${key} is not part of AppManifest v${CURRENT_MANIFEST_VERSION}`);
     }
   }
 }
@@ -591,113 +1289,717 @@ function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
 
+// src/manifest/serialize.ts
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    const out = {};
+    for (const key of Object.keys(record).sort()) {
+      const v = record[key];
+      if (v !== void 0) out[key] = sortValue(v);
+    }
+    return out;
+  }
+  return value;
+}
+function serializeManifest(manifest) {
+  const { contractHash: _omit, ...rest } = manifest;
+  return `${JSON.stringify(sortValue(rest), null, 2)}
+`;
+}
+async function computeContractHash(manifest) {
+  const bytes = new TextEncoder().encode(serializeManifest(manifest));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function serializeManifestWithHash(manifest) {
+  const contractHash = await computeContractHash(manifest);
+  const { contractHash: _omit, ...rest } = manifest;
+  return `${JSON.stringify(sortValue({ ...rest, contractHash }), null, 2)}
+`;
+}
+
 // src/manifest/app-manifest.schema.json
 var app_manifest_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "https://fayz.ai/schemas/app-manifest/v2.json",
+  $id: "https://fayz.ai/schemas/app-manifest/v3.json",
   title: "Fayz AppManifest",
   description: "The canonical, JSON-serializable definition of a Fayz app. Code is referenced by registry id; never inlined.",
   type: "object",
-  required: ["manifestVersion", "id", "name", "surfaces"],
+  required: [
+    "manifestVersion",
+    "id",
+    "name",
+    "surfaces"
+  ],
   additionalProperties: false,
   properties: {
     manifestVersion: {
       type: "integer",
-      const: 2,
+      const: 3,
       description: "Current AppManifest schema version. Older or newer versions require an explicit SDK migration before validation."
     },
-    id: { type: "string", minLength: 1, pattern: "^[a-z0-9][a-z0-9-]*$" },
-    name: { type: "string", minLength: 1 },
+    id: {
+      type: "string",
+      minLength: 1,
+      pattern: "^[a-z0-9][a-z0-9-]*$"
+    },
+    name: {
+      type: "string",
+      minLength: 1
+    },
     backend: {
       type: "object",
       additionalProperties: false,
-      required: ["provider"],
+      required: [
+        "provider"
+      ],
       properties: {
-        provider: { enum: ["supabase", "fayz-api", "fayz-shop", "mock", "custom"] },
-        projectRef: { type: "string", minLength: 1 },
-        url: { type: "string", minLength: 1 },
-        adapterId: { type: "string", minLength: 1 },
-        options: { type: "object" }
+        provider: {
+          enum: [
+            "supabase",
+            "fayz-api",
+            "fayz-shop",
+            "mock",
+            "custom"
+          ]
+        },
+        projectRef: {
+          type: "string",
+          minLength: 1
+        },
+        url: {
+          type: "string",
+          minLength: 1
+        },
+        adapterId: {
+          type: "string",
+          minLength: 1
+        },
+        options: {
+          type: "object"
+        }
+      }
+    },
+    locale: {
+      type: "object"
+    },
+    theme: {
+      type: "object"
+    },
+    permissions: {
+      type: "object"
+    },
+    billing: {
+      type: "object"
+    },
+    entities: {
+      type: "array",
+      items: {
+        type: "object"
       }
     },
-    locale: { type: "object" },
-    theme: { type: "object" },
-    permissions: { type: "object" },
-    billing: { type: "object" },
-    entities: { type: "array", items: { type: "object" } },
     surfaces: {
       type: "object",
       minProperties: 1,
-      additionalProperties: { $ref: "#/$defs/surface" }
+      additionalProperties: {
+        $ref: "#/$defs/surface"
+      }
+    },
+    limitDeclarations: {
+      type: "array",
+      description: "Resolved 4-layer limit-declaration merge (core < entity-derived < plugin < app) so server runtimes count exactly what the client counts.",
+      items: {
+        type: "object",
+        required: [
+          "key",
+          "table"
+        ],
+        additionalProperties: false,
+        properties: {
+          key: {
+            type: "string",
+            minLength: 1
+          },
+          label: {
+            type: "string"
+          },
+          table: {
+            type: "string",
+            minLength: 1
+          },
+          kindFilter: {
+            type: "string"
+          },
+          period: {
+            enum: [
+              "month",
+              "total"
+            ]
+          }
+        }
+      }
+    },
+    agent: {
+      $ref: "#/$defs/agentContract"
+    },
+    contractHash: {
+      type: "string",
+      minLength: 1,
+      description: "sha256 of the canonical serialization (excluding this field)."
     }
   },
   $defs: {
     surface: {
       type: "object",
-      required: ["scaffold"],
+      required: [
+        "scaffold"
+      ],
       additionalProperties: false,
       properties: {
-        scaffold: { type: "string", minLength: 1 },
-        options: { type: "object" },
-        plugins: { type: "array", items: { $ref: "#/$defs/pluginRef" } },
-        pages: { type: "array", items: { $ref: "#/$defs/page" } }
+        scaffold: {
+          type: "string",
+          minLength: 1
+        },
+        options: {
+          type: "object"
+        },
+        plugins: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/pluginRef"
+          }
+        },
+        pages: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/page"
+          }
+        }
       }
     },
     pluginRef: {
       type: "object",
-      required: ["id"],
+      required: [
+        "id"
+      ],
       additionalProperties: false,
       properties: {
-        id: { type: "string", minLength: 1 },
-        config: { type: "object" },
-        enabled: { type: "boolean" }
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        config: {
+          type: "object"
+        },
+        enabled: {
+          type: "boolean"
+        }
       }
     },
     page: {
       type: "object",
-      required: ["path"],
+      required: [
+        "path"
+      ],
       additionalProperties: false,
       description: "Exactly one of blocks/entity/component must be set.",
       properties: {
-        path: { type: "string", minLength: 1 },
-        label: { type: "string" },
-        icon: { type: "string" },
-        section: { enum: ["main", "secondary", "settings"] },
-        blocks: { type: "array", items: { $ref: "#/$defs/block" } },
-        entity: { type: "string", minLength: 1 },
-        component: { type: "string", minLength: 1 },
+        path: {
+          type: "string",
+          minLength: 1
+        },
+        label: {
+          type: "string"
+        },
+        icon: {
+          type: "string"
+        },
+        section: {
+          enum: [
+            "main",
+            "secondary",
+            "settings"
+          ]
+        },
+        blocks: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/block"
+          }
+        },
+        entity: {
+          type: "string",
+          minLength: 1
+        },
+        component: {
+          type: "string",
+          minLength: 1
+        },
         permission: {
           type: "object",
-          required: ["feature", "action"],
+          required: [
+            "feature",
+            "action"
+          ],
           additionalProperties: false,
           properties: {
-            feature: { type: "string", minLength: 1 },
-            action: { type: "string", minLength: 1 }
+            feature: {
+              type: "string",
+              minLength: 1
+            },
+            action: {
+              type: "string",
+              minLength: 1
+            }
           }
         }
       },
       oneOf: [
-        { required: ["blocks"] },
-        { required: ["entity"] },
-        { required: ["component"] }
+        {
+          required: [
+            "blocks"
+          ]
+        },
+        {
+          required: [
+            "entity"
+          ]
+        },
+        {
+          required: [
+            "component"
+          ]
+        }
       ]
     },
     block: {
       type: "object",
-      required: ["type"],
+      required: [
+        "type"
+      ],
       additionalProperties: false,
       properties: {
-        type: { type: "string", minLength: 1 },
-        id: { type: "string" },
-        props: { type: "object" },
-        children: { type: "array", items: { $ref: "#/$defs/block" } }
+        type: {
+          type: "string",
+          minLength: 1
+        },
+        id: {
+          type: "string"
+        },
+        props: {
+          type: "object"
+        },
+        children: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/block"
+          }
+        }
+      }
+    },
+    agentContract: {
+      type: "object",
+      additionalProperties: false,
+      description: "Everything a server-side agent runtime needs to operate the app without a browser. Derived from code at publish; synced to Fayz as the versioned AgentContract.",
+      properties: {
+        persona: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            name: {
+              type: "string"
+            },
+            systemPrompt: {
+              type: "string"
+            },
+            icon: {
+              type: "string"
+            }
+          }
+        },
+        executionPlane: {
+          enum: [
+            "client",
+            "server"
+          ]
+        },
+        entities: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/entityContract"
+          }
+        },
+        tools: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/aiToolContract"
+          }
+        },
+        registries: {
+          type: "array",
+          items: {
+            type: "object",
+            required: [
+              "pluginId",
+              "id"
+            ],
+            additionalProperties: false,
+            properties: {
+              pluginId: {
+                type: "string",
+                minLength: 1
+              },
+              id: {
+                type: "string",
+                minLength: 1
+              },
+              entityKey: {
+                type: "string"
+              },
+              readOnly: {
+                type: "boolean"
+              }
+            }
+          }
+        },
+        declaredFeatures: {
+          type: "array",
+          items: {
+            type: "object"
+          }
+        },
+        rpcs: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/rpcContract"
+          }
+        },
+        domainKnowledge: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            statuses: {
+              type: "object"
+            },
+            scheduleDefaults: {
+              type: "object"
+            },
+            businessRules: {
+              type: "array",
+              items: {
+                type: "object",
+                required: [
+                  "id",
+                  "description"
+                ],
+                additionalProperties: false,
+                properties: {
+                  id: {
+                    type: "string",
+                    minLength: 1
+                  },
+                  description: {
+                    type: "string",
+                    minLength: 1
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    entityContract: {
+      type: "object",
+      required: [
+        "key",
+        "label",
+        "data",
+        "fields"
+      ],
+      additionalProperties: false,
+      properties: {
+        key: {
+          type: "string",
+          minLength: 1
+        },
+        label: {
+          type: "string",
+          minLength: 1
+        },
+        labelPlural: {
+          type: "string"
+        },
+        limitKey: {
+          type: "string"
+        },
+        data: {
+          type: "object",
+          required: [
+            "table"
+          ],
+          additionalProperties: false,
+          properties: {
+            table: {
+              type: "string",
+              minLength: 1
+            },
+            schema: {
+              type: "string"
+            },
+            tenantScoped: {
+              type: "boolean"
+            },
+            tenantIdColumn: {
+              type: "string"
+            },
+            searchColumns: {
+              type: "array",
+              items: {
+                type: "string"
+              }
+            },
+            selectColumns: {
+              type: "string"
+            },
+            columnMap: {
+              type: "object"
+            },
+            archetype: {
+              type: "string"
+            },
+            archetypeKind: {
+              type: "string"
+            },
+            filters: {
+              type: "object"
+            }
+          }
+        },
+        fields: {
+          type: "array",
+          items: {
+            type: "object",
+            required: [
+              "key",
+              "label",
+              "type"
+            ],
+            additionalProperties: false,
+            properties: {
+              key: {
+                type: "string",
+                minLength: 1
+              },
+              label: {
+                type: "string"
+              },
+              type: {
+                type: "string",
+                minLength: 1
+              },
+              required: {
+                type: "boolean"
+              },
+              searchable: {
+                type: "boolean"
+              },
+              hint: {
+                type: "string"
+              },
+              options: {
+                type: "array",
+                items: {
+                  type: "string"
+                }
+              },
+              relationTable: {
+                type: "string"
+              }
+            }
+          }
+        },
+        permission: {
+          type: "object",
+          required: [
+            "feature",
+            "action"
+          ],
+          additionalProperties: false,
+          properties: {
+            feature: {
+              type: "string",
+              minLength: 1
+            },
+            action: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        }
+      }
+    },
+    aiToolContract: {
+      type: "object",
+      required: [
+        "id",
+        "name",
+        "description",
+        "mode"
+      ],
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        name: {
+          type: "string",
+          minLength: 1,
+          pattern: "^[a-zA-Z0-9_-]{1,64}$"
+        },
+        description: {
+          type: "string",
+          minLength: 1
+        },
+        mode: {
+          enum: [
+            "read",
+            "persist"
+          ]
+        },
+        parameters: {
+          type: "object"
+        },
+        permission: {
+          type: "object",
+          required: [
+            "feature",
+            "action"
+          ],
+          additionalProperties: false,
+          properties: {
+            feature: {
+              type: "string",
+              minLength: 1
+            },
+            action: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        },
+        limitKey: {
+          type: "string"
+        },
+        execution: {
+          oneOf: [
+            {
+              type: "object",
+              required: [
+                "plane",
+                "kind",
+                "rpc"
+              ],
+              additionalProperties: false,
+              properties: {
+                plane: {
+                  const: "server"
+                },
+                kind: {
+                  const: "rpc"
+                },
+                rpc: {
+                  type: "string",
+                  minLength: 1
+                }
+              }
+            },
+            {
+              type: "object",
+              required: [
+                "plane",
+                "kind",
+                "entity"
+              ],
+              additionalProperties: false,
+              properties: {
+                plane: {
+                  const: "server"
+                },
+                kind: {
+                  const: "entity_read"
+                },
+                entity: {
+                  type: "string",
+                  minLength: 1
+                }
+              }
+            },
+            {
+              type: "object",
+              required: [
+                "plane"
+              ],
+              additionalProperties: false,
+              properties: {
+                plane: {
+                  const: "client"
+                }
+              }
+            }
+          ]
+        },
+        requiresConfirmation: {
+          type: "boolean"
+        },
+        pluginId: {
+          type: "string"
+        },
+        category: {
+          type: "string"
+        }
+      }
+    },
+    rpcContract: {
+      type: "object",
+      required: [
+        "name",
+        "kind",
+        "description"
+      ],
+      additionalProperties: false,
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1,
+          pattern: "^agent_[a-z0-9_]+$"
+        },
+        kind: {
+          enum: [
+            "read",
+            "write"
+          ]
+        },
+        description: {
+          type: "string",
+          minLength: 1
+        },
+        payloadSchema: {
+          type: "object"
+        },
+        audits: {
+          type: "boolean"
+        }
       }
     }
   }
 };
-var ManifestContext = React2__namespace.createContext(null);
+var ManifestContext = React3__namespace.createContext(null);
 function useManifest() {
-  return React2__namespace.useContext(ManifestContext);
+  return React3__namespace.useContext(ManifestContext);
 }
 function defineApp(manifest) {
   const full = {
@@ -723,16 +2025,16 @@ function renderApp(input, opts = {}) {
   if (!surface) {
     throw new Error(`Surface "${surfaceName}" not found in manifest.`);
   }
-  const Scaffold = chunk5X2VX3RQ_cjs.getScaffold(surface.scaffold);
+  const Scaffold = chunkZOPJB5FN_cjs.getScaffold(surface.scaffold);
   if (!Scaffold) {
     throw new Error(
       `Scaffold "${surface.scaffold}" is not registered. Import the package that provides it (e.g. @fayz-ai/saas or @fayz-ai/shop) before calling renderApp.`
     );
   }
-  return React2__namespace.createElement(
+  return React3__namespace.createElement(
     ManifestContext.Provider,
     { value: manifest },
-    React2__namespace.createElement(Scaffold, { manifest, surface: surfaceName })
+    React3__namespace.createElement(Scaffold, { manifest, surface: surfaceName })
   );
 }
 var MAX_ENTRIES = 20;
@@ -793,275 +2095,283 @@ Object.defineProperty(exports, "assertPluginManifestContract", {
 });
 Object.defineProperty(exports, "FAYZ_CLOUD_PUBLISHABLE_KEY", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.FAYZ_CLOUD_PUBLISHABLE_KEY; }
+  get: function () { return chunkKSI2L3E4_cjs.FAYZ_CLOUD_PUBLISHABLE_KEY; }
 });
 Object.defineProperty(exports, "FAYZ_CLOUD_URL", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.FAYZ_CLOUD_URL; }
+  get: function () { return chunkKSI2L3E4_cjs.FAYZ_CLOUD_URL; }
 });
 Object.defineProperty(exports, "clearGlobalCache", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.clearGlobalCache; }
+  get: function () { return chunkKSI2L3E4_cjs.clearGlobalCache; }
+});
+Object.defineProperty(exports, "countByTenant", {
+  enumerable: true,
+  get: function () { return chunkKSI2L3E4_cjs.countByTenant; }
 });
 Object.defineProperty(exports, "createArchetypeProvider", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.createArchetypeProvider; }
+  get: function () { return chunkKSI2L3E4_cjs.createArchetypeProvider; }
 });
 Object.defineProperty(exports, "createCacheStore", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.createCacheStore; }
+  get: function () { return chunkKSI2L3E4_cjs.createCacheStore; }
 });
 Object.defineProperty(exports, "createFayzApiProvider", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.createFayzApiProvider; }
+  get: function () { return chunkKSI2L3E4_cjs.createFayzApiProvider; }
 });
 Object.defineProperty(exports, "createMockProvider", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.createMockProvider; }
+  get: function () { return chunkKSI2L3E4_cjs.createMockProvider; }
 });
 Object.defineProperty(exports, "createSupabaseProvider", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.createSupabaseProvider; }
+  get: function () { return chunkKSI2L3E4_cjs.createSupabaseProvider; }
 });
 Object.defineProperty(exports, "getActiveTenantId", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.getActiveTenantId; }
+  get: function () { return chunkKSI2L3E4_cjs.getActiveTenantId; }
 });
 Object.defineProperty(exports, "getFayzCloudClient", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.getFayzCloudClient; }
+  get: function () { return chunkKSI2L3E4_cjs.getFayzCloudClient; }
 });
 Object.defineProperty(exports, "getSupabaseClientOptional", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.getSupabaseClientOptional; }
+  get: function () { return chunkKSI2L3E4_cjs.getSupabaseClientOptional; }
 });
 Object.defineProperty(exports, "globalCache", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.globalCache; }
+  get: function () { return chunkKSI2L3E4_cjs.globalCache; }
+});
+Object.defineProperty(exports, "invalidateCount", {
+  enumerable: true,
+  get: function () { return chunkKSI2L3E4_cjs.invalidateCount; }
 });
 Object.defineProperty(exports, "resolveDataProvider", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.resolveDataProvider; }
+  get: function () { return chunkKSI2L3E4_cjs.resolveDataProvider; }
 });
 Object.defineProperty(exports, "setActiveTenantId", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.setActiveTenantId; }
+  get: function () { return chunkKSI2L3E4_cjs.setActiveTenantId; }
 });
 Object.defineProperty(exports, "setGlobalSupabaseClient", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.setGlobalSupabaseClient; }
+  get: function () { return chunkKSI2L3E4_cjs.setGlobalSupabaseClient; }
 });
 Object.defineProperty(exports, "stableKey", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.stableKey; }
+  get: function () { return chunkKSI2L3E4_cjs.stableKey; }
 });
 Object.defineProperty(exports, "withCache", {
   enumerable: true,
-  get: function () { return chunk54SRL7AJ_cjs.withCache; }
+  get: function () { return chunkKSI2L3E4_cjs.withCache; }
 });
 Object.defineProperty(exports, "clearEntityRegistry", {
   enumerable: true,
-  get: function () { return chunk2NTHNWEH_cjs.clearEntityRegistry; }
+  get: function () { return chunkUKU4RIWM_cjs.clearEntityRegistry; }
 });
 Object.defineProperty(exports, "deriveEntityKey", {
   enumerable: true,
-  get: function () { return chunk2NTHNWEH_cjs.deriveEntityKey; }
+  get: function () { return chunkUKU4RIWM_cjs.deriveEntityKey; }
 });
 Object.defineProperty(exports, "getAllEntities", {
   enumerable: true,
-  get: function () { return chunk2NTHNWEH_cjs.getAllEntities; }
+  get: function () { return chunkUKU4RIWM_cjs.getAllEntities; }
 });
 Object.defineProperty(exports, "getEntityByKey", {
   enumerable: true,
-  get: function () { return chunk2NTHNWEH_cjs.getEntityByKey; }
+  get: function () { return chunkUKU4RIWM_cjs.getEntityByKey; }
 });
 Object.defineProperty(exports, "registerEntity", {
   enumerable: true,
-  get: function () { return chunk2NTHNWEH_cjs.registerEntity; }
+  get: function () { return chunkUKU4RIWM_cjs.registerEntity; }
 });
 Object.defineProperty(exports, "PLUGIN_API_VERSION", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.PLUGIN_API_VERSION; }
+  get: function () { return chunkZOPJB5FN_cjs.PLUGIN_API_VERSION; }
 });
 Object.defineProperty(exports, "PluginRuntimeProvider", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.PluginRuntimeProvider; }
+  get: function () { return chunkZOPJB5FN_cjs.PluginRuntimeProvider; }
 });
 Object.defineProperty(exports, "Registry", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.Registry; }
+  get: function () { return chunkZOPJB5FN_cjs.Registry; }
 });
 Object.defineProperty(exports, "blockRegistry", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.blockRegistry; }
+  get: function () { return chunkZOPJB5FN_cjs.blockRegistry; }
 });
 Object.defineProperty(exports, "componentRegistry", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.componentRegistry; }
+  get: function () { return chunkZOPJB5FN_cjs.componentRegistry; }
 });
 Object.defineProperty(exports, "definePlugin", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.definePlugin; }
+  get: function () { return chunkZOPJB5FN_cjs.definePlugin; }
 });
 Object.defineProperty(exports, "getBlock", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getBlock; }
+  get: function () { return chunkZOPJB5FN_cjs.getBlock; }
 });
 Object.defineProperty(exports, "getComponent", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getComponent; }
+  get: function () { return chunkZOPJB5FN_cjs.getComponent; }
 });
 Object.defineProperty(exports, "getDashboardWidgets", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getDashboardWidgets; }
+  get: function () { return chunkZOPJB5FN_cjs.getDashboardWidgets; }
 });
 Object.defineProperty(exports, "getMetric", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getMetric; }
+  get: function () { return chunkZOPJB5FN_cjs.getMetric; }
 });
 Object.defineProperty(exports, "getPage", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getPage; }
+  get: function () { return chunkZOPJB5FN_cjs.getPage; }
 });
 Object.defineProperty(exports, "getPlugin", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getPlugin; }
+  get: function () { return chunkZOPJB5FN_cjs.getPlugin; }
 });
 Object.defineProperty(exports, "getPluginFactory", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getPluginFactory; }
+  get: function () { return chunkZOPJB5FN_cjs.getPluginFactory; }
 });
 Object.defineProperty(exports, "getScaffold", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getScaffold; }
+  get: function () { return chunkZOPJB5FN_cjs.getScaffold; }
 });
 Object.defineProperty(exports, "getWidgetsForZone", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.getWidgetsForZone; }
+  get: function () { return chunkZOPJB5FN_cjs.getWidgetsForZone; }
 });
 Object.defineProperty(exports, "isCustomId", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.isCustomId; }
+  get: function () { return chunkZOPJB5FN_cjs.isCustomId; }
 });
 Object.defineProperty(exports, "listBlocks", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.listBlocks; }
+  get: function () { return chunkZOPJB5FN_cjs.listBlocks; }
 });
 Object.defineProperty(exports, "listMetrics", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.listMetrics; }
+  get: function () { return chunkZOPJB5FN_cjs.listMetrics; }
 });
 Object.defineProperty(exports, "listPluginFactories", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.listPluginFactories; }
+  get: function () { return chunkZOPJB5FN_cjs.listPluginFactories; }
 });
 Object.defineProperty(exports, "listPlugins", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.listPlugins; }
+  get: function () { return chunkZOPJB5FN_cjs.listPlugins; }
 });
 Object.defineProperty(exports, "metricRegistry", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.metricRegistry; }
+  get: function () { return chunkZOPJB5FN_cjs.metricRegistry; }
 });
 Object.defineProperty(exports, "pageRegistry", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.pageRegistry; }
+  get: function () { return chunkZOPJB5FN_cjs.pageRegistry; }
 });
 Object.defineProperty(exports, "pluginFactoryRegistry", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.pluginFactoryRegistry; }
+  get: function () { return chunkZOPJB5FN_cjs.pluginFactoryRegistry; }
 });
 Object.defineProperty(exports, "pluginRegistry", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.pluginRegistry; }
+  get: function () { return chunkZOPJB5FN_cjs.pluginRegistry; }
 });
 Object.defineProperty(exports, "registerBlock", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.registerBlock; }
+  get: function () { return chunkZOPJB5FN_cjs.registerBlock; }
 });
 Object.defineProperty(exports, "registerComponent", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.registerComponent; }
+  get: function () { return chunkZOPJB5FN_cjs.registerComponent; }
 });
 Object.defineProperty(exports, "registerMetric", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.registerMetric; }
+  get: function () { return chunkZOPJB5FN_cjs.registerMetric; }
 });
 Object.defineProperty(exports, "registerPage", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.registerPage; }
+  get: function () { return chunkZOPJB5FN_cjs.registerPage; }
 });
 Object.defineProperty(exports, "registerPlugin", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.registerPlugin; }
+  get: function () { return chunkZOPJB5FN_cjs.registerPlugin; }
 });
 Object.defineProperty(exports, "registerPluginFactory", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.registerPluginFactory; }
+  get: function () { return chunkZOPJB5FN_cjs.registerPluginFactory; }
 });
 Object.defineProperty(exports, "registerScaffold", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.registerScaffold; }
+  get: function () { return chunkZOPJB5FN_cjs.registerScaffold; }
 });
 Object.defineProperty(exports, "resolvePluginComponent", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.resolvePluginComponent; }
+  get: function () { return chunkZOPJB5FN_cjs.resolvePluginComponent; }
 });
 Object.defineProperty(exports, "resolvePluginRuntime", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.resolvePluginRuntime; }
+  get: function () { return chunkZOPJB5FN_cjs.resolvePluginRuntime; }
 });
 Object.defineProperty(exports, "scaffoldRegistry", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.scaffoldRegistry; }
+  get: function () { return chunkZOPJB5FN_cjs.scaffoldRegistry; }
 });
 Object.defineProperty(exports, "useConnectorsForPlugin", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.useConnectorsForPlugin; }
+  get: function () { return chunkZOPJB5FN_cjs.useConnectorsForPlugin; }
 });
 Object.defineProperty(exports, "usePluginRuntime", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.usePluginRuntime; }
+  get: function () { return chunkZOPJB5FN_cjs.usePluginRuntime; }
 });
 Object.defineProperty(exports, "usePluginRuntimeOptional", {
   enumerable: true,
-  get: function () { return chunk5X2VX3RQ_cjs.usePluginRuntimeOptional; }
+  get: function () { return chunkZOPJB5FN_cjs.usePluginRuntimeOptional; }
 });
 Object.defineProperty(exports, "I18nProvider", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.I18nProvider; }
+  get: function () { return chunkCATASHPK_cjs.I18nProvider; }
 });
 Object.defineProperty(exports, "coreTranslations", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.coreTranslations; }
+  get: function () { return chunkCATASHPK_cjs.coreTranslations; }
 });
 Object.defineProperty(exports, "getCurrentLocale", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.getCurrentLocale; }
+  get: function () { return chunkCATASHPK_cjs.getCurrentLocale; }
 });
 Object.defineProperty(exports, "mergeTranslations", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.mergeTranslations; }
+  get: function () { return chunkCATASHPK_cjs.mergeTranslations; }
 });
 Object.defineProperty(exports, "registerTranslations", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.registerTranslations; }
+  get: function () { return chunkCATASHPK_cjs.registerTranslations; }
 });
 Object.defineProperty(exports, "setCurrentLocale", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.setCurrentLocale; }
+  get: function () { return chunkCATASHPK_cjs.setCurrentLocale; }
 });
 Object.defineProperty(exports, "setLocaleStore", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.setLocaleStore; }
+  get: function () { return chunkCATASHPK_cjs.setLocaleStore; }
 });
 Object.defineProperty(exports, "useI18nConfig", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.useI18nConfig; }
+  get: function () { return chunkCATASHPK_cjs.useI18nConfig; }
 });
 Object.defineProperty(exports, "useTranslation", {
   enumerable: true,
-  get: function () { return chunkQR7U2URY_cjs.useTranslation; }
+  get: function () { return chunkCATASHPK_cjs.useTranslation; }
 });
 Object.defineProperty(exports, "hashRouterAdapter", {
   enumerable: true,
@@ -1083,38 +2393,65 @@ exports.BlockChildren = BlockChildren;
 exports.BlockRenderer = BlockRenderer;
 exports.COUNTRIES = COUNTRIES;
 exports.CURRENT_MANIFEST_VERSION = CURRENT_MANIFEST_VERSION;
+exports.DATA_CHANGED_EVENT = DATA_CHANGED_EVENT;
 exports.DEFAULT_COUNTRY = DEFAULT_COUNTRY;
+exports.MIN_QUERY_LENGTH = MIN_QUERY_LENGTH;
 exports.WidgetZone = WidgetZone;
 exports.absoluteUrl = absoluteUrl;
 exports.appManifestSchema = app_manifest_schema_default;
 exports.applySeo = applySeo;
 exports.breadcrumbJsonLd = breadcrumbJsonLd;
 exports.buildCSV = buildCSV;
+exports.clearPostalCache = clearPostalCache;
+exports.clearSearchCache = clearSearchCache;
+exports.computeContractHash = computeContractHash;
 exports.createEventBus = createEventBus;
 exports.createSafeDataProvider = createSafeDataProvider;
+exports.createViaCepProvider = createViaCepProvider;
 exports.defineApp = defineApp;
+exports.digitsOf = digitsOf;
 exports.downloadCSV = downloadCSV;
+exports.emitDataChanged = emitDataChanged;
 exports.eventBus = eventBus;
 exports.exportCSV = exportCSV;
+exports.foldText = foldText;
+exports.foldWithMap = foldWithMap;
 exports.formatCurrency = formatCurrency;
 exports.formatDate = formatDate;
 exports.formatDateTime = formatDateTime;
+exports.formatPostalCode = formatPostalCode;
 exports.getActiveLocale = getActiveLocale;
 exports.getCountry = getCountry;
 exports.getDefaultCurrency = getDefaultCurrency;
+exports.getPostalLookupProvider = getPostalLookupProvider;
+exports.highlightRanges = highlightRanges;
+exports.isSearchIndexAvailable = isSearchIndexAvailable;
+exports.isValidPostalCode = isValidPostalCode;
+exports.lookupPostalCode = lookupPostalCode;
 exports.maskDigitCount = maskDigitCount;
 exports.maskPhone = maskPhone;
+exports.matchesDataChange = matchesDataChange;
 exports.migrateManifest = migrateManifest;
 exports.navHistoryBack = navHistoryBack;
+exports.normalizePostalCode = normalizePostalCode;
+exports.normalizeQuery = normalizeQuery;
 exports.organizationJsonLd = organizationJsonLd;
 exports.recordNavigation = recordNavigation;
 exports.registerManifestMigration = registerManifestMigration;
 exports.renderApp = renderApp;
 exports.renderBlocks = renderBlocks;
 exports.routeModule = routeModule;
+exports.scoreCandidate = scoreCandidate;
+exports.searchEverything = searchEverything;
 exports.seoOrigin = seoOrigin;
+exports.serializeManifest = serializeManifest;
+exports.serializeManifestWithHash = serializeManifestWithHash;
 exports.setDefaultCurrency = setDefaultCurrency;
+exports.setPostalLookupProvider = setPostalLookupProvider;
+exports.setSearchIndexAvailable = setSearchIndexAvailable;
+exports.similarity = similarity;
 exports.unmaskPhone = unmaskPhone;
+exports.useDataChanged = useDataChanged;
 exports.useManifest = useManifest;
 exports.useNavHistoryStore = useNavHistoryStore;
 exports.useNavReferrer = useNavReferrer;