@ai-matrx/agents 0.6.2 → 0.7.0

package/dist/catalog/index.cjs

@@ -0,0 +1,1344 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// catalog/index.ts
+var catalog_exports = {};
+__export(catalog_exports, {
+  AGENT_CARDS_LIMIT_DESKTOP: () => AGENT_CARDS_LIMIT_DESKTOP,
+  AGENT_CARDS_LIMIT_MOBILE: () => AGENT_CARDS_LIMIT_MOBILE,
+  AGENT_LIST_ITEMS_PER_PAGE: () => AGENT_LIST_ITEMS_PER_PAGE,
+  AGENT_NONE_SENTINEL: () => AGENT_NONE_SENTINEL,
+  AGENT_SEARCH_LIMIT: () => AGENT_SEARCH_LIMIT,
+  AgentCatalogConfigError: () => AgentCatalogConfigError,
+  AgentCatalogReadError: () => AgentCatalogReadError,
+  DEFAULT_AGENT_CATALOG_LABELS: () => DEFAULT_AGENT_CATALOG_LABELS,
+  DEFAULT_AGENT_CONSUMER_STATE: () => DEFAULT_AGENT_CONSUMER_STATE,
+  MandateDefaultRowError: () => MandateDefaultRowError,
+  _resetCatalogGlobalState: () => _resetCatalogGlobalState,
+  agentConsumerHasActiveFilters: () => agentConsumerHasActiveFilters,
+  agentListEmptyLabel: () => agentListEmptyLabel,
+  agentMatchesSearch: () => agentMatchesSearch,
+  applyAgentSortComparator: () => applyAgentSortComparator,
+  asAgentId: () => asAgentId,
+  assertAgentCatalogSchema: () => assertAgentCatalogSchema,
+  computeAgentSearchScore: () => computeAgentSearchScore,
+  createAgentCatalog: () => createAgentCatalog,
+  createMemoryStorage: () => createMemoryStorage,
+  defaultRowFromResolution: () => defaultRowFromResolution,
+  defaultStorage: () => defaultStorage,
+  detectDefaultRowDrift: () => detectDefaultRowDrift,
+  filterBuiltinTypeAgents: () => filterBuiltinTypeAgents,
+  filterUserTypeAgents: () => filterUserTypeAgents,
+  getRegisteredAgentCatalog: () => getRegisteredAgentCatalog,
+  isMandateAgentId: () => isMandateAgentId,
+  makeSelectFilteredAgents: () => makeSelectFilteredAgents,
+  makeSelectFilteredAgentsCount: () => makeSelectFilteredAgentsCount,
+  makeSelectFilteredBuiltinAgents: () => makeSelectFilteredBuiltinAgents,
+  makeSelectFilteredBuiltinAgentsCount: () => makeSelectFilteredBuiltinAgentsCount,
+  makeSelectFilteredOwnedAgents: () => makeSelectFilteredOwnedAgents,
+  makeSelectFilteredSharedAgents: () => makeSelectFilteredSharedAgents,
+  makeSelectOwnedAgentCards: () => makeSelectOwnedAgentCards,
+  makeSelectOwnedAgentListItems: () => makeSelectOwnedAgentListItems,
+  makeSelectSharedAgentCards: () => makeSelectSharedAgentCards,
+  makeSelectSharedAgentListItems: () => makeSelectSharedAgentListItems,
+  mandateAgentId: () => mandateAgentId,
+  memoize1: () => memoize1,
+  memoize2: () => memoize2,
+  memoize3: () => memoize3,
+  parseMandateResolution: () => parseMandateResolution,
+  readAgentCatalogRows: () => readAgentCatalogRows,
+  readCachedDefaultRow: () => readCachedDefaultRow,
+  readSingleAgentRow: () => readSingleAgentRow,
+  resolveDefaultRow: () => resolveDefaultRow,
+  searchAgentsOnServer: () => searchAgentsOnServer,
+  selectAllAgentCategories: () => selectAllAgentCategories,
+  selectAllAgentTags: () => selectAllAgentTags,
+  selectAllSystemAgentCategories: () => selectAllSystemAgentCategories,
+  selectAllSystemAgentTags: () => selectAllSystemAgentTags,
+  selectBuiltinTypeAgents: () => selectBuiltinTypeAgents,
+  selectTotalBuiltinAgentsCount: () => selectTotalBuiltinAgentsCount,
+  selectTotalFavoriteAgentsCount: () => selectTotalFavoriteAgentsCount,
+  selectTotalOwnedAgentsCount: () => selectTotalOwnedAgentsCount,
+  selectTotalSharedAgentsCount: () => selectTotalSharedAgentsCount,
+  selectTotalUserAgentsCount: () => selectTotalUserAgentsCount,
+  selectUserTypeAgents: () => selectUserTypeAgents,
+  shouldDefaultAgentListToPublicTab: () => shouldDefaultAgentListToPublicTab,
+  sortFilteredAgents: () => sortFilteredAgents,
+  toAgentSummary: () => toAgentSummary,
+  writeAgentFavorite: () => writeAgentFavorite,
+  writeCachedDefaultRow: () => writeCachedDefaultRow
+});
+module.exports = __toCommonJS(catalog_exports);
+
+// catalog/types.ts
+function asAgentId(value) {
+  return value;
+}
+function mandateAgentId(mandateKey) {
+  return `mandate:${mandateKey}`;
+}
+function isMandateAgentId(id) {
+  return id.startsWith("mandate:");
+}
+var AGENT_NONE_SENTINEL = "__none__";
+var DEFAULT_AGENT_CONSUMER_STATE = {
+  tab: "mine",
+  sortBy: "updated-desc",
+  searchTerm: "",
+  includedCats: [],
+  includedTags: [],
+  favFilter: "all",
+  archFilter: "active",
+  accessFilter: "any",
+  favoritesFirst: true,
+  listPage: 1,
+  sharedPage: 1,
+  serverMatchedIds: [],
+  isServerSearching: false,
+  deepSearch: false
+};
+var AgentCatalogConfigError = class extends Error {
+  name = "AgentCatalogConfigError";
+  /** Machine code, for a host that routes config failures. */
+  code;
+  /** What the host must do, in a sentence a person can act on. */
+  remedy;
+  constructor(args) {
+    super(`${args.message} \u2014 ${args.remedy}`);
+    this.code = args.code;
+    this.remedy = args.remedy;
+  }
+};
+
+// catalog/ports.ts
+var DEFAULT_AGENT_CATALOG_LABELS = {
+  publicTab: "Public",
+  systemBadge: "system",
+  searchPlaceholder: "Search agents...",
+  currentAgentHeading: "Current agent",
+  emptyDefault: "No agents found",
+  emptyShared: "No shared agents found",
+  emptySystem: "No system agents found",
+  loading: "Loading...",
+  triggerFallback: "Agents",
+  triggerResolving: "Naming the agent\u2026",
+  triggerUnnameable: "An agent this list cannot name",
+  hoverHint: "Hover an agent to preview its details, or click to select."
+};
+
+// catalog/data.ts
+var import_db = require("@ai-matrx/data/db");
+
+// catalog/rows.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" ? value : null;
+}
+function bool(value) {
+  return value === true;
+}
+function boolOrNull(value) {
+  return typeof value === "boolean" ? value : null;
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === "string");
+}
+function agentType(value) {
+  return value === "builtin" ? "builtin" : "user";
+}
+function toAgentSummary(raw) {
+  if (!isRecord(raw)) return null;
+  const id = str(raw["id"]);
+  if (!id) return null;
+  return {
+    id: asAgentId(id),
+    name: str(raw["name"]),
+    description: str(raw["description"]),
+    category: str(raw["category"]),
+    tags: stringArray(raw["tags"]),
+    agentType: agentType(raw["agent_type"]),
+    modelId: str(raw["model_id"]),
+    isActive: bool(raw["is_active"]),
+    isArchived: bool(raw["is_archived"]),
+    isFavorite: bool(raw["is_favorite"]),
+    createdBy: str(raw["created_by"]),
+    organizationId: str(raw["organization_id"]),
+    taskId: str(raw["task_id"]),
+    sourceAgentId: str(raw["source_agent_id"]),
+    createdAt: str(raw["created_at"]),
+    updatedAt: str(raw["updated_at"]),
+    isOwner: boolOrNull(raw["is_owner"]),
+    accessLevel: str(raw["access_level"]),
+    sharedByEmail: str(raw["shared_by_email"])
+  };
+}
+
+// catalog/data.ts
+var LIST_PAGE_SIZE = 1e3;
+var AGENT_SEARCH_LIMIT = 50;
+var AgentCatalogReadError = class extends Error {
+  name = "AgentCatalogReadError";
+  source;
+  constructor(source, detail) {
+    super(`${source}: ${detail}`);
+    this.source = source;
+  }
+};
+function pgDetail(error) {
+  return error.code ? `${error.message} (${error.code})` : error.message;
+}
+async function readAgentCatalogRows(client) {
+  const raw = await (0, import_db.readAllRows)(
+    ({ from, to }) => Promise.resolve(
+      client.rpc("agx_get_list_full", {}, { count: "exact" }).order("id", { ascending: true }).range(from, to)
+    ).then((res) => ({
+      // `data` crosses a HOST-generated-type boundary, so it arrives as
+      // `unknown` and is narrowed here rather than asserted anywhere.
+      data: Array.isArray(res.data) ? res.data : null,
+      error: res.error,
+      count: res.count ?? null
+    })),
+    { label: "agx_get_list_full", pageSize: LIST_PAGE_SIZE }
+  );
+  const rows = [];
+  let dropped = 0;
+  for (const item of raw) {
+    const summary = toAgentSummary(item);
+    if (summary) rows.push(summary);
+    else dropped += 1;
+  }
+  if (dropped > 0) {
+    throw new AgentCatalogReadError(
+      "agx_get_list_full",
+      `${dropped} row(s) came back without an id and were refused. A row that cannot be identified cannot be selected, so the catalogue is not trustworthy \u2014 check the RPC's return shape.`
+    );
+  }
+  return rows;
+}
+async function searchAgentsOnServer(client, args) {
+  const q = args.query.trim();
+  if (!q) return { ids: [], rows: [] };
+  const { data, error } = await client.rpc("agx_search", {
+    p_query: q,
+    p_deep: args.deep ?? false,
+    p_limit: args.limit ?? AGENT_SEARCH_LIMIT,
+    p_offset: 0
+  });
+  if (error) throw new AgentCatalogReadError("agx_search", pgDetail(error));
+  const rows = [];
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      const summary = toAgentSummary(item);
+      if (summary) rows.push(summary);
+    }
+  }
+  return { ids: rows.map((r) => r.id), rows };
+}
+async function readSingleAgentRow(client, agentId) {
+  try {
+    const hit = await searchAgentsOnServer(client, {
+      query: agentId,
+      limit: 5
+    });
+    const exact = hit.rows.find((r) => r.id === agentId);
+    if (exact) return exact;
+  } catch {
+  }
+  const { data, error } = await client.rpc("agx_resolve_agent_address", {
+    p_ids: [agentId]
+  });
+  if (error) {
+    throw new AgentCatalogReadError(
+      "agx_resolve_agent_address",
+      pgDetail(error)
+    );
+  }
+  if (!Array.isArray(data)) return null;
+  for (const item of data) {
+    if (typeof item !== "object" || item === null) continue;
+    const record = item;
+    if (record["agent_id"] !== agentId) continue;
+    const name = record["agent_name"];
+    return toAgentSummary({
+      id: agentId,
+      name: typeof name === "string" ? name : null,
+      agent_type: record["agent_type"],
+      is_active: true
+    });
+  }
+  return null;
+}
+async function writeAgentFavorite(client, agentId, isFavorite) {
+  const { error } = await client.schema("agent").from("definition").update({ is_favorite: isFavorite }).eq("id", agentId);
+  if (error) {
+    throw new AgentCatalogReadError(
+      "agent.definition.is_favorite",
+      pgDetail(error)
+    );
+  }
+}
+
+// catalog/default-row.ts
+var CACHE_PREFIX = "ai-matrx.agents.catalog.default-row:";
+var MandateDefaultRowError = class extends Error {
+  name = "MandateDefaultRowError";
+  mandateKey;
+  remedy;
+  constructor(args) {
+    super(`${args.message} \u2014 ${args.remedy}`);
+    this.mandateKey = args.mandateKey;
+    this.remedy = args.remedy;
+  }
+};
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseMandateResolution(mandateKey, raw) {
+  if (!isRecord2(raw)) {
+    throw new MandateDefaultRowError({
+      mandateKey,
+      message: `mandate "${mandateKey}": the resolution endpoint did not return an object`,
+      remedy: "check that the transport points at the AI Matrx server and that GET /mandates/{key}/resolution is reachable"
+    });
+  }
+  const agentId = raw["agent_id"];
+  const definitionAgentId = raw["definition_agent_id"];
+  const provenance = raw["provenance"];
+  const holderType = raw["holder_type"];
+  return {
+    mandateKey: typeof raw["mandate_key"] === "string" ? raw["mandate_key"] : mandateKey,
+    holderType: typeof holderType === "string" ? holderType : "agent",
+    agentId: typeof agentId === "string" ? agentId : null,
+    isVersion: raw["is_version"] === true,
+    definitionAgentId: typeof definitionAgentId === "string" ? definitionAgentId : null,
+    provenance: typeof provenance === "string" ? provenance : "system"
+  };
+}
+async function askTheServer(transport, mandateKey) {
+  const path = `/mandates/${encodeURIComponent(mandateKey)}/resolution`;
+  const response = await transport.fetch(path, {
+    method: "GET",
+    headers: { Accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new MandateDefaultRowError({
+      mandateKey,
+      message: `mandate "${mandateKey}": the server refused to resolve it (HTTP ${response.status})`,
+      remedy: response.status === 404 ? "the mandate does not exist \u2014 check the key this picker was given" : "check the caller's session and organization context, then retry"
+    });
+  }
+  return parseMandateResolution(mandateKey, await response.json());
+}
+function createMemoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    getItem: (k) => map.get(k) ?? null,
+    setItem: (k, v) => {
+      map.set(k, v);
+    },
+    removeItem: (k) => {
+      map.delete(k);
+    }
+  };
+}
+function defaultStorage() {
+  try {
+    const ls = globalThis.localStorage;
+    if (ls) {
+      const probe = `${CACHE_PREFIX}__probe__`;
+      ls.setItem(probe, "1");
+      ls.removeItem(probe);
+      return ls;
+    }
+  } catch {
+  }
+  return createMemoryStorage();
+}
+function readCachedDefaultRow(storage, mandateKey) {
+  try {
+    const raw = storage.getItem(CACHE_PREFIX + mandateKey);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!isRecord2(parsed)) return null;
+    const holderId = parsed["holderId"];
+    const holderName = parsed["holderName"];
+    if (typeof holderId !== "string" || typeof holderName !== "string") {
+      return null;
+    }
+    const description = parsed["holderDescription"];
+    const provenance = parsed["provenance"];
+    const at = parsed["at"];
+    return {
+      mandateKey,
+      holderId,
+      holderName,
+      holderDescription: typeof description === "string" ? description : null,
+      provenance: typeof provenance === "string" ? provenance : "system",
+      at: typeof at === "number" ? at : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function writeCachedDefaultRow(storage, resolved) {
+  try {
+    storage.setItem(CACHE_PREFIX + resolved.mandateKey, JSON.stringify(resolved));
+  } catch {
+  }
+}
+function defaultRowFromResolution(resolved) {
+  return {
+    id: mandateAgentId(resolved.mandateKey),
+    name: resolved.holderName,
+    description: resolved.holderDescription,
+    category: null,
+    tags: [],
+    agentType: "builtin",
+    modelId: null,
+    isActive: true,
+    isArchived: false,
+    isFavorite: false,
+    createdBy: null,
+    organizationId: null,
+    taskId: null,
+    sourceAgentId: resolved.holderId,
+    createdAt: null,
+    updatedAt: null,
+    isOwner: null,
+    accessLevel: null,
+    sharedByEmail: null,
+    mandateKey: resolved.mandateKey
+  };
+}
+function detectDefaultRowDrift(cached, live) {
+  if (!cached) return null;
+  if (cached.holderId !== live.holderId) {
+    return `The default agent for "${live.mandateKey}" changed: this screen was showing "${cached.holderName}", and the platform now resolves it to "${live.holderName}". The list below is correct; anything that cached the old name is not.`;
+  }
+  if (cached.holderName !== live.holderName) {
+    return `The default agent for "${live.mandateKey}" was renamed: "${cached.holderName}" is now "${live.holderName}".`;
+  }
+  return null;
+}
+async function resolveDefaultRow(args) {
+  const { mandateKey, transport, client, storage, lookupRow } = args;
+  const cached = readCachedDefaultRow(storage, mandateKey);
+  const verdict = await askTheServer(transport, mandateKey);
+  if (verdict.holderType !== "agent") {
+    throw new MandateDefaultRowError({
+      mandateKey,
+      message: `mandate "${mandateKey}": the ${verdict.provenance} rung names a ${verdict.holderType} Holder, and an agent picker can only offer an agent`,
+      remedy: `rebind the ${verdict.provenance} rung to an agent, or drop defaultMandateKey from this picker`
+    });
+  }
+  const holderId = verdict.definitionAgentId ?? verdict.agentId;
+  if (!holderId) {
+    throw new MandateDefaultRowError({
+      mandateKey,
+      message: `mandate "${mandateKey}": the server resolved it without naming an agent`,
+      remedy: `bind the ${verdict.provenance} rung to an agent`
+    });
+  }
+  let holder = lookupRow(holderId);
+  if (!holder) {
+    holder = await readSingleAgentRow(client, holderId) ?? void 0;
+  }
+  if (!holder || !holder.name) {
+    throw new MandateDefaultRowError({
+      mandateKey,
+      message: `mandate "${mandateKey}": its Holder resolved, but nothing this caller can read could name that agent`,
+      remedy: "grant this user access to the Holder, or make it a platform agent \u2014 the picker will not print a placeholder name in its place"
+    });
+  }
+  const resolved = {
+    mandateKey,
+    holderId,
+    holderName: holder.name,
+    holderDescription: holder.description,
+    provenance: verdict.provenance,
+    at: Date.now()
+  };
+  const drift = detectDefaultRowDrift(cached, resolved);
+  writeCachedDefaultRow(storage, resolved);
+  return { resolved, row: defaultRowFromResolution(resolved), drift };
+}
+
+// catalog/global-state.ts
+var STATE_SLOT = /* @__PURE__ */ Symbol.for("ai-matrx.agents.catalog");
+function getCatalogGlobalState() {
+  const holder = globalThis;
+  let state = holder[STATE_SLOT];
+  if (!state) {
+    state = {
+      catalogs: /* @__PURE__ */ new Map(),
+      listInFlight: /* @__PURE__ */ new Map(),
+      listFetchedAt: /* @__PURE__ */ new Map(),
+      defaultRows: /* @__PURE__ */ new Map()
+    };
+    holder[STATE_SLOT] = state;
+  }
+  return state;
+}
+function _resetCatalogGlobalState() {
+  const state = getCatalogGlobalState();
+  state.catalogs.clear();
+  state.listInFlight.clear();
+  state.listFetchedAt.clear();
+  state.defaultRows.clear();
+}
+
+// catalog/schema.ts
+var BAD_UUID = "00000000-0000-0000-0000-000000000000";
+var SELF_TEST_MISSING_RPC = "agx_this_function_does_not_exist_probe";
+var DEMANDED_RPCS = {
+  agx_get_list_full: {},
+  agx_search: { p_query: "__probe__", p_deep: false, p_limit: 1, p_offset: 0 },
+  agx_resolve_agent_address: { p_ids: [BAD_UUID] }
+};
+function isMissingFunctionError(error) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  return code === "PGRST202" || code === "42883";
+}
+async function assertAgentCatalogSchema(client, options = {}) {
+  const {
+    selfTest = false,
+    throwOnViolation = true,
+    probeWrite = true
+  } = options;
+  const names = Object.keys(DEMANDED_RPCS);
+  if (selfTest) names.push(SELF_TEST_MISSING_RPC);
+  const missing = [];
+  const unreachable = [];
+  const answered = [];
+  for (const fn of names) {
+    const args = DEMANDED_RPCS[fn] ?? {};
+    try {
+      const { error } = await client.rpc(fn, args);
+      if (error == null) answered.push(fn);
+      else if (isMissingFunctionError(error)) missing.push(fn);
+      else answered.push(fn);
+    } catch (e) {
+      unreachable.push({ fn, error: e });
+    }
+  }
+  if (selfTest) {
+    const selfTestMissing = missing.includes(SELF_TEST_MISSING_RPC);
+    const idx = missing.indexOf(SELF_TEST_MISSING_RPC);
+    if (idx >= 0) missing.splice(idx, 1);
+    const answeredIdx = answered.indexOf(SELF_TEST_MISSING_RPC);
+    if (answeredIdx >= 0) answered.splice(answeredIdx, 1);
+    if (!selfTestMissing) {
+      throw new Error(
+        `assertAgentCatalogSchema self-test FAILED: the fabricated function "${SELF_TEST_MISSING_RPC}" did not come back as missing. This probe cannot currently fail, so its green result proves nothing \u2014 the client is swallowing or faking errors.`
+      );
+    }
+  }
+  let favoriteWritable = null;
+  if (probeWrite) {
+    try {
+      const { error } = await client.schema("agent").from("definition").update({ is_favorite: false }).eq("id", BAD_UUID);
+      favoriteWritable = !isPermissionRefusal(error);
+    } catch (e) {
+      unreachable.push({ fn: "agent.definition.is_favorite", error: e });
+    }
+  }
+  if (unreachable.length > 0) {
+    throw new Error(
+      `assertAgentCatalogSchema could not complete: ${unreachable.length} probe call(s) failed to reach the database (${unreachable.map((u) => u.fn).join(", ")}). This is NOT a schema verdict \u2014 fix connectivity and re-run.`
+    );
+  }
+  const ok = missing.length === 0 && favoriteWritable !== false;
+  const report = {
+    ok,
+    missing,
+    unreachable,
+    answered,
+    favoriteWritable
+  };
+  if (!ok && throwOnViolation) {
+    const parts = [];
+    if (missing.length > 0) {
+      parts.push(
+        `cannot answer ${missing.length} demanded function(s): ${missing.join(", ")}`
+      );
+    }
+    if (favoriteWritable === false) {
+      parts.push("refuses a write to agent.definition.is_favorite");
+    }
+    throw new Error(
+      `DEMANDED SCHEMA VIOLATION: the database this client points at ${parts.join("; and ")}. @ai-matrx/agents/catalog cannot render a correct picker against it \u2014 point the client at Matrx Main, or apply the agx_* migrations.`
+    );
+  }
+  return report;
+}
+function isPermissionRefusal(error) {
+  if (!error) return false;
+  const code = error.code;
+  return code === "42501" || code === "42P01" || code === "PGRST205";
+}
+
+// catalog/store.ts
+var LIST_TTL_MS = 15 * 60 * 1e3;
+var LIST_STALE_MS = 4 * 60 * 60 * 1e3;
+function createDefaultErrorSink() {
+  let announced = false;
+  return (event) => {
+    if (!announced) {
+      announced = true;
+      console.error(
+        "[@ai-matrx/agents/catalog] no errorSink is bound, so failures are only reaching the console. Pass `errorSink` to createAgentCatalog to route them into your diagnostics surface."
+      );
+    }
+    console.error(`[@ai-matrx/agents/catalog] ${event.code}: ${event.message}`, {
+      ...event.context ?? {}
+    });
+  };
+}
+function errorMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function createAgentCatalog(config) {
+  if (!config || typeof config !== "object") {
+    throw new AgentCatalogConfigError({
+      code: "missing_config",
+      message: "createAgentCatalog was called without a config object",
+      remedy: "pass { client, identity }"
+    });
+  }
+  if (!config.client || typeof config.client.rpc !== "function") {
+    throw new AgentCatalogConfigError({
+      code: "missing_client",
+      message: "createAgentCatalog needs a Supabase client \u2014 it IS the catalogue read",
+      remedy: "pass `client` (a supabase-js client, or anything with rpc() and schema().from())"
+    });
+  }
+  if (typeof config.client.schema !== "function") {
+    throw new AgentCatalogConfigError({
+      code: "client_cannot_write",
+      message: "the client passed to createAgentCatalog has no schema() \u2014 the favorite write has nowhere to go",
+      remedy: "pass a full supabase-js client"
+    });
+  }
+  if (!config.identity || typeof config.identity.requireUserId !== "function") {
+    throw new AgentCatalogConfigError({
+      code: "missing_identity",
+      message: "createAgentCatalog needs to know who is asking",
+      remedy: "pass `identity: { requireUserId() }` \u2014 never a silent anonymous read"
+    });
+  }
+  const catalogId = config.catalogId ?? "default";
+  const client = config.client;
+  const identity = config.identity;
+  const errorSink = config.errorSink ?? createDefaultErrorSink();
+  const notifier = config.notifier;
+  const storage = config.storage ?? defaultStorage();
+  const transport = config.transport;
+  const labels = {
+    ...DEFAULT_AGENT_CATALOG_LABELS,
+    ...config.labels ?? {}
+  };
+  const globalState = getCatalogGlobalState();
+  if (globalState.catalogs.has(catalogId)) {
+    errorSink({
+      code: "catalog_replaced",
+      message: `a second agent catalog was created under id "${catalogId}" and has REPLACED the first. Two catalogs with one id share a freshness stamp and an in-flight promise; give each one its own \`catalogId\`.`
+    });
+  }
+  let state = {
+    rows: [],
+    byId: {},
+    status: "idle",
+    error: null,
+    consumers: {},
+    defaultRows: {}
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  function publish(next) {
+    state = next;
+    for (const listener of listeners) listener();
+  }
+  function mergeRows(incoming) {
+    if (incoming.length === 0) return;
+    const byId = { ...state.byId };
+    for (const row of incoming) byId[row.id] = row;
+    publish({ ...state, byId, rows: Object.values(byId) });
+  }
+  function replaceRows(incoming) {
+    const byId = {};
+    for (const row of incoming) byId[row.id] = row;
+    publish({ ...state, byId, rows: Object.values(byId) });
+  }
+  let anonymousReported = false;
+  function getUserIdOrNull() {
+    try {
+      return identity.requireUserId();
+    } catch (e) {
+      if (!anonymousReported) {
+        anonymousReported = true;
+        errorSink({
+          code: "identity_unavailable",
+          message: "identity.requireUserId() threw, so the picker is treating this session as signed out and opening on the public catalogue. Favoriting is unavailable until a session exists.",
+          context: { detail: errorMessage(e) }
+        });
+      }
+      return null;
+    }
+  }
+  function isFresh() {
+    const at = globalState.listFetchedAt.get(catalogId);
+    if (at === void 0) return false;
+    return Date.now() - at < LIST_TTL_MS;
+  }
+  function isStale() {
+    const at = globalState.listFetchedAt.get(catalogId);
+    if (at === void 0) return true;
+    return Date.now() - at > LIST_STALE_MS;
+  }
+  async function load() {
+    publish({ ...state, status: "loading", error: null });
+    try {
+      const rows = await readAgentCatalogRows(client);
+      replaceRows(rows);
+      publish({ ...state, status: "succeeded", error: null });
+      globalState.listFetchedAt.set(catalogId, Date.now());
+    } catch (e) {
+      const message = errorMessage(e);
+      publish({ ...state, status: "failed", error: message });
+      errorSink({
+        code: "list_read_failed",
+        message: `the agent catalogue could not be read: ${message}`,
+        context: { catalogId }
+      });
+      throw e;
+    }
+  }
+  async function ensureLoaded(options) {
+    const force = options?.force ?? false;
+    if (!force && isFresh()) return;
+    const existing = globalState.listInFlight.get(catalogId);
+    if (existing) return existing;
+    const run = load().finally(() => {
+      if (globalState.listInFlight.get(catalogId) === run) {
+        globalState.listInFlight.delete(catalogId);
+      }
+    });
+    globalState.listInFlight.set(catalogId, run);
+    return run;
+  }
+  function getConsumer(consumerId) {
+    return state.consumers[consumerId] ?? DEFAULT_AGENT_CONSUMER_STATE;
+  }
+  function writeConsumer(consumerId, next) {
+    publish({
+      ...state,
+      consumers: { ...state.consumers, [consumerId]: next }
+    });
+  }
+  function registerConsumer(consumerId, initial) {
+    if (state.consumers[consumerId]) return;
+    writeConsumer(consumerId, {
+      ...DEFAULT_AGENT_CONSUMER_STATE,
+      ...initial ?? {}
+    });
+  }
+  function unregisterConsumer(consumerId) {
+    if (!state.consumers[consumerId]) return;
+    const consumers = { ...state.consumers };
+    delete consumers[consumerId];
+    publish({ ...state, consumers });
+  }
+  function setConsumerFilter(consumerId, patch) {
+    const current = state.consumers[consumerId] ?? {
+      ...DEFAULT_AGENT_CONSUMER_STATE
+    };
+    writeConsumer(consumerId, {
+      ...current,
+      ...patch,
+      listPage: 1,
+      sharedPage: 1
+    });
+  }
+  function setConsumerPage(consumerId, which, page) {
+    const current = state.consumers[consumerId];
+    if (!current) return;
+    writeConsumer(
+      consumerId,
+      which === "list" ? { ...current, listPage: page } : { ...current, sharedPage: page }
+    );
+  }
+  function setConsumerServerSearch(consumerId, args) {
+    const current = state.consumers[consumerId] ?? {
+      ...DEFAULT_AGENT_CONSUMER_STATE
+    };
+    const next = { ...current };
+    if (args.matchedIds !== void 0) next.serverMatchedIds = args.matchedIds;
+    if (args.isSearching !== void 0) next.isServerSearching = args.isSearching;
+    if (next.serverMatchedIds === current.serverMatchedIds && next.isServerSearching === current.isServerSearching) {
+      return;
+    }
+    writeConsumer(consumerId, next);
+  }
+  function resetConsumerFilters(consumerId) {
+    if (!state.consumers[consumerId]) return;
+    writeConsumer(consumerId, { ...DEFAULT_AGENT_CONSUMER_STATE });
+  }
+  async function searchServer(query, deep = false) {
+    const result = await searchAgentsOnServer(client, { query, deep });
+    mergeRows(result.rows);
+    return result.ids;
+  }
+  async function setFavorite(agentId, isFavorite) {
+    const existing = state.byId[agentId];
+    if (!existing) {
+      errorSink({
+        code: "favorite_unknown_agent",
+        message: `cannot favorite ${agentId}: it is not in this catalogue`
+      });
+      return;
+    }
+    mergeRows([{ ...existing, isFavorite }]);
+    try {
+      await writeAgentFavorite(client, agentId, isFavorite);
+    } catch (e) {
+      mergeRows([existing]);
+      errorSink({
+        code: "favorite_write_failed",
+        message: `the favorite could not be saved: ${errorMessage(e)}`,
+        context: { agentId, isFavorite }
+      });
+      notifier?.({
+        level: "error",
+        title: "Favorite not saved",
+        message: "The star was put back because the change could not be saved. Check your connection and try again."
+      });
+      throw e;
+    }
+  }
+  function writeDefaultRow(mandateKey, next) {
+    publish({
+      ...state,
+      defaultRows: { ...state.defaultRows, [mandateKey]: next }
+    });
+  }
+  const defaultRowsInFlight = /* @__PURE__ */ new Set();
+  function ensureDefaultRow(mandateKey) {
+    if (!mandateKey) return;
+    if (state.defaultRows[mandateKey] || defaultRowsInFlight.has(mandateKey)) {
+      return;
+    }
+    if (!transport) {
+      throw new AgentCatalogConfigError({
+        code: "missing_transport",
+        message: `a picker asked for the default row of mandate "${mandateKey}", but this catalog has no transport`,
+        remedy: "pass `transport` (createMatrxTransport from @ai-matrx/agents/matrx) to createAgentCatalog \u2014 clients never walk the mandate ladder themselves, they ask the server"
+      });
+    }
+    defaultRowsInFlight.add(mandateKey);
+    writeDefaultRow(mandateKey, {
+      mandateKey,
+      row: null,
+      resolved: null,
+      loading: true,
+      drift: null,
+      error: null
+    });
+    void (async () => {
+      try {
+        const outcome = await resolveDefaultRow({
+          mandateKey,
+          transport,
+          client,
+          storage,
+          errorSink,
+          lookupRow: (id) => state.byId[id]
+        });
+        getCatalogGlobalState().defaultRows.set(
+          `${catalogId}::${mandateKey}`,
+          outcome.resolved
+        );
+        writeDefaultRow(mandateKey, {
+          mandateKey,
+          row: outcome.row,
+          resolved: outcome.resolved,
+          loading: false,
+          drift: outcome.drift,
+          error: null
+        });
+        if (outcome.drift) {
+          errorSink({
+            code: "default_row_drift",
+            message: outcome.drift,
+            context: { mandateKey, holderId: outcome.resolved.holderId }
+          });
+          notifier?.({
+            level: "warning",
+            title: "The default agent changed",
+            message: outcome.drift
+          });
+        }
+      } catch (e) {
+        const message = e instanceof MandateDefaultRowError ? e.message : errorMessage(e);
+        writeDefaultRow(mandateKey, {
+          mandateKey,
+          row: null,
+          resolved: null,
+          loading: false,
+          drift: null,
+          error: message
+        });
+        errorSink({
+          code: "default_row_unresolved",
+          message,
+          context: { mandateKey }
+        });
+      } finally {
+        defaultRowsInFlight.delete(mandateKey);
+      }
+    })();
+  }
+  function getDefaultRow(mandateKey) {
+    return state.defaultRows[mandateKey];
+  }
+  function dismissDefaultRowDrift(mandateKey) {
+    const current = state.defaultRows[mandateKey];
+    if (!current || !current.drift) return;
+    writeDefaultRow(mandateKey, { ...current, drift: null });
+  }
+  const catalog = {
+    catalogId,
+    labels,
+    errorSink,
+    notifier,
+    canResolveMandates: transport !== void 0,
+    getState: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getAgent: (agentId) => state.byId[agentId],
+    getUserIdOrNull,
+    ensureLoaded,
+    isFresh,
+    isStale,
+    getConsumer,
+    registerConsumer,
+    unregisterConsumer,
+    setConsumerFilter,
+    setConsumerPage,
+    setConsumerServerSearch,
+    resetConsumerFilters,
+    searchServer,
+    setFavorite,
+    ensureDefaultRow,
+    getDefaultRow,
+    dismissDefaultRowDrift,
+    assertSchema: (options) => assertAgentCatalogSchema(client, options)
+  };
+  globalState.catalogs.set(catalogId, catalog);
+  return catalog;
+}
+function getRegisteredAgentCatalog(catalogId = "default") {
+  const found = getCatalogGlobalState().catalogs.get(catalogId);
+  return found;
+}
+
+// catalog/labels.ts
+function agentListEmptyLabel(tab, labels) {
+  switch (tab) {
+    case "system":
+      return labels.emptySystem;
+    case "shared":
+      return labels.emptyShared;
+    default:
+      return labels.emptyDefault;
+  }
+}
+function shouldDefaultAgentListToPublicTab(args) {
+  if (!args.userId) return true;
+  if (!args.agentsLoaded) return false;
+  return args.ownedCount === 0;
+}
+
+// catalog/score.ts
+function computeAgentSearchScore(agent, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return 0;
+  let score = 0;
+  const name = (agent.name ?? "").toLowerCase();
+  const desc = (agent.description ?? "").toLowerCase();
+  if (name === q) score += 1e4;
+  else if (name.startsWith(q)) score += 5e3;
+  else if (matchesWholeWord(name, q)) score += 3e3;
+  else if (name.includes(q)) score += 2e3;
+  if (desc === q) score += 1e3;
+  else if (desc.includes(q)) score += 500;
+  if (agent.category?.toLowerCase().includes(q)) score += 300;
+  if (agent.tags?.some((t) => t.toLowerCase().includes(q))) score += 300;
+  if (agent.modelId?.toLowerCase().includes(q)) score += 100;
+  if (agent.agentType?.toLowerCase().includes(q)) score += 100;
+  if (agent.outputFormat?.toLowerCase().includes(q)) score += 100;
+  const id = agent.id.toLowerCase();
+  if (id === q) score += 1e5;
+  else if (id.includes(q)) score += 5e3;
+  if (agent.sharedByEmail?.toLowerCase().includes(q)) score += 200;
+  if (score === 0 && q.includes(" ")) {
+    const terms = q.split(/\s+/).filter(Boolean);
+    let hits = 0;
+    let termScore = 0;
+    for (const term of terms) {
+      const inName = name.includes(term);
+      const matched = inName || desc.includes(term) || (agent.category?.toLowerCase().includes(term) ?? false) || (agent.tags?.some((t) => t.toLowerCase().includes(term)) ?? false);
+      if (matched) {
+        hits += 1;
+        termScore += inName ? 400 : 100;
+      }
+    }
+    if (hits === terms.length) score += termScore;
+  }
+  return score;
+}
+function matchesWholeWord(haystack, q) {
+  const escaped = q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${escaped}\\b`).test(haystack);
+}
+function agentMatchesSearch(agent, query) {
+  return computeAgentSearchScore(agent, query) > 0;
+}
+
+// catalog/selectors.ts
+var AGENT_CARDS_LIMIT_DESKTOP = 8;
+var AGENT_CARDS_LIMIT_MOBILE = 4;
+var AGENT_LIST_ITEMS_PER_PAGE = 20;
+function memoize1(fn) {
+  let lastA;
+  let last;
+  let has = false;
+  return (a) => {
+    if (!has || lastA !== a) {
+      last = fn(a);
+      lastA = a;
+      has = true;
+    }
+    return last;
+  };
+}
+function memoize2(fn) {
+  let lastA;
+  let lastB;
+  let last;
+  let has = false;
+  return (a, b) => {
+    if (!has || lastA !== a || lastB !== b) {
+      last = fn(a, b);
+      lastA = a;
+      lastB = b;
+      has = true;
+    }
+    return last;
+  };
+}
+function memoize3(fn) {
+  let lastA;
+  let lastB;
+  let lastC;
+  let last;
+  let has = false;
+  return (a, b, c) => {
+    if (!has || lastA !== a || lastB !== b || lastC !== c) {
+      last = fn(a, b, c);
+      lastA = a;
+      lastB = b;
+      lastC = c;
+      has = true;
+    }
+    return last;
+  };
+}
+function applyAgentSortComparator(a, b, sortBy) {
+  switch (sortBy) {
+    case "name-asc":
+      return (a.name ?? "").localeCompare(b.name ?? "");
+    case "name-desc":
+      return (b.name ?? "").localeCompare(a.name ?? "");
+    case "created-desc":
+      return +new Date(b.createdAt ?? 0) - +new Date(a.createdAt ?? 0);
+    case "category-asc":
+      return (a.category ?? "").localeCompare(b.category ?? "");
+    case "updated-desc":
+    default:
+      return +new Date(b.updatedAt ?? 0) - +new Date(a.updatedAt ?? 0);
+  }
+}
+var selectAllAgentCategories = memoize1(
+  (agents) => {
+    const cats = /* @__PURE__ */ new Set();
+    for (const a of agents) {
+      if (a.agentType === "user" && a.category) cats.add(a.category);
+    }
+    return Array.from(cats).sort();
+  }
+);
+var selectAllSystemAgentCategories = memoize1(
+  (agents) => {
+    const cats = /* @__PURE__ */ new Set();
+    for (const a of agents) {
+      if (a.agentType === "builtin" && a.category) cats.add(a.category);
+    }
+    return Array.from(cats).sort();
+  }
+);
+var selectAllAgentTags = memoize1(
+  (agents) => {
+    const tags = /* @__PURE__ */ new Set();
+    for (const a of agents) {
+      if (a.agentType === "user") a.tags?.forEach((t) => tags.add(t));
+    }
+    return Array.from(tags).sort();
+  }
+);
+var selectAllSystemAgentTags = memoize1(
+  (agents) => {
+    const tags = /* @__PURE__ */ new Set();
+    for (const a of agents) {
+      if (a.agentType === "builtin") a.tags?.forEach((t) => tags.add(t));
+    }
+    return Array.from(tags).sort();
+  }
+);
+var selectUserTypeAgents = memoize1(
+  (agents) => agents.filter((a) => a.agentType === "user")
+);
+var selectBuiltinTypeAgents = memoize1(
+  (agents) => agents.filter((a) => a.agentType === "builtin")
+);
+function sortFilteredAgents(filtered, consumer) {
+  const { searchTerm, sortBy, favFilter, favoritesFirst } = consumer;
+  if (searchTerm) {
+    const scores = /* @__PURE__ */ new Map();
+    filtered.forEach((a) => {
+      scores.set(a.id, computeAgentSearchScore(a, searchTerm));
+    });
+    const serverRank = /* @__PURE__ */ new Map();
+    consumer.serverMatchedIds.forEach((id, i) => serverRank.set(id, i));
+    return [...filtered].sort((a, b) => {
+      const sa = scores.get(a.id) ?? 0;
+      const sb = scores.get(b.id) ?? 0;
+      if (sb !== sa) return sb - sa;
+      if (sa === 0) {
+        const ra = serverRank.get(a.id);
+        const rb = serverRank.get(b.id);
+        if (ra !== void 0 && rb !== void 0 && ra !== rb) return ra - rb;
+      }
+      return applyAgentSortComparator(a, b, sortBy);
+    });
+  }
+  return [...filtered].sort((a, b) => {
+    if (favoritesFirst && favFilter === "all") {
+      const aFav = a.isFavorite ? 1 : 0;
+      const bFav = b.isFavorite ? 1 : 0;
+      if (bFav !== aFav) return bFav - aFav;
+    }
+    return applyAgentSortComparator(a, b, sortBy);
+  });
+}
+function filterUserTypeAgents(agents, consumer) {
+  const {
+    searchTerm,
+    includedCats,
+    includedTags,
+    favFilter,
+    archFilter,
+    accessFilter,
+    tab
+  } = consumer;
+  const serverMatched = new Set(consumer.serverMatchedIds);
+  const filtered = agents.filter((agent) => {
+    if (tab === "mine" && agent.isOwner !== true) return false;
+    if (tab === "shared" && !(agent.isOwner === false && agent.accessLevel != null))
+      return false;
+    if (archFilter === "active" && agent.isArchived) return false;
+    if (archFilter === "archived" && !agent.isArchived) return false;
+    if (favFilter === "yes" && !agent.isFavorite) return false;
+    if (favFilter === "no" && agent.isFavorite) return false;
+    if (accessFilter === "owned" && agent.isOwner !== true) return false;
+    if (accessFilter === "shared" && agent.isOwner !== false) return false;
+    if (accessFilter === "editable" && agent.accessLevel !== "owner" && agent.accessLevel !== "admin" && agent.accessLevel !== "editor")
+      return false;
+    if (includedCats.length > 0) {
+      const category = agent.category;
+      if (!category) {
+        if (!includedCats.includes(AGENT_NONE_SENTINEL)) return false;
+      } else if (!includedCats.includes(category)) {
+        return false;
+      }
+    }
+    if (includedTags.length > 0) {
+      const isUntagged = !agent.tags?.length;
+      if (isUntagged) {
+        if (!includedTags.includes(AGENT_NONE_SENTINEL)) return false;
+      } else if (!agent.tags?.some((t) => includedTags.includes(t))) {
+        return false;
+      }
+    }
+    if (searchTerm && !agentMatchesSearch(agent, searchTerm) && !serverMatched.has(agent.id))
+      return false;
+    return true;
+  });
+  return sortFilteredAgents(filtered, consumer);
+}
+function filterBuiltinTypeAgents(agents, consumer) {
+  const { searchTerm, favFilter, includedCats, includedTags } = consumer;
+  const serverMatched = new Set(consumer.serverMatchedIds);
+  const filtered = agents.filter((agent) => {
+    if (favFilter === "yes" && !agent.isFavorite) return false;
+    if (favFilter === "no" && agent.isFavorite) return false;
+    if (includedCats.length > 0) {
+      const category = agent.category;
+      if (!category) {
+        if (!includedCats.includes(AGENT_NONE_SENTINEL)) return false;
+      } else if (!includedCats.includes(category)) {
+        return false;
+      }
+    }
+    if (includedTags.length > 0) {
+      const isUntagged = !agent.tags?.length;
+      if (isUntagged) {
+        if (!includedTags.includes(AGENT_NONE_SENTINEL)) return false;
+      } else if (!agent.tags?.some((t) => includedTags.includes(t))) {
+        return false;
+      }
+    }
+    if (searchTerm && !agentMatchesSearch(agent, searchTerm) && !serverMatched.has(agent.id))
+      return false;
+    return true;
+  });
+  return sortFilteredAgents(filtered, consumer);
+}
+var makeSelectFilteredOwnedAgents = () => memoize2(
+  (agents, consumer) => filterUserTypeAgents(selectUserTypeAgents(agents), {
+    ...consumer,
+    tab: "mine"
+  })
+);
+var makeSelectFilteredSharedAgents = () => memoize2(
+  (agents, consumer) => filterUserTypeAgents(selectUserTypeAgents(agents), {
+    ...consumer,
+    tab: "shared"
+  })
+);
+var makeSelectFilteredAgents = (includeSystemInAll = false) => memoize2(
+  (agents, consumer) => {
+    const userAgents = selectUserTypeAgents(agents);
+    const builtinAgents = selectBuiltinTypeAgents(agents);
+    if (consumer.tab === "system") {
+      return filterBuiltinTypeAgents(builtinAgents, consumer);
+    }
+    if (includeSystemInAll && consumer.tab === "all") {
+      return [
+        ...filterUserTypeAgents(userAgents, consumer),
+        ...filterBuiltinTypeAgents(builtinAgents, consumer)
+      ];
+    }
+    return filterUserTypeAgents(userAgents, consumer);
+  }
+);
+var makeSelectFilteredBuiltinAgents = () => memoize2(
+  (agents, consumer) => filterBuiltinTypeAgents(selectBuiltinTypeAgents(agents), consumer)
+);
+function pageAfterCards(filtered, limit, page) {
+  const afterCards = filtered.slice(limit);
+  const pageEnd = page * AGENT_LIST_ITEMS_PER_PAGE;
+  const items = afterCards.slice(0, pageEnd);
+  return {
+    items,
+    hasMore: items.length < afterCards.length,
+    totalAfterCards: afterCards.length
+  };
+}
+var makeSelectOwnedAgentCards = (isMobile) => {
+  const selectFiltered = makeSelectFilteredOwnedAgents();
+  const limit = isMobile ? AGENT_CARDS_LIMIT_MOBILE : AGENT_CARDS_LIMIT_DESKTOP;
+  return memoize2(
+    (agents, consumer) => selectFiltered(agents, consumer).slice(0, limit)
+  );
+};
+var makeSelectOwnedAgentListItems = (isMobile) => {
+  const selectFiltered = makeSelectFilteredOwnedAgents();
+  const limit = isMobile ? AGENT_CARDS_LIMIT_MOBILE : AGENT_CARDS_LIMIT_DESKTOP;
+  return memoize2(
+    (agents, consumer) => pageAfterCards(selectFiltered(agents, consumer), limit, consumer.listPage)
+  );
+};
+var makeSelectSharedAgentCards = (isMobile) => {
+  const selectFiltered = makeSelectFilteredSharedAgents();
+  const limit = isMobile ? AGENT_CARDS_LIMIT_MOBILE : AGENT_CARDS_LIMIT_DESKTOP;
+  return memoize2(
+    (agents, consumer) => selectFiltered(agents, consumer).slice(0, limit)
+  );
+};
+var makeSelectSharedAgentListItems = (isMobile) => {
+  const selectFiltered = makeSelectFilteredSharedAgents();
+  const limit = isMobile ? AGENT_CARDS_LIMIT_MOBILE : AGENT_CARDS_LIMIT_DESKTOP;
+  return memoize2(
+    (agents, consumer) => pageAfterCards(
+      selectFiltered(agents, consumer),
+      limit,
+      consumer.sharedPage
+    )
+  );
+};
+var makeSelectFilteredAgentsCount = () => {
+  const selectFiltered = makeSelectFilteredAgents();
+  return memoize2(
+    (agents, consumer) => selectFiltered(agents, consumer).length
+  );
+};
+var makeSelectFilteredBuiltinAgentsCount = () => {
+  const selectFiltered = makeSelectFilteredBuiltinAgents();
+  return memoize2(
+    (agents, consumer) => selectFiltered(agents, consumer).length
+  );
+};
+function agentConsumerHasActiveFilters(consumer, defaults) {
+  return consumer.tab !== defaults.tab || consumer.sortBy !== defaults.sortBy || consumer.searchTerm !== "" || consumer.includedCats.length > 0 || consumer.includedTags.length > 0 || consumer.favFilter !== defaults.favFilter || consumer.archFilter !== defaults.archFilter || consumer.accessFilter !== defaults.accessFilter || consumer.favoritesFirst !== defaults.favoritesFirst;
+}
+var selectTotalUserAgentsCount = memoize1(
+  (agents) => selectUserTypeAgents(agents).length
+);
+var selectTotalOwnedAgentsCount = memoize1(
+  (agents) => selectUserTypeAgents(agents).filter((a) => a.isOwner === true).length
+);
+var selectTotalSharedAgentsCount = memoize1(
+  (agents) => selectUserTypeAgents(agents).filter(
+    (a) => a.isOwner === false && a.accessLevel != null
+  ).length
+);
+var selectTotalBuiltinAgentsCount = memoize1(
+  (agents) => selectBuiltinTypeAgents(agents).length
+);
+var selectTotalFavoriteAgentsCount = memoize1(
+  (agents) => selectUserTypeAgents(agents).filter((a) => a.isFavorite).length
+);
+//# sourceMappingURL=index.cjs.map