@fayz-ai/core 0.8.1 → 0.8.3

package/dist/index.js

@@ -1,15 +1,15 @@
 export { withAfterHooks } from './chunk-BBDNC3FP.js';
 export { PluginContractError, assertConnectorContract, assertPluginManifestContract } from './chunk-X5THHG6T.js';
-import { getSupabaseClientOptional } from './chunk-ZBIWYDAR.js';
-export { FAYZ_CLOUD_PUBLISHABLE_KEY, FAYZ_CLOUD_URL, clearGlobalCache, createArchetypeProvider, createCacheStore, createFayzApiProvider, createMockProvider, createSupabaseProvider, getActiveTenantId, getFayzCloudClient, getSupabaseClientOptional, globalCache, resolveDataProvider, setActiveTenantId, setGlobalSupabaseClient, stableKey, withCache } from './chunk-ZBIWYDAR.js';
-export { clearEntityRegistry, deriveEntityKey, getAllEntities, getEntityByKey, registerEntity } from './chunk-WKZVSKEU.js';
-import { getBlock, getScaffold } from './chunk-CHGX6UYR.js';
-export { PLUGIN_API_VERSION, PluginRuntimeProvider, Registry, blockRegistry, componentRegistry, definePlugin, getBlock, getComponent, getDashboardWidgets, getMetric, getPage, getPlugin, getPluginFactory, getScaffold, getWidgetsForZone, isCustomId, listBlocks, listMetrics, listPluginFactories, listPlugins, metricRegistry, pageRegistry, pluginFactoryRegistry, pluginRegistry, registerBlock, registerComponent, registerMetric, registerPage, registerPlugin, registerPluginFactory, registerScaffold, resolvePluginComponent, resolvePluginRuntime, scaffoldRegistry, useConnectorsForPlugin, usePluginRuntime, usePluginRuntimeOptional } from './chunk-CHGX6UYR.js';
-import { getCurrentLocale } from './chunk-KNIVT6XZ.js';
-export { I18nProvider, coreTranslations, getCurrentLocale, mergeTranslations, registerTranslations, setCurrentLocale, setLocaleStore, useI18nConfig, useTranslation } from './chunk-KNIVT6XZ.js';
+import { globalCache, getActiveTenantId, getSupabaseClientOptional, resolveDataProvider } from './chunk-TYPVSWLG.js';
+export { FAYZ_CLOUD_PUBLISHABLE_KEY, FAYZ_CLOUD_URL, clearGlobalCache, countByTenant, createArchetypeProvider, createCacheStore, createFayzApiProvider, createMockProvider, createSupabaseProvider, getActiveTenantId, getFayzCloudClient, getSupabaseClientOptional, globalCache, invalidateCount, resolveDataProvider, setActiveTenantId, setGlobalSupabaseClient, stableKey, withCache } from './chunk-TYPVSWLG.js';
+export { clearEntityRegistry, deriveEntityKey, getAllEntities, getEntityByKey, registerEntity } from './chunk-CU64QI4A.js';
+import { getBlock, getScaffold } from './chunk-YH25Y4FW.js';
+export { PLUGIN_API_VERSION, PluginRuntimeProvider, Registry, blockRegistry, componentRegistry, definePlugin, getBlock, getComponent, getDashboardWidgets, getMetric, getPage, getPlugin, getPluginFactory, getScaffold, getWidgetsForZone, isCustomId, listBlocks, listMetrics, listPluginFactories, listPlugins, metricRegistry, pageRegistry, pluginFactoryRegistry, pluginRegistry, registerBlock, registerComponent, registerMetric, registerPage, registerPlugin, registerPluginFactory, registerScaffold, resolvePluginComponent, resolvePluginRuntime, scaffoldRegistry, useConnectorsForPlugin, usePluginRuntime, usePluginRuntimeOptional } from './chunk-YH25Y4FW.js';
+import { getCurrentLocale } from './chunk-DZALZ6Q6.js';
+export { I18nProvider, coreTranslations, getCurrentLocale, mergeTranslations, registerTranslations, setCurrentLocale, setLocaleStore, useI18nConfig, useTranslation } from './chunk-DZALZ6Q6.js';
 export { hashRouterAdapter, windowRouterAdapter } from './chunk-Y2C2FBQP.js';
 export { FayzRuntimeError, createFayzRuntimeClient } from './chunk-7RTUHSKY.js';
-import * as React2 from 'react';
+import * as React3 from 'react';
 import { useEffect } from 'react';
 import { create } from 'zustand';
 
@@ -25,6 +25,97 @@ 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.useRef(handler);
+  ref.current = handler;
+  React3.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) {
+    globalCache.invalidate(`${getActiveTenantId() ?? "_"}:${payload.table}`);
+  } else {
+    globalCache.clear();
+  }
+  pending.push({ op: "unknown", source: "agent", ...payload });
+  if (flushTimer) return;
+  flushTimer = setTimeout(flush, 120);
+}
+function useDataChanged(match, handler, deps = []) {
+  const handlerRef = React3.useRef(handler);
+  handlerRef.current = handler;
+  const { table, entityKey, archetype } = match;
+  React3.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) {
@@ -84,6 +175,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 : "";
@@ -245,58 +422,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.useRef(handler);
-  ref.current = handler;
-  React2.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 `${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 = getSupabaseClientOptional();
+  const tenantId = 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 = 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.createElement(
+  return React3.createElement(
     "div",
     {
       style: {
@@ -313,14 +992,14 @@ function UnknownBlock({ type }) {
 function BlockRenderer({ node }) {
   const Comp = getBlock(node.type);
   const childEls = node.children?.length ? node.children.map(
-    (child, i) => React2.createElement(BlockRenderer, { key: child.id ?? `${child.type}-${i}`, node: child })
+    (child, i) => React3.createElement(BlockRenderer, { key: child.id ?? `${child.type}-${i}`, node: child })
   ) : null;
-  if (!Comp) return React2.createElement(UnknownBlock, { type: node.type });
-  return React2.createElement(Comp, { ...node.props ?? {}, node }, childEls);
+  if (!Comp) return React3.createElement(UnknownBlock, { type: node.type });
+  return React3.createElement(Comp, { ...node.props ?? {}, node }, childEls);
 }
 function renderBlocks(nodes) {
   return nodes.map(
-    (node, i) => React2.createElement(BlockRenderer, { key: node.id ?? `${node.type}-${i}`, node })
+    (node, i) => React3.createElement(BlockRenderer, { key: node.id ?? `${node.type}-${i}`, node })
   );
 }
 function BlockChildren({ node }) {
@@ -329,7 +1008,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"]);
@@ -343,7 +1022,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"]);
@@ -355,6 +1037,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;
@@ -392,6 +1075,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");
@@ -552,7 +1250,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}`);
     }
   }
 }
@@ -573,113 +1271,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"
+          }
+        }
+      }
+    },
+    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: {
-        type: { type: "string", minLength: 1 },
-        id: { type: "string" },
-        props: { type: "object" },
-        children: { type: "array", items: { $ref: "#/$defs/block" } }
+        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.createContext(null);
+var ManifestContext = React3.createContext(null);
 function useManifest() {
-  return React2.useContext(ManifestContext);
+  return React3.useContext(ManifestContext);
 }
 function defineApp(manifest) {
   const full = {
@@ -711,10 +2013,10 @@ function renderApp(input, opts = {}) {
       `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.createElement(
+  return React3.createElement(
     ManifestContext.Provider,
     { value: manifest },
-    React2.createElement(Scaffold, { manifest, surface: surfaceName })
+    React3.createElement(Scaffold, { manifest, surface: surfaceName })
   );
 }
 var MAX_ENTRIES = 20;
@@ -757,6 +2059,6 @@ function routeModule(path) {
   return path.replace(/^\/+/, "").split("/")[0] ?? "";
 }
 
-export { BlockChildren, BlockRenderer, COUNTRIES, CURRENT_MANIFEST_VERSION, DEFAULT_COUNTRY, WidgetZone, absoluteUrl, app_manifest_schema_default as appManifestSchema, applySeo, breadcrumbJsonLd, buildCSV, createEventBus, createSafeDataProvider, defineApp, downloadCSV, eventBus, exportCSV, formatCurrency, formatDate, formatDateTime, getActiveLocale, getCountry, getDefaultCurrency, maskDigitCount, maskPhone, migrateManifest, navHistoryBack, organizationJsonLd, recordNavigation, registerManifestMigration, renderApp, renderBlocks, routeModule, seoOrigin, setDefaultCurrency, unmaskPhone, useManifest, useNavHistoryStore, useNavReferrer, useOnEvent, useSeo, validateManifest };
+export { BlockChildren, BlockRenderer, COUNTRIES, CURRENT_MANIFEST_VERSION, DATA_CHANGED_EVENT, DEFAULT_COUNTRY, MIN_QUERY_LENGTH, WidgetZone, absoluteUrl, app_manifest_schema_default as appManifestSchema, applySeo, breadcrumbJsonLd, buildCSV, clearPostalCache, clearSearchCache, computeContractHash, createEventBus, createSafeDataProvider, createViaCepProvider, defineApp, digitsOf, downloadCSV, emitDataChanged, eventBus, exportCSV, foldText, foldWithMap, formatCurrency, formatDate, formatDateTime, formatPostalCode, getActiveLocale, getCountry, getDefaultCurrency, getPostalLookupProvider, highlightRanges, isSearchIndexAvailable, isValidPostalCode, lookupPostalCode, maskDigitCount, maskPhone, matchesDataChange, migrateManifest, navHistoryBack, normalizePostalCode, normalizeQuery, organizationJsonLd, recordNavigation, registerManifestMigration, renderApp, renderBlocks, routeModule, scoreCandidate, searchEverything, seoOrigin, serializeManifest, serializeManifestWithHash, setDefaultCurrency, setPostalLookupProvider, setSearchIndexAvailable, similarity, unmaskPhone, useDataChanged, useManifest, useNavHistoryStore, useNavReferrer, useOnEvent, useSeo, validateManifest };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map