@fayz-ai/core 0.8.2 → 0.8.4

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-XJKW2JRW.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-XJKW2JRW.js';
+import { globalCache, getActiveTenantId, getSupabaseClientOptional, resolveDataProvider } from './chunk-GULZD7XW.js';
+export { clearGlobalCache, countByTenant, createArchetypeProvider, createCacheStore, createFayzApiProvider, createMockProvider, createSupabaseProvider, getActiveTenantId, getSupabaseClientOptional, globalCache, invalidateCount, resolveDataProvider, setActiveTenantId, setGlobalSupabaseClient, stableKey, withCache } from './chunk-GULZD7XW.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-JHGXROKV.js';
-export { I18nProvider, coreTranslations, getCurrentLocale, mergeTranslations, registerTranslations, setCurrentLocale, setLocaleStore, useI18nConfig, useTranslation } from './chunk-JHGXROKV.js';
+import { getCurrentLocale } from './chunk-MJ4ML56F.js';
+export { I18nProvider, coreTranslations, getCurrentLocale, mergeTranslations, registerTranslations, setCurrentLocale, setLocaleStore, useI18nConfig, useTranslation } from './chunk-MJ4ML56F.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) {
@@ -331,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: {
@@ -399,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 }) {
@@ -1386,9 +1979,9 @@ var app_manifest_schema_default = {
     }
   }
 };
-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 = {
@@ -1420,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;
@@ -1466,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, clearPostalCache, computeContractHash, createEventBus, createSafeDataProvider, createViaCepProvider, defineApp, downloadCSV, eventBus, exportCSV, formatCurrency, formatDate, formatDateTime, formatPostalCode, getActiveLocale, getCountry, getDefaultCurrency, getPostalLookupProvider, isValidPostalCode, lookupPostalCode, maskDigitCount, maskPhone, migrateManifest, navHistoryBack, normalizePostalCode, organizationJsonLd, recordNavigation, registerManifestMigration, renderApp, renderBlocks, routeModule, seoOrigin, serializeManifest, serializeManifestWithHash, setDefaultCurrency, setPostalLookupProvider, 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